/// <summary>
/// Returns a list of <see cref="MutationVariant" /> that can be executed on this given test project duplication.
/// </summary>
/// <param name="mutationIdentifiers"></param>
/// <param name="mutationLevel"></param>
/// <returns></returns>
public IList <MutationVariant> GetMutationVariants(IList <MutationVariantIdentifier> mutationIdentifiers,
MutationLevel mutationLevel)
{
var foundMutations = new List <MutationVariant>();
foreach (var reference in TestProjectReferences)
{
// Read the reference its contents
using var stream = reference.OpenReadStream();
using var binReader = new BinaryReader(stream);
var data = binReader.ReadBytes((int)stream.Length);
var decompiler = new CodeDecompiler(reference.FullFilePath(), new MemoryStream(data));
// Create assembly mutator and look up the mutations according to the passed identifiers.
var assembly = new AssemblyMutator(new MemoryStream(data));
foreach (var type in assembly.Types)
{
var toMutateMethods = new HashSet <string>(
mutationIdentifiers.Select(x => x.MemberName)
);
foreach (var method in type.Methods)
{
if (!toMutateMethods.Contains(method.AssemblyQualifiedName))
{
continue;
}
var methodMutationId = 0;
foreach (var group in method.AllMutations(mutationLevel))
{
foreach (var mutation in group)
{
var mutationIdentifier = mutationIdentifiers.FirstOrDefault(x =>
x.MutationId == methodMutationId && method.AssemblyQualifiedName == x.MemberName);
if (mutationIdentifier.MemberName != null)
{
foundMutations.Add(new MutationVariant(false, assembly, mutationIdentifier,
new MutationAnalyzerInfo
{
AnalyzerDescription = group.AnalyzerDescription,
AnalyzerName = group.AnalyzerName
}, method.Handle, mutation, "", decompiler.Decompile(method.Handle)));
}
methodMutationId++;
}
}
}
}
}
return(foundMutations);
}
public void AssemblyMutator_Has_Right_Types()
{
using Stream stream = new MemoryStream(File.ReadAllBytes("test.dll"));
using var mutator = new AssemblyMutator(stream);
Assert.AreEqual(mutator.Types.Count, 2);
Assert.AreEqual(mutator.Types[0].AssemblyQualifiedName, _nameSpaceTestAssemblyTarget1);
Assert.AreEqual(mutator.Types[1].AssemblyQualifiedName, _nameSpaceTestAssemblyTarget2);
}
public void AssemblyMutator_Type_TestAssemblyTarget2_Has_Right_Fields()
{
using Stream stream = new MemoryStream(File.ReadAllBytes("test.dll"));
using var mutator = new AssemblyMutator(stream);
var target1 = mutator.Types.First(x =>
x.AssemblyQualifiedName == _nameSpaceTestAssemblyTarget2);
Assert.AreEqual(target1.Fields.Count, 2); // ctor, cctor, two target methods.
Assert.IsNotNull(target1.Fields.FirstOrDefault(x => x.Name == "Constant"), null);
Assert.IsNotNull(target1.Fields.FirstOrDefault(x => x.Name == "Static"), null);
}
public void AssemblyMutator_Type_TestAssemblyTarget2_Has_Right_Methods()
{
using Stream stream = new MemoryStream(File.ReadAllBytes("test.dll"));
using var mutator = new AssemblyMutator(stream);
var target1 = mutator.Types.First(x =>
x.AssemblyQualifiedName == _nameSpaceTestAssemblyTarget2);
Assert.AreEqual(target1.Methods.Count, 4);
Assert.IsNotNull(target1.Methods.FirstOrDefault(x => x.Name == "TestMethod1"), null);
Assert.IsNotNull(target1.Methods.FirstOrDefault(x => x.Name == "TestMethod2"), null);
}
public void AssemblyMutator_Type_TestAssemblyTarget1_Constant_Has_Right_Mutation()
{
using Stream stream = new MemoryStream(File.ReadAllBytes("test.dll"));
using var mutator = new AssemblyMutator(stream);
var target1 = mutator.Types.First(x =>
x.AssemblyQualifiedName == _nameSpaceTestAssemblyTarget1);
var field = target1.Fields.FirstOrDefault(x => x.Name == "Constant");
var mutations = field.ConstantFieldMutations(MutationLevel.Detailed);
var arithmeticMutations =
mutations.FirstOrDefault(x => x.AnalyzerName == new BooleanConstantMutationAnalyzer().Name);
Assert.AreEqual(mutations.Count(), 1);
Assert.IsNotNull(arithmeticMutations, null);
}
public void AssemblyMutator_Type_TestAssemblyTarget1_TestMethod1_Has_Right_Mutations()
{
using Stream stream = new MemoryStream(File.ReadAllBytes("test.dll"));
using var mutator = new AssemblyMutator(stream);
var target1 = mutator.Types.First(x =>
x.AssemblyQualifiedName == _nameSpaceTestAssemblyTarget1);
var method1 = target1.Methods.FirstOrDefault(x => x.Name == "TestMethod1");
var mutations = method1.OpCodeMutations(MutationLevel.Detailed).Select(x => x).ToList();
var arithmeticMutations =
mutations.FirstOrDefault(x => x.AnalyzerName == new ArithmeticMutationAnalyzer().Name);
var comparisonMutations =
mutations.FirstOrDefault(x => x.AnalyzerName == new ComparisonMutationAnalyzer().Name);
Assert.AreEqual(mutations.Count, 2);
Assert.IsNotNull(arithmeticMutations, null);
Assert.IsNotNull(comparisonMutations, null);
}
public MutationVariant(
bool causesTimeOut,
AssemblyMutator assembly,
MutationVariantIdentifier mutationIdentifier,
MutationAnalyzerInfo mutationAnalyzerInfo,
EntityHandle memberHandle,
IMutation mutation,
string mutatedSource,
string originalSource
)
{
CausesTimeOut = causesTimeOut;
Assembly = assembly;
MutationIdentifier = mutationIdentifier;
MutationAnalyzerInfo = mutationAnalyzerInfo;
MemberHandle = memberHandle;
Mutation = mutation;
MutatedSource = mutatedSource;
OriginalSource = originalSource;
}
/// <summary>
/// Returns information about the test project.
/// </summary>
/// <returns></returns>
private TestProjectInfo GetTestProjectInfo(TestProjectDuplication duplication, IProjectInfo testProjectInfo)
{
var testFramework = GetTestFramework(testProjectInfo);
// Read the test project into memory.
var projectInfo = new TestProjectInfo
{
TestFramework = testFramework,
TestModule = ModuleDefinition.ReadModule(duplication.TestProjectFile.FullFilePath())
};
// Foreach project reference load it in memory as an 'assembly mutator'.
foreach (var projectReferencePath in duplication.TestProjectReferences)
{
var loadProjectReferenceModel = new AssemblyMutator(projectReferencePath.FullFilePath());
if (loadProjectReferenceModel.Types.Count > 0)
{
projectInfo.DependencyAssemblies.Add(loadProjectReferenceModel);
}
}
return(projectInfo);
}
