public void IsTestMember_MethodHasParameters_ReturnsTrue()
        {
            // not actually executable, but NUnit still considers it a test case
            // and marks it as ignored
            var m = CreateMethod("[Test] public void M(int a) {}");

            Assert.IsTrue(NUnitTestFramework.IsTestMethod(m));
        }
        public void IsTestClassReturnsTrueHasClassHasFullyQualifiedNUnitTestFixtureAttribute()
        {
            var c = NRefactoryHelper.CreateTypeDefinition("[NUnit.Framework.TestFixtureAttribute] class EmptyClass {}");

            Assert.IsTrue(NUnitTestFramework.IsTestClass(c));
        }
        public void IsTestClassReturnsFalseWhenClassHasTestFixtureAttributeAndIsAbstract()
        {
            var c = NRefactoryHelper.CreateTypeDefinition("using NUnit.Framework; [TestFixture] abstract class EmptyClass {}");

            Assert.IsFalse(NUnitTestFramework.IsTestClass(c));
        }
        public void IsTestClassReturnsTrueHasClassHasTestFixtureAttributeMissingAttributePart()
        {
            var c = NRefactoryHelper.CreateTypeDefinition("using NUnit.Framework; [TestFixture] class EmptyClass {}");

            Assert.IsTrue(NUnitTestFramework.IsTestClass(c));
        }
        public void IsTestClassReturnsFalseHasClassHasNoAttributes()
        {
            var c = NRefactoryHelper.CreateTypeDefinition("class EmptyClass {}");

            Assert.IsFalse(NUnitTestFramework.IsTestClass(c));
        }
Ejemplo n.º 6
0
        public void IsBuildNeededBeforeTestRunReturnsTrue()
        {
            NUnitTestFramework testFramework = new NUnitTestFramework();

            Assert.IsTrue(testFramework.IsBuildNeededBeforeTestRun);
        }
Ejemplo n.º 7
0
 void CreateTestFramework()
 {
     testFramework = new NUnitTestFramework();
 }
        public void IsTestClassReturnsTrueWhenContainingTestMethod()
        {
            var c = NRefactoryHelper.CreateTypeDefinition("using NUnit.Framework; class C { [Test] public void M() {} }");

            Assert.IsTrue(NUnitTestFramework.IsTestClass(c));
        }
        public void IsTestMember_MethodIsStatic_ReturnsTrue()
        {
            var m = CreateMethod("[Test] public static void M() {}");

            Assert.IsTrue(NUnitTestFramework.IsTestMethod(m));
        }
        public void IsTestMember_MethodHasFullyQualifiedNUnitTestAttribute_ReturnsTrue()
        {
            var m = CreateMethod("[NUnit.Framework.TestAttribute] public void M() {}");

            Assert.IsTrue(NUnitTestFramework.IsTestMethod(m));
        }
 public void IsTestMember_MethodIsNull_ReturnsFalse()
 {
     Assert.IsFalse(NUnitTestFramework.IsTestMethod(null));
 }
        public void IsTestMember_MethodHasTestAttributeWithoutAttributePart_ReturnsTrue()
        {
            var m = CreateMethod("[Test] public void M() {}");

            Assert.IsTrue(NUnitTestFramework.IsTestMethod(m));
        }
        public void IsTestMember_MethodHasNoAttributes_ReturnsFalse()
        {
            var m = CreateMethod("public void M() {}");

            Assert.IsFalse(NUnitTestFramework.IsTestMethod(m));
        }
        public void TestCase_WithParameter()
        {
            var m = CreateMethod("[TestCase(1), TestCase(2)] public void M(int x) {}");

            Assert.IsTrue(NUnitTestFramework.IsTestMethod(m));
        }
 public void IsTestClassReturnsFalseWhenClassIsNull()
 {
     Assert.IsFalse(NUnitTestFramework.IsTestClass(null));
 }
        public void TestCase()
        {
            var m = CreateMethod("[TestCase] public void M() {}");

            Assert.IsTrue(NUnitTestFramework.IsTestMethod(m));
        }
        public void IsTestClassReturnsFalseWhenClassHasTestAttributeWithoutUsingNUnit()
        {
            var c = NRefactoryHelper.CreateTypeDefinition("class C { [Test] public void M() {} }");

            Assert.IsFalse(NUnitTestFramework.IsTestClass(c));
        }
        public void IsTestClassReturnsTrueWhenAbstractClassContainsInnerClassWithTestMethod()
        {
            var c = NRefactoryHelper.CreateTypeDefinition("using NUnit.Framework; abstract class C { class Inner { [Test] public void M() {} } }");

            Assert.IsTrue(NUnitTestFramework.IsTestClass(c));
        }
 public void Init()
 {
     SD.InitializeForUnitTests();
     SD.Services.AddService(typeof(IParserService), MockRepository.GenerateStrictMock <IParserService>());
     testFramework = new NUnitTestFramework();
 }
        public void IsTestClassReturnsTrueWhenStaticClassWithAttribute()
        {
            var c = NRefactoryHelper.CreateTypeDefinition("using NUnit.Framework; [TestFixture] static class C { }");

            Assert.IsTrue(NUnitTestFramework.IsTestClass(c));
        }
Ejemplo n.º 21
0
 public void Init()
 {
     testFramework = new NUnitTestFramework();
 }
Ejemplo n.º 22
0
        public void NUnitTestFrameworkCreateTestDebuggerReturnsNUnitTestDebugger()
        {
            NUnitTestFramework testFramework = new NUnitTestFramework();

            Assert.IsInstanceOf(typeof(NUnitTestDebugger), testFramework.CreateTestDebugger());
        }