public static NUnitTestMethod MakeTestCase(object fixture, string methodName) { NUnitTestMethod test = MakeTestCase(fixture.GetType(), methodName); test.Fixture = fixture; return(test); }
/// <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")); }
public WebDriverTestMethod(NUnitTestMethod method, bool needsNewDriverBeforeTest, bool needsNewDriverAfterTest) : base(method.Method) { this.needsDriverBefore = needsNewDriverBeforeTest; this.needsDriverAfter = needsNewDriverAfterTest; this.ExceptionProcessor = method.ExceptionProcessor; }
public void TestCases(MethodInfo method, RunState state) { Test built = _sut.BuildFrom(method); NUnitTestMethod testMethod = built.Tests[0] as NUnitTestMethod; Assert.IsNotNull(testMethod); Assert.That(testMethod.RunState, Is.EqualTo(state)); }
public void SetUp() { MethodInfo fakeTestMethod1 = GetType() .GetMethod("FakeTestMethod1", BindingFlags.Instance | BindingFlags.NonPublic); fakeTest1 = new NUnitTestMethod(fakeTestMethod1); MethodInfo fakeTestMethod2 = GetType() .GetMethod("FakeTestMethod2", BindingFlags.Instance | BindingFlags.NonPublic); fakeTest2 = new NUnitTestMethod(fakeTestMethod2); }
public WebDriverTestMethod(NUnitTestMethod method, bool needsNewDriverBeforeTest, bool needsNewDriverAfterTest) : base(method.Method) { this.needsDriverBefore = needsNewDriverBeforeTest; this.needsDriverAfter = needsNewDriverAfterTest; this.ExceptionExpected = method.ExceptionExpected; this.ExceptionHandler = method.ExceptionHandler; this.ExpectedExceptionName = method.ExpectedExceptionName; this.ExpectedExceptionType = method.ExpectedExceptionType; this.ExpectedMessage = method.ExpectedMessage; }
public string SetTestName(NUnitTestMethod test, string newName) { string previousName = test.TestName.Name; test.TestName.Name = newName; // Just in case the class name is the same as the test name, we only want to replace the test name portion // test.TestName.FullName = test.TestName.FullName.Replace(previousName, newName); int indexOfTestName = test.TestName.FullName.LastIndexOf(previousName); test.TestName.FullName = test.TestName.FullName.Remove(indexOfTestName); test.TestName.FullName += newName; return(test.TestName.FullName); }
public RetriedTestMethod(NUnitTestMethod test, int tryCount, int requiredPassCount) : base(test.TestName) { this.backingTest = test; this.tryCount = tryCount; this.requiredPassCount = requiredPassCount; this.Properties = backingTest.Properties; this.Categories = backingTest.Categories; this.Description = backingTest.Description; this.IgnoreReason = backingTest.IgnoreReason; this.RunState = backingTest.RunState; }
public void TestMethodSpecifiedInInitialize() { var method = new DefaultUnresolvedMethod(new DefaultUnresolvedTypeDefinition("TestFixture"), "Test"); var testMethod = new NUnitTestMethod(testProject, method); NUnitConsoleApplication app = new NUnitConsoleApplication(new[] { testMethod }); app.NoLogo = false; app.ShadowCopy = true; app.NoXmlOutputFile = false; string expectedCommandLine = "\"C:\\Projects\\MyTests\\MyTests.dll\" /run=\"TestFixture.Test\""; Assert.AreEqual(expectedCommandLine, app.GetArguments()); }
public override void SetUp() { base.SetUp(); AddCodeFile("test.cs", @"using NUnit.Framework; namespace RootNamespace.Tests { [TestFixture] class MyTestFixture { [Test] public void TestMethod1() {} [Test] public void TestMethod2() {} } }"); testClass = testProject.GetTestClass(new FullTypeName("RootNamespace.Tests.MyTestFixture")); testMethod1 = testClass.FindTestMethod("TestMethod1"); testMethod2 = testClass.FindTestMethod("TestMethod2"); }
public Test Decorate(Test test, MemberInfo member) { NUnitTestMethod testMethod = test as NUnitTestMethod; if (testMethod != null && testMethod.RunState == RunState.Runnable) { List <Attribute> ignoreAttributes = new List <Attribute>(); Attribute[] ignoreAttr = Reflect.GetAttributes(member, IgnoreBrowserAttributeTypeFullName, true); if (ignoreAttr != null) { ignoreAttributes.AddRange(ignoreAttr); } Attribute[] ignoreClassAttributes = Reflect.GetAttributes(member.DeclaringType, IgnoreBrowserAttributeTypeFullName, true); if (ignoreClassAttributes != null) { ignoreAttributes.AddRange(ignoreClassAttributes); } foreach (Attribute attr in ignoreAttributes) { IgnoreBrowserAttribute browserToIgnoreAttr = attr as IgnoreBrowserAttribute; if (browserToIgnoreAttr != null && IgnoreTestForBrowser(browserToIgnoreAttr.Value)) { string ignoreReason = "Ignoring browser " + EnvironmentManager.Instance.Browser.ToString() + "."; if (!string.IsNullOrEmpty(browserToIgnoreAttr.Reason)) { ignoreReason = ignoreReason + " " + browserToIgnoreAttr.Reason; } test.RunState = RunState.Ignored; test.IgnoreReason = ignoreReason; } } if (test.RunState == RunState.Runnable) { NeedsFreshDriverAttribute needsDriverAttr = Reflect.GetAttribute(member, NeedsFreshDriverAttributeTypeFullName, false) as NeedsFreshDriverAttribute; if (needsDriverAttr != null) { test = new WebDriverTestMethod(testMethod, needsDriverAttr.BeforeTest, needsDriverAttr.AfterTest); } } } return(test); }
/// <summary> /// Initializes an instance of this class. /// </summary> /// <param name="fixtureType">The type of the test fixture</param> /// <param name="param">The argument to pass to the Test Fixture Set Up method</param> public BrowserStackFixture(Type fixtureType, string param) : base(fixtureType) { this.Fixture = Reflect.Construct(fixtureType); this.Param = param; ModifyTestName(this.TestName, param); this.fixtureTearDownMethods = Reflect.GetMethodsWithAttribute(fixtureType, NUnitFramework.FixtureTearDownAttribute, true); this.setUpMethods = Reflect.GetMethodsWithAttribute(fixtureType, NUnitFramework.SetUpAttribute, true); this.tearDownMethods = Reflect.GetMethodsWithAttribute(fixtureType, NUnitFramework.TearDownAttribute, true); foreach (MethodInfo method in Reflect.GetMethodsWithAttribute(fixtureType, NUnitFramework.TestAttribute, true)) { NUnitTestMethod methodTest = new NUnitTestMethod(method); ModifyTestName(methodTest.TestName, param); this.Add(methodTest); } }
public override void SetUp() { base.SetUp(); resultChangedCalled = false; AddCodeFile("test.cs", @" using NUnit.Framework; namespace RootNamespace.Tests { [TestFixture] class MyTestFixture { [Test] public void TestMethod() { } } }"); testClass = (NUnitTestClass)testProject.NestedTests.Single().NestedTests.Single(); testMethod = (NUnitTestMethod)testClass.NestedTests.Single(); }
/// <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); }
public override void SetUp() { base.SetUp(); AddCodeFileInNamespace("base.cs", @" abstract class MyTestFixtureBase { [Test] public void MyTest() {} [Test] public void MyTest() {} }"); AddCodeFileInNamespace("derived.cs", @" class MyTestFixture : MyTestFixtureBase { [Test] public void MyTest() {} [Test] public void MyTest() {} }"); testClass = testProject.NestedTests.Cast <NUnitTestClass>().Single(c => c.ClassName == "MyTestFixture"); baseMethod = testClass.FindTestMethod("MyTestFixtureBase.MyTest"); derivedMethod = testClass.FindTestMethod("MyTest"); }
public MaxTimeTestCase( NUnitTestMethod testCase, int maxTime, bool expectFailure ) : base( testCase.Method ) { this.maxTime = maxTime; this.expectFailure = expectFailure; // Copy all the attributes of the original test this.Description = testCase.Description; this.Fixture = testCase.Fixture; this.Parent = testCase.Parent; this.RunState = testCase.RunState; this.IgnoreReason = testCase.IgnoreReason; this.ExceptionExpected = testCase.ExceptionExpected; this.ExpectedExceptionName = testCase.ExpectedExceptionName; this.ExpectedExceptionType = testCase.ExpectedExceptionType; this.ExpectedMessage = testCase.ExpectedMessage; this.Properties = testCase.Properties; this.Categories = testCase.Categories; }
public MaxTimeTestCase(NUnitTestMethod testCase, int maxTime, bool expectFailure) : base(testCase.Method) { this.maxTime = maxTime; this.expectFailure = expectFailure; // Copy all the attributes of the original test this.Description = testCase.Description; this.Fixture = testCase.Fixture; this.Parent = testCase.Parent; this.RunState = testCase.RunState; this.IgnoreReason = testCase.IgnoreReason; this.ExceptionExpected = testCase.ExceptionExpected; this.ExpectedExceptionName = testCase.ExpectedExceptionName; this.ExpectedExceptionType = testCase.ExpectedExceptionType; this.ExpectedMessage = testCase.ExpectedMessage; this.Properties = testCase.Properties; this.Categories = testCase.Categories; }
public void SetUp() { MethodInfo fakeTestMethod = GetType().GetMethod("FakeTestCase", BindingFlags.Instance | BindingFlags.NonPublic); var nunitTest = new NUnitTestMethod(fakeTestMethod); nunitTest.Categories.Add("cat1"); nunitTest.Properties.Add("Priority", "medium"); var nunitFixture = new TestSuite("FakeNUnitFixture"); nunitFixture.Categories.Add("super"); nunitFixture.Add(nunitTest); Assert.That(nunitTest.Parent, Is.SameAs(nunitFixture)); var fixtureNode = new TestNode(nunitFixture); fakeNUnitTest = (ITest)fixtureNode.Tests[0]; testConverter = new TestConverter(new TestLogger(), ThisAssemblyPath); }
/// <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; } 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; return testMethod; }
public RetriedTestMethod(NUnitTestMethod test, int tryCount, int requiredPassCount) : base(test.Method) { _tryCount = tryCount; _requiredPassCount = requiredPassCount; }
/// <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; }
/// <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); }
public override System.Collections.IEnumerable GetTestCasesFor(MethodInfo method) { Configuration_WebCommonAttribute assignedAttributeForMethod = Attribute.GetCustomAttribute(method, typeof(Configuration_WebCommonAttribute), false) as Configuration_WebCommonAttribute; List <TestCaseData> returnTestCases = new List <TestCaseData>(); List <TestCaseData> generatedTestCases = null; if (assignedAttributeForMethod.DataGeneratorClass != null && !string.IsNullOrEmpty(assignedAttributeForMethod.DataGeneratorMethod)) { ConstructorInfo methodsClass = assignedAttributeForMethod.DataGeneratorClass.GetConstructor(Type.EmptyTypes); MethodInfo methodInfo = assignedAttributeForMethod.DataGeneratorClass.GetMethod(assignedAttributeForMethod.DataGeneratorMethod); object methodsClassObject = methodsClass.Invoke(new object[] { }); object[] methodParameter = new object[] { }; if (assignedAttributeForMethod.PassDataGeneratorConfigurationObject) { methodParameter = new object[] { assignedAttributeForMethod } } ; generatedTestCases = (List <TestCaseData>)methodInfo.Invoke(methodsClassObject, methodParameter); } // If user did not specify a method to generate test data from // We should just go on with the test and set up configuration information if (generatedTestCases == null) { generatedTestCases = new List <TestCaseData>() { new TestCaseData() } } ; // Browser will always add the method to the changed list foreach (Browser browser in Enum.GetValues(typeof(Browser))) { // Try to split up Browser.ALL to separate test cases if (!assignedAttributeForMethod.Cfg_Browser.HasFlag(browser) || browser == Browser.ALL) { continue; } foreach (TestCaseData arguments in generatedTestCases) { NUnitTestMethod test = new NUnitTestMethod(method); Configuration_WebCommonAttribute configurationForTestCase = Attribute.GetCustomAttribute(method, typeof(Configuration_WebCommonAttribute), false) as Configuration_WebCommonAttribute; configurationForTestCase.Cfg_Browser = browser; string newTestName = string.Format("{0}({1})_{2}", test.TestName.Name, GetArgumentsAsString(arguments.Arguments), browser.ToString()); SetTestName(test, newTestName); TestCaseData browserTestData = new TestCaseData(arguments.Arguments); browserTestData.SetName(test.TestName.Name); Configuration.Changes.Add(test.TestName.FullName, configurationForTestCase); returnTestCases.Add(browserTestData); } } return(returnTestCases); } } }
/// <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); }