public void CanIgnoreIndividualTestCasesWithUntilDate()
{
TestSuite suite = TestBuilder.MakeParameterizedMethodSuite(
typeof(TestCaseSourceAttributeFixture), nameof(TestCaseSourceAttributeFixture.MethodWithIgnoredTestCases));
DateTimeOffset untilDate = DateTimeOffset.Parse("4242-01-01 00:00:00", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
Test testCase = TestFinder.Find("MethodWithIgnoredTestCases(3)", suite, false);
Assert.That(testCase.RunState, Is.EqualTo(RunState.Ignored));
Assert.That(testCase.Properties.Get(PropertyNames.SkipReason), Is.EqualTo(string.Format("Ignoring until {0}. Ignore Me Until The Future", untilDate.ToString("u"))));
Assert.That(testCase.Properties.Get(PropertyNames.IgnoreUntilDate), Is.EqualTo(untilDate.ToString("u")));
untilDate = DateTimeOffset.Parse("1492-01-01", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
testCase = TestFinder.Find("MethodWithIgnoredTestCases(4)", suite, false);
Assert.That(testCase.RunState, Is.EqualTo(RunState.Runnable));
Assert.That(testCase.Properties.Get(PropertyNames.IgnoreUntilDate), Is.EqualTo(untilDate.ToString("u")));
untilDate = DateTimeOffset.Parse("4242-01-01 12:42:33Z", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
testCase = TestFinder.Find("MethodWithIgnoredTestCases(5)", suite, false);
Assert.That(testCase.RunState, Is.EqualTo(RunState.Ignored));
Assert.That(testCase.Properties.Get(PropertyNames.SkipReason), Is.EqualTo(string.Format("Ignoring until {0}. Ignore Me Until The Future", untilDate.ToString("u"))));
Assert.That(testCase.Properties.Get(PropertyNames.IgnoreUntilDate), Is.EqualTo(untilDate.ToString("u")));
}
private IEnumerable <TestMethodInstance> GetNotDoneTests(Assembly a, NotDoneFilter notDoneFilter, Configuration config)
{
var finder = new TestFinder(a, notDoneFilter);
var methodExploder = finder.FindAllMethods().Select(method => new WebTestMethodExploder(method, config));
return(methodExploder.SelectMany(x => x.Explode()));
}
public void CanExcludePlatform()
{
bool isLinux = OSPlatform.CurrentPlatform.IsUnix;
bool isMacOSX = OSPlatform.CurrentPlatform.IsMacOSX;
TestSuite suite = TestBuilder.MakeParameterizedMethodSuite(
typeof(TestCaseAttributeFixture), "MethodWitExcludePlatform");
Test testCase1 = TestFinder.Find("MethodWitExcludePlatform(1)", suite, false);
Test testCase2 = TestFinder.Find("MethodWitExcludePlatform(2)", suite, false);
Test testCase3 = TestFinder.Find("MethodWitExcludePlatform(3)", suite, false);
Test testCase4 = TestFinder.Find("MethodWitExcludePlatform(4)", suite, false);
if (isLinux)
{
Assert.That(testCase1.RunState, Is.EqualTo(RunState.Runnable));
Assert.That(testCase2.RunState, Is.EqualTo(RunState.Skipped));
Assert.That(testCase3.RunState, Is.EqualTo(RunState.Runnable));
Assert.That(testCase4.RunState, Is.EqualTo(RunState.Runnable));
}
else if (isMacOSX)
{
Assert.That(testCase1.RunState, Is.EqualTo(RunState.Runnable));
Assert.That(testCase2.RunState, Is.EqualTo(RunState.Runnable));
Assert.That(testCase3.RunState, Is.EqualTo(RunState.Skipped));
Assert.That(testCase4.RunState, Is.EqualTo(RunState.Runnable));
}
else
{
Assert.That(testCase1.RunState, Is.EqualTo(RunState.Skipped));
Assert.That(testCase2.RunState, Is.EqualTo(RunState.Runnable));
Assert.That(testCase3.RunState, Is.EqualTo(RunState.Runnable));
Assert.That(testCase4.RunState, Is.EqualTo(RunState.Runnable));
}
}
public void ExplicitTestCaseDoesNotMatchWhenNotSelectedDirectly()
{
NUnit.Core.TestCase explicitTest = (NUnit.Core.TestCase)TestFinder.Find("ExplicitlyRunTest", testSuite);
NameFilter filter = new NameFilter(testSuite.TestName);
Assert.AreEqual(false, filter.Pass(explicitTest));
}
public void CanIgnoreIndividualTestCasesWithUntilDate()
{
var methodName = nameof(TestCaseAttributeFixture.MethodWithIgnoredWithUntilDateTestCases);
TestSuite suite = TestBuilder.MakeParameterizedMethodSuite(
typeof(TestCaseAttributeFixture), methodName);
Test testCase = TestFinder.Find($"{methodName}(1)", suite, false);
Assert.That(testCase.RunState, Is.EqualTo(RunState.Runnable));
string untilDateString = DateTimeOffset.Parse("4242-01-01", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal).ToString("u");
testCase = TestFinder.Find($"{methodName}(2)", suite, false);
Assert.That(testCase.RunState, Is.EqualTo(RunState.Ignored));
Assert.That(testCase.Properties.Get(PropertyNames.SkipReason), Is.EqualTo(string.Format("Ignoring until {0}. Should not run", untilDateString)));
Assert.That(testCase.Properties.Get(PropertyNames.IgnoreUntilDate), Is.EqualTo(untilDateString));
untilDateString = DateTimeOffset.Parse("1942-01-01", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal).ToString("u");
testCase = TestFinder.Find($"{methodName}(3)", suite, false);
Assert.That(testCase.RunState, Is.EqualTo(RunState.Runnable));
Assert.That(testCase.Properties.Get(PropertyNames.IgnoreUntilDate), Is.EqualTo(untilDateString));
untilDateString = DateTimeOffset.Parse("4242-01-01T01:23:45Z", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal).ToString("u");
testCase = TestFinder.Find($"{methodName}(4)", suite, false);
Assert.That(testCase.RunState, Is.EqualTo(RunState.Ignored));
Assert.That(testCase.Properties.Get(PropertyNames.SkipReason), Is.EqualTo(string.Format("Ignoring until {0}. Don't Run Me!", untilDateString)));
Assert.That(testCase.Properties.Get(PropertyNames.IgnoreUntilDate), Is.EqualTo(untilDateString));
testCase = TestFinder.Find($"{methodName}(5)", suite, false);
Assert.That(testCase.RunState, Is.EqualTo(RunState.NotRunnable));
}
public Program(GraphSchemaIOConnection connectionInfo, IServiceProvider serviceProvider, TestFinder testFinder, TestExecutor testExecutor)
{
ConnectionInfo = connectionInfo;
ServiceProvider = serviceProvider;
TestFinder = testFinder;
TestExecutor = testExecutor;
}
public void ExplicitTestCaseDoesNotMatchWhenNotSelectedDirectly()
{
Test explicitTest = TestFinder.Find("ExplicitlyRunTest", testSuite, true);
SimpleNameFilter filter = new SimpleNameFilter("Mock Test Suite");
Assert.AreEqual(false, filter.Pass(explicitTest));
}
public void Hierarchy()
{
TestSuiteBuilder builder = new TestSuiteBuilder();
Test suite = builder.Build(new TestPackage(testsDll));
suite = (Test)suite.Tests[0];
Assert.AreEqual("NUnit", suite.TestName.Name);
suite = (Test)suite.Tests[0];
Assert.AreEqual("Tests", suite.TestName.Name);
Assert.AreEqual(MockAssembly.Fixtures, suite.Tests.Count);
Test singletonSuite = TestFinder.Find("Singletons", suite, false);
Assert.AreEqual(1, singletonSuite.Tests.Count);
Test mockSuite = TestFinder.Find("Assemblies", suite, false);
Assert.AreEqual(1, mockSuite.Tests.Count);
Test mockFixtureSuite = TestFinder.Find("MockTestFixture", mockSuite, false);
Assert.AreEqual(MockTestFixture.Tests, mockFixtureSuite.Tests.Count);
foreach (Test t in mockFixtureSuite.Tests)
{
Assert.IsFalse(t.IsSuite, "Should not be a suite");
}
}
public void TestMethodWithMultipleTestCasesUsesCorrectNames()
{
string name = "TestMethodWithMultipleTestCases";
string fullName = typeof(TestMethodSignatureFixture).FullName + "." + name;
TestSuite suite = (TestSuite)TestFinder.Find(name, fixture, false);
Assert.That(suite.TestCount, Is.EqualTo(3));
ArrayList names = new ArrayList();
ArrayList fullNames = new ArrayList();
foreach (Test test in suite.Tests)
{
names.Add(test.TestName.Name);
fullNames.Add(test.TestName.FullName);
}
Assert.That(names, Has.Member(name + "(12,3,4)"));
Assert.That(names, Has.Member(name + "(12,2,6)"));
Assert.That(names, Has.Member(name + "(12,4,3)"));
Assert.That(fullNames, Has.Member(fullName + "(12,3,4)"));
Assert.That(fullNames, Has.Member(fullName + "(12,2,6)"));
Assert.That(fullNames, Has.Member(fullName + "(12,4,3)"));
}
public void TestDoesNotMatch()
{
NUnit.Core.TestCase mock1 = (NUnit.Core.TestCase)TestFinder.Find("MockTest1", testSuite);
NameFilter filter = new NameFilter(mock1.TestName);
Assert.IsFalse(filter.Pass(mock3), "Name Filter did pass test case");
Assert.IsTrue(filter.Pass(testSuite), "Name Filter did not pass test suite");
}
public void SetUp()
{
testSuite = new TestSuite("MyTestSuite");
testFixture = TestFixtureBuilder.BuildFrom(typeof(MockTestFixture));
testSuite.Add(testFixture);
testCase = TestFinder.Find("MockTest1", testFixture, false);
}
public ToLowerCaseContextAction(LanguageIndependentContextActionDataProvider dataProvider)
{
_projectFile = dataProvider.PsiFile
.GetSourceFile()
.ToProjectFile();
_testFinder = new TestFinder();
}
public void MethodWithoutParamsIsNamedCorrectly()
{
Test instance = (Test)fixture.Tests[0];
Test method = TestFinder.Find("MethodWithoutParams", instance, false);
Assert.That(method, Is.Not.Null);
Assert.That(method.TestName.FullName, Is.EqualTo(instance.TestName.FullName + ".MethodWithoutParams"));
}
public void WhenResultIsNotSet_IndexReflectsRunState(string testName, int expectedIndex)
{
Test test = TestFinder.Find(testName, testFixture, false);
TestSuiteTreeNode node = new TestSuiteTreeNode(new TestInfo(test));
Assert.AreEqual(expectedIndex, node.ImageIndex);
Assert.AreEqual(expectedIndex, node.SelectedImageIndex);
}
public void ExplicitTestCaseMatchesWhenSelectedDirectly()
{
Test explicitTest = TestFinder.Find("ExplicitlyRunTest", testSuite, true);
SimpleNameFilter filter = new SimpleNameFilter("NUnit.Tests.Assemblies.MockTestFixture.ExplicitlyRunTest");
Assert.IsTrue(filter.Pass(explicitTest), "Name Filter did not pass on test case");
Assert.IsTrue(filter.Pass(testSuite), "Name Filter did not pass on test suite");
}
public void NoTests()
{
var a = Assembly.GetExecutingAssembly();
var finder = new TestFinder(a, test0);
var methods = finder.FindAllMethods();
Assert.AreEqual(0, methods.Count());
}
public void Return_methods_in_class_with_test_method_attribute()
{
var classes = new TestFinder().GetClassesWithFabulousTestClassAttribute(_assembly);
var methods = new TestFinder().GetMethodsWithFabulousTestMethodAttribute(classes.First());
Assert.That(methods.Any());
}
public void ExplicitTestCaseMatchesWhenSelectedDirectly()
{
NUnit.Core.TestCase explicitTest = (NUnit.Core.TestCase)TestFinder.Find("ExplicitlyRunTest", testSuite);
NameFilter filter = new NameFilter(explicitTest.TestName);
Assert.IsTrue(filter.Pass(explicitTest), "Name Filter did not pass on test case");
Assert.IsTrue(filter.Pass(testSuite), "Name Filter did not pass on test suite");
}
public void FilterByAssemblyWithoutDll()
{
var a = Assembly.GetExecutingAssembly();
var finder = new TestFinder(a, test1);
var methods = finder.FindAllMethods();
Assert.AreEqual(2, methods.Count());
}
public void TimeoutCanBeSetOnTestFixture()
{
TestResult result = TestBuilder.RunTestFixture(typeof(ThreadingFixtureWithTimeout));
Assert.That(result.ResultState, Is.EqualTo(ResultState.Failure));
result = TestFinder.Find("Test2WithInfiniteLoop", result, false);
Assert.That(result.ResultState, Is.EqualTo(ResultState.Failure));
Assert.That(result.Message, Text.Contains("50ms"));
}
public void TestTimeoutNotElapsed()
{
TimeoutTestCaseFixture fixture = new TimeoutTestCaseFixture();
TestSuite suite = TestBuilder.MakeFixture(fixture);
TestMethod testMethod = (TestMethod)TestFinder.Find("TestTimeOutNotElapsed", suite, false);
ITestResult result = TestBuilder.RunTest(testMethod, fixture);
Assert.That(result.ResultState, Is.EqualTo(ResultState.Success));
}
private void CheckParameterOutput(ITestResult result)
{
var childResult = TestFinder.Find(
"DisplayRunParameters", result, true);
Assert.That(childResult.Output, Is.EqualTo(
"Parameter X = 5" + Environment.NewLine +
"Parameter Y = 7" + Environment.NewLine));
}
public void SuiteNameMatch()
{
NUnit.Core.TestSuite mockTest = (NUnit.Core.TestSuite)TestFinder.Find("MockTestFixture", testSuite);
NameFilter filter = new NameFilter(mockTest.TestName);
Assert.IsTrue(filter.Pass(mock3), "Name Filter did not pass test case");
Assert.IsTrue(filter.Pass(mockTest), "Suite did not pass test case");
Assert.IsTrue(filter.Pass(testSuite), "Suite did not pass test case");
}
public void HighLevelSuite()
{
NUnit.Core.TestSuite mockTest = (NUnit.Core.TestSuite)TestFinder.Find("MockTestFixture", testSuite, true);
SimpleNameFilter filter = new SimpleNameFilter("NUnit.Tests.Assemblies.MockTestFixture");
Assert.AreEqual(true, filter.Pass(mock3), "test case");
Assert.AreEqual(true, filter.Pass(mockTest), "fixture");
Assert.AreEqual(true, filter.Pass(testSuite), "test suite");
}
public void SuiteNameMatch()
{
NUnit.Core.TestSuite mockTest = (NUnit.Core.TestSuite)TestFinder.Find("MockTestFixture", testSuite, true);
SimpleNameFilter filter = new SimpleNameFilter("NUnit.Tests.Assemblies.MockTestFixture");
Assert.IsTrue(filter.Pass(mock3), "Name Filter did not pass test case");
Assert.IsTrue(filter.Pass(mockTest), "Fixture did not pass test case");
Assert.IsTrue(filter.Pass(testSuite), "Suite did not pass test case");
}
public void ExplicitTestSuiteDoesNotMatchWhenNotSelectedDirectly()
{
NUnit.Core.TestSuite mockTest = (NUnit.Core.TestSuite)TestFinder.Find("MockTestFixture", testSuite, true);
mockTest.RunState = RunState.Explicit;
SimpleNameFilter filter = new SimpleNameFilter("Mock Test Suite");
Assert.AreEqual(false, filter.Pass(mock3), "descendant of explicit suite should not match");
Assert.AreEqual(false, filter.Pass(mockTest), "explicit suite should not match");
}
public void MultipleNameMatchWithTrailingComma()
{
Test mock1 = TestFinder.Find("MockTest1", testSuite, true);
SimpleNameFilter filter = new SimpleNameFilter("NUnit.Tests.Assemblies.MockTestFixture.MockTest3,NUnit.Tests.Assemblies.MockTestFixture.MockTest1,");
Assert.IsTrue(filter.Pass(mock3), "Name Filter did not pass test case");
Assert.IsTrue(filter.Pass(mock1), "Name Filter did not pass test case");
Assert.IsTrue(filter.Pass((TestSuite)testSuite.Tests[0]), "Name Filter did not pass test suite");
}
public void GoodSignature()
{
string methodName = "TestVoid";
Test fixture = TestFixtureBuilder.BuildFrom(typeof(SignatureTestFixture));
Test foundTest = TestFinder.Find(methodName, fixture);
Assert.IsNotNull(foundTest);
Assert.AreEqual(RunState.Runnable, foundTest.RunState);
}
public void HighLevelSuite()
{
NUnit.Core.TestSuite mockTest = (NUnit.Core.TestSuite)TestFinder.Find("MockTestFixture", testSuite);
NameFilter filter = new NameFilter(testSuite.TestName);
Assert.AreEqual(true, filter.Pass(mock3), "test case");
Assert.AreEqual(true, filter.Pass(mockTest), "middle suite");
Assert.AreEqual(true, filter.Pass(testSuite), "test suite");
}
public void TestTimeoutElapsed()
{
TimeoutTestCaseFixture fixture = new TimeoutTestCaseFixture();
TestSuite suite = TestBuilder.MakeFixture(fixture);
TestMethod testMethod = (TestMethod)TestFinder.Find("TestTimeOutElapsed", suite, false);
ITestResult result = TestBuilder.RunTest(testMethod, fixture);
Assert.That(result.ResultState, Is.EqualTo(ResultState.Failure));
Assert.That(result.Message, Does.Contain("100ms"));
}
