protected override SyntaxNode InjectMutations(AccessorDeclarationSyntax sourceNode, SyntaxNode targetNode, MutationContext context)
{
var result = base.InjectMutations(sourceNode, targetNode, context) as AccessorDeclarationSyntax;
if (result?.Body == null && result?.ExpressionBody == null)
{
return(result);
}
if (!context.HasStatementLevelMutant)
{
return(result);
}
// we need to inject static marker
if (result.Body == null)
{
result = MutantPlacer.ConvertExpressionToBody(result);
}
var converter = sourceNode.NeedsReturn()
? (Func <Mutation, StatementSyntax>)((toConvert) =>
SyntaxFactory.ReturnStatement(sourceNode.ExpressionBody !.Expression.InjectMutation(toConvert)))
: (toConvert) =>
SyntaxFactory.ExpressionStatement(sourceNode.ExpressionBody !.Expression.InjectMutation(toConvert));
var newBody =
MutantPlacer.PlaceStatementControlledMutations(result.Body,
context.StatementLevelControlledMutations.Union(context.BlockLevelControlledMutations).
Select(m => (m.Id, converter(m.Mutation))));
context.BlockLevelControlledMutations.Clear();
context.StatementLevelControlledMutations.Clear();
return(result.WithBody(SyntaxFactory.Block(newBody)));
}
/// <inheritdoc/>
/// Inject mutations and convert expression body to block body if required.
protected override BaseMethodDeclarationSyntax InjectMutations(T sourceNode, BaseMethodDeclarationSyntax targetNode,
MutationContext context)
{
targetNode = base.InjectMutations(sourceNode, targetNode, context);
if (targetNode.Body != null)
{
// add a return in case we changed the control flow
return(MutantPlacer.AddEndingReturn(targetNode) as T);
}
if (!context.HasStatementLevelMutant)
{
return(targetNode);
}
// we need to move to a body version of the method
targetNode = MutantPlacer.ConvertExpressionToBody(targetNode);
StatementSyntax mutatedBlock = targetNode.Body;
var converter = targetNode.NeedsReturn()
? (Func <Mutation, StatementSyntax>)((toConvert) =>
SyntaxFactory.ReturnStatement(sourceNode.ExpressionBody !.Expression.InjectMutation(toConvert)))
: (toConvert) =>
SyntaxFactory.ExpressionStatement(sourceNode.ExpressionBody !.Expression.InjectMutation(toConvert));
mutatedBlock =
MutantPlacer.PlaceStatementControlledMutations(mutatedBlock,
context.StatementLevelControlledMutations.Union(context.BlockLevelControlledMutations).
Select(m => (m.Id, converter(m.Mutation))));
context.BlockLevelControlledMutations.Clear();
context.StatementLevelControlledMutations.Clear();
return(targetNode.ReplaceNode(targetNode.Body !,
SyntaxFactory.Block(mutatedBlock)));
}
protected override BasePropertyDeclarationSyntax InjectMutations(PropertyDeclarationSyntax sourceNode,
BasePropertyDeclarationSyntax targetNode, MutationContext context)
{
var result = base.InjectMutations(sourceNode, targetNode, context);
if (!context.HasStatementLevelMutant)
{
return(result);
}
var mutated = result as PropertyDeclarationSyntax;
if (mutated?.ExpressionBody == null)
{
return(result);
}
mutated = MutantPlacer.ConvertPropertyExpressionToBodyAccessor(mutated);
var getter = mutated.GetAccessor();
result = mutated.ReplaceNode(getter.Body !, SyntaxFactory.Block(
MutantPlacer.PlaceStatementControlledMutations(
getter.Body,
context.StatementLevelControlledMutations.Union(context.BlockLevelControlledMutations).Select(
m => (m.Id,
SyntaxFactory.ReturnStatement(
sourceNode.ExpressionBody !.Expression
.InjectMutation(m.Mutation)) as StatementSyntax)))))
.WithSemicolonToken(SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken));
return(result);
}
public void MutantPlacer_ShouldPlaceWithIfStatement(int id)
{
// 1 + 8;
var originalNode = SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression,
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(8))));
// 1 - 8;
var mutatedNode = SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression,
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(8))));
var mutants = new List <(Mutant, StatementSyntax)> {
(new Mutant {
Id = id, Mutation = new Mutation {
ReplacementNode = mutatedNode
}
}, mutatedNode)
};
var result = MutantPlacer.PlaceStatementControlledMutations(originalNode, mutants);
result.ToFullString().Replace(CodeInjection.HelperNamespace, "StrykerNamespace").ShouldBeSemantically("if (StrykerNamespace.MutantControl.IsActive(" + id + @"))
{
1 - 8;
} else {
1 + 8;
}");
var removedResult = MutantPlacer.RemoveMutant(result);
removedResult.ToString().ShouldBeSemantically(originalNode.ToString());
}
/// <inheritdoc/>
/// <remarks>Inject pending mutations that are controlled with 'if' statements.</remarks>
protected override StatementSyntax InjectMutations(T sourceNode, StatementSyntax targetNode, MutationContext context)
{
var mutated = MutantPlacer.PlaceStatementControlledMutations(targetNode,
context.StatementLevelControlledMutations.Select(m => (m.Id, (sourceNode as StatementSyntax).InjectMutation(m.Mutation))));
context.StatementLevelControlledMutations.Clear();
return(mutated);
}
public void MutantPlacer_ShouldPlaceWithIfStatement(int id)
{
// 1 + 8;
var originalNode = SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression,
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(8))));
// 1 - 8;
var mutatedNode = SyntaxFactory.ExpressionStatement(SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression,
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)),
SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(8))));
var result = MutantPlacer.PlaceStatementControlledMutations(originalNode, new[] { (id, (StatementSyntax)mutatedNode) });
/// <inheritdoc/>
/// <remarks>Inject all pending mutations and control them with if statements.</remarks>
protected override StatementSyntax InjectMutations(T sourceNode, StatementSyntax targetNode, MutationContext context)
{
// we inject all pending mutations
var mutationsToInject = context.StatementLevelControlledMutations
.Union(context.BlockLevelControlledMutations);
// mutations are controlled by 'if's
var blockLevelMutations = MutantPlacer.PlaceStatementControlledMutations(targetNode,
mutationsToInject.Select(m =>
(m.Id, (sourceNode as StatementSyntax).InjectMutation(m.Mutation))));
context.BlockLevelControlledMutations.Clear();
context.StatementLevelControlledMutations.Clear();
// ensure we have a block at the end
return(blockLevelMutations);
}
/// <inheritdoc/>
/// Inject mutations and convert expression body to block body if required.
protected override BaseMethodDeclarationSyntax InjectMutations(T sourceNode, BaseMethodDeclarationSyntax targetNode,
MutationContext context)
{
// find out parameters
targetNode = base.InjectMutations(sourceNode, targetNode, context);
if (targetNode.Body != null)
{
// inject initialization to default for all out parameters
targetNode = sourceNode.ParameterList.Parameters.Where(p => p.Modifiers.Any(m => m.Kind() == SyntaxKind.OutKeyword))
.Aggregate(targetNode, (current, parameter) => MutantPlacer.AddDefaultInitialization(current, parameter.Identifier, parameter.Type));
// add a return in case we changed the control flow
return(MutantPlacer.AddEndingReturn(targetNode) as T);
}
if (!context.HasStatementLevelMutant)
{
return(targetNode);
}
// we need to move to a body version of the method
targetNode = MutantPlacer.ConvertExpressionToBody(targetNode);
StatementSyntax mutatedBlock = targetNode.Body;
var converter = targetNode.NeedsReturn()
? (Func <Mutation, StatementSyntax>)((toConvert) =>
SyntaxFactory.ReturnStatement(sourceNode.ExpressionBody !.Expression.InjectMutation(toConvert)))
: (toConvert) =>
SyntaxFactory.ExpressionStatement(sourceNode.ExpressionBody !.Expression.InjectMutation(toConvert));
mutatedBlock =
MutantPlacer.PlaceStatementControlledMutations(mutatedBlock,
context.StatementLevelControlledMutations.Union(context.BlockLevelControlledMutations).
Select(m => (m.Id, converter(m.Mutation))));
context.BlockLevelControlledMutations.Clear();
context.StatementLevelControlledMutations.Clear();
return(targetNode.ReplaceNode(targetNode.Body !,
SyntaxFactory.Block(mutatedBlock)));
}