public void Async40AcceptanceTest()
{
string code = @"
using System;
using System.Threading;
using System.Threading.Tasks;
using Xunit;
public class TestClass
{
[Fact]
public Task TestMethod()
{
return Task.Factory.StartNew(() =>
{
Thread.Sleep(1);
})
.ContinueWith(_ =>
{
Assert.True(false);
});
}
}
";
XmlNode assemblyNode = Execute(code);
XmlNode testNode = ResultXmlUtility.AssertResult(assemblyNode, "Fail", "TestClass.TestMethod");
XmlNode failureNode = testNode.SelectSingleNode("failure");
ResultXmlUtility.AssertAttribute(failureNode, "exception-type", typeof(TrueException).FullName);
}
public void TheoryViaDataAcceptanceTest()
{
string code = @"
using Xunit.Extensions;
public class Stub
{
[Theory]
[InlineData(1, ""hello"", 2.3)]
[InlineData(42, ""world"", 21.12)]
public void PassingTestData(int foo, string bar, double baz)
{
}
}
";
XmlNode assemblyNode = Execute(code, null, "xunit.extensions.dll");
XmlNode testNode1 = ResultXmlUtility.GetResult(assemblyNode, 0, 0);
ResultXmlUtility.AssertAttribute(testNode1, "result", "Pass");
ResultXmlUtility.AssertAttribute(testNode1, "name", "Stub." + @"PassingTestData(foo: 1, bar: ""hello"", baz: 2.3)");
XmlNode testNode2 = ResultXmlUtility.GetResult(assemblyNode, 0, 1);
ResultXmlUtility.AssertAttribute(testNode2, "result", "Pass");
ResultXmlUtility.AssertAttribute(testNode2, "name", "Stub." + @"PassingTestData(foo: 42, bar: ""world"", baz: 21.12)");
}
public void TheoryWithNoDataAttributes()
{
string code = @"
using Xunit.Extensions;
public class Stub
{
[Theory]
public void TheoryMethod(int x)
{
}
}
";
XmlNode assemblyNode = Execute(code, null, "xunit.extensions.dll");
XmlNode testNode = ResultXmlUtility.GetResult(assemblyNode, 0, 0);
ResultXmlUtility.AssertAttribute(testNode, "result", "Fail");
ResultXmlUtility.AssertAttribute(testNode, "name", "Stub.TheoryMethod");
XmlNode failureNode = testNode.SelectSingleNode("failure");
ResultXmlUtility.AssertAttribute(failureNode, "exception-type", typeof(InvalidOperationException).FullName);
XmlNode messageNode = failureNode.SelectSingleNode("message");
Assert.Equal("System.InvalidOperationException : No data found for Stub.TheoryMethod", messageNode.InnerText);
}
public void CallbackIncludesStartMessages()
{
const string code = @"
using Xunit;
public class TestClass
{
[Fact] public void TestMethod1() {}
[Fact] public void TestMethod2() {}
[Fact] public void TestMethod3() {}
}";
using (MockAssembly assembly = new MockAssembly())
{
assembly.Compile(code);
List <XmlNode> nodes = new List <XmlNode>();
using (ExecutorWrapper wrapper = new ExecutorWrapper(assembly.FileName, null, false))
wrapper.RunTests("TestClass",
new List <string> {
"TestMethod1"
},
node => { nodes.Add(node); return(true); });
Assert.Equal(3, nodes.Count);
Assert.Equal("start", nodes[0].Name); // <start>
ResultXmlUtility.AssertAttribute(nodes[0], "name", "TestClass.TestMethod1");
ResultXmlUtility.AssertAttribute(nodes[0], "type", "TestClass");
ResultXmlUtility.AssertAttribute(nodes[0], "method", "TestMethod1");
Assert.Equal("test", nodes[1].Name);
Assert.Equal("class", nodes[2].Name);
}
}
public void AssemblyFilenameInXmlMatchesOriginallyPassedNameToExecutor()
{
using (MockAssembly mockAssembly = new MockAssembly())
{
mockAssembly.Compile("");
XmlNode assemblyNode = mockAssembly.Run(null);
ResultXmlUtility.AssertAttribute(assemblyNode, "name", mockAssembly.FileName);
}
}
public void TestCommandReturnsStartXml_WithDisplayName()
{
MethodInfo method = typeof(TestMethodCommandClass).GetMethod("TestMethod");
Mock <TestCommand> command = new Mock <TestCommand>(Reflector.Wrap(method), "Display Name!", 0);
command.CallBase = true;
XmlNode result = command.Object.ToStartXml();
Assert.Equal("start", result.Name);
ResultXmlUtility.AssertAttribute(result, "name", "Display Name!");
ResultXmlUtility.AssertAttribute(result, "type", typeof(TestMethodCommandClass).FullName);
ResultXmlUtility.AssertAttribute(result, "method", "TestMethod");
}
public void NamedFailingTest()
{
string code = codeHeader + @"
public class ExampleSpecUsage
{
[Spec(""Failing specification"")]
public void Failing()
{
Assert.True(false);
}
}
";
XmlNode assemblyNode = Execute(code);
XmlNode resultNode = ResultXmlUtility.GetResult(assemblyNode);
ResultXmlUtility.AssertAttribute(resultNode, "result", "Fail");
ResultXmlUtility.AssertAttribute(resultNode, "name", "Failing specification");
}
public void FactMethodsCannotHaveArguments()
{
string code = @"
using System;
using Xunit;
public class MockTestClass
{
[Fact] public void FactWithParameters(int x) { }
}
";
XmlNode assemblyNode = Execute(code);
XmlNode testNode = ResultXmlUtility.AssertResult(assemblyNode, "Fail", "MockTestClass.FactWithParameters");
XmlNode failureNode = testNode.SelectSingleNode("failure");
ResultXmlUtility.AssertAttribute(failureNode, "exception-type", typeof(InvalidOperationException).FullName);
Assert.Equal("System.InvalidOperationException : Fact method MockTestClass.FactWithParameters cannot have parameters", failureNode.SelectSingleNode("message").InnerText);
}
public void NamedSkippedTest()
{
string code = codeHeader + @"
public class ExampleSpecUsage
{
[Spec(""Skipped specification"", Skip=""Failing, not sure why..."")]
public void Skippy()
{
Assert.False(true);
}
}
";
XmlNode assemblyNode = Execute(code);
XmlNode resultNode = ResultXmlUtility.GetResult(assemblyNode);
ResultXmlUtility.AssertAttribute(resultNode, "result", "Skip");
ResultXmlUtility.AssertAttribute(resultNode, "name", "Skipped specification");
}
public void ThrowingDataAttributeAcceptanceTest()
{
string code = @"
using System;
using System.Collections.Generic;
using System.Reflection;
using Xunit;
using Xunit.Extensions;
public class MisbehavingTestClass
{
[Theory, MisbehavedData]
public void TheoryWithMisbehavingData(string a)
{
Assert.True(true);
}
}
public class MisbehavedDataAttribute : DataAttribute
{
public override IEnumerable<object[]> GetData(MethodInfo method, Type[] paramTypes)
{
throw new Exception();
}
}
";
XmlNode assemblyNode = Execute(code, null, "xunit.extensions.dll");
XmlNode testNode = ResultXmlUtility.GetResult(assemblyNode, 0, 0);
ResultXmlUtility.AssertAttribute(testNode, "result", "Fail");
ResultXmlUtility.AssertAttribute(testNode, "name", "MisbehavingTestClass.TheoryWithMisbehavingData");
XmlNode failureNode = testNode.SelectSingleNode("failure");
ResultXmlUtility.AssertAttribute(failureNode, "exception-type", typeof(InvalidOperationException).FullName);
XmlNode messageNode = failureNode.SelectSingleNode("message");
Assert.Contains("System.InvalidOperationException : An exception was thrown while getting data for theory MisbehavingTestClass.TheoryWithMisbehavingData:", messageNode.InnerText);
}
public void UsesSingleInstanceOfFixtureDataForAllTests()
{
string code =
@"
using System;
using System.Diagnostics;
using Xunit;
public class TestFixtureTest : IUseFixture<object>
{
public static object fixtureData = null;
public void SetFixture(object data)
{
if (fixtureData == null)
fixtureData = data;
else
Assert.Same(fixtureData, data);
}
[Fact]
public void Test1()
{
}
[Fact]
public void Test2()
{
}
}";
XmlNode assemblyNode = Execute(code);
XmlNode result0 = ResultXmlUtility.GetResult(assemblyNode, 0);
ResultXmlUtility.AssertAttribute(result0, "result", "Pass");
XmlNode result1 = ResultXmlUtility.GetResult(assemblyNode, 1);
ResultXmlUtility.AssertAttribute(result1, "result", "Pass");
}
public void TheoryWithDataAttributesWithNoData()
{
string code = @"
using System;
using System.Collections.Generic;
using System.Reflection;
using Xunit.Extensions;
public class EmptyTheoryData : DataAttribute
{
public override IEnumerable<object[]> GetData(MethodInfo methodUnderTest, Type[] parameterTypes)
{
return new object[0][];
}
}
public class Stub
{
[Theory]
[EmptyTheoryData]
public void TheoryMethod(int x)
{
}
}
";
XmlNode assemblyNode = Execute(code, null, "xunit.extensions.dll");
XmlNode testNode = ResultXmlUtility.GetResult(assemblyNode, 0, 0);
ResultXmlUtility.AssertAttribute(testNode, "result", "Fail");
ResultXmlUtility.AssertAttribute(testNode, "name", "Stub.TheoryMethod");
XmlNode failureNode = testNode.SelectSingleNode("failure");
ResultXmlUtility.AssertAttribute(failureNode, "exception-type", typeof(InvalidOperationException).FullName);
XmlNode messageNode = failureNode.SelectSingleNode("message");
Assert.Equal("System.InvalidOperationException : No data found for Stub.TheoryMethod", messageNode.InnerText);
}
public void TheoryViaXlsAcceptanceTest()
{
if (IntPtr.Size == 8) // Test always fails in 64-bit; no JET engine
{
return;
}
string code = @"
using System.Data;
using Xunit.Extensions;
public class Stub
{
[Theory, ExcelData(@""DataTheories\AcceptanceTestData.xls"", ""select * from Data"")]
public void PassingTestData(int? foo, string bar, string baz)
{
}
}
";
XmlNode assemblyNode = Execute(code, null, "xunit.extensions.dll");
XmlNode testNode1 = ResultXmlUtility.GetResult(assemblyNode, 0, 0);
ResultXmlUtility.AssertAttribute(testNode1, "result", "Pass");
ResultXmlUtility.AssertAttribute(testNode1, "name", "Stub." + @"PassingTestData(foo: 1, bar: ""Foo"", baz: ""Bar"")");
XmlNode testNode2 = ResultXmlUtility.GetResult(assemblyNode, 0, 1);
ResultXmlUtility.AssertAttribute(testNode2, "result", "Pass");
ResultXmlUtility.AssertAttribute(testNode2, "name", "Stub." + @"PassingTestData(foo: null, bar: null, baz: null)");
XmlNode testNode3 = ResultXmlUtility.GetResult(assemblyNode, 0, 2);
ResultXmlUtility.AssertAttribute(testNode3, "result", "Pass");
ResultXmlUtility.AssertAttribute(testNode3, "name", "Stub." + @"PassingTestData(foo: 14, bar: ""Biff"", baz: ""Baz"")");
}
public void TestsFromAbstractBaseClassesShouldBeExecuted()
{
string code = @"
using Xunit;
public abstract class TestBase
{
[Fact]
public void BaseTestMethod() {}
}
public class DerivedTestClass1 : TestBase
{
[Fact]
public void TestMethod1() {}
}
public class DerivedTestClass2 : TestBase
{
[Fact]
public void TestMethod2() {}
}";
XmlNode assemblyNode = Execute(code);
XmlNode result00 = ResultXmlUtility.GetResult(assemblyNode, 0, 0);
ResultXmlUtility.AssertAttribute(result00, "result", "Pass");
XmlNode result01 = ResultXmlUtility.GetResult(assemblyNode, 0, 1);
ResultXmlUtility.AssertAttribute(result01, "result", "Pass");
XmlNode result10 = ResultXmlUtility.GetResult(assemblyNode, 1, 0);
ResultXmlUtility.AssertAttribute(result10, "result", "Pass");
XmlNode result11 = ResultXmlUtility.GetResult(assemblyNode, 1, 1);
ResultXmlUtility.AssertAttribute(result11, "result", "Pass");
}
public void AssertAreEqualTwoNumbersNotEqualShouldThrowException()
{
string code = @"
using System;
using Xunit;
public class MockTestClass
{
[Fact]
public void TwoNumbersAreNotEqual()
{
Assert.Equal(2, 3);
}
}
";
XmlNode assemblyNode = Execute(code);
XmlNode testNode = ResultXmlUtility.AssertResult(assemblyNode, "Fail", "MockTestClass.TwoNumbersAreNotEqual");
XmlNode failureNode = testNode.SelectSingleNode("failure");
ResultXmlUtility.AssertAttribute(failureNode, "exception-type", typeof(EqualException).FullName);
}
public void ClassWithFixtureAndSkippedFactDoesNotSetFixtureData()
{
string code = @"
using Xunit;
public class MyFacts : IUseFixture<object>
{
public void SetFixture(object data)
{
Assert.True(false);
}
[Fact(Skip=""Skip Me!"")]
public void SkippedTest() {}
}
";
XmlNode assemblyNode = Execute(code);
XmlNode result = ResultXmlUtility.GetResult(assemblyNode);
ResultXmlUtility.AssertAttribute(result, "result", "Skip");
}
public void IncorrectParameterCountThrows()
{
string code = @"
using Xunit.Extensions;
public class Stub
{
[Theory]
[InlineData(1)]
[InlineData(2, 3)]
[InlineData(4)]
public void PassingTestData(int x)
{
}
}
";
XmlNode assemblyNode = Execute(code, null, "xunit.extensions.dll");
XmlNode testNode1 = ResultXmlUtility.GetResult(assemblyNode, 0, 0);
ResultXmlUtility.AssertAttribute(testNode1, "result", "Pass");
ResultXmlUtility.AssertAttribute(testNode1, "name", "Stub." + @"PassingTestData(x: 1)");
XmlNode testNode2 = ResultXmlUtility.GetResult(assemblyNode, 0, 1);
ResultXmlUtility.AssertAttribute(testNode2, "result", "Fail");
ResultXmlUtility.AssertAttribute(testNode2, "name", "Stub." + @"PassingTestData(x: 2, ???: 3)");
XmlNode failureNode = testNode2.SelectSingleNode("failure");
ResultXmlUtility.AssertAttribute(failureNode, "exception-type", typeof(InvalidOperationException).FullName);
XmlNode testNode3 = ResultXmlUtility.GetResult(assemblyNode, 0, 2);
ResultXmlUtility.AssertAttribute(testNode3, "result", "Pass");
ResultXmlUtility.AssertAttribute(testNode3, "name", "Stub." + @"PassingTestData(x: 4)");
}
public void TheoryWithInlineDataOfSingleNullPassesNullToTestMethod()
{
string code = @"
using Xunit;
using Xunit.Extensions;
public class Stub
{
[Theory]
[InlineData(null)]
public void PassingTestData(string foo)
{
Assert.Null(foo);
}
}
";
XmlNode assemblyNode = Execute(code, null, "xunit.extensions.dll");
XmlNode testNode = ResultXmlUtility.GetResult(assemblyNode, 0, 0);
ResultXmlUtility.AssertAttribute(testNode, "result", "Pass");
ResultXmlUtility.AssertAttribute(testNode, "name", "Stub.PassingTestData(foo: null)");
}
