Integer mutators

src/Stryker.Core/Stryker.Core.UnitTest/Mutators/IntegerNegationMutatorTests.cs

@@ -0,0 +1,51 @@
+using Microsoft.CodeAnalysis.CSharp;
+using Shouldly;
+using Stryker.Core.Mutators;
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Xunit;
+
+namespace Stryker.Core.UnitTest.Mutators;
+
+public class IntegerNegationMutatorTests : TestBase
+{
+    [Fact]
+    public void ShouldBeMutationLevelStandard()
+    {
+        var target = new IntegerNegationMutator();
+        target.MutationLevel.ShouldBe(MutationLevel.Standard);
+    }
+
+    [Theory]
+    [InlineData(10, -10)]
+    [InlineData(-10, 10)]
+    public void ShouldMutate(int original, int expected)
+    {
+        var target = new IntegerNegationMutator();
+        var parent = SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(original)));
+
+        var result = target.ApplyMutations(parent.DescendantNodes().First() as LiteralExpressionSyntax, null).ToList();
+
+        var mutation = result.ShouldHaveSingleItem();
+
+        mutation.ReplacementNode.ShouldBeOfType<LiteralExpressionSyntax>()
+            .Token.Value.ShouldBe(expected);
+        mutation.DisplayName.ShouldBe("Number negation mutation");
+    }
+
+    [Theory]
+    [InlineData(SyntaxKind.StringLiteralExpression)]
+    [InlineData(SyntaxKind.CharacterLiteralExpression)]
+    [InlineData(SyntaxKind.NullLiteralExpression)]
+    [InlineData(SyntaxKind.DefaultLiteralExpression)]
+    [InlineData(SyntaxKind.TrueLiteralExpression)]
+    [InlineData(SyntaxKind.FalseLiteralExpression)]
+    public void ShouldNotMutate(SyntaxKind original)
+    {
+        var target = new IntegerNegationMutator();
+
+        var result = target.ApplyMutations(SyntaxFactory.LiteralExpression(original), null).ToList();
+
+        Assert.Empty(result);
+    }
+}

src/Stryker.Core/Stryker.Core.UnitTest/Mutators/IntegerNullificationMutatorTests.cs

@@ -0,0 +1,52 @@
+using Microsoft.CodeAnalysis.CSharp;
+using Shouldly;
+using Stryker.Core.Mutators;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Xunit;
+
+namespace Stryker.Core.UnitTest.Mutators;
+
+public class IntegerNullificationMutatorTests : TestBase
+{
+    [Fact]
+    public void ShouldBeMutationLevelStandard()
+    {
+        var target = new IntegerNullificationMutator();
+        target.MutationLevel.ShouldBe(MutationLevel.Standard);
+    }
+
+    [Theory]
+    [InlineData(10, 0)]
+    [InlineData(-10, 0)]
+    public void ShouldMutate(int original, int expected)
+    {
+        var target = new IntegerNullificationMutator();
+
+        var parent = SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(original)));
+
+        var result = target.ApplyMutations(parent.DescendantNodes().First() as LiteralExpressionSyntax, null).ToList();
+
+        var mutation = result.ShouldHaveSingleItem();
+
+        mutation.ReplacementNode.ShouldBeOfType<LiteralExpressionSyntax>()
+            .Token.Value.ShouldBe(expected);
+        mutation.DisplayName.ShouldBe("Integer nullification mutation");
+    }
+
+    [Theory]
+    [InlineData("array[1]")]
+    public void ShouldNotMutate(string expression)
+    {
+        var target = new IntegerNullificationMutator();
+
+        var parent = SyntaxFactory.ParseExpression(expression);
+        var child = parent.DescendantNodes(_ => true).OfType<LiteralExpressionSyntax>().FirstOrDefault();
+
+
+        var result = target.ApplyMutations(child, null).ToList();
+
+        Assert.Empty(result);
+    }
+}

src/Stryker.Core/Stryker.Core.UnitTest/Options/Inputs/IgnoreMutationsInputTests.cs

