public override SyntaxNode VisitIfStatement(IfStatementSyntax node)
{
//check if the condition does not involve realational or equality operators
//as the main operator between the only two members in that expression
if (!(node.Condition is BinaryExpressionSyntax))
{
if (!node.Condition.ToFullString().Contains("out"))
{
var trueLiteralExpression = SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression);
var falseLiteralExpression = SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression);
var trueConditionNode = node.ReplaceNode(node.Condition, trueLiteralExpression);
var falseConditionNode = node.ReplaceNode(node.Condition, falseLiteralExpression);
var classMutatedWithTrueCondition =
_classRootNode.ReplaceNode(node, trueConditionNode);
_mutantCreator.CreateNewMutant(classMutatedWithTrueCondition, false);
var classMutatedWithFalseCondition =
_classRootNode.ReplaceNode(node, falseConditionNode);
_mutantCreator.CreateNewMutant(classMutatedWithFalseCondition, false);
}
}
return(node);
}
public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
{
var variableDeclarationSyntax = node.Declaration;
VariableDeclaratorSyntax variableDeclarator = variableDeclarationSyntax.Variables[0];
if (variableDeclarator.Initializer != null)
{
var nodeSemanticModel =
_semanticModel.Compilation.GetSemanticModel(node.SyntaxTree);
var symbolInfo = nodeSemanticModel.GetSymbolInfo(variableDeclarationSyntax.Type);
var typeSymbol = symbolInfo.Symbol;
ExpressionSyntax replaceValueSyntaxNode = _randomTypeGenerator.ResolveType(typeSymbol.ToString());
//if (typeSymbol.IsAbstract)
//{
// //get a type that implements that interface
// string toBeResolvedType =
// _randomTypeGenerator.GetTypeForInterface(typeSymbol.ToString());
// replaceValueSyntaxNode = toBeResolvedType != null ?
// _randomTypeGenerator.ResolveType(toBeResolvedType) : null;
//}
//else
//{
// replaceValueSyntaxNode =
// _randomTypeGenerator.ResolveType(typeSymbol.ToString());
//}
if (replaceValueSyntaxNode != null)
{
var newLocalVariableDeclarationNode =
SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
variableDeclarationSyntax.Type)
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
variableDeclarator.Identifier)
.WithInitializer(
SyntaxFactory.EqualsValueClause(replaceValueSyntaxNode)))))
.NormalizeWhitespace();
var mutatedClassRoot = _classRootNode.ReplaceNode(node, newLocalVariableDeclarationNode);
_mutantCreator.CreateNewMutant(mutatedClassRoot, false);
}
}
return(node);
}
public override SyntaxNode VisitAssignmentExpression(AssignmentExpressionSyntax node)
{
bool isRemovableNode = false;
if (node.Left is MemberAccessExpressionSyntax)
{
var memberAccessExpression = node.Left as MemberAccessExpressionSyntax;
if (memberAccessExpression.Expression is ThisExpressionSyntax)
{
var accessedMemberName = memberAccessExpression.Name.Identifier.ToString();
if (_classFieldsIdentifiers.Contains(accessedMemberName))
{
isRemovableNode = true;
}
}
if (memberAccessExpression.Expression is IdentifierNameSyntax)
{
var identifierNameSyntax = memberAccessExpression.Expression as IdentifierNameSyntax;
var identifier = identifierNameSyntax.Identifier.ToString();
if (_classFieldsIdentifiers.Contains(identifier))
{
isRemovableNode = true;
}
}
}
if (node.Left is IdentifierNameSyntax)
{
var identifierNameSyntax = node.Left as IdentifierNameSyntax;
var identifier = identifierNameSyntax.Identifier.ToString();
if (_classFieldsIdentifiers.Contains(identifier))
{
isRemovableNode = true;
}
}
if (isRemovableNode)
{
var mutatedNamespaceRoot = _classRootNode.RemoveNode(node.Parent,
SyntaxRemoveOptions.KeepLeadingTrivia |
SyntaxRemoveOptions.KeepTrailingTrivia);
_mutantCreator.CreateNewMutant(mutatedNamespaceRoot, true);
}
return(node);
}
public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node)
{
SyntaxToken expressionOperator = node.OperatorToken;
SyntaxToken newToken = SyntaxFactory.Token(SyntaxKind.None);
// < becomes <=
if (expressionOperator.IsKind(SyntaxKind.LessThanToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.LessThanEqualsToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// <= becomes <
if (expressionOperator.IsKind(SyntaxKind.LessThanEqualsToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.LessThanToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// >= becomes >
if (expressionOperator.IsKind(SyntaxKind.GreaterThanEqualsToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.GreaterThanToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// > becomes >=
if (expressionOperator.IsKind(SyntaxKind.GreaterThanToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// create a new mutant class
if (!newToken.IsKind(SyntaxKind.None))
{
var mutatedBinaryExressionNode = node.ReplaceToken(expressionOperator, newToken);
var mutatedClassRoot = _classRootNode.ReplaceNode(node, mutatedBinaryExressionNode);
_mutantCreator.CreateNewMutant(mutatedClassRoot, false);
}
return(node);
}
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
{
var nodeSemanticModel = _semanticModel.Compilation.GetSemanticModel(node.SyntaxTree);
var typeInfo = nodeSemanticModel.GetTypeInfo(node);
if (typeInfo.Type.Name.ToLower() == "void")
{
try
{
//get the parent node -- usually an ExpressionStatement node
var voidInvocationParentNode = node.Parent;
var mutatedClassRoot =
_classRootNode.RemoveNode(voidInvocationParentNode, SyntaxRemoveOptions.KeepNoTrivia);
_mutantCreator.CreateNewMutant(mutatedClassRoot, true);
}
catch (Exception e)
{
}
}
return(node);
}
public override SyntaxNode VisitAssignmentExpression(AssignmentExpressionSyntax node)
{
var nodeSemanticModel = _semanticModel.Compilation.GetSemanticModel(node.SyntaxTree);
var typeInfo = nodeSemanticModel.GetTypeInfo(node);
ExpressionSyntax replaceValueSyntaxNode = _randomTypeGenerator.ResolveType(typeInfo.Type.ToString());
//if (typeInfo.Type.IsAbstract) // TODO: rethink this, might be abstract class, not interface
//{
// //get a type that implements that interface
// string toBeResolvedType =
// _randomTypeGenerator.GetTypeForInterface(typeInfo.Type.Name);
// replaceValueSyntaxNode = toBeResolvedType != null ?
// _randomTypeGenerator.ResolveType(toBeResolvedType) : null;
//}
//else
//{
// replaceValueSyntaxNode =
// _randomTypeGenerator.ResolveType(typeInfo.Type.ToString());
//}
if (replaceValueSyntaxNode != null)
{
var newAssignmentNode =
SyntaxFactory.AssignmentExpression(
node.Kind(),
node.Left,
replaceValueSyntaxNode).NormalizeWhitespace();
var mutatedClassRoot = _classRootNode.ReplaceNode(node, newAssignmentNode);
_mutantCreator.CreateNewMutant(mutatedClassRoot, false);
}
return(node);
}
public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node)
{
SyntaxToken expressionOperatorToken = node.OperatorToken;
SyntaxToken newToken = SyntaxFactory.Token(SyntaxKind.None);
// - becomes +
if (expressionOperatorToken.IsKind(SyntaxKind.MinusToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.PlusToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// + becomes -
if (expressionOperatorToken.IsKind(SyntaxKind.PlusToken))
{
//make sure it is not a string concatenation expression
//if you want to ask about the SymbolInfo for a given Node, get the semantic model for that node first
var nodeSemanticModel = _semanticModel.Compilation.GetSemanticModel(node.SyntaxTree);
var typeInfo = nodeSemanticModel.GetTypeInfo(node);
if (typeInfo.Type.Name != "String")
{
newToken = SyntaxFactory.Token(SyntaxKind.MinusToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
//TODO: find a way to mutate string concatenation expressions as well
}
// / becomes *
if (expressionOperatorToken.IsKind(SyntaxKind.SlashToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.AsteriskToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// * becomes /
if (expressionOperatorToken.IsKind(SyntaxKind.AsteriskToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.SlashToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// % becomes *
if (expressionOperatorToken.IsKind(SyntaxKind.PercentToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.AsteriskToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// & becomes |
if (expressionOperatorToken.IsKind(SyntaxKind.AmpersandToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.BarToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// | becomes &
if (expressionOperatorToken.IsKind(SyntaxKind.BarToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.AmpersandToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// ^ becomes &
if (expressionOperatorToken.IsKind(SyntaxKind.CaretToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.AmpersandToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// << becomes >>
if (expressionOperatorToken.IsKind(SyntaxKind.LessThanLessThanToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.GreaterThanGreaterThanToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// >> becomes <<
if (expressionOperatorToken.IsKind(SyntaxKind.GreaterThanGreaterThanToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.LessThanLessThanToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
if (!newToken.IsKind(SyntaxKind.None))
{
var mutatedBinaryExressionNode = node.ReplaceToken(expressionOperatorToken, newToken);
var mutatedClassRoot = _classRootNode.ReplaceNode(node, mutatedBinaryExressionNode);
_mutantCreator.CreateNewMutant(mutatedClassRoot, false);
}
return(node);
}
public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node)
{
var nodeSemanticModel = _semanticModel.Compilation.GetSemanticModel(node.SyntaxTree);
var typeInfo = nodeSemanticModel.GetTypeInfo(node.Expression);
ExpressionSyntax replaceValueSyntaxNode;
if (typeInfo.Type != null)
{
replaceValueSyntaxNode =
_randomTypeGenerator.ResolveType(typeInfo.Type.ToString());
//if (typeInfo.Type.IsAbstract) // TODO: rethink this, might be abstract class, not interface
//{
// //get a type that implements that interface
// string toBeResolvedType =
// _randomTypeGenerator.GetTypeForInterface(typeInfo.Type.Name);
// replaceValueSyntaxNode = toBeResolvedType != null ?
// _randomTypeGenerator.ResolveType(toBeResolvedType) : null;
//}
//else
//{
// replaceValueSyntaxNode =
// _randomTypeGenerator.ResolveType(typeInfo.Type.ToString());
//}
}
else
{
replaceValueSyntaxNode = null;
}
//replace with random value
if (replaceValueSyntaxNode != null)
{
var newReturnStatemenNode =
SyntaxFactory.ReturnStatement(replaceValueSyntaxNode)
.NormalizeWhitespace();
var mutatedClassRoot = _classRootNode.ReplaceNode(node, newReturnStatemenNode);
_mutantCreator.CreateNewMutant(mutatedClassRoot, false);
}
else
{
if (typeInfo.Type == null)
{
return(node);
}
if (typeInfo.Type != null && typeInfo.Type.Name == "T")
{
return(node);
}
if (typeInfo.Type.BaseType != null && typeInfo.Type.BaseType.Name == "Enum")
{
return(node);
}
// replace with return null;
var nullReturnStatementNode = SyntaxFactory.ReturnStatement(
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))
.NormalizeWhitespace();
var mutatedClassRoot = _classRootNode.ReplaceNode(node, nullReturnStatementNode);
_mutantCreator.CreateNewMutant(mutatedClassRoot, false);
}
return(node);
}
