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);
}
