private Test BuildSingleFixture(Type type, Attribute attr)
{
object[] arguments = null;
if (attr != null)
{
arguments = (object[])Reflect.GetPropertyValue(attr, "Arguments");
#if NET_2_0
if (type.ContainsGenericParameters)
{
Type[] typeArgs = (Type[])Reflect.GetPropertyValue(attr, "TypeArgs");
if (typeArgs.Length > 0 ||
TypeHelper.CanDeduceTypeArgsFromArgs(type, arguments, ref typeArgs))
{
type = TypeHelper.MakeGenericType(type, typeArgs);
}
}
#endif
}
this.fixture = new NUnitTestFixture(type, arguments);
CheckTestFixtureIsValid(fixture);
NUnitFramework.ApplyCommonAttributes(type, fixture);
AddTestCases(type);
if (this.fixture.RunState != RunState.NotRunnable && this.fixture.TestCount == 0)
{
this.fixture.RunState = RunState.NotRunnable;
this.fixture.IgnoreReason = fixture.TestName.Name + " does not have any tests";
}
return(this.fixture);
}
////private MethodInfo _methodinfo;
/// <summary>
/// Constructor to map method with this class.
/// </summary>
/// <param name="method">Method in test fixture without parameters.</param>
public WalmartTestMethod(MethodInfo method)
: base(method)
{
NUnitFramework.ApplyCommonAttributes(method, this);
NUnitFramework.ApplyExpectedExceptionAttribute(method, this);
var categories = new List <string>();
var className = method.DeclaringType;
categories.ForEach(c => Categories.Add(c));
var notReadyAttr = method.GetCustomAttributes(typeof(NotReadyAttribute), true);
if (notReadyAttr.Any())
{
Categories.Add("NotReady");
}
////Add EUAT as Category
var regressionAttr = method.GetCustomAttributes(typeof(RegressionAttribute), true);
if (regressionAttr.Any())
{
Categories.Add("Regression");
}
////Add ToFix as Category
var tofixAttr = method.GetCustomAttributes(typeof(ToFixAttribute), true);
if (tofixAttr.Any())
{
Categories.Add("ToFix");
}
}
private bool IsValidFixtureType(Type type, ref string reason)
{
if (type.IsAbstract)
{
reason = string.Format("{0} is an abstract class", type.FullName);
return(false);
}
if (Reflect.GetConstructor(type) == null)
{
reason = string.Format("{0} does not have a valid constructor", type.FullName);
return(false);
}
if (!NUnitFramework.CheckSetUpTearDownMethods(type, NUnitFramework.SetUpAttribute, ref reason) ||
!NUnitFramework.CheckSetUpTearDownMethods(type, NUnitFramework.TearDownAttribute, ref reason))
{
return(false);
}
if (Reflect.HasMethodWithAttribute(type, NUnitFramework.FixtureSetUpAttribute, true))
{
reason = "TestFixtureSetUp method not allowed on a SetUpFixture";
return(false);
}
if (Reflect.HasMethodWithAttribute(type, NUnitFramework.FixtureTearDownAttribute, true))
{
reason = "TestFixtureTearDown method not allowed on a SetUpFixture";
return(false);
}
return(true);
}
/// <summary>
/// Initializes an instance of <see cref="InconclusiveTestCase"/>.
/// </summary>
/// <param name="testCase">Original test case.</param>
public InconclusiveTestCase(NUnitTestMethod testCase)
: base(testCase.Method)
{
NUnitFramework.ApplyCommonAttributes(testCase.Method, this);
NUnitFramework.ApplyExpectedExceptionAttribute(testCase.Method, this);
// Copy all the attributes of the original test
this.BuilderException = testCase.BuilderException;
this.Categories = testCase.Categories;
this.Description = testCase.Description;
this.ExceptionProcessor = testCase.ExceptionProcessor;
this.Fixture = testCase.Fixture;
this.IgnoreReason = testCase.IgnoreReason;
this.Parent = testCase.Parent;
this.Properties = testCase.Properties;
this.RunState = testCase.RunState;
this.TestName.Name = testCase.TestName.Name;
this.TestName.FullName = testCase.TestName.FullName;
this.TestName.RunnerID = testCase.TestName.RunnerID;
this.TestName.TestID = testCase.TestName.TestID;
this.setUpMethods = GetFieldValue <MethodInfo[]>(typeof(TestMethod), testCase, "setUpMethods");
this.tearDownMethods = GetFieldValue <MethodInfo[]>(typeof(TestMethod), testCase, "tearDownMethods");
this.actions = GetFieldValue <TestAction[]>(typeof(TestMethod), testCase, "actions");
this.suiteActions = GetFieldValue <TestAction[]>(typeof(TestMethod), testCase, "suiteActions");
this.SetFieldValue("arguments", GetFieldValue <object[]>(typeof(TestMethod), testCase, "arguments"));
this.SetFieldValue("expectedResult", GetFieldValue <object>(typeof(TestMethod), testCase, "expectedResult"));
this.SetFieldValue("hasExpectedResult", GetFieldValue <bool>(typeof(TestMethod), testCase, "hasExpectedResult"));
}
protected void InspectTests(ITest test, List <string> methodNames, HashSet <string> categoryNames)
{
foreach (ITest t in test.Tests)
{
if (t is NUnitTestMethod)
{
methodNames.Add(t.TestName.FullName);
}
if (t.Categories != null)
{
foreach (string category in t.Categories)
{
if (NUnitFramework.IsValidCategoryName(category) && !categoryNames.Contains(category))
{
categoryNames.Add(category);
}
}
}
if (t.Tests != null)
{
InspectTests(t, methodNames, categoryNames);
}
}
}
/// <summary>
/// Check that the fixture type is valid. This method ensures that
/// the type is not abstract and that there is no more than one of
/// each setup or teardown method and that their signatures are correct.
/// </summary>
/// <param name="fixtureType">The type of the fixture to check</param>
/// <param name="reason">A message indicating why the fixture is invalid</param>
/// <returns>True if the fixture is valid, false if not</returns>
private bool IsValidFixtureType(Type fixtureType, ref string reason)
{
//if (fixtureType.IsAbstract && !fixtureType.IsSealed)
//{
// reason = string.Format("{0} is an abstract class", fixtureType.FullName);
// return false;
//}
#if CLR_2_0 || CLR_4_0
if (fixtureType.ContainsGenericParameters)
{
reason = "Fixture type contains generic parameters. You must either provide "
+ "Type arguments or specify constructor arguments that allow NUnit "
+ "to deduce the Type arguments.";
return(false);
}
#endif
return(NUnitFramework.CheckSetUpTearDownMethods(fixtureType, NUnitFramework.SetUpAttribute, ref reason) &&
NUnitFramework.CheckSetUpTearDownMethods(fixtureType, NUnitFramework.TearDownAttribute, ref reason) &&
NUnitFramework.CheckSetUpTearDownMethods(fixtureType, NUnitFramework.TestFixtureSetUpAttribute, ref reason) &&
NUnitFramework.CheckSetUpTearDownMethods(fixtureType, NUnitFramework.OneTimeSetUpAttribute, ref reason) &&
NUnitFramework.CheckSetUpTearDownMethods(fixtureType, NUnitFramework.TestFixtureTearDownAttribute, ref reason) &&
NUnitFramework.CheckSetUpTearDownMethods(fixtureType, NUnitFramework.OneTimeTearDownAttribute, ref reason));
}
public static TestSuite CreateTestSuite(MethodInfo method)
{
var suite = new DecompilationTestSuite(method);
NUnitFramework.ApplyCommonAttributes(method, suite);
PopulateTestSuite(method, suite);
return(suite);
}
public Test BuildFrom(Type type)
{
var testFixture = new ConcordionTestFixture(type);
testFixture.Add(new ConcordionTest(type));
NUnitFramework.ApplyCommonAttributes(type, testFixture);
return(testFixture);
}
public Test BuildFrom(Type type)
{
var testSuite = new TestSuite(type.FullName);
testSuite.Add(new ConcordionTest(type));
NUnitFramework.ApplyCommonAttributes(type, testSuite);
return(testSuite);
}
private static void HandleException(Exception e, TestResult testResult)
{
if (e is NUnitException)
{
e = e.InnerException;
}
testResult.SetResult(NUnitFramework.GetResultState(e), e);
}
public Test BuildFrom(Type type)
{
NativeTestFactory nativeTestFactory = new NativeTestFactory();
SpecificationBuilder.BuildTestFixture(type, nativeTestFactory, new GlobalSetupOwner());
var result = nativeTestFactory.RootTest.GetNative() as Test;
NUnitFramework.ApplyCommonAttributes(type.GetCustomAttributes(false).Cast <Attribute>().ToArray(), result);
return(result);
}
public RowTestSuite CreateRowTestSuite(MethodInfo method)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
RowTestSuite testSuite = new RowTestSuite(method);
NUnitFramework.ApplyCommonAttributes(method, testSuite);
return(testSuite);
}
public void AddCategories(ITest test)
{
if (test.Categories != null)
{
foreach (string name in test.Categories)
{
if (NUnitFramework.IsValidCategoryName(name))
{
Add(name);
}
}
}
}
public static CecilTestSuite CreateTestSuite(MethodInfo method)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
var suite = new CecilTestSuite(method);
NUnitFramework.ApplyCommonAttributes(method, suite);
PopulateTestSuite(method, suite);
return(suite);
}
private Test BuildSingleFixture(Type type, Attribute attr)
{
object[] arguments = null;
IList categories = null;
if (attr != null)
{
arguments = (object[])Reflect.GetPropertyValue(attr, "Arguments");
categories = Reflect.GetPropertyValue(attr, "Categories") as IList;
#if CLR_2_0 || CLR_4_0
if (type.ContainsGenericParameters)
{
Type[] typeArgs = (Type[])Reflect.GetPropertyValue(attr, "TypeArgs");
if (typeArgs.Length > 0 ||
TypeHelper.CanDeduceTypeArgsFromArgs(type, arguments, ref typeArgs))
{
type = TypeHelper.MakeGenericType(type, typeArgs);
}
}
#endif
}
this.fixture = new NUnitTestFixture(type, arguments);
CheckTestFixtureIsValid(fixture);
NUnitFramework.ApplyCommonAttributes(type, fixture);
if (categories != null)
{
foreach (string category in categories)
{
fixture.Categories.Add(category);
}
}
if (fixture.RunState == RunState.Runnable && attr != null)
{
object objIgnore = Reflect.GetPropertyValue(attr, "Ignore");
if (objIgnore != null && (bool)objIgnore == true)
{
fixture.RunState = RunState.Ignored;
fixture.IgnoreReason = (string)Reflect.GetPropertyValue(attr, "IgnoreReason");
}
}
AddTestCases(type);
return(this.fixture);
}
/// <summary>
/// Builds a single NUnitTestMethod, either as a child of the fixture
/// or as one of a set of test cases under a ParameterizedTestMethodSuite.
/// </summary>
/// <param name="method">The MethodInfo from which to construct the TestMethod</param>
/// <param name="parms">The ParameterSet to be used, or null</param>
/// <returns></returns>
public static NUnitTestMethod BuildSingleTestMethod(MethodInfo method, ParameterSet parms)
{
NUnitTestMethod testMethod = new NUnitTestMethod(method);
if (CheckTestMethodSignature(testMethod, parms))
{
NUnitFramework.ApplyCommonAttributes(method, testMethod);
NUnitFramework.ApplyExpectedExceptionAttribute(method, testMethod);
}
if (parms != null)
{
// NOTE: After the call to CheckTestMethodSignature, the Method
// property of testMethod may no longer be the same as the
// original MethodInfo, so we reassign it here.
method = testMethod.Method;
if (parms.TestName != null)
{
testMethod.TestName.Name = parms.TestName;
testMethod.TestName.FullName = method.ReflectedType.FullName + "." + parms.TestName;
}
else if (parms.Arguments != null)
{
string name = MethodHelper.GetDisplayName(method, parms.Arguments);
testMethod.TestName.Name = name;
testMethod.TestName.FullName = method.ReflectedType.FullName + "." + name;
}
if (parms.ExpectedExceptionName != null)
{
testMethod.exceptionProcessor = new ExpectedExceptionProcessor(testMethod, parms);
}
foreach (string key in parms.Properties.Keys)
{
testMethod.Properties.Add(key, parms.Properties[key]);
}
// Description is stored in parms.Properties
if (parms.Description != null)
{
testMethod.Description = parms.Description;
}
}
return(testMethod);
}
private TestSuite BuildTestAssembly(string assemblyName, IList fixtures, bool autoSuites)
{
TestSuite testAssembly = new TestAssembly(assemblyName);
if (autoSuites)
{
NamespaceTreeBuilder treeBuilder =
new NamespaceTreeBuilder(testAssembly);
treeBuilder.Add(fixtures);
testAssembly = treeBuilder.RootSuite;
}
else
{
foreach (TestSuite fixture in fixtures)
{
if (fixture != null)
{
if (fixture is SetUpFixture)
{
fixture.RunState = RunState.NotRunnable;
fixture.IgnoreReason = "SetUpFixture cannot be used when loading tests as a flat list of fixtures";
}
testAssembly.Add(fixture);
}
}
}
if (fixtures.Count == 0)
{
testAssembly.RunState = RunState.NotRunnable;
testAssembly.IgnoreReason = "Has no TestFixtures";
}
NUnitFramework.ApplyCommonAttributes(assembly, testAssembly);
testAssembly.Properties["_PID"] = System.Diagnostics.Process.GetCurrentProcess().Id;
testAssembly.Properties["_APPDOMAIN"] = AppDomain.CurrentDomain.FriendlyName;
// TODO: Make this an option? Add Option to sort assemblies as well?
testAssembly.Sort();
return(testAssembly);
}
TestFixture BuildFixture(Type type, ParameterizedTestFixtureAttribute attr, object parameter)
{
var categories = (IList <string>)Reflect.GetPropertyValue(attr, "Categories");
Type fixtureType;
if (type.IsGenericType)
{
fixtureType = type.MakeGenericType(attr.Type);
}
else
{
fixtureType = type;
}
var parameterizedFixture = typeof(ParameterizedTestFixture <>).MakeGenericType(attr.Type);
var fixture = (NUnitTestFixture)Reflect.Construct(parameterizedFixture, new object[] { fixtureType, Configuration, parameter });
NUnitFramework.ApplyCommonAttributes(fixtureType, fixture);
if (categories != null)
{
foreach (string category in categories)
{
fixture.Categories.Add(category);
}
}
if (fixture.RunState == RunState.Runnable && attr != null)
{
var objIgnore = Reflect.GetPropertyValue(attr, "Ignore");
if (objIgnore != null && (bool)objIgnore == true)
{
fixture.RunState = RunState.Ignored;
fixture.IgnoreReason = (string)Reflect.GetPropertyValue(attr, "IgnoreReason");
}
}
AddTestCases(fixture);
return(fixture);
}
/// <summary>
/// Determine if the method is an NUnit test method.
/// The method must normally be marked with the test
/// attribute for this to be true. If the test config
/// file sets AllowOldStyleTests to true, then any
/// method beginning "test..." (case-insensitive)
/// is treated as a test unless it is also marked
/// as a setup or teardown method.
/// </summary>
/// <param name="method">A MethodInfo for the method being used as a test method</param>
/// <returns>True if the builder can create a test case from this method</returns>
public override bool CanBuildFrom(MethodInfo method)
{
if (Reflect.HasAttribute(method, NUnitFramework.TestAttribute, false))
{
return(true);
}
if (allowOldStyleTests)
{
Regex regex = new Regex("^(?i:test)");
if (regex.Match(method.Name).Success &&
!NUnitFramework.IsSetUpMethod(method) &&
!NUnitFramework.IsTearDownMethod(method) &&
!NUnitFramework.IsFixtureSetUpMethod(method) &&
!NUnitFramework.IsFixtureTearDownMethod(method))
{
return(true);
}
}
return(false);
}
private TestSuite BuildTestAssembly(string assemblyName, IList fixtures, bool autoSuites)
{
TestSuite testAssembly = new TestSuite(assemblyName);
if (autoSuites)
{
NamespaceTreeBuilder treeBuilder =
new NamespaceTreeBuilder(testAssembly);
treeBuilder.Add(fixtures);
testAssembly = treeBuilder.RootSuite;
}
else
{
foreach (TestSuite fixture in fixtures)
{
if (fixture is SetUpFixture)
{
fixture.RunState = RunState.NotRunnable;
fixture.IgnoreReason = "SetUpFixture cannot be used when loading tests as a flat list of fixtures";
}
testAssembly.Add(fixture);
}
}
if (fixtures.Count == 0)
{
testAssembly.RunState = RunState.NotRunnable;
testAssembly.IgnoreReason = "Has no TestFixtures";
}
NUnitFramework.ApplyCommonAttributes(assembly, testAssembly);
// TODO: Make this an option? Add Option to sort assemblies as well?
testAssembly.Sort();
return(testAssembly);
}
/// <summary>
/// Builds a single NUnitTestMethod, either as a child of the fixture
/// or as one of a set of test cases under a ParameterizedTestMethodSuite.
/// </summary>
/// <param name="method">The MethodInfo from which to construct the TestMethod</param>
/// <param name="parms">The ParameterSet to be used, or null</param>
/// <returns></returns>
public static NUnitTestMethod BuildSingleTestMethod(MethodInfo method, Test parentSuite, ParameterSet parms)
{
NUnitTestMethod testMethod = new NUnitTestMethod(method);
string prefix = method.ReflectedType.FullName;
if (parentSuite != null)
{
prefix = parentSuite.TestName.FullName;
testMethod.TestName.FullName = prefix + "." + testMethod.TestName.Name;
}
if (CheckTestMethodSignature(testMethod, parms))
{
if (parms == null)
{
NUnitFramework.ApplyCommonAttributes(method, testMethod);
}
NUnitFramework.ApplyExpectedExceptionAttribute(method, testMethod);
}
if (parms != null)
{
// NOTE: After the call to CheckTestMethodSignature, the Method
// property of testMethod may no longer be the same as the
// original MethodInfo, so we reassign it here.
method = testMethod.Method;
if (parms.TestName != null)
{
testMethod.TestName.Name = parms.TestName;
testMethod.TestName.FullName = prefix + "." + parms.TestName;
}
else if (parms.OriginalArguments != null)
{
string name = MethodHelper.GetDisplayName(method, parms.OriginalArguments);
testMethod.TestName.Name = name;
testMethod.TestName.FullName = prefix + "." + name;
}
if (parms.Ignored)
{
testMethod.RunState = RunState.Ignored;
testMethod.IgnoreReason = parms.IgnoreReason;
}
else if (parms.Explicit)
{
testMethod.RunState = RunState.Explicit;
}
if (parms.ExpectedExceptionName != null)
{
testMethod.exceptionProcessor = new ExpectedExceptionProcessor(testMethod, parms);
}
foreach (string key in parms.Properties.Keys)
{
testMethod.Properties[key] = parms.Properties[key];
}
// Description is stored in parms.Properties
if (parms.Description != null)
{
testMethod.Description = parms.Description;
}
}
//if (testMethod.BuilderException != null && testMethod.RunState != RunState.NotRunnable)
//{
// testMethod.RunState = RunState.NotRunnable;
// testMethod.IgnoreReason = testMethod.BuilderException.Message;
//}
if (parentSuite != null)
{
if (parentSuite.RunState == RunState.NotRunnable && testMethod.RunState != RunState.NotRunnable)
{
testMethod.RunState = RunState.NotRunnable;
testMethod.IgnoreReason = parentSuite.IgnoreReason;
}
if (parentSuite.RunState == RunState.Ignored && testMethod.RunState != RunState.Ignored && testMethod.RunState != RunState.NotRunnable)
{
testMethod.RunState = RunState.Ignored;
testMethod.IgnoreReason = parentSuite.IgnoreReason;
}
}
return(testMethod);
}
/// <summary>
/// Get Testcase with Test case attributes
/// </summary>
/// <param name="method">The MethodInfo object.</param>
public ArrayList GetTestCasesWithTestCaseAttribute(MethodInfo method)
{
ArrayList testCaseCollection = new ArrayList();
testMethods = Reflect.IsAsyncMethod(method) ? new NUnitAsyncTestMethod(method) : new NUnitTestMethod(method);
ParameterizedMethodSuite methodSuite = new ParameterizedMethodSuite(method);
NUnitFramework.ApplyCommonAttributes(method, methodSuite);
IEnumerable ParameterList = ParamProvider.GetTestCasesFor(method);
testCaseCollection.Add(testMethods.FixtureType.FullName + "." + method.Name);
foreach (object source in ParameterList)
{
ParameterSet parms;
if (source == null)
{
parms = new ParameterSet();
parms.Arguments = new object[] { null };
}
else
{
parms = source as ParameterSet;
}
if (parms == null)
{
if (source.GetType().GetInterface("NUnit.Framework.ITestCaseData") != null)
{
parms = ParameterSet.FromDataSource(source);
}
else
{
parms = new ParameterSet();
ParameterInfo[] parameters = method.GetParameters();
Type sourceType = source.GetType();
if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(sourceType))
{
parms.Arguments = new object[] { source }
}
;
else if (source is object[])
{
parms.Arguments = (object[])source;
}
else if (source is Array)
{
Array array = (Array)source;
if (array.Rank == 1)
{
parms.Arguments = new object[array.Length];
for (int i = 0; i < array.Length; i++)
{
parms.Arguments[i] = (object)array.GetValue(i);
}
}
}
else
{
parms.Arguments = new object[] { source }
};
}
}
TestMethod testMethod = NUnit.Core.Builders.NUnitTestCaseBuilder.BuildSingleTestMethod(method, null, parms);
testCaseCollection.Add(testMethod.TestName.FullName);
}
return(testCaseCollection);
}
/// <summary>
/// Set additional properties of the newly created test case based
/// on its attributes. As implemented, the method sets the test's
/// RunState, Description, Categories and Properties.
/// </summary>
/// <param name="method">A MethodInfo for the method being used as a test method</param>
/// <param name="testCase">The test case being constructed</param>
protected override void SetTestProperties(MethodInfo method, TestCase testCase)
{
NUnitFramework.ApplyCommonAttributes(method, testCase);
NUnitFramework.ApplyExpectedExceptionAttribute(method, (TestMethod)testCase);
}
public TestMethodExtension BuildSingleTestMethod(MethodInfo method, Test parentSuite, ParameterSet parms, ScreenCapture screenCapture, IDictionary properties)
{
//TODO : Here it doesn't support Async Await Method, BTW, the Async Await just be supported from .net 4.5
TestMethodExtension testMethod = new TestMethodExtension(method, screenCapture);
string prefix = method.ReflectedType.FullName;
if (parentSuite != null)
{
testMethod.Properties = properties;
prefix = parentSuite.TestName.FullName;
testMethod.TestName.FullName = prefix + "." + testMethod.TestName.Name;
}
if (CheckTestMethodSignature(testMethod, parms))
{
if (parms == null)
{
NUnitFramework.ApplyCommonAttributes(method, testMethod);
}
NUnitFramework.ApplyExpectedExceptionAttribute(method, testMethod);
}
if (parms != null)
{
method = testMethod.Method;
if (parms.TestName != null)
{
testMethod.TestName.Name = parms.TestName;
testMethod.TestName.FullName = prefix + "." + parms.TestName;
}
else if (parms.OriginalArguments != null)
{
string name = MethodHelper.GetDisplayName(method, parms.OriginalArguments);
testMethod.TestName.Name = name;
testMethod.TestName.FullName = prefix + "." + name;
}
if (parms.Ignored)
{
testMethod.RunState = RunState.Ignored;
testMethod.IgnoreReason = parms.IgnoreReason;
}
else if (parms.Explicit)
{
testMethod.RunState = RunState.Explicit;
}
foreach (string key in parms.Properties.Keys)
{
testMethod.Properties[key] = parms.Properties[key];
}
if (parms.Description != null)
{
testMethod.Description = parms.Description;
}
}
if (parentSuite != null)
{
if (parentSuite.RunState == RunState.NotRunnable && testMethod.RunState != RunState.NotRunnable)
{
testMethod.RunState = RunState.NotRunnable;
testMethod.IgnoreReason = parentSuite.IgnoreReason;
}
if (parentSuite.RunState == RunState.Ignored && testMethod.RunState != RunState.Ignored && testMethod.RunState != RunState.NotRunnable)
{
testMethod.RunState = RunState.Ignored;
testMethod.IgnoreReason = parentSuite.IgnoreReason;
}
}
return(testMethod);
}
public RandomizerTestFixture(Type fixtureType)
: base(fixtureType)
{
this.fixtureSetUp = NUnitFramework.GetFixtureSetUpMethod(fixtureType);
this.fixtureTearDown = NUnitFramework.GetFixtureTearDownMethod(fixtureType);
}
private Test BuildSingleFixture(Type type, Attribute attr)
{
object[] arguments = null;
IList categories = null;
if (attr != null)
{
arguments = GetArgsFromAttribute(attr);
categories = Reflect.GetPropertyValue(attr, "Categories") as IList;
#if CLR_2_0 || CLR_4_0
if (type.ContainsGenericParameters)
{
Type[] typeArgs = GetTypeArgsFromAttribute(attr);
if (typeArgs == null)
{
int cnt = 0;
foreach (object o in arguments)
{
if (o is Type)
{
cnt++;
}
else
{
break;
}
}
typeArgs = new Type[cnt];
for (int i = 0; i < cnt; i++)
{
typeArgs[i] = (Type)arguments[i];
}
if (cnt > 0)
{
object[] args = new object[arguments.Length - cnt];
for (int i = 0; i < args.Length; i++)
{
args[i] = arguments[cnt + i];
}
arguments = args;
}
}
if (typeArgs.Length > 0 ||
TypeHelper.CanDeduceTypeArgsFromArgs(type, arguments, ref typeArgs))
{
type = TypeHelper.MakeGenericType(type, typeArgs);
}
}
#endif
}
this.fixture = new NUnitTestFixture(type, arguments);
CheckTestFixtureIsValid(fixture);
NUnitFramework.ApplyCommonAttributes(type, fixture);
if (categories != null)
{
foreach (string category in categories)
{
fixture.Categories.Add(category);
}
}
if (fixture.RunState == RunState.Runnable && attr != null)
{
object objIgnore = Reflect.GetPropertyValue(attr, "Ignore");
if (objIgnore != null && (bool)objIgnore == true)
{
fixture.RunState = RunState.Ignored;
fixture.IgnoreReason = (string)Reflect.GetPropertyValue(attr, "IgnoreReason");
}
}
AddTestCases(type);
return(this.fixture);
}
/// <summary>
/// Method that sets properties of the test suite based on the
/// information in the provided Type.
/// </summary>
/// <param name="type">The type to examine</param>
/// <param name="suite">The test suite being constructed</param>
protected override void SetTestSuiteProperties(Type type, TestSuite suite)
{
base.SetTestSuiteProperties(type, suite);
NUnitFramework.ApplyCommonAttributes(type, suite);
}
protected override void DoOneTimeSetUp(TestResult suiteResult)
{
base.DoOneTimeSetUp(suiteResult);
suiteResult.AssertCount = NUnitFramework.GetAssertCount();
}
protected override void DoOneTimeTearDown(TestResult suiteResult)
{
base.DoOneTimeTearDown(suiteResult);
suiteResult.AssertCount += NUnitFramework.GetAssertCount();
}
/// <summary>
/// Builds a ParameterizedMetodSuite containing individual
/// test cases for each set of parameters provided for
/// this method.
/// </summary>
/// <param name="method">The MethodInfo for which a test is to be built</param>
/// <returns>A ParameterizedMethodSuite populated with test cases</returns>
public static Test BuildParameterizedMethodSuite(MethodInfo method, Test parentSuite)
{
ParameterizedMethodSuite methodSuite = new ParameterizedMethodSuite(method);
NUnitFramework.ApplyCommonAttributes(method, methodSuite);
if (parentSuite != null)
{
if (parentSuite.RunState == RunState.NotRunnable && methodSuite.RunState != RunState.NotRunnable)
{
methodSuite.RunState = RunState.NotRunnable;
methodSuite.IgnoreReason = parentSuite.IgnoreReason;
}
if (parentSuite.RunState == RunState.Ignored && methodSuite.RunState != RunState.Ignored && methodSuite.RunState != RunState.NotRunnable)
{
methodSuite.RunState = RunState.Ignored;
methodSuite.IgnoreReason = parentSuite.IgnoreReason;
}
}
foreach (object source in CoreExtensions.Host.TestCaseProviders.GetTestCasesFor(method, parentSuite))
{
ParameterSet parms;
if (source == null)
{
parms = new ParameterSet();
parms.Arguments = new object[] { null };
}
else
{
parms = source as ParameterSet;
}
if (parms == null)
{
if (source.GetType().GetInterface("NUnit.Framework.ITestCaseData") != null)
{
parms = ParameterSet.FromDataSource(source);
}
else
{
parms = new ParameterSet();
ParameterInfo[] parameters = method.GetParameters();
Type sourceType = source.GetType();
if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(sourceType))
{
parms.Arguments = new object[] { source }
}
;
else if (source is object[])
{
parms.Arguments = (object[])source;
}
else if (source is Array)
{
Array array = (Array)source;
if (array.Rank == 1)
{
parms.Arguments = new object[array.Length];
for (int i = 0; i < array.Length; i++)
{
parms.Arguments[i] = (object)array.GetValue(i);
}
}
}
else
{
parms.Arguments = new object[] { source }
};
}
}
TestMethod test = BuildSingleTestMethod(method, parentSuite, parms);
methodSuite.Add(test);
}
return(methodSuite);
}
