static public async Task ClassInit(TestContext context) #endif { app = new KZApplication(test.Constants.MarketplaceUrl, test.Constants.AppName); await app.Initialize(); EnqueueTestComplete(); }
public static void ClassInit(TestContext context) { if (string.IsNullOrEmpty(imageName)) { imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false); } }
public void WithGlobalFilter_WithInstanceFilter_ManyFilter_GlobalFilterDisabled_InstanceFilterDisabled() { using (var ctx = new TestContext(true, enableFilter1: false, enableFilter2: false, enableFilter3: false, enableFilter4: false)) { ctx.Filter<Inheritance_Interface_Entity>(QueryFilterHelper.Filter.Filter5, entities => entities.Where(x => x.ColumnInt != 5)); ctx.Filter<Inheritance_Interface_IEntity>(QueryFilterHelper.Filter.Filter6, entities => entities.Where(x => x.ColumnInt != 6)); ctx.Filter<Inheritance_Interface_Base>(QueryFilterHelper.Filter.Filter7, entities => entities.Where(x => x.ColumnInt != 7)); ctx.Filter<Inheritance_Interface_IBase>(QueryFilterHelper.Filter.Filter8, entities => entities.Where(x => x.ColumnInt != 8)); ctx.Filter(QueryFilterHelper.Filter.Filter5).Disable(); ctx.Filter(QueryFilterHelper.Filter.Filter6).Disable(); ctx.Filter(QueryFilterHelper.Filter.Filter7).Disable(); ctx.Filter(QueryFilterHelper.Filter.Filter8).Disable(); Assert.AreEqual(9, ctx.Inheritance_Interface_Entities.Filter( QueryFilterHelper.Filter.Filter1, QueryFilterHelper.Filter.Filter2, QueryFilterHelper.Filter.Filter3, QueryFilterHelper.Filter.Filter4, QueryFilterHelper.Filter.Filter5, QueryFilterHelper.Filter.Filter6, QueryFilterHelper.Filter.Filter7, QueryFilterHelper.Filter.Filter8).Sum(x => x.ColumnInt)); } }
private void TakeScreenshot(TestContext testContext) { var filename = Path.GetFullPath(testContext.FullyQualifiedTestClassName + ".jpg"); try { var screenLeft = SystemInformation.VirtualScreen.Left; var screenTop = SystemInformation.VirtualScreen.Top; var screenWidth = SystemInformation.VirtualScreen.Width; var screenHeight = SystemInformation.VirtualScreen.Height; // Create a bitmap of the appropriate size to receive the screenshot. using (var bmp = new Bitmap(screenWidth, screenHeight)) { // Draw the screenshot into our bitmap. using (var g = Graphics.FromImage(bmp)) { g.CopyFromScreen(screenLeft, screenTop, 0, 0, bmp.Size); } bmp.Save(filename, ImageFormat.Jpeg); } testContext.AddResultFile(filename); } catch (Exception ex) { Logger.WriteLine("An exception occured while trying to take screenshot:"); Logger.WriteLine(ex); } }
public void Many_Executor() { TestContext.DeleteAll(x => x.Association_Multi_OneToMany_Lefts); TestContext.DeleteAll(x => x.Association_Multi_OneToMany_Right1s); TestContext.DeleteAll(x => x.Association_Multi_OneToMany_Right2s); using (var ctx = new TestContext()) { var left = TestContext.Insert(ctx, x => x.Association_Multi_OneToMany_Lefts, 1).First(); left.Right1s = TestContext.Insert(ctx, x => x.Association_Multi_OneToMany_Right1s, 5); left.Right2s = TestContext.Insert(ctx, x => x.Association_Multi_OneToMany_Right2s, 5); ctx.SaveChanges(); } using (var ctx = new TestContext()) { var item = ctx.Association_Multi_OneToMany_Lefts .Include(left => left.Right1s, true) .Include(left => left.Right2s, true) .First(); // TEST: context Assert.AreEqual(11, ctx.ChangeTracker.Entries().Count()); } }
public void Many_Property_Type() { TestContext.DeleteAll(x => x.Entity_Basic_Manies); TestContext.Insert(x => x.Entity_Basic_Manies, 50); using (var ctx = new TestContext()) { // BEFORE Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column1)); Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column2)); Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column3)); // ACTION var entity = new Entity_Basic_Many {Column1 = 99, Column2 = 66, Column3 = 33}; var rowsAffected = ctx.Entity_Basic_Manies.Where(x => x.Column1 > 10 && x.Column1 <= 40).Update(x => new Entity_Basic_Many { Column1 = entity.Column1, Column2 = entity.Column2, Column3 = entity.Column3 }); // AFTER Assert.AreEqual(3430, ctx.Entity_Basic_Manies.Sum(x => x.Column1)); Assert.AreEqual(2440, ctx.Entity_Basic_Manies.Sum(x => x.Column2)); Assert.AreEqual(1450, ctx.Entity_Basic_Manies.Sum(x => x.Column3)); Assert.AreEqual(30, rowsAffected); } }
public void Tag_NotEqual() { var testCacheKey = Guid.NewGuid().ToString(); TestContext.DeleteAll(x => x.Entity_Basics); TestContext.Insert(x => x.Entity_Basics, 1); using (var ctx = new TestContext()) { // BEFORE var itemCountBefore = ctx.Entity_Basics.FromCache(testCacheKey).Count(); var cacheCountBefore = QueryCacheHelper.GetCacheCount(); TestContext.DeleteAll(x => x.Entity_Basics); // AFTER var itemCountAfter = ctx.Entity_Basics.FromCache(testCacheKey, Guid.NewGuid().ToString()).Count(); var cacheCountAfter = QueryCacheHelper.GetCacheCount(); // TEST: The item count are NOT equal (A new cache key is used, the query is materialized) Assert.AreNotEqual(itemCountBefore, itemCountAfter); Assert.AreEqual(0, itemCountAfter); // TEST: The cache count are NOT equal (A new cache key is used) Assert.AreEqual(cacheCountBefore + 1, cacheCountAfter); } }
public async Task TestGetClusterInfo() { // arrange var ctx = new TestContext(); var urlProvider = ctx.UrlProviderFake; var restReqExecutor = ctx.RestRequestExecutorFake; var anyUri = Enumerable.Repeat(new Uri("anyscheme://anypath"), 1); urlProvider.GetUrlAsync().Returns(Task.FromResult(anyUri)); var anyClusterInfo = new ClusterInfo { HadoopBuildVersion = "AnyBuildVersion", HadoopVersion = "AnyVersion", HadoopVersionBuiltOn = "AnyVersionBuildOn", }; restReqExecutor.ExecuteAsync<ClusterInfo>( Arg.Is<RestRequest>( req => req.Resource == "ws/v1/cluster/info" && req.RootElement == "clusterInfo" && req.Method == Method.GET), anyUri.First(), CancellationToken.None).Returns(Task.FromResult(anyClusterInfo)); // act var yarnClient = ctx.GetClient(); ClusterInfo actualClusterInfo = await yarnClient.GetClusterInfoAsync(); // assert Assert.Equal(anyClusterInfo, actualClusterInfo); var unused = urlProvider.Received(1).GetUrlAsync(); }
public async Task TestGetClusterMetrics() { var ctx = new TestContext(); var urlProvider = ctx.UrlProviderFake; var restReqExecutor = ctx.RestRequestExecutorFake; var anyUri = Enumerable.Repeat(new Uri("anyscheme://anypath"), 1); urlProvider.GetUrlAsync().Returns(Task.FromResult(anyUri)); var anyClusterMetrics = new ClusterMetrics { ActiveNodes = 5, AllocatedMB = 1000, AllocatedVirtualCores = 10, AppsCompleted = 301 }; restReqExecutor.ExecuteAsync<ClusterMetrics>( Arg.Is<RestRequest>( req => req.Resource == "ws/v1/cluster/metrics" && req.RootElement == "clusterMetrics" && req.Method == Method.GET), anyUri.First(), CancellationToken.None).Returns(Task.FromResult(anyClusterMetrics)); var yarnClient = ctx.GetClient(); ClusterMetrics actualClusterMetrics = await yarnClient.GetClusterMetricsAsync(); Assert.Equal(anyClusterMetrics, actualClusterMetrics); var unused = urlProvider.Received(1).GetUrlAsync(); }
public void Initialize() { Context = new TestContext(); Context.Service.Start(Context.EndPoint); Context.Client.Connect(Context.EndPoint); Assert.IsTrue(Context.WaitFor(() => Context.ConnectedUsers.Count() == 1, Context.WaitingPeriod)); }
public void BracketedIdentifierSimplificationTest() { var expected = $@"#Region ""{FeaturesResources.Assembly} mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"" ' mscorlib.v4_0_30319_17626.dll #End Region Imports System.Runtime Imports System.Runtime.InteropServices Namespace System <__DynamicallyInvokableAttribute> <AttributeUsage(AttributeTargets.Class Or AttributeTargets.Struct Or AttributeTargets.Enum Or AttributeTargets.Constructor Or AttributeTargets.Method Or AttributeTargets.Property Or AttributeTargets.Field Or AttributeTargets.Event Or AttributeTargets.Interface Or AttributeTargets.Delegate, Inherited:=False)> <ComVisible(True)> Public NotInheritable Class [|ObsoleteAttribute|] Inherits Attribute <__DynamicallyInvokableAttribute> Public Sub New() <__DynamicallyInvokableAttribute> Public Sub New(message As String) <__DynamicallyInvokableAttribute> <TargetedPatchingOptOut(""Performance critical to inline this type of method across NGen image boundaries"")> Public Sub New(message As String, [error] As Boolean) <__DynamicallyInvokableAttribute> Public ReadOnly Property IsError As Boolean <__DynamicallyInvokableAttribute> Public ReadOnly Property Message As String End Class End Namespace"; using (var context = new TestContext(LanguageNames.VisualBasic)) { context.GenerateAndVerifySource("System.ObsoleteAttribute", expected); } }
public async Task TestConnection (TestContext ctx, CancellationToken cancellationToken, InstrumentationConnectionProvider provider, SimpleConnectionParameters parameters, SimpleConnectionTestRunner runner) { await runner.Run (ctx, cancellationToken); }
public void Thirty() { TestContext.DeleteAll(x => x.Entity_Basics); TestContext.Insert(x => x.Entity_Basics, 50); using (var ctx = new TestContext()) { // BEFORE Assert.AreEqual(1225, ctx.Entity_Basics.Sum(x => x.ColumnInt)); // ACTION var clock = new Stopwatch(); clock.Start(); var rowsAffected = ctx.Entity_Basics.Where(x => x.ColumnInt > 10 && x.ColumnInt <= 40).Update(x => new Entity_Basic { ColumnInt = 99 }, update => { update.BatchDelayInterval = 50; update.BatchSize = 5; }); clock.Stop(); // AFTER Assert.AreEqual(460, ctx.Entity_Basics.Sum(x => x.ColumnInt)); Assert.AreEqual(30, rowsAffected); Assert.IsTrue(clock.ElapsedMilliseconds > 250 && clock.ElapsedMilliseconds < 600); } }
public void WithGlobalFilter_ManyFilter_Include() { using (var ctx = new TestContext(true, enableFilter1: false, enableFilter2: false, enableFilter3: false, enableFilter4: false, includeInterface: true, includeBaseClass: true, includeBaseInterface: true)) { Assert.AreEqual(36, ctx.Inheritance_Interface_Entities.Sum(x => x.ColumnInt)); } }
public void Tag_Expire() { var testCacheKey = Guid.NewGuid().ToString(); TestContext.DeleteAll(x => x.Entity_Basics); TestContext.Insert(x => x.Entity_Basics, 1); using (var ctx = new TestContext()) { // BEFORE var itemCountBefore = ctx.Entity_Basics.FromCache(testCacheKey).Count(); var cacheCountBefore = QueryCacheHelper.GetCacheCount(); TestContext.DeleteAll(x => x.Entity_Basics); QueryCacheManager.ExpireTag(testCacheKey); var cacheCountExpired = QueryCacheHelper.GetCacheCount(); // TEST: The cache count are NOT equal (The cache key has been removed) Assert.AreEqual(cacheCountBefore - 1, cacheCountExpired); // AFTER var itemCountAfter = ctx.Entity_Basics.FromCache(testCacheKey).Count(); var cacheCountAfter = QueryCacheHelper.GetCacheCount(); // TEST: The item count are NOT equal (The query has been expired) Assert.AreNotEqual(itemCountBefore, itemCountAfter); Assert.AreEqual(0, itemCountAfter); // TEST: The cache count are NOT equal (The expired cache key is added) Assert.AreEqual(cacheCountExpired + 1, cacheCountAfter); Assert.AreEqual(cacheCountBefore, cacheCountAfter); } }
public static void InitializeAssembly(TestContext context) { //System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); #if NET using (var dbContext = new EntityFramework5.DbContextTest.TestDbContextContainer()) { dbContext.Database.CreateIfNotExists(); // Delete all data var allOrders = (from x in dbContext.DbContextOrders select x).ToList(); foreach (var x in allOrders) { dbContext.DbContextOrders.Remove(x); } var allCustomers = (from x in dbContext.DbContextCustomers select x).ToList(); foreach (var x in allCustomers) { dbContext.DbContextCustomers.Remove(x); } var allProducts = (from x in dbContext.DbContextProducts select x).ToList(); foreach (var x in allProducts) { dbContext.DbContextProducts.Remove(x); } dbContext.SaveChanges(); } #endif }
public async Task RestClientGetRequestReturnsResponse() { var tc = new TestContext(); var client = tc.GetRestClient(); var anyRequest = new RestRequest { Method = Method.GET, Resource = AnyResource, RootElement = AnyRootElement }; var successfulResponseMessage = CreateSuccessfulResponseMessage(); tc.HttpClient.GetAsync(AnyRequestUri + anyRequest.Resource, CancellationToken.None) .Returns(Task.FromResult(successfulResponseMessage)); var response = await client.ExecuteRequestAsync<AnyResponse>(anyRequest, AnyRequestUri, CancellationToken.None); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(AnyStringField, response.Data.AnyStringField); Assert.Equal(AnyIntField, response.Data.AnyIntField); Assert.Null(response.Exception); var unused = tc.HttpClient.Received(1).GetAsync(AnyRequestUri + anyRequest.Resource, CancellationToken.None); }
public void WithGlobalFilter_SingleFilter_Enable() { using (var ctx = new TestContext(false, enableFilter1: true)) { Assert.AreEqual(44, ctx.Inheritance_Interface_Entities.Sum(x => x.ColumnInt)); } }
public void Many_Variable() { TestContext.DeleteAll(x => x.Entity_Basic_Manies); TestContext.Insert(x => x.Entity_Basic_Manies, 50); using (var ctx = new TestContext()) { // BEFORE Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column1)); Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column2)); Assert.AreEqual(1225, ctx.Entity_Basic_Manies.Sum(x => x.Column3)); // ACTION var value1 = 99; var value2 = 66; var value3 = 33; var rowsAffected = ctx.Entity_Basic_Manies.Where(x => x.Column1 > 10 && x.Column1 <= 40).Update(x => new Entity_Basic_Many { Column1 = value1, Column2 = value2, Column3 = value3 }); // AFTER Assert.AreEqual(3430, ctx.Entity_Basic_Manies.Sum(x => x.Column1)); Assert.AreEqual(2440, ctx.Entity_Basic_Manies.Sum(x => x.Column2)); Assert.AreEqual(1450, ctx.Entity_Basic_Manies.Sum(x => x.Column3)); Assert.AreEqual(30, rowsAffected); } }
public static void ClassInitialize(TestContext context) { longPathDirectory = Util.MakeLongPath(context.TestDir); longPathRoot = longPathDirectory.Substring(0, context.TestDir.Length + 1 + longPathDirectory.Substring(context.TestDir.Length + 1).IndexOf('\\')); Directory.CreateDirectory(longPathDirectory); Debug.Assert(Directory.Exists(longPathDirectory)); }
public void Queryable_AsNoTracking() { TestContext.DeleteAll(x => x.Entity_Basics); TestContext.Insert(x => x.Entity_Basics, 10); using (var ctx = new TestContext()) { // BEFORE var futureValue1 = ctx.Entity_Basics.Where(x => x.ColumnInt < 5).OrderBy(x => x.ColumnInt).AsNoTracking().FutureValue(); var futureValue2 = ctx.Entity_Basics.Where(x => x.ColumnInt >= 5).OrderBy(x => x.ColumnInt).AsNoTracking().FutureValue(); // TEST: The batch contains 2 queries Assert.AreEqual(2, QueryFutureManager.AddOrGetBatch(ctx.GetObjectContext()).Queries.Count); var value = futureValue1.Value; // AFTER // TEST: The batch contains 0 queries Assert.AreEqual(0, QueryFutureManager.AddOrGetBatch(ctx.GetObjectContext()).Queries.Count); // TEST: The futureList1 has a value and the first item is returned Assert.IsTrue(futureValue1.HasValue); Assert.AreEqual(0, value.ColumnInt); // TEST: The futureList2 has a value and the first item is returned Assert.IsTrue(futureValue2.HasValue); Assert.AreEqual(5, futureValue2.Value.ColumnInt); // TEST: No entries has been loaded in the change tracker Assert.AreEqual(0, ctx.ChangeTracker.Entries().Count()); } }
internal static void TestNotReusedOnAssemblyDiffers(string projectLanguage) { var metadataSources = new[] { @"[assembly: System.Reflection.AssemblyVersion(""1.0.0.0"")] public class D {}", @"[assembly: System.Reflection.AssemblyVersion(""2.0.0.0"")] public class D {}" }; using (var context = new TestContext(projectLanguage)) { var projectId = ProjectId.CreateNewId(); var metadataProject = context.CurrentSolution .AddProject(projectId, "Metadata", "Metadata", LanguageNames.CSharp).GetProject(projectId) .AddMetadataReference(TestReferences.NetFx.v4_0_30319.mscorlib) .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release)); var references = new List<MetadataReference>(); foreach (var source in metadataSources) { var newDoc = metadataProject.AddDocument("MetadataSource", source); metadataProject = newDoc.Project; references.Add(MetadataReference.CreateFromImage(metadataProject.GetCompilationAsync().Result.EmitToArray())); metadataProject = metadataProject.RemoveDocument(newDoc.Id); } var project = context.DefaultProject.AddMetadataReference(references[0]); var a = context.GenerateSource("D", project); project = project.RemoveMetadataReference(references[0]).AddMetadataReference(references[1]); var b = context.GenerateSource("D", project); context.VerifyDocumentNotReused(a, b); } }
public static void IntializeAssembly(TestContext ctx) { // 根据配置文件中的设置来设置 // 测试数据库 DatabaseTestClass.TestService.DeployDatabaseProject(); DatabaseTestClass.TestService.GenerateData(); }
public void Single_Executor() { TestContext.DeleteAll(x => x.Association_OneToMany_Lefts); TestContext.DeleteAll(x => x.Association_OneToMany_Rights); using (var ctx = new TestContext()) { var left = TestContext.Insert(ctx, x => x.Association_OneToMany_Lefts, 1).First(); left.Rights = TestContext.Insert(ctx, x => x.Association_OneToMany_Rights, 5); ctx.SaveChanges(); } using (var ctx = new TestContext()) { var item = ctx.Association_OneToMany_Lefts.IncludeQuery(left => left.Rights.Where(x => x.ColumnInt > 2)).First(); // TEST: context Assert.AreEqual(3, ctx.ChangeTracker.Entries().Count()); // TEST: right Assert.AreEqual(2, item.Rights.Count); if (item.Rights[0].ColumnInt == 3) { Assert.AreEqual(3, item.Rights[0].ColumnInt); Assert.AreEqual(4, item.Rights[1].ColumnInt); } else { Assert.AreEqual(4, item.Rights[0].ColumnInt); Assert.AreEqual(3, item.Rights[1].ColumnInt); } } }
public void Queryable_AsTracking() { TestContext.DeleteAll(x => x.Entity_Basics); TestContext.Insert(x => x.Entity_Basics, 10); using (var ctx = new TestContext()) { // BEFORE var cacheCountBefore = QueryFutureManager.Cache.Count(); var futureValue1 = ctx.Entity_Basics.Where(x => x.ColumnInt < 5).OrderBy(x => x.ColumnInt).FutureValue(); var futureValue2 = ctx.Entity_Basics.Where(x => x.ColumnInt >= 5).OrderBy(x => x.ColumnInt).FutureValue(); // TEST: The cache count are NOT equal (A new context has been added) Assert.AreEqual(cacheCountBefore + 1, QueryFutureManager.Cache.Count()); var value = futureValue1.Value; // AFTER // TEST: The cache count are equal (The new context has been removed) Assert.AreEqual(cacheCountBefore, QueryFutureManager.Cache.Count()); // TEST: The futureList1 has a value and the first item is returned Assert.IsTrue(futureValue1.HasValue); Assert.AreEqual(0, value.ColumnInt); // TEST: The futureList2 has a value and the first item is returned Assert.IsTrue(futureValue2.HasValue); Assert.AreEqual(5, futureValue2.Value.ColumnInt); // TEST: The first item of both FutureValue has been added Assert.AreEqual(2, ctx.ChangeTracker.Entries().Count()); } }
public static void Initialize(TestContext context) { Connection.DisableServerCertValidation = true; // uncomment the following to write frame traces //Trace.TraceLevel = TraceLevel.Frame; //Trace.TraceListener = (f, a) => System.Diagnostics.Trace.WriteLine(DateTime.Now.ToString("[hh:ss.fff]") + " " + string.Format(f, a)); }
public Task Test (TestContext ctx, CancellationToken cancellationToken, InstrumentationConnectionProvider provider, GenericConnectionInstrumentParameters parameters, GenericConnectionInstrumentTestRunner runner) { return runner.Run (ctx, cancellationToken); }
internal static void GenerateAndVerifySource(string metadataSource, string symbolName, string projectLanguage, string expected, bool compareTokens = true, bool includeXmlDocComments = false) { using (var context = new TestContext(projectLanguage, SpecializedCollections.SingletonEnumerable(metadataSource), includeXmlDocComments)) { context.GenerateAndVerifySource(symbolName, expected, compareTokens); } }
public void IncludeEntityAdded_IsFalse() { TestContext.DeleteAll(x => x.AuditEntries); TestContext.DeleteAll(x => x.Entity_Basics); TestContext.Insert(x => x.Entity_Basics, 2); var audit = AuditHelper.AutoSaveAudit(); audit.Configuration.IncludeEntityAdded = false; using (var ctx = new TestContext()) { var list = ctx.Entity_Basics.OrderBy(x => x.ID).ToList(); // INSERT one TestContext.Insert(ctx, x => x.Entity_Basics, 1); // DELETE one ctx.Entity_Basics.Remove(list[0]); // UPDATE one list[1].ColumnInt++; ctx.SaveChanges(audit); } // UnitTest - Audit { var entries = audit.Entries; // Entries { // Entries Count Assert.AreEqual(2, entries.Count); // Entries State Assert.AreEqual(AuditEntryState.EntityModified, entries[0].State); Assert.AreEqual(AuditEntryState.EntityDeleted, entries[1].State); } } // UnitTest - Audit (Database) { using (var ctx = new TestContext()) { // ENSURE order var entries = ctx.AuditEntries.OrderBy(x => x.AuditEntryID).ToList(); // Entries { // Entries Count Assert.AreEqual(2, entries.Count); // Entries State Assert.AreEqual(AuditEntryState.EntityModified, entries[0].State); Assert.AreEqual(AuditEntryState.EntityDeleted, entries[1].State); } } } }
public Task Test_HTMLBinding_Stress_Collection_CreateBinding(JavascriptBindingMode imode, TestPerformanceKind context, TestContext ipath = TestContext.Index) { int r = 100; var datacontext = new TwoList(); datacontext.L1.AddRange(Enumerable.Range(0, r).Select(i => new Skill())); var stopWatch = new Stopwatch(); stopWatch.Start(); var test = new TestInContext() { Path = ipath, Bind = (win) => HTML_Binding.Bind(win, datacontext, imode), Test = (mb) => { stopWatch.Stop(); var ts = stopWatch.ElapsedMilliseconds; _Logger.Info($"Perf: {((double) (ts)) / 1000} sec for {r} iterations"); var js = mb.JSRootObject; var col = GetSafe(() => GetCollectionAttribute(js, "L1")); col.GetArrayLength().Should().Be(r); CheckVsExpectation(ts, context); } }; return RunAsync(test); }
public static System.Collections.Generic.HashSet <TestEntity> GetEntitiesWithMultipleEntityIndicesValue2(this TestContext context, string value2) { return(((JCMG.EntitasRedux.EntityIndex <TestEntity, string>)context.GetEntityIndex(Contexts.MultipleEntityIndicesValue2)).GetEntities(value2)); }
public static void Setup(TestContext context) { // Launch the Calculator app WindowTransformSession = Utility.CreateNewSession(CommonTestSettings.CalculatorAppId); Assert.IsNotNull(WindowTransformSession); }
public RegisterCheckSuccessSteps(TestContext context) : base(context) { }
public static void ClassInitialize(TestContext c) { }
public static void ClassInitialize(TestContext context) { GraphBrowser.Initialize(); }
public static void ClassInitialize(TestContext context) { _testDIContext = TestDIContextFactory.CreateDefaultContext(); }
public static void Init(TestContext context) { Reusable.Logging.LoggerFactory.Initialize <Reusable.Logging.Adapters.NLogFactory>(); }
public static void ClassInit(TestContext context) { }
public static void ClassInitialize(TestContext a) { _mockClient = new Mock <AmazonStepFunctionsClient>("access key", "secret", Amazon.RegionEndpoint.USEast1); }
public static System.Collections.Generic.HashSet <TestEntity> GetEntitiesWithPosition2(this TestContext context, EntitasRedux.Tests.IntVector2 position, EntitasRedux.Tests.IntVector2 size) { return(((EntitasRedux.Tests.MyCustomEntityIndex)(context.GetEntityIndex(Contexts.EntitasReduxTestsMyCustomEntityIndex))).GetEntitiesWithPosition2(position, size)); }
public static void Setup(TestContext context) { BaseSetup(context); }
public static void ClassInitialize(TestContext context) { PtfTestClassBase.Initialize(context); }
public static void AssemblyInit(TestContext context) { AssertFailureExceptionFactory.ConfigureForMicrosoftTest(); TestSetupHelpers.CleanupProcess(WebSec.Common.Constants.ChromeDriver); TestSetupHelpers.StartIisExpress(); }
public static void SuiteSetUp(TestContext testContext) { testFile1 = WriteStreamToTempFile("emergency-backup.log"); testFile2 = WriteStreamToTempFile("empty.txt"); testFile3 = WriteStreamToTempFile("binary.jar"); }
private void RegisterHearingServices(TestContext context) { context.Config.ServicesConfiguration = Options.Create(_configRoot.GetSection("Services").Get <ServicesConfiguration>()).Value; context.Config.ServicesConfiguration.BookingsApiResourceId.Should().NotBeNullOrEmpty(); }
public static void Initialize(TestContext context) { _zapClient = new ClientApi(_zapUrl, _zapPort, _zapApiKey); }
private static void RegisterApiSettings(TestContext context) { context.Response = new HttpResponseMessage(); }
private void RegisterTestSettings(TestContext context) { context.Config.TestSettings = Options.Create(_configRoot.GetSection("Testing").Get <TestSettings>()).Value; ConfigurationManager.VerifyConfigValuesSet(context.Config.TestSettings); }
Task ITestMethodLifecycle.OnTestEndAsync(TestContext context, Exception exception, CancellationToken cancellationToken) { return(Task.CompletedTask); }
public ConfigHooks(TestContext context) { _configRoot = ConfigurationManager.BuildConfig("D76B6EB8-F1A2-4A51-9B8F-21E1B6B81E4F"); context.Config = new Config(); context.UserAccounts = new List <UserAccount>(); }
public static void Initialize(TestContext textContext) { DocumentClientSwitchLinkExtension.Reset("HeadersValidationTests"); }
public static void DoDeployment(TestContext context) { AssertListener.Initialize(); }
public static void ClassInitialize(TestContext testContext) { TestEnvironment.Initialize(testContext); }
Task ITestMethodLifecycle.OnTestStartAsync(TestContext context, CancellationToken cancellationToken) { Context = context; return(Task.CompletedTask); }
public static void Intialize(TestContext context) { imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false); }
public static void ClassInit(TestContext testContext) { _testContext = testContext; }
public async Task BeforeAllAsync() { await Profiler.Run( async() => { // Set up logging LogEventLevel consoleLevel = Context.Current.Verbose ? LogEventLevel.Verbose : LogEventLevel.Information; var loggerConfig = new LoggerConfiguration() .MinimumLevel.Verbose() .WriteTo.NUnit(consoleLevel); Context.Current.LogFile.ForEach(f => loggerConfig.WriteTo.File(f)); Log.Logger = loggerConfig.CreateLogger(); // Install IoT Edge using (var cts = new CancellationTokenSource(Context.Current.SetupTimeout)) { // NUnit's [Timeout] attribute isn't supported in .NET Standard // and even if it were, it doesn't run the teardown method when // a test times out. We need teardown to run, to remove the // device registration from IoT Hub and stop the daemon. So // we have our own timeout mechanism. DateTime startTime = DateTime.Now; CancellationToken token = cts.Token; Assert.IsNull(this.device); this.device = await EdgeDevice.GetOrCreateIdentityAsync( Context.Current.DeviceId, this.iotHub, token); await this.daemon.UninstallAsync(token); await this.daemon.InstallAsync( this.device.ConnectionString, Context.Current.PackagePath, Context.Current.Proxy, token); try { await this.daemon.WaitForStatusAsync(EdgeDaemonStatus.Running, token); var agent = new EdgeAgent(this.device.Id, this.iotHub); await agent.WaitForStatusAsync(EdgeModuleStatus.Running, token); await agent.PingAsync(token); } // ReSharper disable once RedundantCatchClause catch { throw; } finally { string prefix = $"{Context.Current.DeviceId}-{TestContext.CurrentContext.Test.NormalizedName()}"; IEnumerable <string> paths = await EdgeLogs.CollectAsync(startTime, prefix, token); foreach (string path in paths) { TestContext.AddTestAttachment(path); } } } }, "Completed end-to-end test setup"); }
public static void Init(TestContext context) { SubscribeToUnhandledExceptions(context, true); }
public static void ClassInit(TestContext context) { mapper = AutoMapperHelper.RunCreateMaps(); }
public static new void ClassInitialize(TestContext testContext) { TestSuiteBase.ClassInitialize(testContext); }