public void Sleep100ms(IMetricCollector collector) { using (collector.StartCollection()) { Thread.Sleep(100); } }
public void ColdStartSandbox_100ms(IMetricCollector collector) { using (var sandbox = new ColdStartSandbox()) { var testClass = sandbox.CreateInstance<ColdStartEnabledTests>(); testClass.Sleep100ms(collector); } }
public void Calibration_100ms_controlled(IMetricCollector collector) { Thread.Sleep(100); using (collector.StartCollection()) { Thread.Sleep(100); } }
public void OrderBy(IMetricCollector collector, bool tracking, int queriesPerIteration) { using (var context = _fixture.CreateContext()) { var query = context.Products .ApplyTracking(tracking) .OrderBy(p => p.Retail); using (collector.StartCollection()) { for (var i = 0; i < queriesPerIteration; i++) { query.ToList(); } } Assert.Equal(1000, query.Count()); Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries"); } }
public void StoredProcedure(IMetricCollector collector, bool tracking, int queriesPerIteration) { using (var context = _fixture.CreateContext()) { var query = context.Products .SqlQuery("EXECUTE dbo.SearchProducts @p0, @p1", 10, 14) .ApplyTracking(tracking); using (collector.StartCollection()) { for (var i = 0; i < queriesPerIteration; i++) { query.ToList(); } } Assert.Equal(500, query.Count()); Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries"); } }
public void SelectParameterized(IMetricCollector collector, bool tracking, int queriesPerIteration) { using (var context = _fixture.CreateContext()) { var query = context.Products .SqlQuery("SELECT * FROM dbo.Products WHERE CurrentPrice >= @p0 AND CurrentPrice <= @p1", 10, 14) .ApplyTracking(tracking); using (collector.StartCollection()) { for (var i = 0; i < queriesPerIteration; i++) { query.ToList(); } } Assert.Equal(500, query.Count()); Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries"); } }
public void SelectAll(IMetricCollector collector, bool tracking, int queriesPerIteration) { using (var context = _fixture.CreateContext()) { var query = context.Products .FromSql("SELECT * FROM dbo.Products") .ApplyTracking(tracking); using (collector.StartCollection()) { for (var i = 0; i < queriesPerIteration; i++) { query.ToList(); } } Assert.Equal(1000, query.Count()); Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries"); } }
public async Task Insert(IMetricCollector collector, bool disableBatching, bool async) { using (var context = _fixture.CreateContext(disableBatching)) { using (context.Database.BeginTransaction()) { var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: false); context.Customers.AddRange(customers); collector.StartCollection(); var records = async ? await context.SaveChangesAsync() : context.SaveChanges(); collector.StopCollection(); Assert.Equal(1000, records); } } }
public void LoadAll(IMetricCollector collector, bool tracking, bool caching, int queriesPerIteration) { using (var context = _fixture.CreateContext()) { var query = context.Products .ApplyCaching(caching) .ApplyTracking(tracking); using (collector.StartCollection()) { for (int i = 0; i < queriesPerIteration; i++) { query.ToList(); } } Assert.Equal(1000, query.Count()); Assert.False(tracking && queriesPerIteration != 1, "Multiple queries per iteration not valid for tracking queries"); } }
public void AttachParents(IMetricCollector collector) { using (var context = _fixture.CreateContext()) { var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: true); var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 1, setPrimaryKeys: true); orders.ForEach(o => context.Orders.Attach(o)); Assert.All(customers, c => Assert.Null(c.Orders)); using (collector.StartCollection()) { foreach (var customer in customers) { context.Customers.Attach(customer); } } Assert.All(customers, c => Assert.Equal(1, c.Orders.Count)); } }
public void AttachChildren(IMetricCollector collector) { using (var context = _fixture.CreateContext()) { var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: true); var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 1, setPrimaryKeys: true); customers.ForEach(c => context.Customers.Attach(c)); Assert.All(orders, o => Assert.Null(o.Customer)); using (collector.StartCollection()) { foreach (var order in orders) { context.Orders.Attach(order); } } Assert.All(orders, o => Assert.NotNull(o.Customer)); } }
public void SkipTake(IMetricCollector collector, bool tracking, bool caching, int queriesPerIteration) { using (var context = _fixture.CreateContext(queryCachingEnabled: caching)) { var query = context.Products .ApplyTracking(tracking) .OrderBy(p => p.ProductId) .Skip(500).Take(500); using (collector.StartCollection()) { for (int i = 0; i < queriesPerIteration; i++) { query.ToList(); } } Assert.Equal(500, query.Count()); Assert.False(tracking && queriesPerIteration != 1, "Multiple queries per iteration not valid for tracking queries"); } }
// NOTE: Composition is done on client, so there is no async version public void SelectComposed(IMetricCollector collector, bool tracking, int queriesPerIteration) { using (var context = _fixture.CreateContext()) { var query = context.Products .SqlQuery("SELECT * FROM dbo.Products") .ApplyTracking(tracking) .Where(p => p.CurrentPrice >= 10 && p.CurrentPrice <= 14) .OrderBy(p => p.Name); using (collector.StartCollection()) { for (var i = 0; i < queriesPerIteration; i++) { query.ToList(); } } Assert.Equal(500, query.Count()); Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries"); } }
public void Include(IMetricCollector collector, bool tracking, int queriesPerIteration) { using (var context = _fixture.CreateContext()) { var query = context.Customers .ApplyTracking(tracking) .Include(c => c.Orders); using (collector.StartCollection()) { for (var i = 0; i < queriesPerIteration; i++) { query.ToList(); } } var result = query.ToList(); Assert.Equal(1000, result.Count); Assert.Equal(2000, result.SelectMany(c => c.Orders).Count()); Assert.False(tracking && (queriesPerIteration != 1), "Multiple queries per iteration not valid for tracking queries"); } }
public async Task Update(IMetricCollector collector, bool async) { using (var context = _fixture.CreateContext()) { using (context.Database.BeginTransaction()) { foreach (var customer in context.Customers) { customer.FirstName += " Modified"; } collector.StartCollection(); var records = async ? await context.SaveChangesAsync() : context.SaveChanges(); collector.StopCollection(); Assert.Equal(1000, records); } } }
public void AttachParents(IMetricCollector collector, bool autoDetectChanges) { using (var context = _fixture.CreateContext()) { context.Configuration.AutoDetectChangesEnabled = autoDetectChanges; var customers = _fixture.CreateCustomers(5000, setPrimaryKeys: true); var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 2, setPrimaryKeys: true); orders.ForEach(o => context.Orders.Attach(o)); Assert.All(customers, c => Assert.Null(c.Orders)); using (collector.StartCollection()) { foreach (var customer in customers) { context.Customers.Attach(customer); } } Assert.All(customers, c => Assert.Equal(2, c.Orders.Count)); } }
public void AddChildren(IMetricCollector collector, bool autoDetectChanges) { using (var context = _fixture.CreateContext()) { context.Configuration.AutoDetectChangesEnabled = autoDetectChanges; var customers = _fixture.CreateCustomers(5000, setPrimaryKeys: true); var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 2, setPrimaryKeys: false); customers.ForEach(c => context.Customers.Attach(c)); Assert.All(orders, o => Assert.Null(o.Customer)); using (collector.StartCollection()) { foreach (var order in orders) { context.Orders.Add(order); } } Assert.All(orders, o => Assert.NotNull(o.Customer)); } }
public void AttachChildren(IMetricCollector collector, bool autoDetectChanges) { using (var context = _fixture.CreateContext()) { context.ChangeTracker.AutoDetectChangesEnabled = autoDetectChanges; var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: true); var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 1, setPrimaryKeys: true); context.Customers.AttachRange(customers); Assert.All(orders, o => Assert.Null(o.Customer)); using (collector.StartCollection()) { foreach (var order in orders) { context.Orders.Attach(order); } } Assert.All(orders, o => Assert.NotNull(o.Customer)); } }
public void AddParents(IMetricCollector collector, bool autoDetectChanges) { using (var context = _fixture.CreateContext()) { context.ChangeTracker.AutoDetectChangesEnabled = autoDetectChanges; var customers = _fixture.CreateCustomers(1000, setPrimaryKeys: true); var orders = _fixture.CreateOrders(customers, ordersPerCustomer: 1, setPrimaryKeys: false); context.Orders.AddRange(orders); Assert.All(customers, c => Assert.Null(c.Orders)); using (collector.StartCollection()) { foreach (var customer in customers) { context.Customers.Add(customer); } } Assert.All(customers, c => Assert.Equal(1, c.Orders.Count)); } }
public async Task Count(IMetricCollector collector, bool async, int queriesPerIteration) { using (var context = _fixture.CreateContext()) { var query = context.Products; using (collector.StartCollection()) { for (var i = 0; i < queriesPerIteration; i++) { if (async) { await query.CountAsync(); } else { query.Count(); } } } Assert.Equal(1000, query.Count()); } }
public async Task PredicateAcrossOptionalNavigationFilteredResults(IMetricCollector collector, bool async, int queriesPerIteration) { using (var context = AdventureWorksFixture.CreateContext()) { var query = context.Store.Where(s => s.SalesPerson.Bonus > 3000); using (collector.StartCollection()) { for (var i = 0; i < queriesPerIteration; i++) { if (async) { await query.ToListAsync(); } else { query.ToList(); } } } Assert.Equal(466, query.Count()); } }
public BenchmarkTestInvoker( ITest test, IMetricCollector metricCollector, IMessageBus messageBus, Type testClass, object[] constructorArguments, MethodInfo testMethod, object[] testMethodArguments, IReadOnlyList <BeforeAfterTestAttribute> beforeAfterAttributes, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) : base( test, messageBus, testClass, constructorArguments, testMethod, testMethodArguments, beforeAfterAttributes, aggregator, cancellationTokenSource) { _metricCollector = metricCollector; }
public void AddMetricCollector(string alisa, IMetricCollector metric) { Metrics[alisa] = metric; }
public Scope(IMetricCollector collector) { _collector = collector; }
public void InitializeAndSaveChanges_AdventureWorks(IMetricCollector collector, bool cold, int count) { RunColdStartEnabledTest(cold, t => t.InitializeAndSaveChanges_AdventureWorks(collector, count)); }
public void InitializeAndQuery_AdventureWorks(IMetricCollector collector, bool cold, int count) { RunColdStartEnabledTest(cold, c => c.InitializeAndQuery_AdventureWorks(collector, count)); }
public void CreateAndDisposeUnusedContext(IMetricCollector collector, bool cold, int count) { RunColdStartEnabledTest(cold, c => c.CreateAndDisposeUnusedContext(collector, count)); }
public void Aggregate(RunSummary other, IMetricCollector collector) { Aggregate(other); TimeElapsed = collector.TimeElapsed; MemoryDelta = collector.MemoryDelta; }
public void Configure(IApplicationBuilder app, IMetricCollector collector) { collector.StopCollection(); }
public LoggingCommandExecutionAuditor(ILogger <LoggingCommandExecutionAuditor> logger, IMetricCollector metricCollector) { _logger = logger; _metricCollector = metricCollector; }
public BenchmarkTestInvoker( ITest test, IMetricCollector metricCollector, IMessageBus messageBus, Type testClass, object[] constructorArguments, MethodInfo testMethod, object[] testMethodArguments, IReadOnlyList<BeforeAfterTestAttribute> beforeAfterAttributes, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) : base( test, messageBus, testClass, constructorArguments, testMethod, testMethodArguments, beforeAfterAttributes, aggregator, cancellationTokenSource) { _metricCollector = metricCollector; }