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();
});
}
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");
}
