private SyntaxNode MutateWithConditionalExpressions(ExpressionSyntax currentNode)
{
ExpressionSyntax expressionAst = currentNode;
foreach (var mutant in FindMutants(currentNode))
{
Mutants.Add(mutant);
}
return(expressionAst);
}
private SyntaxNode MutateWithIfStatements(SyntaxNode currentNode)
{
var ast = currentNode;
foreach (var mutant in currentNode.ChildNodes().SelectMany(FindMutants))
{
Mutants.Add(mutant);
}
return(ast);
}
private void AddBlockMutants(SyntaxNode currentNode)
{
if (currentNode is StatementSyntax block && currentNode.Kind() == SyntaxKind.Block)
{
var mutant = FindMutantsWithoutChild(block).FirstOrDefault();
if (mutant != null)
{
Mutants.Add(mutant);
}
}
}
public WorldDbContext(System.Data.Common.DbConnection connection, bool loadData)
: base(connection, true)
{
if (loadData)
{
MutantSize = (int)Parameters.Find("mutantSize").Value;
NumMutants = (int)Parameters.Find("numMutants").Value;
if (Mutants.Count() != NumMutants)
{
throw new Exception("Incomplete Database");
}
}
}
public IEnumerable <Mutant> GenerateMutationsForNode(SyntaxNode current, MutationContext context)
{
var mutations = new List <Mutant>();
foreach (var mutator in Mutators)
{
foreach (var mutation in mutator.Mutate(current, _options))
{
var id = MutantCount;
Logger.LogDebug("Mutant {0} created {1} -> {2} using {3}", id, mutation.OriginalNode,
mutation.ReplacementNode, mutator.GetType());
var newMutant = new Mutant
{
Id = id,
Mutation = mutation,
ResultStatus = MutantStatus.NotRun,
IsStaticValue = context.InStaticValue
};
var duplicate = false;
// check if we have a duplicate
foreach (var mutant in Mutants)
{
if (mutant.Mutation.OriginalNode != mutation.OriginalNode ||
!SyntaxFactory.AreEquivalent(mutant.Mutation.ReplacementNode, newMutant.Mutation.ReplacementNode))
{
continue;
}
Logger.LogDebug($"Mutant {id} discarded as it is a duplicate of {mutant.Id}");
duplicate = true;
break;
}
if (duplicate)
{
continue;
}
Mutants.Add(newMutant);
MutantCount++;
mutations.Add(newMutant);
}
}
return(mutations);
}
public IEnumerable <Mutant> GetLatestMutantBatch()
{
var mutants = new List <Mutant>();
foreach (var mutant in Mutants)
{
if (mutant.Mutation.Type != MutatorType.MethodCall)
{
mutants.Add(mutant);
continue;
}
if (Mutants.Count(x => x.Mutation.Location == mutant.Mutation.Location) == 1)
{
mutants.Add(mutant);
}
}
var tempMutants = mutants;
Mutants = new Collection <Mutant>();
return(tempMutants);
}
private T ApplyMutant <T>(T node, Mutant mutant) where T : SyntaxNode
{
Mutants.Add(mutant);
return(node.ReplaceNode(mutant.Mutation.OriginalNode, mutant.Mutation.ReplacementNode));
}
private SyntaxNode Mutate(SyntaxNode currentNode, SyntaxNodeAnalysis analysis)
{
if (currentNode is MethodDeclarationSyntax ||
currentNode is ConstructorDeclarationSyntax ||
currentNode is PropertyDeclarationSyntax)
{
foreach (var blockNode in currentNode.DescendantNodes <BlockSyntax>())
{
if (analysis.IsNodeArid(blockNode))
{
continue;
}
AddBlockMutants(blockNode);
}
}
if (GetExpressionSyntax(currentNode) is var expressionSyntax &&
expressionSyntax != null &&
!analysis.IsNodeArid(expressionSyntax))
{
if (currentNode is ExpressionStatementSyntax syntax)
{
if (expressionSyntax is AssignmentExpressionSyntax)
{
return(MutateWithIfStatements(expressionSyntax.Parent));
}
if (GetExpressionSyntax(expressionSyntax) is var subExpressionSyntax && subExpressionSyntax != null)
{
return(currentNode.ReplaceNode(expressionSyntax, Mutate(expressionSyntax, analysis)));
}
return(MutateWithIfStatements(syntax));
}
return(currentNode.ReplaceNode(expressionSyntax, MutateWithConditionalExpressions(expressionSyntax)));
}
if (currentNode is StatementSyntax statement &&
currentNode.Kind() != SyntaxKind.Block &&
!analysis.IsNodeArid(statement))
{
if (currentNode is LocalFunctionStatementSyntax localFunction)
{
return(localFunction.ReplaceNode(localFunction.Body, Mutate(localFunction.Body, analysis)));
}
if (currentNode is IfStatementSyntax ifStatement)
{
if (!ifStatement.Statement.ChildNodes().Any())
{
return(null);
}
ifStatement = ifStatement.ReplaceNode(ifStatement.Condition,
MutateWithConditionalExpressions(ifStatement.Condition));
if (ifStatement.Else != null)
{
ifStatement = ifStatement.ReplaceNode(ifStatement.Else, Mutate(ifStatement.Else, analysis));
}
try
{
if (ifStatement.Statement != null)
{
return(ifStatement.ReplaceNode(ifStatement.Statement,
Mutate(ifStatement.Statement, analysis)));
}
}
catch (Exception e)
{
Trace.TraceError("unable to process if statement at line {0} {1}",
ifStatement?.Statement?.LineNumber() + 1, e);
}
}
return(MutateWithIfStatements(statement));
}
if (currentNode is InvocationExpressionSyntax invocationExpression &&
invocationExpression.ArgumentList.Arguments.Count == 0 &&
!analysis.IsNodeArid(invocationExpression))
{
var mutant = FindMutants(invocationExpression).FirstOrDefault();
if (mutant != null)
{
Mutants.Add(mutant);
}
}
var children = currentNode.ChildNodes().ToList();
foreach (var child in children)
{
Mutate(child, analysis);
}
return(currentNode);
}
