public void Run(XunitTestAssemblyTask assemblyTask, bool disableAllConcurrency)
{
var environment = new TestEnvironment(assemblyTask, disableAllConcurrency);
try
{
if (environment.TestAssemblyConfiguration.ShadowCopyOrDefault)
server.SetTempFolderPath(environment.ShadowCopyPath);
using (var controller = GetFrontController(environment))
{
var discoverer = new Discoverer(controller, RunContext, environment);
var testCases = discoverer.GetTestCases();
if (testCases.Count == 0)
throw new InternalErrorException("Unexpected: Unable to find any matching test cases");
if (testCases.Count > 0)
{
RunContext.AddRange(testCases);
var executor = new Executor(controller, RunContext, environment);
executor.RunTests(testCases);
}
}
environment.DiagnosticMessages.Report(server);
}
catch (Exception e)
{
ReportException(assemblyTask, environment, e);
}
}
public void GetAll_OnlyReturnsImplementingTypes()
{
Type[] types = { typeof(Bar), typeof(string), typeof(IDisposable) };
_typeContainerMock.Setup(container => container.GetTypes()).Returns(types);
var subject = new Discoverer(_typeContainerMock.Object);
Assert.AreEqual(1, subject.GetAll<IFoo>().Count());
}
public void GetAll_ReturnsOnlyDefaultConstructable()
{
Type[] types = { typeof(NonDefaultConstructableFoo), typeof(Bar) };
_typeContainerMock.Setup(container => container.GetTypes()).Returns(types);
var subject = new Discoverer(_typeContainerMock.Object);
Assert.AreEqual(1, subject.GetAll<IFoo>().Count());
}
public static async Task DiscoverAsync()
{
Discoverer discoverer = new Discoverer();
discoverer.AgentFound += DiscovererAgentFound;
Console.WriteLine("v1 discovery");
await discoverer.DiscoverAsync(VersionCode.V1, new IPEndPoint(IPAddress.Broadcast, 161), new OctetString("public"), 6000);
Console.WriteLine("v2 discovery");
await discoverer.DiscoverAsync(VersionCode.V2, new IPEndPoint(IPAddress.Broadcast, 161), new OctetString("public"), 6000);
Console.WriteLine("v3 discovery");
await discoverer.DiscoverAsync(VersionCode.V3, new IPEndPoint(IPAddress.Broadcast, 161), null, 6000);
}
public void TestDiscoverer()
{
if (Environment.GetEnvironmentVariable("CI") == "true")
{
return;
}
var engine = CreateEngine();
engine.Listener.ClearBindings();
var serverEndPoint = new IPEndPoint(IPAddress.Any, Port.NextId);
engine.Listener.AddBinding(serverEndPoint);
engine.Start();
var timeout = 1000;
var wait = 60 * timeout;
try
{
var signal = new AutoResetEvent(false);
var discoverer = new Discoverer();
discoverer.AgentFound += (sender, args)
=>
{
Assert.True(args.Agent.Address.ToString() != "0.0.0.0");
signal.Set();
};
discoverer.Discover(VersionCode.V1, new IPEndPoint(IPAddress.Broadcast, serverEndPoint.Port),
new OctetString("public"), timeout);
Assert.True(signal.WaitOne(wait));
signal.Reset();
discoverer.Discover(VersionCode.V2, new IPEndPoint(IPAddress.Broadcast, serverEndPoint.Port),
new OctetString("public"), timeout);
Assert.True(signal.WaitOne(wait));
signal.Reset();
discoverer.Discover(VersionCode.V3, new IPEndPoint(IPAddress.Broadcast, serverEndPoint.Port), null,
timeout);
Assert.True(signal.WaitOne(wait));
}
finally
{
if (SnmpMessageExtension.IsRunningOnWindows)
{
engine.Stop();
}
}
}
public void TestGetTestsDefaultTag1()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--list-tests [Tag1]";
settings.FilenameFilter = ".*";
var discoverer = new Discoverer(settings);
string[] sources = { Path_Testset01 };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(4, tests.Count);
}
public void LongNamesNotDiscoverableVerbose(string versionpath)
{
var source = Paths.TestExecutable_Discover(TestContext, versionpath);
if (string.IsNullOrEmpty(source))
{
Assert.Fail($"Missing test executable for {versionpath}.");
return;
}
var settings = new Settings();
settings.DiscoverCommandLine = "-v high --list-tests NotDefaultDiscoverable*";
settings.FilenameFilter = ".*";
var discoverer = new Discoverer(settings);
string[] sources = { source };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.IsTrue(discoverer.Log.Contains("Error"));
Assert.IsTrue(discoverer.Log.Contains("{???}"));
switch (versionpath)
{
case "Rel_0_1":
case "Rel_1_0":
case "Rel_1_1":
case "Rel_1_2":
case "Rel_2_0":
case "Rel_2_1":
case "Rel_2_2":
case "Rel_2_3":
case "Rel_3_0":
case "Rel_4_0":
case "Rel_4_1":
Assert.AreEqual(0, tests.Count);
Assert.IsTrue(discoverer.Log.Contains("Line: 29"));
Assert.IsTrue(discoverer.Log.Contains("Line: 34"));
Assert.IsTrue(discoverer.Log.Contains("Line: 39"));
break;
default:
Assert.AreEqual(1, tests.Count);
Assert.IsTrue(discoverer.Log.Contains("Line: 29"));
Assert.IsTrue(discoverer.Log.Contains("Line: 34"));
break;
}
}
public void Should_Instantiate_The_Discoverer_Type_From_The_ConditionalFact()
{
var mockedInstantiatedDiscoverer = new Discoverer();
var messageSink = new Mock <IMessageSink>().Object;
var provider = new XunitTestCaseDiscovererProvider();
var mockReflectionHelper = new Mock <IReflectionHelper>();
mockReflectionHelper.Setup(rh => rh.CreateInstance <IXunitTestCaseDiscoverer>(FakeDiscoverer.Type, It.Is <object[]>(args => args.Length == 1 && args[0] == messageSink))).Returns(mockedInstantiatedDiscoverer);
var conditionalFactWithDiscovererType = new ConditionalFact(FakeDiscoverer.Type);
provider.ReflectionHelper = mockReflectionHelper.Object;
var discoverer = provider.Provide(conditionalFactWithDiscovererType, messageSink);
Assert.Same(mockedInstantiatedDiscoverer, discoverer);
}
public void Tag1IncludeHidden()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--list-tests [Tag1]";
settings.FilenameFilter = ".*";
settings.IncludeHidden = true;
var discoverer = new Discoverer(settings);
string[] sources = { Path_Hidden };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(4, tests.Count);
}
public void TestGetTestsDefaultAllNoHidden()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--list-tests *";
settings.FilenameFilter = ".*";
settings.IncludeHidden = false;
var discoverer = new Discoverer(settings);
string[] sources = { Path_Testset01 };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(2, tests.Count);
}
public void GetAuthorizedLinksTest()
{
authMoq.Setup(x => x.IsAuthorized(It.IsAny <AuthorizeAttributes>())).Returns(true);
routeMoq.Setup(x => x.GetRoute(It.IsAny <RouteAttributes>())).Returns("route");
var explorer = new Discoverer(new Extractor(), new Settings {
});
var nodes = explorer.Discover(System.Reflection.Assembly.GetAssembly(GetType()).FullName);
var local = nodes.Where(x => x.Key.Contains(nameof(Discovery.Tests.DiscovererTests)));
var parser = new Parser(authMoq.Object, routeMoq.Object);
var method = typeof(Discovery.Tests.DiscovererTests).GetMethods().First(x => x.Name == nameof(Discovery.Tests.DiscovererTests.Stub_Overloaded_CheckMethodParametersTest) && x.GetParameters().Length == 0);
var entries = parser.GetLinks(explorer.GetKey(method), local);
Assert.AreEqual(4, entries.Count());
}
static async private void AsyncMain()
{
//await EnumerateAllServicesFromAllHosts();
Console.WriteLine("Searching...");
Discoverer d = new Discoverer();
await d.DiscoverNAO();
foreach (NAOHost nao in d.NAOs)
{
if (verbose)
Console.WriteLine(nao.Name + ": " + nao.IP);
else
Console.WriteLine(nao.IP);
}
}
public void AllVerbose(string versionpath)
{
if (versionpath.StartsWith("Rel3"))
{
return; // the --list-test-names-only option is not available in Catch2 v3
}
var source = Paths.TestExecutable_Hidden(TestContext, versionpath);
if (string.IsNullOrEmpty(source))
{
Assert.Fail($"Missing test executable for {versionpath}.");
return;
}
var source_dummy = Paths.TestExecutable_Dummy(TestContext, versionpath);
if (string.IsNullOrEmpty(source_dummy))
{
Assert.Fail($"Missing test executable for {versionpath}.");
return;
}
var settings = new Settings();
settings.DiscoverCommandLine = "--verbosity high --list-test-names-only *";
settings.FilenameFilter = ".*";
settings.IncludeHidden = false; // With use of "--list-test-names-only" this parameter is effectively ignored
var discoverer = new Discoverer(settings);
string[] sources = { source };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(6, tests.Count);
// Also check with multiple sources
string[] sources2 = { source, source_dummy };
tests = discoverer.GetTests(sources2) as List <TestCase>;
Assert.AreEqual(7, tests.Count);
Assert.AreEqual(29, tests[0].Line);
Assert.AreEqual(34, tests[1].Line);
Assert.AreEqual(39, tests[2].Line);
Assert.AreEqual(44, tests[3].Line);
Assert.AreEqual(30, tests[4].Line);
Assert.AreEqual(35, tests[5].Line);
Assert.AreEqual(31, tests[6].Line);
}
public void LongNamesVerbose()
{
var settings = new Settings();
settings.DiscoverCommandLine = "-v high --list-tests LongTestCaseNames*";
settings.FilenameFilter = ".*";
var discoverer = new Discoverer(settings);
string[] sources = { Path_Discover };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(8, tests.Count);
Assert.AreEqual("LongTestCaseNames. a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[0].Name);
Assert.AreEqual("LongTestCaseNames. a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789&i123456789b123456789j123456789k123456789l123456789"
, tests[1].Name);
Assert.AreEqual("LongTestCaseNames. a123456789b123456789c123456789d123456789e123456789&f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[2].Name);
Assert.AreEqual("LongTestCaseNames. a123456789b123456789c123456789d123456789e123456789&f123456789b123456789g123456789d123456789h123456789&i123456789b123456789j123456789k123456789l123456789"
, tests[3].Name);
Assert.AreEqual("LongTestCaseNames.a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[4].Name);
Assert.AreEqual("LongTestCaseNames.a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789&i123456789b123456789j123456789k123456789l123456789"
, tests[5].Name);
Assert.AreEqual("LongTestCaseNames.a123456789b123456789c123456789d123456789e123456789&f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[6].Name);
Assert.AreEqual("LongTestCaseNames.a123456789b123456789c123456789d123456789e123456789&f123456789b123456789g123456789d123456789h123456789&i123456789b123456789j123456789k123456789l123456789"
, tests[7].Name);
Assert.IsTrue(tests[0].Filename.EndsWith(@"catch_discover\ut_longtestcasenames.cpp"));
Assert.IsTrue(tests[1].Filename.EndsWith(@"catch_discover\ut_longtestcasenames.cpp"));
Assert.IsTrue(tests[2].Filename.EndsWith(@"catch_discover\ut_longtestcasenames.cpp"));
Assert.IsTrue(tests[3].Filename.EndsWith(@"catch_discover\ut_longtestcasenames.cpp"));
Assert.IsTrue(tests[4].Filename.EndsWith(@"catch_discover\ut_longtestcasenames.cpp"));
Assert.IsTrue(tests[5].Filename.EndsWith(@"catch_discover\ut_longtestcasenames.cpp"));
Assert.IsTrue(tests[6].Filename.EndsWith(@"catch_discover\ut_longtestcasenames.cpp"));
Assert.IsTrue(tests[7].Filename.EndsWith(@"catch_discover\ut_longtestcasenames.cpp"));
Assert.AreEqual(29, tests[0].Line);
Assert.AreEqual(34, tests[1].Line);
Assert.AreEqual(39, tests[2].Line);
Assert.AreEqual(44, tests[3].Line);
Assert.AreEqual(49, tests[4].Line);
Assert.AreEqual(54, tests[5].Line);
Assert.AreEqual(59, tests[6].Line);
Assert.AreEqual(64, tests[7].Line);
}
public void DuplicateTestnameVerbose(string versionpath)
{
var source = Paths.TestExecutable_Duplicates(TestContext, versionpath);
if (string.IsNullOrEmpty(source))
{
Assert.Fail($"Missing test executable for {versionpath}.");
return;
}
var settings = new Settings();
settings.DiscoverCommandLine = "-v high --list-tests";
settings.FilenameFilter = ".*";
settings.IncludeHidden = false;
var discoverer = new Discoverer(settings);
string[] sources = { source };
var tests = discoverer.GetTests(sources) as List <TestCase>;
if (versionpath.StartsWith("Rel3"))
{
// This is no longer a problem starting Catch2 v3
Assert.AreEqual(3, tests.Count);
Assert.IsFalse(string.IsNullOrEmpty(discoverer.Log));
Assert.IsTrue(discoverer.Log.Contains("WARNING"));
Assert.IsTrue(discoverer.Log.Contains("SameTestNames. Duplicate"));
Assert.AreEqual("SameTestNames. Duplicate", tests[0].Name);
Assert.AreEqual("[[DUPLICATE 1>>.SameTestNames. Duplicate", tests[1].Name);
Assert.AreEqual("[[DUPLICATE 2>>.SameTestNames. Duplicate", tests[2].Name);
Assert.IsTrue(tests[0].Filename.EndsWith(@"Catch_Duplicates\UT_SameTestNames.cpp"));
Assert.IsTrue(tests[1].Filename.EndsWith(@"Catch_Duplicates\UT_SameTestNames.cpp"));
Assert.IsTrue(tests[2].Filename.EndsWith(@"Catch_Duplicates\UT_SameTestNames.cpp"));
Assert.AreEqual(28, tests[0].Line);
Assert.AreEqual(42, tests[1].Line);
Assert.AreEqual(56, tests[2].Line);
}
else
{
Assert.AreEqual(0, tests.Count);
Assert.IsFalse(string.IsNullOrEmpty(discoverer.Log));
Assert.IsTrue(discoverer.Log.Contains("Error Occurred"));
}
}
public void DiscoverSelfReferential()
{
DiscoverableParent parent = new DiscoverableParent();
parent.Parent = new DiscoverableParent();
IList <IDiscoverableParent> list = Discoverer.Discover <IDiscoverableParent>(parent);
Assert.Equal(2, list.Count);
parent.Parent = parent;
list = Discoverer.Discover <IDiscoverableParent>(parent);
Assert.Equal(1, list.Count);
}
public void GetBaseTest()
{
authMoq.Setup(x => x.IsAuthorized(It.IsAny <AuthorizeAttributes>())).Returns(false);
var settings = new Settings {
};
var extractor = new Extractor();
var discoverer = new Discoverer(extractor, settings);
var orchestrator = new Orchestrator(extractor, discoverer, authMoq.Object);
orchestrator.Setup(settings, System.Reflection.Assembly.GetAssembly(GetType()).FullName);
var output = orchestrator.GetBase();
Assert.IsTrue(orchestrator.Nodes.Count() > 0);
Assert.AreEqual(0, output.Links.Count());
}
protected void AssertDiscoveredMethod(Type testFixtureInAssemblyToDiscoverTestsIn, string expectedNameOfFirstTestMethod)
{
// Arrange
var discoverer = new Discoverer(new List<string> { testFixtureInAssemblyToDiscoverTestsIn.Assembly.Location });
// Act
var discoveredTests = discoverer.Discover();
// Assert
discoveredTests.Should().NotBeNullOrEmpty();
var discoveredTest = discoveredTests.FirstOrDefault(x => x.Name == testFixtureInAssemblyToDiscoverTestsIn.Name);
discoveredTest.Should().NotBeNull();
var discoveredMethod = discoveredTest.TestMethods.FirstOrDefault(x => x.Name == expectedNameOfFirstTestMethod);
discoveredMethod.Should().NotBeNull();
}
public void TestGetTestsLongTag2D()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--discover \"Testset02.Tests07. Longtag2\"";
settings.FilenameFilter = ".*";
var discoverer = new Discoverer(settings);
string[] sources = { Path_Testset02 };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(1, tests.Count);
Assert.AreEqual(1, tests[0].Tags.Count);
Assert.AreEqual("This is a long tag name, a very long tag name. Did I say it was a long tag name. Yes, it is a long tag name and it just growing and growing and growing. Where it ends, well it doesn't end here. It ends all the way over here."
, tests[0].Tags[0]);
}
public void DefaultSettings(string versionpath)
{
var source = Paths.TestExecutable_Hidden(TestContext, versionpath);
if (string.IsNullOrEmpty(source))
{
Assert.Fail($"Missing test executable for {versionpath}.");
return;
}
var discoverer = new Discoverer(null);
string[] sources = { source };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(6, tests.Count);
}
public void TestGetTestsDuplicateTestname()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--list-tests";
settings.FilenameFilter = ".*";
settings.IncludeHidden = false;
var discoverer = new Discoverer(settings);
string[] sources = { Path_Testset04 };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(0, tests.Count);
Assert.IsFalse(string.IsNullOrEmpty(discoverer.Log));
Assert.IsTrue(discoverer.Log.Contains("Error Occurred"));
}
public void TestGetTestsLongTag1D()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--discover \"Testset02.Tests07. Longtag1\"";
settings.FilenameFilter = ".*";
var discoverer = new Discoverer(settings);
string[] sources = { Path_Testset02 };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(1, tests.Count);
Assert.AreEqual(1, tests[0].Tags.Count);
Assert.AreEqual("Long tag 01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
, tests[0].Tags[0]);
}
public void Discover_Finds_Regular_Test_Fixture_And_Method()
{
// Arrange
var discoverer = new Discoverer(new List<string> { TestAssemblyLocation });
// Act
var discoveredTests = discoverer.Discover();
// Assert
discoveredTests.Should().NotBeNullOrEmpty();
var discoveredTest = discoveredTests.FirstOrDefault(x => x.Name == typeof(RegularTestClass).Name);
discoveredTest.Should().NotBeNull();
var discoveredMethod = discoveredTest.TestMethods.FirstOrDefault(x => x.Name == "RegularTestMethod");
discoveredMethod.Should().NotBeNull();
}
public async void TestDiscovererAsync()
{
var engine = CreateEngine();
engine.Listener.ClearBindings();
var serverEndPoint = new IPEndPoint(IPAddress.Any, Port.NextId);
engine.Listener.AddBinding(serverEndPoint);
engine.Start();
try
{
var signal = new AutoResetEvent(false);
var discoverer = new Discoverer();
discoverer.AgentFound += (sender, args)
=>
{
Assert.True(args.Agent.Address.ToString() != "0.0.0.0");
signal.Set();
};
await discoverer.DiscoverAsync(VersionCode.V1, new IPEndPoint(IPAddress.Broadcast, serverEndPoint.Port),
new OctetString("public"), 3000);
signal.WaitOne();
signal.Reset();
await discoverer.DiscoverAsync(VersionCode.V2, new IPEndPoint(IPAddress.Broadcast, serverEndPoint.Port),
new OctetString("public"), 3000);
signal.WaitOne();
signal.Reset();
await discoverer.DiscoverAsync(VersionCode.V3, new IPEndPoint(IPAddress.Broadcast, serverEndPoint.Port),
null, 3000);
signal.WaitOne();
}
finally
{
if (SnmpMessageExtension.IsRunningOnWindows)
{
engine.Stop();
}
}
}
public void DiscoverTest()
{
var explorer = new Discoverer(new Extractor(), new Settings {
});
var nodes = explorer.Discover(System.Reflection.Assembly.GetAssembly(GetType()).FullName);
var local = nodes.Where(x => x.Key.Contains(nameof(DiscovererTests)));
var allExits = local.SelectMany(x => x.Exits);
Assert.AreEqual(4, allExits.Count());
Assert.AreEqual(7, nodes.Count());
Assert.AreEqual(4, local.Count());
Assert.AreEqual(3, nodes.Where(x => x.Key.Contains(nameof(ExtractorTests))).Count());
Assert.AreEqual(3, local.Where(x => x.Metadata.IsEntry).Count());
Assert.IsTrue(local.Single(x => x.Metadata.IsLeaf).Key.Contains(nameof(Stub_Overloaded_CheckMethodParametersTest))); // leaf
Assert.AreEqual(1, local.Single(x => x.Key.Contains(nameof(Stub_CheckMethodParametersTest))).Exits.Count()); // leaf
}
public void NoHidden()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--list-test-names-only";
settings.FilenameFilter = ".*";
settings.IncludeHidden = true; // With use of "--list-test-names-only" this parameter is effectively ignored
var discoverer = new Discoverer(settings);
string[] sources = { Path_Hidden };
var tests = discoverer.GetTests(sources) as List <TestCase>;
#if TA_CATCH2_V2_0_1 || TA_CATCH2_V2_1_0 || TA_CATCH2_V2_1_1 || TA_CATCH2_V2_1_2
Assert.AreEqual(6, tests.Count);
#else
Assert.AreEqual(2, tests.Count);
#endif
}
public static void Run(string[] args)
{
GLib.ExceptionManager.UnhandledException += ExceptionManager_UnhandledException;
string uri = "http://download.blender.org/durian/trailer/sintel_trailer-1080p.mp4";
// Missing GError ?
uri = "https://www.freedesktop.org/software/gstreamer-sdk/data/media/sintel_trailer-480p.webm";
if (args.Length > 1)
{
uri = args[0];
}
Gst.Application.Init(ref args);
Console.WriteLine($"Discovering {uri}");
Discoverer = new Discoverer(5 * Gst.Constants.SECOND);
if (Discoverer == null)
{
Console.WriteLine("Error creating discoverer ");
return;
}
// Connect to the interesting signals
Discoverer.Discovered += OnDiscoveredCb;
Discoverer.Finished += OnFinishedCb;
// Start the discoverer process (nothing to do yet)
Discoverer.Start();
//Add a request to process asynchronously the URI passed through the command line
if (!Discoverer.DiscoverUriAsync(uri))
{
$"Failed to start discovering {uri}".PrintErr();
return;
}
// Create a GLib Main Loop and set it to run, so we can wait for the signals
MainLoop = new GLib.MainLoop();
MainLoop.Run();
Discoverer.Stop();
Console.ReadLine();
}
public void Names(string versionpath)
{
if (versionpath.StartsWith("Rel3"))
{
return; // the --list-test-names-only option is not available in Catch2 v3
}
var source = Paths.TestExecutable_Discover(TestContext, versionpath);
if (string.IsNullOrEmpty(source))
{
Assert.Fail($"Missing test executable for {versionpath}.");
return;
}
var settings = new Settings();
settings.DiscoverCommandLine = "--list-test-names-only *TestCases*";
settings.FilenameFilter = ".*";
var discoverer = new Discoverer(settings);
string[] sources = { source };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(13, tests.Count);
Assert.AreEqual("TestCases. abcdefghijklmnopqrstuvwxyz", tests[0].Name);
Assert.AreEqual("TestCases. ZXYWVUTSRQPONMLKJIHGFEDCBA", tests[1].Name);
Assert.AreEqual("TestCases. 0123456789", tests[2].Name);
Assert.AreEqual("TestCases. []{}!@#$%^&*()_-+=|\\?/><,~`';:", tests[3].Name);
Assert.AreEqual("TestCases. \"name\"", tests[4].Name);
Assert.AreEqual("TestCases. \\", tests[5].Name);
Assert.AreEqual("\\TestCases. name", tests[6].Name);
Assert.AreEqual("TestCases. End with space ", tests[7].Name);
Assert.AreEqual("TestCases. End with spaces ", tests[8].Name);
Assert.AreEqual("TestCasesLongName01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
, tests[9].Name);
Assert.AreEqual("TestCases. LongName 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
, tests[10].Name);
Assert.AreEqual("TestCases. LongName 0123456789-01234567890123456789-01234567890123456789-01234567890123456789-01234567890123456789-0123456789"
, tests[11].Name);
Assert.AreEqual("TestCases. with <xml/> in name", tests[12].Name);
}
public void DiscoverOrphansTest()
{
var explorer = new Discoverer(new Extractor(), new Settings {
AllowOrphans = true
});
var nodes = explorer.Discover(System.Reflection.Assembly.GetAssembly(GetType()).FullName);
var local = nodes.Where(x => x.Key.Contains(nameof(DiscovererTests)));
var allExits = local.SelectMany(x => x.Exits).ToList();
var test = allExits.ToArray();
Assert.AreEqual(5, allExits.Count());
Assert.AreEqual(8, nodes.Count());
Assert.AreEqual(5, local.Count());
Assert.AreEqual(3, nodes.Where(x => x.Key.Contains(nameof(ExtractorTests))).Count());
Assert.AreEqual(3, local.Where(x => x.Metadata.IsEntry).Count());
Assert.AreEqual(1, local.Single(x => x.Key.Contains(nameof(Stub_Orphan))).Exits.Count()); // leaf
}
public void TestGetTestsDefaultAll()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--list-tests *";
settings.IncludeHidden = true;
var discoverer = new Discoverer(settings);
string[] sources = { Path_Testset01 };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(6, tests.Count);
// Also check with multiple sources
string[] sources2 = { Path_Testset01, Path_Dummy };
tests = discoverer.GetTests(sources2) as List <TestCase>;
Assert.AreEqual(7, tests.Count);
}
public void TestGetTestsNameOnly()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--list-test-names-only *";
settings.IncludeHidden = false; // With use of "--list-test-names-only" this parameter is effectively ignored
var discoverer = new Discoverer(settings);
string[] sources = { Path_Testset01 };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(6, tests.Count);
// Also check with multiple sources
string[] sources2 = { Path_Testset01, Path_Dummy };
tests = discoverer.GetTests(sources2) as List <TestCase>;
Assert.AreEqual(7, tests.Count);
}
protected void AssertDiscoveredMethod(Type testFixtureInAssemblyToDiscoverTestsIn, params string[] expectedTestMethodsName)
{
// Arrange
var discoverer = new Discoverer(new List<string> { testFixtureInAssemblyToDiscoverTestsIn.Assembly.Location }, @"..\..\..\packages\NUnit.ConsoleRunner.3.2.0\tools\nunit3-console.exe");
// Act
var discoveredTests = discoverer.Discover();
// Assert
discoveredTests.Should().NotBeNullOrEmpty();
var discoveredTest = discoveredTests.SingleOrDefault(x => x.Name == testFixtureInAssemblyToDiscoverTestsIn.Name);
discoveredTest.Should().NotBeNull();
var discoveredMethodsNames = discoveredTest.TestMethods.Select(p => p.Name);
foreach (var expectedTestMethodName in expectedTestMethodsName)
Assert.Contains(expectedTestMethodName, discoveredMethodsNames.ToList());
}
public void LongNames(string versionpath)
{
if (versionpath.StartsWith("Rel3"))
{
return; // the --list-test-names-only option is not available in Catch2 v3
}
var source = Paths.TestExecutable_Discover(TestContext, versionpath);
if (string.IsNullOrEmpty(source))
{
Assert.Fail($"Missing test executable for {versionpath}.");
return;
}
var settings = new Settings();
settings.DiscoverCommandLine = "--list-test-names-only LongTestCaseNames*";
settings.FilenameFilter = ".*";
var discoverer = new Discoverer(settings);
string[] sources = { source };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(8, tests.Count);
Assert.AreEqual("LongTestCaseNames. a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[0].Name);
Assert.AreEqual("LongTestCaseNames. a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789&i123456789b123456789j123456789k123456789l123456789"
, tests[1].Name);
Assert.AreEqual("LongTestCaseNames. a123456789b123456789c123456789d123456789e123456789&f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[2].Name);
Assert.AreEqual("LongTestCaseNames. a123456789b123456789c123456789d123456789e123456789&f123456789b123456789g123456789d123456789h123456789&i123456789b123456789j123456789k123456789l123456789"
, tests[3].Name);
Assert.AreEqual("LongTestCaseNames.a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[4].Name);
Assert.AreEqual("LongTestCaseNames.a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789&i123456789b123456789j123456789k123456789l123456789"
, tests[5].Name);
Assert.AreEqual("LongTestCaseNames.a123456789b123456789c123456789d123456789e123456789&f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[6].Name);
Assert.AreEqual("LongTestCaseNames.a123456789b123456789c123456789d123456789e123456789&f123456789b123456789g123456789d123456789h123456789&i123456789b123456789j123456789k123456789l123456789"
, tests[7].Name);
}
public static void Main(string[] args)
{
var uri = "http://download.blender.org/durian/trailer/sintel_trailer-1080p.mp4";
// if a URI was provided, use it instead of the default one
if (args.Length > 1)
{
uri = args[0];
}
// Initialize GStreamer
Gst.Application.Init(ref args);
Console.WriteLine("Discovering '{0}'", uri);
// Instantiate the Discoverer
Discoverer = new Discoverer(5L * Gst.Constants.SECOND);
// Connect to the interesting signals
Discoverer.Discovered += HandleDiscovered;
Discoverer.Finished += (sender, e) => {
Console.WriteLine("Finished discovering");
MainLoop.Quit();
};
// Start the discoverer process (nothing to do yet)
Discoverer.Start();
// Add a request to process asynchronously the URI passed through the command line
if (!Discoverer.DiscoverUriAsync(uri))
{
Console.WriteLine("Failed to start discovering URI '{0}'", uri);
return;
}
// Create a GLib Main Loop and set it to run, so we can wait for the signals
MainLoop = new GLib.MainLoop();
MainLoop.Run();
// Stop the discoverer process
Discoverer.Stop();
}
public static void Main(string[] args)
{
if (args.Length != 0)
{
return;
}
Discoverer discoverer = new Discoverer();
discoverer.AgentFound += DiscovererAgentFound;
Console.WriteLine("v1 discovery");
discoverer.Discover(VersionCode.V1, new IPEndPoint(IPAddress.Broadcast, 161), new OctetString("public"), 6000);
Console.WriteLine("v2 discovery");
discoverer.Discover(VersionCode.V2, new IPEndPoint(IPAddress.Broadcast, 161), new OctetString("public"), 6000);
Console.WriteLine("v3 discovery");
discoverer.Discover(VersionCode.V3, new IPEndPoint(IPAddress.Broadcast, 161), null, 6000);
Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}
public void LongNamesNotDiscoverable()
{
var settings = new Settings();
settings.DiscoverCommandLine = "--list-test-names-only NotDefaultDiscoverable*";
settings.FilenameFilter = ".*";
var discoverer = new Discoverer(settings);
string[] sources = { Path_Discover };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(3, tests.Count);
Assert.AreEqual("NotDefaultDiscoverable. a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[0].Name);
Assert.AreEqual("NotDefaultDiscoverable. a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[1].Name);
Assert.AreEqual("NotDefaultDiscoverable. a123456789b123456789c123456789d123456789e123456789f123"
, tests[2].Name);
}
public void LongNamesNotDiscoverableVerbose(string versionpath)
{
if (versionpath.StartsWith("Rel3"))
{
return; // the --list-test-names-only option is not available in Catch2 v3
}
var source = Paths.TestExecutable_Discover(TestContext, versionpath);
if (string.IsNullOrEmpty(source))
{
Assert.Fail($"Missing test executable for {versionpath}.");
return;
}
var settings = new Settings();
settings.DiscoverCommandLine = "-v high --list-test-names-only NotDefaultDiscoverable*";
settings.FilenameFilter = ".*";
var discoverer = new Discoverer(settings);
string[] sources = { source };
var tests = discoverer.GetTests(sources) as List <TestCase>;
Assert.AreEqual(3, tests.Count);
Assert.AreEqual("NotDefaultDiscoverable. a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[0].Name);
Assert.AreEqual("NotDefaultDiscoverable. a123456789b123456789c123456789d123456789e123456789& f123456789b123456789g123456789d123456789h123456789& i123456789b123456789j123456789k123456789l123456789"
, tests[1].Name);
Assert.AreEqual("NotDefaultDiscoverable. a123456789b123456789c123456789d123456789e123456789f123"
, tests[2].Name);
Assert.IsTrue(tests[0].Filename.EndsWith(@"Catch_Discover\UT_NotDefaultDiscoverable.cpp"));
Assert.IsTrue(tests[1].Filename.EndsWith(@"Catch_Discover\UT_NotDefaultDiscoverable.cpp"));
Assert.IsTrue(tests[2].Filename.EndsWith(@"Catch_Discover\UT_NotDefaultDiscoverable.cpp"));
Assert.AreEqual(29, tests[0].Line);
Assert.AreEqual(34, tests[1].Line);
Assert.AreEqual(39, tests[2].Line);
}
public void GetAll_SkipsInterfaces()
{
Type[] types = { typeof(IBar) };
_typeContainerMock.Setup(container => container.GetTypes()).Returns(types);
var subject = new Discoverer(_typeContainerMock.Object);
Assert.IsEmpty(subject.GetAll<IFoo>());
}
/// <summary>
/// Discovers the tests.
/// </summary>
private void DiscoverTests()
{
System.Threading.Tasks.Task.Factory.StartNew(new Action(() =>
{
var potentialTestDLLs = IDEHelper.GetPotentialTestDLLs();
var testDiscoverer = new Discoverer(potentialTestDLLs);
testDiscoverer.Discover(UpdateTreeView);
}));
}
