private Test TryGetTypeTest(ITypeInfo type, Test assemblyTest)
{
Test typeTest;
if (!typeTests.TryGetValue(type, out typeTest))
{
try
{
XunitTypeInfoAdapter xunitTypeInfo = new XunitTypeInfoAdapter(type);
ITestClassCommand command = TestClassCommandFactory.Make(xunitTypeInfo);
if (command != null)
{
typeTest = CreateTypeTest(xunitTypeInfo, command);
}
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, type, "An exception was thrown while exploring an xUnit.net test type.", ex));
}
if (typeTest != null)
{
assemblyTest.AddChild(typeTest);
typeTests.Add(type, typeTest);
}
}
return(typeTest);
}
public void RunWithClassReturnsTypeToRunWith()
{
ITestClassCommand command = TestClassCommandFactory.Make(typeof(MyRunWithTestClass));
Assert.IsType <MyRunWith>(command);
Assert.Equal(typeof(MyRunWithTestClass), command.TypeUnderTest.Type);
}
public void NoTestMethodsShouldReturnNull()
{
Type type = typeof(StubClass);
ITestClassCommand command = TestClassCommandFactory.Make(type);
Assert.Null(command);
}
private IUnitTestElement ProcessTestMethod(IMethod method, IList<IUnitTestElement> subElements)
{
var type = method.GetContainingType();
var @class = type as IClass;
if (type == null || @class == null)
return null;
var typeInfo = @class.AsTypeInfo();
if (@class.IsAbstract && TypeUtility.ContainsTestMethods(typeInfo))
return ProcessTestMethodInAbstractClass(method, subElements);
if (!IsValidTestClass(@class))
return null;
var command = TestClassCommandFactory.Make(typeInfo);
if (command == null)
return null;
var testClassElement = classes[type];
if (testClassElement == null)
return null;
var methodInfo = method.AsMethodInfo(typeInfo);
if (command.IsTestMethod(methodInfo))
{
var clrTypeName = type.GetClrName();
return unitTestElementFactory.GetOrCreateTestMethod(project, testClassElement, clrTypeName, method.ShortName,
MethodUtility.GetSkipReason(methodInfo), methodInfo.GetTraits(), false);
}
return null;
}
public void StubTestClassMakesTestClassCommand()
{
Type testClassType = typeof(StubTestClass);
ITestClassCommand command = TestClassCommandFactory.Make(testClassType);
Assert.IsType <TestClassCommand>(command);
Assert.Equal(typeof(StubTestClass), command.TypeUnderTest.Type);
}
public XmlNode RunTests(string type, List <string> methods, Predicate <XmlNode> callback)
{
var testClass = testRun.Classes.Single(c => c.Typename == type);
var methodInfos = (from m in methods
select testClass.GetMethod(m)).ToList();
Predicate <XmlNode> nonNullCallback = node => node == null || callback(node);
var testClassCommand = TestClassCommandFactory.Make(testClass);
SetRandomizer(testClassCommand);
var classResult = TestClassCommandRunner.Execute(testClassCommand,
methodInfos,
command => nonNullCallback(command.ToStartXml()),
result => nonNullCallback(ToXml(resultInspector(result))));
return(ToXml(classResult));
}
public void AllStagesOfTestLifetimeExistOnSameThread()
{
Type testClassType = typeof(ThreadLifetimeSpy);
ITestClassCommand command = TestClassCommandFactory.Make(testClassType);
ThreadFixtureSpy.Reset();
ThreadLifetimeSpy.Reset();
TestClassCommandRunner.Execute(command, null, null, null);
// The fixture data may take place on a different thread from the test, but that's
// an acceptable limitation, as the fixture should have no knowledge of the test
// class that it's attached to. This means that fixtures cannot use thread local
// storage, but there's no reason for them to need that anyway, as their own data
// remains the same throughout all the tests for a given class.
Assert.NotEqual(-1, ThreadFixtureSpy.CtorThreadId);
Assert.Equal(ThreadFixtureSpy.CtorThreadId, ThreadFixtureSpy.DisposeThreadId);
Assert.NotEqual(-1, ThreadLifetimeSpy.CtorThreadId);
Assert.Equal(ThreadLifetimeSpy.CtorThreadId, ThreadLifetimeSpy.DisposeThreadId);
Assert.Equal(ThreadLifetimeSpy.CtorThreadId, ThreadLifetimeSpy.TestThreadId);
}
public void TimeoutCommandMustUseReplacementBeginInvoke()
{
Type testClassType = typeof(TestClassCommandFactoryTests.ThreadLifetimeSpy);
ITestClassCommand command = TestClassCommandFactory.Make(testClassType);
TestClassCommandFactoryTests.ThreadFixtureSpy.Reset();
TestClassCommandFactoryTests.ThreadLifetimeSpy.Reset();
try
{
TestClassCommandRunner.Execute(command, null, null, null);
}
catch (NotSupportedException e)
{
// If this test fails, you need to modify TimeoutCommand.Execute to use
// working versions of delegate's BeginInvoke/EndInvoke. You should replace
// with WorkingBeginInvoke and WorkingEndInvoke. WorkingEndInvoke's return
// value will require casting to MethodResult.
// The asynchronous methods on Invoke are compiler generated, and supposed
// to be implemented by the runtime. Silverlight doesn't implement them.
// I don't really know why.
throw new AsyncDelegateMethodsNotSupportedException("TimeoutCommand.Execute", e);
}
}
public TestClassCommandTypeAdapter()
{
testClassCommand = TestClassCommandFactory.Make(typeof(TClassUnderTest));
}
public void RunWithForInvalidTestClassCommandReturnsNull()
{
ITestClassCommand command = TestClassCommandFactory.Make(typeof(MyInvalidRunWithTestClass));
Assert.Null(command);
}
public void AbstractTestClassReturnsNull()
{
ITestClassCommand command = TestClassCommandFactory.Make(typeof(AbstractTestClass));
Assert.Null(command);
}
