public void TestNonEnum()
        {
            TypeDefinition type = GetTest("NonEnum");

            Assert.AreEqual(RuleResult.DoesNotApply, runner.CheckType(type), "RuleResult");
            Assert.AreEqual(0, runner.Defects.Count, "Count");
        }
Esempio n. 2
0
        /// <summary>
        /// Runs the rule, depending on its type.
        /// </summary>
        private RuleResult RunRule(TMetadataToken token)
        {
            if (token == null)
            {
                throw new ArgumentNullException("token");
            }

            MethodDefinition md = (token as MethodDefinition);

            if (md != null)
            {
                if (FireEvents)
                {
                    runner.OnAssembly(md.DeclaringType.Module.Assembly);
                    runner.OnType(md.DeclaringType);
                    runner.OnMethod(md);
                }
                return(runner.CheckMethod(token as MethodDefinition));
            }

            TypeDefinition td = (token as TypeDefinition);

            if (td != null)
            {
                if (FireEvents)
                {
                    runner.OnAssembly(md.DeclaringType.Module.Assembly);
                    runner.OnType(md.DeclaringType);
                }
                return(runner.CheckType(td));
            }

            AssemblyDefinition ad = (token as AssemblyDefinition);

            if (ad != null)
            {
                if (FireEvents)
                {
                    runner.OnAssembly(td.Module.Assembly);
                }
                return(runner.CheckAssembly(ad));
            }

            throw new NotImplementedException(token.GetType().ToString());
        }
 public void TestEnumHasSingularName()
 {
     type = assembly.MainModule.GetType("Test.Rules.Naming.DayOfWeek");
     Assert.AreEqual(RuleResult.Success, runner.CheckType(type), "RuleResult");
     Assert.AreEqual(0, runner.Defects.Count, "Count");
 }
Esempio n. 4
0
 public void LargeClassTest()
 {
     type = assembly.MainModule.GetType("Test.Rules.Smells.LargeClass");
     Assert.AreEqual(RuleResult.Failure, runner.CheckType(type), "Test.Rules.Smells.LargeClass failure test");
     // 'x', 'foo', 'bar', 'f', 'c' and 's' are reported as prefixes
     Assert.AreEqual(6, runner.Defects.Count, "Test.Rules.Smells.LargeClass defect count check");
 }
Esempio n. 5
0
 public void TestFlagsHasPluralName()
 {
     type = assembly.MainModule.GetType("Test.Rules.Naming.AppDomainManagerInitializationOptions");
     Assert.AreEqual(RuleResult.Success, runner.CheckType(type), "RuleResult");
     Assert.AreEqual(0, runner.Defects.Count, "Count");
 }
Esempio n. 6
0
        public void TestClassWithStaticCtor()
        {
            TypeDefinition type = GetTest <ClassWithStaticCtor> ();

            Assert.AreEqual(RuleResult.Success, runner.CheckType(type), "RuleResult");
            Assert.AreEqual(0, runner.Defects.Count, "Count");
        }
Esempio n. 7
0
 public void BaseClassWithCodeDuplicatedTest()
 {
     type = assembly.MainModule.GetType("Test.Rules.Smells.BaseClassWithCodeDuplicated");
     Assert.AreEqual(RuleResult.Failure, runner.CheckType(type), "Test.Rules.Smells.BaseClassWithCodeDuplicated failure test");
     Assert.AreEqual(1, runner.Defects.Count, "Test.Rules.Smells.BaseClassWithCodeDuplicated defect count check");
 }