public void ToolkitLoggingWorks() { using (TestTraceListener log = new TestTraceListener()) { Platform.Connect(); Platform.Disconnect(); Assert.IsTrue(log.Contains("GameGuts Toolkit"), "Toolkit connection messages missing from trace log"); } }
static AssemblyWeaver() { TestListener = new TestTraceListener(); Debug.Listeners.Clear(); Debug.Listeners.Add(TestListener); BeforeAssemblyPath = Path.GetFullPath(@"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll"); var beforePdbPath = Path.ChangeExtension(BeforeAssemblyPath, "pdb"); #if (!DEBUG) BeforeAssemblyPath = BeforeAssemblyPath.Replace("Debug", "Release"); beforePdbPath = beforePdbPath.Replace("Debug", "Release"); #endif AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll"); var afterPdbPath = beforePdbPath.Replace(".pdb", "2.pdb"); AfterAssembly2Path = BeforeAssemblyPath.Replace(".dll", "3.dll"); var afterPdb2Path = beforePdbPath.Replace(".pdb", "3.pdb"); Assembly = WeaveAssembly(AfterAssemblyPath, beforePdbPath, afterPdbPath, moduleDefinition => { var assemblyResolver = new MockAssemblyResolver(); var weavingTask = new ModuleWeaver { ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver, LogError = LogError, DefineConstants = new List<string> { "DEBUG" } // Always testing the debug weaver }; weavingTask.Execute(); }); Assembly2 = WeaveAssembly(AfterAssembly2Path, beforePdbPath, afterPdb2Path, moduleDefinition => { var assemblyResolver = new MockAssemblyResolver(); var weavingTask = new ModuleWeaver { Config = new XElement("NullGuard", new XAttribute("IncludeDebugAssert", false), new XAttribute("ExcludeRegex", "^ClassToExclude$")), ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver, LogError = LogError, DefineConstants = new List<string> { "DEBUG" } // Always testing the debug weaver }; weavingTask.Execute(); }); }
static AssemblyWeaver() { TestListener = new TestTraceListener(); Debug.Listeners.Clear(); Debug.Listeners.Add(TestListener); BeforeAssemblyPath = Path.GetFullPath(@"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll"); var beforePdbPath = Path.ChangeExtension(BeforeAssemblyPath, "pdb"); #if (!DEBUG) BeforeAssemblyPath = BeforeAssemblyPath.Replace("Debug", "Release"); beforePdbPath = beforePdbPath.Replace("Debug", "Release"); #endif AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll"); var afterPdbPath = beforePdbPath.Replace(".pdb", "2.pdb"); File.Copy(BeforeAssemblyPath, AfterAssemblyPath, true); if (File.Exists(beforePdbPath)) { File.Copy(beforePdbPath, afterPdbPath, true); } var assemblyResolver = new MockAssemblyResolver(); var readerParameters = new ReaderParameters(); var writerParameters = new WriterParameters(); if (File.Exists(afterPdbPath)) { readerParameters.ReadSymbols = true; writerParameters.WriteSymbols = true; } var moduleDefinition = ModuleDefinition.ReadModule(AfterAssemblyPath, readerParameters); var weavingTask = new ModuleWeaver { ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver, LogError = LogError, DefineConstants = new List <string> { "DEBUG" } // Always testing the debug weaver }; weavingTask.Execute(); moduleDefinition.Write(AfterAssemblyPath, writerParameters); Assembly = Assembly.LoadFile(AfterAssemblyPath); }
public void Build_Executable() { // Register the test systems var testListener = new TestTraceListener(); using (var scopedTraceListener = new ScopedTraceListenerRegister(testListener)) { // Setup the input build state var buildState = new MockBuildState(); var state = buildState.ActiveState; state.Add("PlatformLibraries", new Value(new ValueList())); state.Add("PlatformIncludePaths", new Value(new ValueList())); state.Add("PlatformLibraryPaths", new Value(new ValueList())); state.Add("PlatformPreprocessorDefinitions", new Value(new ValueList())); // Setup recipe table var buildTable = new ValueTable(); state.Add("Recipe", new Value(buildTable)); buildTable.Add("Name", new Value("Program")); // Setup parameters table var parametersTable = new ValueTable(); state.Add("Parameters", new Value(parametersTable)); parametersTable.Add("TargetDirectory", new Value("C:/Target/")); parametersTable.Add("PackageDirectory", new Value("C:/PackageRoot/")); parametersTable.Add("Compiler", new Value("MOCK")); parametersTable.Add("Flavor", new Value("debug")); var factory = new ValueFactory(); var uut = new RecipeBuildTask(buildState, factory); uut.Execute(); // Verify expected logs Assert.Equal( new List <string>() { }, testListener.GetMessages()); // Verify build state var expectedBuildOperations = new List <BuildOperation>(); Assert.Equal( expectedBuildOperations, buildState.GetBuildOperations()); // TODO: Verify output build state } }
// Use ClassCleanup to run code after all tests in a class have run // [ClassCleanup()] // public static void MyClassCleanup() { } // // Use TestInitialize to run code before running each test // [TestInitialize()] // public void MyTestInitialize() { } // // Use TestCleanup to run code after each test has run // [TestCleanup()] // public void MyTestCleanup() { } // #endregion void RunTest( Action <ITestCalls> test, string resolveName, string expected) { var target = DIContainer.Root.Resolve <ITestCalls>(resolveName); test(target); var actual = string.Join("\r\n", TestTraceListener.Messages); TestTraceListener.Reset(); Assert.AreEqual(expected, actual); }
public TestSourceContext(string sourceName) { if (!string.IsNullOrEmpty(sourceName)) { source = new TraceSource(sourceName); listener = source.Listeners.OfType <TestTraceListener>().First(); listener.MethodCallInformation.Clear(); } else { listener = Trace.Listeners.OfType <TestTraceListener>().First(); listener.MethodCallInformation.Clear(); } }
public override void Test() { TestTraceListener t = new TestTraceListener(); Trace.Clear(); Trace.AddListener(t); Linn.Trace.Level = Linn.Trace.kAll; Linn.Trace.Write(Linn.Trace.kTest, "TestString"); TEST(t.Msg == "TestString"); Linn.Trace.Write(Linn.Trace.kTest, new TestObject()); TEST(t.Msg == "TestObject"); Linn.Trace.WriteLine(Linn.Trace.kTest, "TestString"); TEST(t.Msg == "TestString\n"); Linn.Trace.WriteLine(Linn.Trace.kTest, new TestObject()); TEST(t.Msg == "TestObject\n"); // different trace levels t.Msg = null; Linn.Trace.Level = Linn.Trace.kNone; Linn.Trace.Write(Linn.Trace.kTest, "TestString"); TEST(t.Msg == null); Linn.Trace.Write(Linn.Trace.kTest, new TestObject()); TEST(t.Msg == null); Linn.Trace.WriteLine(Linn.Trace.kTest, "TestString"); TEST(t.Msg == null); Linn.Trace.WriteLine(Linn.Trace.kTest, new TestObject()); TEST(t.Msg == null); Linn.Trace.Level = Linn.Trace.kUpnp; Linn.Trace.Write(Linn.Trace.kTest, "TestString"); TEST(t.Msg == null); Linn.Trace.Write(Linn.Trace.kTest, new TestObject()); TEST(t.Msg == null); Linn.Trace.WriteLine(Linn.Trace.kTest, "TestString"); TEST(t.Msg == null); Linn.Trace.WriteLine(Linn.Trace.kTest, new TestObject()); TEST(t.Msg == null); Linn.Trace.Write(Linn.Trace.kUpnp, "TestString"); TEST(t.Msg == "TestString"); Linn.Trace.Write(Linn.Trace.kUpnp, new TestObject()); TEST(t.Msg == "TestObject"); Linn.Trace.WriteLine(Linn.Trace.kUpnp, "TestString"); TEST(t.Msg == "TestString\n"); Linn.Trace.WriteLine(Linn.Trace.kUpnp, new TestObject()); TEST(t.Msg == "TestObject\n"); }
static AssemblyWeaver() { TestListener = new TestTraceListener(); Debug.Listeners.Clear(); Debug.Listeners.Add(TestListener); BeforeAssemblyPath = Path.GetFullPath(@"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll"); var beforePdbPath = Path.ChangeExtension(BeforeAssemblyPath, "pdb"); #if (!DEBUG) BeforeAssemblyPath = BeforeAssemblyPath.Replace("Debug", "Release"); beforePdbPath = beforePdbPath.Replace("Debug", "Release"); #endif AfterAssemblyPath = BeforeAssemblyPath.Replace(".dll", "2.dll"); var afterPdbPath = beforePdbPath.Replace(".pdb", "2.pdb"); File.Copy(BeforeAssemblyPath, AfterAssemblyPath, true); if (File.Exists(beforePdbPath)) File.Copy(beforePdbPath, afterPdbPath, true); var assemblyResolver = new MockAssemblyResolver(); var readerParameters = new ReaderParameters(); var writerParameters = new WriterParameters(); if (File.Exists(afterPdbPath)) { readerParameters.ReadSymbols = true; writerParameters.WriteSymbols = true; } var moduleDefinition = ModuleDefinition.ReadModule(AfterAssemblyPath, readerParameters); var weavingTask = new ModuleWeaver { ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver, LogError = LogError, DefineConstants = new List<string> { "DEBUG" } // Always testing the debug weaver }; weavingTask.Execute(); moduleDefinition.Write(AfterAssemblyPath, writerParameters); Assembly = Assembly.LoadFile(AfterAssemblyPath); }
#pragma warning restore CA1032, CA1064 // Exceptions should be public. Implement standard exception constructors private static string GetTraceMessage(Action action) { var ttl = new TestTraceListener(); Trace.Listeners.Add(ttl); try { action(); } finally { Trace.Listeners.Remove(ttl); } var msg = ttl.LastMessage; return(msg); }
public void ListExternalParameters() { var runcli = new RunCliAction { ListExternal = true, TestPlanPath = planFile, NonInteractive = true }; var plan = new TestPlan(); var step = new ProcessStep() { LogHeader = null, // test that the log header is a null string. Application = "tap.exe" // test that application is a non-null string. }; plan.ChildTestSteps.Add(step); var stepType = TypeData.GetTypeData(step); stepType.GetMember(nameof(step.LogHeader)).Parameterize(plan, step, "log-header"); stepType.GetMember(nameof(step.Timeout)).Parameterize(plan, step, "timeout"); stepType.GetMember(nameof(step.WaitForEnd)).Parameterize(plan, step, "wait-for-end"); stepType.GetMember(nameof(step.VerdictOnMatch)).Parameterize(plan, step, "match-verdict"); stepType.GetMember(nameof(step.Application)).Parameterize(plan, step, "application"); plan.Save(planFile); var traceListener = new TestTraceListener(); Log.AddListener(traceListener); try { var exitCode = runcli.Execute(CancellationToken.None); Assert.AreEqual(0, exitCode); Log.Flush(); var log = traceListener.allLog.ToString(); StringAssert.Contains("Listing 5 External Test Plan Parameters", log); StringAssert.Contains("application = tap.exe", log); StringAssert.Contains("log-header = ", log); StringAssert.Contains("wait-for-end = True", log); StringAssert.Contains("match-verdict = Pass", log); } finally { Log.RemoveListener(traceListener); File.Delete(planFile); } }
public void Trace_output_indicates_the_resolved_source_for_the_settings() { string log = ""; Settings.Precedence = new[] { "nonexistent", "test", "production" }; var listener = new TestTraceListener(); listener.OnTrace += (Action <string>)(s => log += s); Trace.Listeners.Add(listener); using (new AnonymousDisposable(() => Trace.Listeners.Remove(listener))) { Settings.Get <EnvironmentSettings>(); } log.Should().Contain(string.Format("Resolved setting 'EnvironmentSettings' from settings folder ({0})", Path.Combine(Deployment.Directory, ".config", "test"))); }
public void Log_to_trace() { var sut = new TraceLogger(); using (var traceListener = new TestTraceListener { ActiveTraceLevel = TraceLevel.Verbose }) { foreach (MessageLevel messageLevel in Enum.GetValues(typeof(MessageLevel))) { var traceLevel = messageLevel.ToTraceLevel(); var message = $"message: {messageLevel} - {traceLevel}"; sut.Log(messageLevel, message); traceListener.MessagesFor(traceLevel).Should().Contain(message); } } }
public void LoggedTypeWithLogDebugWillWriteToLog() { var listener = new TestTraceListener(); listener.ExpectCategory("[DEBUG]"); listener.ExpectOutput("[DEBUG] FluentBoilerplate.Tests.Runtime.Providers.Logging.LogProviderTests+Debug.DebugTest = System.String \"Test Value\""); Trace.Listeners.Add(listener); var instance = new DebugTest { Value = "TestValue" }; this.provider.Debug("Test message", instance); listener.ReadTrace.Should().BeTrue("because we should have received a log message"); }
public void Only_install_dependencies_matching_target_framework(string thisGroup, string otherGroup) { var context = new ContextFor <NuPlugPackageManager>(); var sut = context.BuildSut(); var targetFramework = VersionUtility.ParseFrameworkName(thisGroup); var otherFramework = VersionUtility.ParseFrameworkName(otherGroup); var package = "foo".CreatePackage("0.1.0"); var dependency = "bar".CreatePackage("0.1.1"); var otherDependency = "buzz".CreatePackage("0.1.2"); var deps = new[] { new PackageDependencySet(targetFramework, new[] { new PackageDependency(dependency.Id) }), new PackageDependencySet(otherFramework, new[] { new PackageDependency(otherDependency.Id) }) }; package.DependencySets.Returns(deps); var localPackages = Enumerable.Empty <IPackage>(); sut.LocalRepository.GetPackages().Returns(localPackages.AsQueryable()); var remotePackages = new[] { package, dependency, otherDependency }; sut.SourceRepository.GetPackages().Returns(remotePackages.AsQueryable()); //repo sut.Logger = new TraceLogger(); using (var ttl = new TestTraceListener()) { sut.InstallPackage(package, false, false); var infos = ttl.MessagesFor(TraceLevel.Info); infos.Should().BeEquivalentTo( $"Attempting to resolve dependency '{dependency.Id}'.", $"Installing '{dependency.Id} {dependency.Version}'.", $"Successfully installed '{dependency.Id} {dependency.Version}'.", $"Installing '{package.Id} {package.Version}'.", $"Successfully installed '{package.Id} {package.Version}'."); } package.Received().GetCompatiblePackageDependencies(targetFramework); sut.SourceRepository.Received().GetPackages(); }
/// <summary> /// Starts the IPC server for the Integration Test service. /// </summary> private void StartServiceCallback(object sender, EventArgs e) { if (_startMenuCmd.Enabled) { AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainAssemblyResolve; TestTraceListener.Install(); _service = new IntegrationService(); _serviceChannel = new IpcServerChannel( name: $"Microsoft.VisualStudio.IntegrationTest.ServiceChannel_{Process.GetCurrentProcess().Id}", portName: _service.PortName, sinkProvider: DefaultSinkProvider ); var serviceType = typeof(IntegrationService); _marshalledService = RemotingServices.Marshal(_service, serviceType.FullName, serviceType); _serviceChannel.StartListening(null); // Async initialization is a workaround for deadlock loading ExtensionManagerPackage prior to // https://devdiv.visualstudio.com/DevDiv/_git/VSExtensibility/pullrequest/381506 _ = Task.Run(async() => { var componentModel = (IComponentModel?)await AsyncServiceProvider.GlobalProvider.GetServiceAsync(typeof(SComponentModel)).ConfigureAwait(false); Assumes.Present(componentModel); var asyncCompletionTracker = componentModel.GetService <AsyncCompletionTracker>(); asyncCompletionTracker.StartListening(); #pragma warning disable RS0030 // Do not used banned APIs await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); #pragma warning restore RS0030 // Do not used banned APIs var listenerProvider = componentModel.GetService <IAsynchronousOperationListenerProvider>(); s_runningDocTableEventListener = new RunningDocumentTableEventListener(listenerProvider.GetListener(FeatureAttribute.Workspace)); ErrorHandler.ThrowOnFailure(_runningDocumentTable.AdviseRunningDocTableEvents(s_runningDocTableEventListener, out s_runningDocTableEventListenerCookie)); }); SwapAvailableCommands(_startMenuCmd, _stopMenuCmd); } }
public void RunCompositeCloseWhileRunning() { TestTraceListener trace = new TestTraceListener(); Log.AddListener(trace); TestPlan target = getTestTestPlan(); var t1 = Task.Factory.StartNew(() => target.Execute()); try { Thread.Sleep(30); Assert.Throws(typeof(InvalidOperationException), target.Close); } finally { Log.RemoveListener(trace); t1.Wait(); } }
public void Ignore_Walk_info_by_default() { var context = new ContextFor <NuPlugPackageManager>(); var sut = context.BuildSut(); sut.DisableWalkInfo.Should().BeTrue(); var package = "foo".CreatePackage("0.1.0"); sut.Logger = new TraceLogger(); using (var tl = new TestTraceListener()) { sut.InstallPackage(package, false, true); var infos = tl.MessagesFor(TraceLevel.Info); infos.Should().BeEquivalentTo( $"Installing '{package.Id} {package.Version}'.", $"Successfully installed '{package.Id} {package.Version}'."); } }
public void RunCompositeRunTwice() { TestTraceListener trace = new TestTraceListener(); Log.AddListener(trace); TestPlan target = getTestTestPlan(); target.Open(); target.Execute(); target.Execute(); target.Close(); Log.RemoveListener(trace); trace.AssertErrors(); TestTestStep step = target.Steps[0] as TestTestStep; Assert.AreEqual(2, step.PrePlanRunCount, "PrePlanRun was not called the correct number of times."); Assert.AreEqual(2, step.PostPlanRunCount, "PostPlanRun was not called the correct number of times."); }
public void RunCompositeMetaData() { PlanRunCollectorListener listener = new PlanRunCollectorListener(); ResultSettings.Current.Add(listener); TestTraceListener trace = new TestTraceListener(); Log.AddListener(trace); TestPlan target = getTestTestPlan(); TestPlanRun run = target.Execute(); Log.RemoveListener(trace); ResultSettings.Current.Remove(listener); Assert.IsTrue(run.Parameters.Any(par => par.Value.ToString() == "Test Instrument")); Assert.IsFalse(run.Parameters.Any(par => par.Name == "Comment")); }
public async Task Should_CheckSchemaAgreementReturnTrueAndSchemaInAgreementReturnTrue_When_AllNodesUp() { var listener = new TestTraceListener(); var level = Diagnostics.CassandraTraceSwitch.Level; Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Verbose; Trace.Listeners.Add(listener); try { if (_paused) { TestCluster.ResumeNode(2); } //// this test can't be done with simulacron because there's no support for schema_changed responses var tableName = TestUtils.GetUniqueTableName().ToLower(); var cql = new SimpleStatement( $"CREATE TABLE {tableName} (id int PRIMARY KEY, description text)"); var rowSet = await _session.ExecuteAsync(cql).ConfigureAwait(false); Assert.IsTrue(rowSet.Info.IsSchemaInAgreement, "is in agreement"); await TestHelper.RetryAssertAsync( async() => { Assert.IsTrue(await _cluster.Metadata.CheckSchemaAgreementAsync().ConfigureAwait(false), "check"); }, 100, 50).ConfigureAwait(false); } catch (Exception ex) { Trace.Flush(); Assert.Fail("Exception: " + ex.ToString() + Environment.NewLine + string.Join(Environment.NewLine, listener.Queue.ToArray())); } finally { Trace.Listeners.Remove(listener); Diagnostics.CassandraTraceSwitch.Level = level; } }
public void Ignore_AlreadyInstalled_Packages() { var context = new ContextFor <NuPlugPackageManager>(); var packageLookup = Substitute.For <IPackageLookup>(); var packageRegistry = new NuPlugPackageRegistry(); var localRepo = new NuPlugPackageRepository(packageLookup, packageRegistry); var sut = context.BuildSut(); var foo = "foo".CreatePackage("0.1.0"); var bar = "bar".CreatePackage("2.9.0"); var versionSpec = new VersionSpec(SemanticVersion.Parse("2.6.0")) { MaxVersion = null }; var deps = new[] { new PackageDependencySet(sut.TargetFramework, new[] { new PackageDependency(bar.Id, versionSpec) }) }; foo.DependencySets.Returns(deps); localRepo.AddPackage(new NullPackage(bar.Id, bar.Version)); var remotePackages = new[] { foo }; sut.SourceRepository.GetPackages().Returns(remotePackages.AsQueryable()); sut.SetLocalRepository(localRepo); sut.Logger = new TraceLogger(); using (var tl = new TestTraceListener()) { sut.InstallPackage(foo, false, true); var infos = tl.MessagesFor(TraceLevel.Info); infos.Should().BeEquivalentTo( $"Attempting to resolve dependency '{bar.Id} (≥ {versionSpec.MinVersion})'.", //$"{bar.Id} already installed.", $"Installing '{foo.Id} {foo.Version}'.", $"Successfully installed '{foo.Id} {foo.Version}'." ); } }
public void Should_ResetErrorCounterForLogging_When_ThereSendMessageIsSuccessful() { _listener = new TestTraceListener(); Trace.Listeners.Add(_listener); Cassandra.Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Verbose; var cluster = GetCluster(false); var session = GetSession(cluster); using (var target = InsightsClientTests.GetInsightsClient(cluster, session)) { Expression <Func <IControlConnection, Task <Response> > > mockExpression = cc => cc.UnsafeSendQueryRequestAsync( "CALL InsightsRpc.reportInsight(?)", It.IsAny <QueryProtocolOptions>()); Mock.Get(cluster.Metadata.ControlConnection) .SetupSequence(mockExpression) .ReturnsAsync((Response)null) .ReturnsAsync(new FakeResultResponse(ResultResponse.ResultResponseKind.Void)) .ReturnsAsync((Response)null) .ReturnsAsync((Response)null) .ReturnsAsync(new FakeResultResponse(ResultResponse.ResultResponseKind.Void)) .ReturnsAsync((Response)null); target.Init(); TestHelper.RetryAssert( () => { Mock.Get(cluster.Metadata.ControlConnection).Verify(mockExpression, Times.AtLeast(20)); }, 30); Trace.Flush(); Assert.AreEqual(8, _listener.Queue.Count, string.Join(" ; ", _listener.Queue.ToArray())); var messages = _listener.Queue.ToArray(); Assert.AreEqual(messages.Count(m => m.Contains("Could not send insights startup event. Exception:")), 1); Assert.AreEqual(messages.Count(m => m.Contains("Could not send insights status event. Exception:")), 7); } }
public void CreateOperation_Access_WriteAccessRelative_SubFolder() { // Register the test listener var testListener = new TestTraceListener(); using var scopedTraceListener = new ScopedTraceListenerRegister(testListener); var fileSystemState = new FileSystemState(); var readAccessList = new List <Path>() { new Path("C:/WorkingDir/ReadAccess/") }; var writeAccessList = new List <Path>() { new Path("C:/WorkingDir/WriteAccess/") }; var uut = new OperationGraphGenerator(fileSystemState, readAccessList, writeAccessList); uut.CreateOperation( "Do Stuff", new Path("DoStuff.exe"), "do stuff", new Path("C:/WorkingDir/"), new List <Path>(), new List <Path>() { new Path("./WriteAccess/SubFolder/WriteFile.txt"), }); // Verify expected logs Assert.Equal( new List <string>() { "DIAG: Create Operation: Do Stuff", "DIAG: Read Access Subset:", "DIAG: Write Access Subset:", "DIAG: C:/WorkingDir/WriteAccess/", }, testListener.GetMessages()); }
public async Task Should_NotLogMultipleAddressesWarning_When_SingleAddressIsResolved() { var testListener = new TestTraceListener(); Trace.Listeners.Add(testListener); var level = Diagnostics.CassandraTraceSwitch.Level; Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Verbose; try { var target = Create("cp1", "127.0.0.2"); var resolved = (await target.GetConnectionEndPointsAsync(false).ConfigureAwait(false)).ToList(); Assert.AreEqual(1, resolved.Count); Assert.AreEqual(0, testListener.Queue.Count); } finally { Diagnostics.CassandraTraceSwitch.Level = level; Trace.Listeners.Remove(testListener); } }
public void Resolve_assemblies(Type typeToResolve) { using (var sut = new AssemblyResolver { TraceAlways = true }) using (var ttl = new TestTraceListener { ActiveTraceLevel = TraceLevel.Verbose }) { var assembly = typeToResolve.Assembly; var dir = assembly.GetDirectory(); sut.Directories.Add(dir); var requesting = typeof(AssemblyResolver_Should).Assembly; var aName = assembly.GetName(); var resolvedAssembly = sut.ResolveAssembly(this, new ResolveEventArgs(aName.Name, requesting)); resolvedAssembly.GetName().Name.Should().Be(aName.Name); var msgs = ttl.MessagesFor(TraceLevel.Verbose).ToArray(); msgs[0].Should().Be($"Requested to load '{aName.Name}' by '{requesting.FullName}'."); msgs[1].Should().StartWith($"Resolved '{aName.Name}, {aName.Version}' from '{assembly.GetLocation()}"); } }
public void RunCompositeMetaData2() { PlanRunCollectorListener listener = new PlanRunCollectorListener(); ResultSettings.Current.Add(listener); TestTraceListener trace = new TestTraceListener(); Log.AddListener(trace); TestPlan target = getTestTestPlan(); target.Open(); target.Execute(); target.Execute(); target.Close(); Log.RemoveListener(trace); ResultSettings.Current.Remove(listener); Assert.IsTrue(listener.PlanRuns.First().Parameters.Any(par => par.Value.ToString() == "Test Instrument")); Assert.AreEqual(1, listener.PlanRuns.Last().Parameters.Count(par => par.Value.ToString() == "Test Instrument")); }
private static void AssertCatch(Exception ex) { var throwingTypeFilter = (Func <Type, bool>)(type => { throw ex; #pragma warning disable 162 return(true); #pragma warning restore 162 }); var assembly = Assembly.GetExecutingAssembly(); using (var ttl = new TestTraceListener { ActiveTraceLevel = TraceLevel.Verbose }) { using (new SafeDirectoryCatalog(assembly.GetDirectory(), throwingTypeFilter)) ttl.MessagesFor(TraceLevel.Verbose).Should().OnlyContain(msg => msg.StartsWith("Could not load '")); ttl.MessagesFor(TraceLevel.Info).Should().BeEmpty("should only log at Verbose level"); } }
public async Task Should_ReusePreviousResolution_When_ResolveFails() { Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Info; var listener = new TestTraceListener(); Trace.Listeners.Add(listener); var result = Create(name: "proxyMultiple"); var target = result.EndPointResolver; var hostAddress = new IPEndPoint(IPAddress.Parse("163.10.10.10"), SniEndPointResolverTests.Port); var host = new Host(hostAddress); var hostId = Guid.NewGuid(); var row = BuildRow(hostId); host.SetInfo(row); var resolvedCollection = new List <IConnectionEndPoint>(); resolvedCollection.Add(await target.GetConnectionEndPointAsync(host, false).ConfigureAwait(false)); resolvedCollection.Add(await target.GetConnectionEndPointAsync(host, false).ConfigureAwait(false)); Assert.AreEqual(0, listener.Queue.Count); Mock.Get(result.DnsResolver).Verify(m => m.GetHostEntryAsync(It.IsAny <string>()), Times.Once); Mock.Get(result.DnsResolver).Setup(m => m.GetHostEntryAsync("proxyMultiple")).ThrowsAsync(new Exception()); await target.RefreshContactPointCache().ConfigureAwait(false); Mock.Get(result.DnsResolver).Verify(m => m.GetHostEntryAsync(It.IsAny <string>()), Times.Exactly(2)); Assert.AreEqual(1, listener.Queue.Count); Assert.IsTrue(listener.Queue.ToArray()[0].Contains( "Could not resolve endpoint \"proxyMultiple\". Falling back to the result of the previous DNS resolution.")); resolvedCollection.Add(await target.GetConnectionEndPointAsync(host, false).ConfigureAwait(false)); resolvedCollection.Add(await target.GetConnectionEndPointAsync(host, false).ConfigureAwait(false)); Assert.AreSame(resolvedCollection[0].SocketIpEndPoint, resolvedCollection[2].SocketIpEndPoint); Assert.AreSame(resolvedCollection[1].SocketIpEndPoint, resolvedCollection[3].SocketIpEndPoint); }
public void RunCompositeAddInstrumentAfterOpen() { PlanRunCollectorListener listener = new PlanRunCollectorListener(); ResultSettings.Current.Add(listener); TestTraceListener trace = new TestTraceListener(); Log.AddListener(trace); TestPlan target = getTestTestPlan(); target.Open(); TestInstrument instr = InstrumentSettings.Current.FirstOrDefault(i => i is TestInstrument && (i as TestInstrument).Name.EndsWith("2")) as TestInstrument; if (instr == null) { instr = new TestInstrument { Name = "Test Instrument 2" }; InstrumentSettings.Current.Add(instr); } (target.Steps[0] as TestTestStep).Instr = instr; target.Execute(); listener.StepRuns.Clear(); target.Execute(); target.Close(); Log.RemoveListener(trace); ResultSettings.Current.Remove(listener); Assert.AreEqual(2, listener.PlanRuns.Select(run => run.StartTimeStamp).Distinct().Count()); Assert.AreEqual(1, listener.StepRuns.Count()); }
public void SameAssemblyTwiceLoaded() { OpenTap.SessionLogs.Initialize("StartupLog.txt"); var trace = new TestTraceListener(); OpenTap.Log.AddListener(trace); Directory.CreateDirectory("PluginManager.Test"); string path1 = "twice.dll"; GeneratePluginAssembly(path1, "Test1"); string path2 = "PluginManager.Test\\twice.dll"; GeneratePluginAssembly(path2, "Test1"); try { var d = AppDomain.CurrentDomain; var assemblies = d.GetAssemblies().Where(asm => !asm.IsDynamic).Select(asm => Path.GetFileName(asm.Location)).ToList(); Assert.IsTrue(assemblies.Contains("twice.dll")); Log.Flush(); var all = trace.allLog.ToString(); int times = 0; foreach (var line in all.Split('\n')) { if (line.Contains("Warning") && line.Contains("Not loading") && line.Contains("twice.dll")) { times++; } } Assert.AreEqual(times, 1); } finally { DeleteFile(path1); //loaded dlls cannot be deleted... DeleteFile(path2); } }
/// <summary> /// Starts the IPC server for the Integration Test service. /// </summary> private void StartServiceCallback(object sender, EventArgs e) { if (_startMenuCmd.Enabled) { AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainAssemblyResolve; TestTraceListener.Install(); _service = new IntegrationService(); _serviceChannel = new IpcServerChannel( name: $"Microsoft.VisualStudio.IntegrationTest.ServiceChannel_{Process.GetCurrentProcess().Id}", portName: _service.PortName, sinkProvider: DefaultSinkProvider ); var serviceType = typeof(IntegrationService); _marshalledService = RemotingServices.Marshal(_service, serviceType.FullName, serviceType); _serviceChannel.StartListening(null); // Async initialization is a workaround for deadlock loading ExtensionManagerPackage prior to // https://devdiv.visualstudio.com/DevDiv/_git/VSExtensibility/pullrequest/381506 _ = ThreadHelper.JoinableTaskFactory.RunAsync(async() => { await TaskScheduler.Default; var componentModel = await AsyncServiceProvider.GlobalProvider.GetServiceAsync <SComponentModel, IComponentModel>().ConfigureAwait(false); Assumes.Present(componentModel); var asyncCompletionTracker = componentModel.GetService <AsyncCompletionTracker>(); asyncCompletionTracker.StartListening(); }); SwapAvailableCommands(_startMenuCmd, _stopMenuCmd); } }
public async Task Should_LogMultipleAddressesWarning_When_TwoAddressesAreResolved() { var testListener = new TestTraceListener(); Trace.Listeners.Add(testListener); var level = Diagnostics.CassandraTraceSwitch.Level; Diagnostics.CassandraTraceSwitch.Level = TraceLevel.Verbose; try { var target = Create("cp1", "127.0.0.2", "127.0.0.3"); var resolved = (await target.GetConnectionEndPointsAsync(false).ConfigureAwait(false)).ToList(); Assert.AreEqual(2, resolved.Count); Assert.AreEqual(1, testListener.Queue.Count(msg => msg.Contains( "Contact point 'cp1' resolved to multiple (2) addresses. " + "Will attempt to use them all if necessary: '127.0.0.2,127.0.0.3'"))); } finally { Diagnostics.CassandraTraceSwitch.Level = level; Trace.Listeners.Remove(testListener); } }
private HalfEdgeStructure CheckTraceAndGraph(Point[] points, string[] expected) { var myListener = new TestTraceListener(); try { Trace.Listeners.Add(myListener); var edgeGraph = VoroniBuilder.MakeDiagram(points); var theTrace = myListener.GetTrace(); //perhaps there are extra things in the trace. But we should have all of expected[] in order int i = 0; foreach (var actual in theTrace) { if (i >= expected.Length) break; if (actual.StartsWith(expected[i])) i++; } Assert.AreEqual(i, expected.Length); CheckEdgeGraph(edgeGraph); return edgeGraph; } finally { Trace.Listeners.Remove(myListener); } }
public void RunCompositeLogComparison() { // ## Fragile Test // If the settings directory has been loaded in the meantime // Log messages that new files are being created will appear on first run // ComponentSettings are lazily loaded so that first happens when the test plan runs. // We do one run to clear the state of the engine. { TestPlan target2 = getTestTestPlan(); Log.Flush(); target2.PrintTestPlanRunSummary = true; target2.Execute(); Log.Flush(); } TestTraceListener trace1 = new TestTraceListener(); Log.AddListener(trace1); TestPlan target = getTestTestPlan(); target.PrintTestPlanRunSummary = true; target.Execute(); Log.RemoveListener(trace1); TestTraceListener trace2 = new TestTraceListener(); Log.AddListener(trace2); target = getTestTestPlan(); target.PrintTestPlanRunSummary = true; target.Open(); target.Execute(); target.Close(); Log.RemoveListener(trace2); string allLog1 = trace1.allLog.ToString(); string allLog2 = trace2.allLog.ToString(); string[] log1Lines = filterLog(allLog1); string[] log2Lines = filterLog(allLog2); string[] log2LinesNoSpaces = filterLog(allLog2, true); Assert.AreEqual(log1Lines.Count() + 2, log2Lines.Count(), allLog1 + Environment.NewLine + "##########" + Environment.NewLine + allLog2); for (int i = 0; i < log1Lines.Length; i++) { var line = log1Lines[i].Replace(" ", ""); if (!log2LinesNoSpaces.Contains(line)) // We compare lines with removed spaces to avoid flakyness in CI. { // Print actual comparison data Console.WriteLine($"Could not find '{line}' in following logs:"); foreach (var linez in log2LinesNoSpaces) { Console.WriteLine($"{linez}"); } Console.WriteLine($"--------------- Printing logs without spaces removed ---------------"); // Print log data without their spaces removed Console.WriteLine($"First run logs:"); foreach (var linez in log1Lines) { Console.WriteLine($"- {linez}"); } Console.WriteLine($"Second run logs:"); foreach (var linez in log2Lines) { Console.WriteLine($"- {linez}"); } Assert.Fail($"The logs from two testplan executions does not match..."); } } }
// Helper to create a new SystemDiagnosticsTraceWriter configured // to use a custom TraceSource to write its traces to a TestTraceListener. private static SystemDiagnosticsTraceWriter CreateTraceWriter() { TestTraceListener testTraceListener = new TestTraceListener(); TraceSource testTraceSource = new TraceSource("TestTraceSource", SourceLevels.All); testTraceSource.Listeners.Clear(); testTraceSource.Listeners.Add(testTraceListener); SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter(); writer.TraceSource = testTraceSource; return writer; }
public void BaseSetUp() { TestTraceListener listener = new TestTraceListener(TestContext.CurrentContext.Test.ID); Trace.AddListener(listener); }
public void TraceWillTraceRecords() { // Arrange var activity = CreateTestActivity(); var host = new WorkflowApplication(activity); var target = new MemoryTrackingParticipant(); host.Extensions.Add(target); var listener = new TestTraceListener(); Trace.Listeners.Add(listener); // Act host.RunEpisode(); target.Trace(); // Assert Assert.IsTrue(listener.WriteLineCount > 0); }
static AssemblyWeaver() { TestListener = new TestTraceListener(); Debug.Listeners.Clear(); Debug.Listeners.Add(TestListener); BeforeAssemblyPath = Path.GetFullPath(@"..\..\..\AssemblyToProcess\bin\Debug\AssemblyToProcess.dll"); var beforePdbPath = Path.ChangeExtension(BeforeAssemblyPath, "pdb"); MonoBeforeAssemblyPath = Path.GetFullPath(@"..\..\..\AssemblyToProcessMono\bin\Debug\AssemblyToProcessMono.dll"); var monoBeforeMdbPath = MonoBeforeAssemblyPath + ".mdb"; #if (!DEBUG) BeforeAssemblyPath = BeforeAssemblyPath.Replace("Debug", "Release"); beforePdbPath = beforePdbPath.Replace("Debug", "Release"); MonoBeforeAssemblyPath = MonoBeforeAssemblyPath.Replace("Debug", "Release"); monoBeforeMdbPath = monoBeforeMdbPath.Replace("Debug", "Release"); #endif AfterAssemblyPaths = new [] { BeforeAssemblyPath.Replace(".dll", "2.dll"), BeforeAssemblyPath.Replace(".dll", "3.dll"), MonoBeforeAssemblyPath.Replace(".dll", "2.dll") }; AfterAssemblySymbolPaths = new [] { beforePdbPath.Replace(".pdb", "2.pdb"), beforePdbPath.Replace(".pdb", "3.pdb"), monoBeforeMdbPath.Replace(".mdb", "2.mdb") }; Assemblies = new Assembly[3]; Assemblies[0] = WeaveAssembly(BeforeAssemblyPath, AfterAssemblyPaths[0], beforePdbPath, AfterAssemblySymbolPaths[0], moduleDefinition => { var assemblyResolver = new MockAssemblyResolver(); var weavingTask = new ModuleWeaver { ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver, LogInfo = LogInfo, LogWarn = LogWarn, LogError = LogError, DefineConstants = new List<string> { "DEBUG" } // Always testing the debug weaver }; weavingTask.Execute(); }); Assemblies[1] = WeaveAssembly(BeforeAssemblyPath, AfterAssemblyPaths[1], beforePdbPath, AfterAssemblySymbolPaths[1], moduleDefinition => { var assemblyResolver = new MockAssemblyResolver(); var weavingTask = new ModuleWeaver { Config = new XElement("NullGuard", new XAttribute("IncludeDebugAssert", false), new XAttribute("ExcludeRegex", "^ClassToExclude$")), ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver, LogInfo = LogInfo, LogWarn = LogWarn, LogError = LogError, DefineConstants = new List<string> { "DEBUG" } // Always testing the debug weaver }; weavingTask.Execute(); }); Assemblies[2] = WeaveAssembly(MonoBeforeAssemblyPath, AfterAssemblyPaths[2], monoBeforeMdbPath, AfterAssemblySymbolPaths[2], moduleDefinition => { var assemblyResolver = new MockAssemblyResolver(); var weavingTask = new ModuleWeaver { ModuleDefinition = moduleDefinition, AssemblyResolver = assemblyResolver, LogInfo = LogInfo, LogWarn = LogWarn, LogError = LogError, DefineConstants = new List<string> { "DEBUG" } // Always testing the debug weaver }; weavingTask.Execute(); }); }