public void AbstractMethods() { TypeDefinition type = GetTest("AbstractMethodsClass"); foreach (MethodDefinition method in type.Methods) { if (method.IsConstructor) { continue; } Assert.AreEqual(RuleResult.Success, runner.CheckMethod(method), method.ToString()); } }
private void AssertClass <T> () { TestRunner runner; bool failed = false; RuleResult result; // // We assert that exactly 1 error is raised among all the methods in the class // runner = new TestRunner(new DelegatesPassedToNativeCodeMustIncludeExceptionHandlingRule()); foreach (MethodDefinition method in DefinitionLoader.GetTypeDefinition <T> ().Methods) { result = runner.CheckMethod(method); if (result == RuleResult.Failure) { Assert.IsFalse(failed); Assert.AreEqual(1, runner.Defects.Count); failed = true; } } Assert.IsTrue(failed); }
public void TestNotImplemented() { MethodDefinition method = GetTest("NotImplemented"); Assert.AreEqual(RuleResult.Failure, runner.CheckMethod(method), "NotImplemented failure test"); method = GetTest("NotImplementedLocal"); Assert.AreEqual(RuleResult.Success, runner.CheckMethod(method), "NotImplementedLocal success test"); }
/// <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()); }
private void AssertTest(string name, int expectedCount) { TestRunner runner; MethodDefinition method; RuleResult result; RuleResult expected = name.Contains("OK") ? RuleResult.Success : RuleResult.Failure; if (expected == RuleResult.Success) { expectedCount = 0; } // Since the rule only reports errors once for each method, and these tests reuse methods, // we need a new test runner for each test. runner = new TestRunner(new DelegatesPassedToNativeCodeMustIncludeExceptionHandlingRule()); runner.Rules.Clear(); method = DefinitionLoader.GetMethodDefinition <DelegatesPassedToNativeCodeMustIncludeExceptionHandlingTest> (name); result = runner.CheckMethod(method); Assert.AreEqual(expected, result); Assert.AreEqual(expectedCount, runner.Defects.Count, "DefectCount"); }
public void TestEmptyMethod() { MethodDefinition method = GetTest("EmptyMethod"); Assert.AreEqual(RuleResult.DoesNotApply, runner.CheckMethod(method)); }
public void TestNothing() { MethodDefinition method = GetTest("CallNothing"); Assert.AreEqual(RuleResult.Success, runner.CheckMethod(method)); }
public void TestDirectThrow() { MethodDefinition method = GetTest("DirectThrow"); Assert.AreEqual(RuleResult.Success, runner.CheckMethod(method), "RuleResult"); Assert.AreEqual(0, runner.Defects.Count, "Count"); }
public void TestEnvSetBadExitCodeFromNonExecutable() { // get method from this assembly, not generated one Assert.AreEqual(RuleResult.Failure, runner.CheckMethod(GetMethod(assembly.MainModule.GetType("Test.Rules.Portability.EnvSetExitCodeTester"), "SetTooBigExitCode"))); }