private bool RunMutationTestsForAllClassAndMethods(TestsDispatcher dispatcher) { bool result = true; var nspace = Options.Options.OfType <TargetNamespace>().Single().NamespaceName; var testAssembly = Assembly.LoadFrom(_testAssemblyLocation); var matchedTypes = TypeResolver.ResolveNamespaceTypesFromReferences(testAssembly, nspace); System.Console.WriteLine("testassembly : [{0}], matched types : [[{1}]]", testAssembly, String.Join("], [", matchedTypes.Select(t => t.FullName))); //////////////// System.Console.WriteLine("{0} types matched under {1}", matchedTypes.Length, nspace); //////////////////// if (matchedTypes.Length == 0) { _message = String.Format(@"No types found under {0}", nspace); return(false); } foreach (var type in matchedTypes) { var resultBuf = RunMutationTestsForType(type, type.FullName, dispatcher); result &= resultBuf; } if (!String.IsNullOrEmpty(_message)) { return(result); } _message = String.Format(@"Mutation testing {0}", result ? "passed" : "failed"); return(result); }
private bool RunMutationTestsForClassAndMethod(TestsDispatcher dispatcher) { string targetClass = Options.Options.OfType <TargetClass>().Single().ClassName; var testAssembly = Assembly.LoadFrom(_testAssemblyLocation); var matchedType = TypeResolver.ResolveTypeFromReferences(testAssembly, targetClass); if (matchedType == null) { _message = String.Format(@"Unknown type '{0}'", targetClass); return(false); } string targetMethod = Options.Options.OfType <TargetMethod>().Single().MethodName; var typeOptions = Options.Options.OfType <ParameterType>().Select(p => p.ResolvedType).ToArray(); var result = typeOptions.Any() ? RunTests(matchedType.Assembly.Location, targetClass, targetMethod, dispatcher, typeOptions) : RunTests(matchedType.Assembly.Location, targetClass, targetMethod, dispatcher); if (String.IsNullOrEmpty(_message)) { _message = String.Format( @"Mutation testing {0}", result ? "passed" : "failed"); } return(result); }
private bool RunMutationTestsForClass(TestsDispatcher dispatcher) { string targetClass = Options.Options.OfType <TargetClass>().Single().ClassName; var testAssembly = Assembly.LoadFrom(_testAssemblyLocation); var matchedType = TypeResolver.ResolveTypeFromReferences(testAssembly, targetClass); if (matchedType == null) { _message = String.Format(@"Unknown type '{0}'", targetClass); return(false); } var assemblyDefinition = AssemblyDefinition.ReadAssembly(matchedType.Assembly.Location); var targetType = assemblyDefinition.MainModule.Types.FirstOrDefault(t => t.FullName == targetClass); bool result = true; foreach (var methodInfo in targetType.Methods .Where(m => m.HasBody && m.Name != Methods.STATIC_CONSTRUCTOR)) { string targetMethod = methodInfo.Name; string methodReturnType = methodInfo.ReturnType.FullName; var methodsGenerics = methodInfo.GenericParameters.ToArray(); var parameterTypes = methodInfo.Parameters.Select(p => p.ParameterType).ToArray(); bool runResultBuf = RunTests(matchedType.Assembly.Location, targetClass, methodReturnType, targetMethod, methodsGenerics, parameterTypes, dispatcher); result &= runResultBuf; } if (String.IsNullOrEmpty(_message)) { _message = String.Format( @"Mutation testing {0}", result ? "passed" : "failed"); } return(result); }
public override bool Execute() { using (var stream = new MemoryStream()) using (var writer = new StreamWriter(stream)) { ConfigureOutput(writer); var runnerMethod = ConfigureRun(); var successThreshold = Options.Options.OfType <SuccessThreshold>().SingleOrDefault(); var successThresholdValue = successThreshold != null ? successThreshold.MinScore : 1; var parallelLevel = Options.Options.OfType <ParallelLevel>().SingleOrDefault(); var parallelValue = parallelLevel != null ? parallelLevel.ParallelValue : 8; var maxBusyRunners = Options.Options.OfType <MaxBusyRunner>().SingleOrDefault(); var maxBusyRunnersValue = maxBusyRunners != null ? maxBusyRunners.MaxBusyRunnersValue : parallelValue; var oneTimeRunners = Options.Options.Any(o => o is OneTimeRunners); var killTimeFactor = Options.Options.OfType <KillTimeFactor>().SingleOrDefault(); var killTimeFactorValue = killTimeFactor != null ? killTimeFactor.Factor : 2; using (var dispatcher = new TestsDispatcher(parallelValue, maxBusyRunnersValue, oneTimeRunners, killTimeFactorValue)) runnerMethod(dispatcher); RestoreOutput(); var score = _report.GetMutationScore(); var result = score >= successThresholdValue; ReportResult(result, _report); return(result); } }
private bool RunMutationTestsForType(Type type, string targetClass, TestsDispatcher dispatcher) { bool result = true; var assemblyDefinition = AssemblyDefinition.ReadAssembly(type.Assembly.Location); var targetType = assemblyDefinition.MainModule.Types.FirstOrDefault(t => t.FullName == targetClass); foreach (var methodInfo in targetType.Methods.Where(m => m.HasBody && m.Name != Methods.STATIC_CONSTRUCTOR)) { string targetMethod = methodInfo.Name; string methodReturnType = methodInfo.ReturnType.FullName; var methodsGenerics = methodInfo.GenericParameters.ToArray(); var parameterTypes = methodInfo.Parameters.Select(p => p.ParameterType).ToArray(); bool runResultBuf = RunTests(type.Assembly.Location, targetClass, methodReturnType, targetMethod, methodsGenerics, parameterTypes, dispatcher); result &= runResultBuf; } return(result); }
private bool RunTests(string targetAssemblyLocation, string targetClass, string targetMethod, TestsDispatcher dispatcher, Type[] parameterTypes = null) { var parameterList = parameterTypes == null || parameterTypes.Length == 0 ? null : String.Join(", ", parameterTypes.Select(t => t.Name).ToArray()); OutputMethod(targetClass, targetMethod, parameterList); MutationTest mutationTest = parameterTypes == null ? (MutationTest)MutationTestBuilder.For(targetAssemblyLocation, targetClass, targetMethod, dispatcher, _testMethods) : (MutationTest)MutationTestBuilder.For(targetAssemblyLocation, targetClass, targetMethod, dispatcher, _testMethods, parameterTypes); mutationTest.TestAssemblyLocation = _testAssemblyLocation; var result = BuildAndRunMutationTest(mutationTest); return(result); }