@@ -27,7 +27,7 @@ public void ShouldValidateExcludedMutation()
 
             var ex = Should.Throw<InputException>(() => target.Validate<Mutator>());
 
-            ex.Message.ShouldBe($"Invalid excluded mutation (gibberish). The excluded mutations options are [Statement, Arithmetic, Block, Equality, Boolean, Logical, Assignment, Unary, Update, Checked, Linq, String, Bitwise, Initializer, Regex, NullCoalescing, Math, StringMethod, Conditional]");
+            ex.Message.ShouldBe($"Invalid excluded mutation (gibberish). The excluded mutations options are [Statement, Arithmetic, Block, Equality, Boolean, Logical, Assignment, Unary, Update, Checked, Linq, String, Bitwise, Initializer, Regex, NullCoalescing, Math, StringMethod, Conditional, Number]");
         }
 
         [Fact]

src/Stryker.Core/Stryker.Core/Mutants/CsharpMutantOrchestrator.cs

@@ -112,7 +112,9 @@ private static List<IMutator> DefaultMutatorList() =>
         new MathMutator(),
         new SwitchExpressionMutator(),
         new IsPatternExpressionMutator(),
-        new StringMethodMutator()
+        new StringMethodMutator(),
+        new IntegerNullificationMutator(),
+        new IntegerNegationMutator()
     ];
 
     private IEnumerable<IMutator> Mutators { get; }

src/Stryker.Core/Stryker.Core/Mutators/IntegerNegationMutator.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Stryker.Core.Mutants;
+
+namespace Stryker.Core.Mutators;
+
+public class IntegerNegationMutator : MutatorBase<LiteralExpressionSyntax>
+{
+    public override MutationLevel MutationLevel => MutationLevel.Standard;
+
+    public override IEnumerable<Mutation> ApplyMutations(LiteralExpressionSyntax node, SemanticModel semanticModel)
+    {
+        if (!IsNumberLiteral(node) || node.Token.Value is not (int currentValue and not 0))
+        {
+            yield break;
+        }
+
+        var replacementValue = -currentValue;
+        yield return new Mutation
+        {
+            OriginalNode = node,
+            ReplacementNode = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(replacementValue)),
+            DisplayName = "Number negation mutation",
+            Type = Mutator.Number
+        };
+    }
+
+    private static bool IsNumberLiteral(LiteralExpressionSyntax node)
+    {
+        var kind = node.Kind();
+        return kind == SyntaxKind.NumericLiteralExpression && node.Parent is EqualsValueClauseSyntax;
+    }
+
+}

src/Stryker.Core/Stryker.Core/Mutators/IntegerNullificationMutator.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Stryker.Core.Mutants;
+
+namespace Stryker.Core.Mutators;
+
+public class IntegerNullificationMutator : MutatorBase<LiteralExpressionSyntax>
+{
+    public override MutationLevel MutationLevel => MutationLevel.Standard;
+
+    public override IEnumerable<Mutation> ApplyMutations(LiteralExpressionSyntax node, SemanticModel semanticModel)
+    {
+        if (IsNumberLiteral(node) && node.Token.Value is int value && value != 0)
+        {
+            yield return new Mutation
+            {
+                OriginalNode = node,
+                ReplacementNode = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)),
+                DisplayName = "Integer nullification mutation",
+                Type = Mutator.Number
+            };
+        }
+    }
+
+    private static bool IsNumberLiteral(LiteralExpressionSyntax node)
+    {
+        var kind = node.Kind();
+        return kind == SyntaxKind.NumericLiteralExpression && node.Parent is EqualsValueClauseSyntax;
+    }
+}

src/Stryker.Core/Stryker.Core/Mutators/Mutator.cs

@@ -46,7 +46,9 @@ public enum Mutator
     [MutatorDescription("String Method")]
     StringMethod,
     [MutatorDescription("Conditional operators")]
-    Conditional
+    Conditional,
+    [MutatorDescription("Number literals")]
+    Number
 }
 
 public static class EnumExtension