public void Perform_Basic_Startup_Without_Failure()
{
// arrange
var program = new Program();
var dumpFile = Scenario.HelloWorld.GetDumpFile();
var options = new RunOptions()
{
DumpLocation = dumpFile.FullName,
SettingsFile = "Settings/Mortician_Should.json"
};
var analyzer = new TestAnalyzer();
// act
var result = program.DefaultExecution(options, container =>
{
container.ComposeParts(analyzer);
container.ComposeExportedValue <IAnalyzer>(analyzer);
return(container);
});
// assert
result.Should().Be(0);
analyzer.AppDomainCount.Should().Be(3);
analyzer.TypeRepo.Types.FirstOrDefault(t => t.Name == "TestApplications.Console.Person").Should()
.NotBeNull();
analyzer.TypeRepo.Types.FirstOrDefault(t => t.Name == "TestApplications.Console.Address").Should()
.NotBeNull();
analyzer.ThreadRepo.Threads.Any(t =>
t.ManagedStackFrames.Any(f =>
f.DisplayString.Contains("TestApplications.Console.Program.Main")))
.Should().BeTrue();
analyzer.EngineSettings.TestString.Should().Be("This is a test string");
analyzer.RunawayReport.Should().NotBeNull();
}
public void DecoratedTests()
{
using (var analyzer = MakeTestAnalyzer()) {
var code = @"import unittest
def decorator(fn):
def wrapped(*args, **kwargs):
return fn(*args, **kwargs)
return wrapped
class MyTest(unittest.TestCase):
@decorator
def testAbc(self):
pass
";
var entry = AddModule(analyzer, "Fob", code);
entry.Analyze(CancellationToken.None, true);
analyzer.AnalyzeQueuedEntries(CancellationToken.None);
var test = TestAnalyzer.GetTestCasesFromAnalysis(entry).Single();
Assert.AreEqual("testAbc", test.MethodName);
Assert.AreEqual(10, test.StartLine);
test = GetTestCasesFromAst(code, analyzer).Single();
Assert.AreEqual("testAbc", test.MethodName);
Assert.AreEqual(10, test.StartLine);
}
}
private static IEnumerable <TestCaseInfo> GetTestCasesFromAst(string code, PythonAnalyzer analyzer)
{
var codeStream = new MemoryStream(Encoding.UTF8.GetBytes(code));
var m = AstPythonModule.FromStream(analyzer.Interpreter, codeStream, "<string>", analyzer.LanguageVersion, "__main__");
return(TestAnalyzer.GetTestCasesFromAst(m, null));
}
private void InitializeInstanceFields()
{
analyzer = new TestAnalyzer(this, collator);
firstRangeBeginning = new BytesRef(encodeCollationKey(collator.getCollationKey(firstRangeBeginningOriginal).toByteArray()));
firstRangeEnd = new BytesRef(encodeCollationKey(collator.getCollationKey(firstRangeEndOriginal).toByteArray()));
secondRangeBeginning = new BytesRef(encodeCollationKey(collator.getCollationKey(secondRangeBeginningOriginal).toByteArray()));
secondRangeEnd = new BytesRef(encodeCollationKey(collator.getCollationKey(secondRangeEndOriginal).toByteArray()));
}
private void AddModule(TestAnalyzer analyzer, string moduleName, string code, string moduleFile = null)
{
using (var source = new StringReader(code)) {
analyzer.AddModule(
moduleName,
TestData.GetPath("Fob\\" + (moduleFile ?? moduleName.Replace('.', '\\') + ".py")),
source
);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testCollationKeySort() throws Exception
public virtual void testCollationKeySort()
{
Analyzer usAnalyzer = new TestAnalyzer(this, Collator.getInstance(Locale.US));
Analyzer franceAnalyzer = new TestAnalyzer(this, Collator.getInstance(Locale.FRANCE));
Analyzer swedenAnalyzer = new TestAnalyzer(this, Collator.getInstance(new Locale("sv", "se")));
Analyzer denmarkAnalyzer = new TestAnalyzer(this, Collator.getInstance(new Locale("da", "dk")));
// The ICU Collator and Sun java.text.Collator implementations differ in their
// orderings - "BFJDH" is the ordering for java.text.Collator for Locale.US.
testCollationKeySort(usAnalyzer, franceAnalyzer, swedenAnalyzer, denmarkAnalyzer, oStrokeFirst ? "BFJHD" : "BFJDH", "EACGI", "BJDFH", "BJDHF");
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testCollationKeySort() throws Exception
public virtual void testCollationKeySort()
{
Analyzer usAnalyzer = new TestAnalyzer(this, Collator.getInstance(Locale.US));
Analyzer franceAnalyzer = new TestAnalyzer(this, Collator.getInstance(Locale.FRANCE));
Analyzer swedenAnalyzer = new TestAnalyzer(this, Collator.getInstance(new Locale("sv", "se")));
Analyzer denmarkAnalyzer = new TestAnalyzer(this, Collator.getInstance(new Locale("da", "dk")));
// The ICU Collator and Sun java.text.Collator implementations differ in their
// orderings - "BFJDH" is the ordering for java.text.Collator for Locale.US.
testCollationKeySort(usAnalyzer, franceAnalyzer, swedenAnalyzer, denmarkAnalyzer, oStrokeFirst ? "BFJHD" : "BFJDH", "EACGI", "BJDFH", "BJDHF");
}
public void SetUp()
{
const string path = "../../../../InvalidTestProject";
var files = Directory.EnumerateFiles(path, "*.dll", SearchOption.AllDirectories);
var assemblies = new List <Assembly>();
foreach (var file in files)
{
assemblies.Add(Assembly.LoadFrom(file));
}
var classes = assemblies.Distinct().SelectMany(a => a.ExportedTypes).Where(t => t.IsClass);
report = TestAnalyzer.AnalyzeTestAssembly(classes).Where(r => r.Name == "InvalidTests").FirstOrDefault();
}
public void LoadConfigurations_MultipleFiles_ConfigurationsLoad()
{
string[] expectedEntries = { "A", "B" };
var configurationFiles = ImmutableArray.Create<AdditionalText>(
new TestAdditionalDocument("first.xml", $"<Data><Entry>{expectedEntries[0]}</Entry></Data>"),
new TestAdditionalDocument("second.xml", $"<Data><Entry>{expectedEntries[1]}</Entry></Data>"),
new TestAdditionalDocument("third.txt", "<Data><Entry>C</Entry></Data>"));
var additionalFileService = new AdditionalFileService(configurationFiles, FileParseRule);
var testAnalyzer = new TestAnalyzer(additionalFileService, CancellationToken.None);
testAnalyzer.LoadConfigurations(@".+\.xml");
Assert.Equal(expectedEntries, testAnalyzer.Entries);
}
public void TestCollationKeySort()
{
Analyzer usAnalyzer = new TestAnalyzer(Collator.GetInstance(new CultureInfo("en-us")));
Analyzer franceAnalyzer
= new TestAnalyzer(Collator.GetInstance(new CultureInfo("fr")));
Analyzer swedenAnalyzer
= new TestAnalyzer(Collator.GetInstance(new CultureInfo("sv-se")));
Analyzer denmarkAnalyzer
= new TestAnalyzer(Collator.GetInstance(new CultureInfo("da-dk")));
// The ICU Collator and java.text.Collator implementations differ in their
// orderings - "BFJHD" is the ordering for the ICU Collator for Locale.US.
TestCollationKeySort
(usAnalyzer, franceAnalyzer, swedenAnalyzer, denmarkAnalyzer,
"BFJHD", "ECAGI", "BJDFH", "BJDHF");
}
public void TestCaseSubclasses()
{
using (var analyzer = MakeTestAnalyzer()) {
var entry1 = AddModule(analyzer, "Pkg.SubPkg", @"import unittest
class TestBase(unittest.TestCase):
pass
");
var entry2 = AddModule(
analyzer,
"Pkg",
moduleFile: "Pkg\\__init__.py",
code: @"from .SubPkg import TestBase"
);
var code = @"from Pkg.SubPkg import TestBase as TB1
from Pkg import TestBase as TB2
from Pkg import *
class MyTest1(TB1):
def test1(self):
pass
class MyTest2(TB2):
def test2(self):
pass
class MyTest3(TestBase):
def test3(self):
pass
";
var entry3 = AddModule(analyzer, "__main__", code);
entry1.Analyze(CancellationToken.None, true);
entry2.Analyze(CancellationToken.None, true);
entry3.Analyze(CancellationToken.None, true);
analyzer.AnalyzeQueuedEntries(CancellationToken.None);
var test = TestAnalyzer.GetTestCasesFromAnalysis(entry3).ToList();
AssertUtil.ContainsExactly(test.Select(t => t.MethodName), "test1", "test2", "test3");
// Cannot discover tests from subclasses with just the AST
test = GetTestCasesFromAst(code, analyzer).ToList();
AssertUtil.ContainsExactly(test.Select(t => t.MethodName));
}
}
public virtual void TestCollationKeySort()
{
Analyzer usAnalyzer = new TestAnalyzer(this, GetCollator("en-US"));
Collator franceCollator = GetCollator("fr");
franceCollator.FrenchCollation = FrenchCollation.On;
Analyzer franceAnalyzer = new TestAnalyzer(this, franceCollator);
// `useFallback: true` on both Swedish and Danish collators in
// case the region specific collator is not found.
Analyzer swedenAnalyzer = new TestAnalyzer(this, GetCollator("sv-SE", "sv"));
Analyzer denmarkAnalyzer = new TestAnalyzer(this, GetCollator("da-DK", "da"));
// The ICU Collator and Sun java.text.Collator implementations differ in their
// orderings - "BFJDH" is the ordering for java.text.Collator for Locale.US.
this.TestCollationKeySort(usAnalyzer, franceAnalyzer, swedenAnalyzer, denmarkAnalyzer,
this.oStrokeFirst ? "BFJHD" : "BFJDH", "EACGI", "BJDFH", "BJDHF");
}
public void TestCaseRunTestsWithTest() {
using (var analyzer = MakeTestAnalyzer()) {
var entry = AddModule(analyzer, "__main__", @"import unittest
class TestBase(unittest.TestCase):
def test_1(self):
pass
def runTest(self):
pass
");
entry.Analyze(CancellationToken.None, true);
analyzer.AnalyzeQueuedEntries(CancellationToken.None);
var test = TestAnalyzer.GetTestCases(entry).ToList();
AssertUtil.ContainsExactly(test.Select(t => t.MethodName), "test_1");
}
}
public void TestCaseRunTests() {
using (var analyzer = MakeTestAnalyzer()) {
var entry = AddModule(analyzer, "__main__", @"import unittest
class TestBase(unittest.TestCase):
def runTests(self):
pass # should not discover this as it isn't runTest or test*
def runTest(self):
pass
");
entry.Analyze(CancellationToken.None, true);
analyzer.AnalyzeQueuedEntries(CancellationToken.None);
var test = TestAnalyzer.GetTestCases(entry).ToList();
AssertUtil.ContainsExactly(test.Select(t => t.ClassName), "TestBase");
}
}
public void TestDiscover()
{
var ctx = new MockDiscoveryContext();
var sink = new MockTestCaseDiscoverySink();
var logger = new MockMessageLogger();
new TestDiscoverer().DiscoverTests(
new[] { TestInfo.TestAdapterLibProjectFilePath, TestInfo.TestAdapterAProjectFilePath, TestInfo.TestAdapterBProjectFilePath },
ctx,
logger,
sink
);
PrintTestCases(sink.Tests);
var expectedTests = TestInfo.TestAdapterATests.Concat(TestInfo.TestAdapterBTests).ToArray();
Assert.AreEqual(expectedTests.Length, sink.Tests.Count);
foreach (var expectedTest in expectedTests)
{
var expectedFullyQualifiedName = TestAnalyzer.MakeFullyQualifiedTestName(expectedTest.RelativeClassFilePath, expectedTest.ClassName, expectedTest.MethodName);
var actualTestCase = sink.Tests.SingleOrDefault(tc => tc.FullyQualifiedName == expectedFullyQualifiedName);
Assert.IsNotNull(actualTestCase, expectedFullyQualifiedName);
Assert.AreEqual(expectedTest.MethodName, actualTestCase.DisplayName, expectedFullyQualifiedName);
Assert.AreEqual(new Uri(TestExecutor.ExecutorUriString), actualTestCase.ExecutorUri);
Assert.AreEqual(expectedTest.SourceCodeLineNumber, actualTestCase.LineNumber, expectedFullyQualifiedName);
Assert.IsTrue(IsSameFile(expectedTest.SourceCodeFilePath, actualTestCase.CodeFilePath), expectedFullyQualifiedName);
Assert.IsTrue(IsSameFile(expectedTest.ProjectFilePath, actualTestCase.Source), expectedFullyQualifiedName);
sink.Tests.Remove(actualTestCase);
}
Debug.WriteLine("");
Debug.WriteLine("");
Debug.WriteLine("");
Debug.WriteLine("");
PrintTestCases(sink.Tests);
}
public void DecoratedTests()
{
using (var analyzer = MakeTestAnalyzer()) {
var code = @"import unittest
def decorator(fn):
def wrapped(*args, **kwargs):
return fn(*args, **kwargs)
return wrapped
class MyTest(unittest.TestCase):
@decorator
def testAbc(self):
pass
@fake_decorator
def testDef(self):
pass
";
var entry = AddModule(analyzer, "Fob", code);
entry.Analyze(CancellationToken.None, true);
analyzer.AnalyzeQueuedEntries(CancellationToken.None);
var tests = TestAnalyzer.GetTestCasesFromAnalysis(entry)
.Select(t => $"{t.MethodName}:{t.StartLine}");
AssertUtil.ArrayEquals(
new[] { "testAbc:10", "testDef:14" },
tests.ToArray()
);
tests = GetTestCasesFromAst(code, analyzer)
.Select(t => $"{t.MethodName}:{t.StartLine}");
AssertUtil.ArrayEquals(
new[] { "testAbc:9", "testDef:13" },
tests.ToArray()
);
}
}
