diff --git a/.gitignore b/.gitignore index 2fdfcf347..b9bb1fcb4 100644 --- a/.gitignore +++ b/.gitignore @@ -289,3 +289,5 @@ StrykerLogs/ *.DotSettings /src/Stryker.CLI/TestStatisticsAnalyzer/test-stats-report.json .DS_Store + +*.received.* \ No newline at end of file diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props index dcb572bf3..7f60d4d58 100644 --- a/src/Directory.Packages.props +++ b/src/Directory.Packages.props @@ -13,6 +13,7 @@ + diff --git a/src/Stryker.Abstractions/IReadOnlyMutant.cs b/src/Stryker.Abstractions/IReadOnlyMutant.cs index 9a46090c2..1ef0a8e8c 100644 --- a/src/Stryker.Abstractions/IReadOnlyMutant.cs +++ b/src/Stryker.Abstractions/IReadOnlyMutant.cs @@ -1,5 +1,6 @@ using Stryker.Abstractions.TestRunners; using Stryker.Abstractions.Mutants; +using Microsoft.CodeAnalysis; namespace Stryker.Abstractions; @@ -17,4 +18,6 @@ public interface IReadOnlyMutant ITestGuids AssessingTests { get; } bool CountForStats { get; } bool IsStaticValue { get; } + string ReplacementText => Mutation.ReplacementNode.ToString(); + FileLinePositionSpan OriginalLocation => Mutation.OriginalNode.GetLocation().GetMappedLineSpan(); } diff --git a/src/Stryker.Abstractions/Mutation.cs b/src/Stryker.Abstractions/Mutation.cs index a34be4672..99dc9705b 100644 --- a/src/Stryker.Abstractions/Mutation.cs +++ b/src/Stryker.Abstractions/Mutation.cs @@ -1,3 +1,4 @@ +using System; using Microsoft.CodeAnalysis; using Stryker.Abstractions.Mutators; @@ -13,4 +14,8 @@ public class Mutation public string DisplayName { get; set; } public Mutator Type { get; set; } public string Description { get; set; } + + public string? ReplacementText { get; set; } + + public FileLinePositionSpan? OriginalLocation { get; set; } } diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/GeneratedRegexOrchestratorTests.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/GeneratedRegexOrchestratorTests.cs new file mode 100644 index 000000000..1240296f2 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/GeneratedRegexOrchestratorTests.cs @@ -0,0 +1,389 @@ +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis; +using System.IO; +using System.Text.RegularExpressions; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Threading.Tasks; +using Microsoft.CodeAnalysis.Text; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using VerifyMSTest; +using VerifyTests; +using System.Runtime.CompilerServices; +using Serilog.Events; +using Stryker.Abstractions; +using Stryker.Abstractions.Mutators; +using Stryker.Core.InjectedHelpers; +using Stryker.Core.Mutants; +using Stryker.Abstractions.Options; + +namespace Stryker.Core.UnitTest.Mutants; + +[TestClass] +[UsesVerify] +public partial class GeneratedRegexOrchestratorTests : TestBase +{ + private readonly CsharpMutantOrchestrator _target; + private readonly CodeInjection _injector = new(); + private readonly CSharpParseOptions _previewOptions = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.Preview); + + public GeneratedRegexOrchestratorTests() => _target = new CsharpMutantOrchestrator(new MutantPlacer(_injector), + options: new StrykerOptions + { + MutationLevel = MutationLevel.Complete, + OptimizationMode = OptimizationModes.CoverageBasedTest, + LogOptions = new LogOptions + { + LogLevel = LogEventLevel.Verbose + } + }); + + private async Task ShouldMutateSourceToExpectedAsync(string methodName, string actual) + { + var actualNode = _target.Mutate(CSharpSyntaxTree.ParseText(actual, _previewOptions), null); + actual = (await actualNode.GetRootAsync()).ToFullString(); + actual = actual.Replace(_injector.HelperNamespace, "StrykerNamespace"); + actualNode = CSharpSyntaxTree.ParseText(actual, _previewOptions); + actualNode.ShouldNotContainErrors(); + await Verifier.Verify(actual, "cs").UseMethodName(methodName).IgnoreParameters(); + } + + private async Task ShouldNotMutateSourceAsync(string actual) + { + var input = CSharpSyntaxTree.ParseText(actual, _previewOptions); + var actualNode = _target.Mutate(input, null); + actual = (await actualNode.GetRootAsync()).ToFullString(); + actual = actual.Replace(_injector.HelperNamespace, "StrykerNamespace"); + actualNode = CSharpSyntaxTree.ParseText(actual); + actualNode.ShouldBeSemantically(input); + actualNode.ShouldNotContainErrors(); + } + + private async Task ShouldMutateCompiledSourceToExpectedAsync(string methodName, string actual) + { + var cSharpParseOptions = _previewOptions.WithPreprocessorSymbols("GENERATED_REGEX"); + var syntaxTree = CSharpSyntaxTree.ParseText(actual, cSharpParseOptions); + var basePath = Path.GetDirectoryName(typeof(object).Assembly.Location)!; + + var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); + var regex = MetadataReference.CreateFromFile(typeof(Regex).Assembly.Location); + var attribute = MetadataReference.CreateFromFile(Path.Combine(basePath, "System.Runtime.dll")); + + Compilation compilation = CSharpCompilation.Create("MyCompilation", + [syntaxTree], [mscorlib, attribute, regex], + new CSharpCompilationOptions(OutputKind + .DynamicallyLinkedLibrary)); + + var regexGeneratorDll = Path.Combine(basePath, "..", "..", "..", "packs", "Microsoft.NETCore.App.Ref", + Path.GetFileName(basePath), + "analyzers", "dotnet", "cs", "System.Text.RegularExpressions.Generator.dll"); + + var sourceGenerator = + Activator.CreateInstanceFrom(regexGeneratorDll, "System.Text.RegularExpressions.Generator.RegexGenerator") + ?.Unwrap() switch + { + IIncrementalGenerator ig => ig.AsSourceGenerator(), + ISourceGenerator sg => sg, + _ => null + }; + + if (sourceGenerator is not null) + { + GeneratorDriver driver = CSharpGeneratorDriver.Create([sourceGenerator], [], cSharpParseOptions); + driver.RunGeneratorsAndUpdateCompilation(compilation, out compilation, out _); + + if (compilation.GetDiagnostics().Where(static a => a.Severity == DiagnosticSeverity.Error).Any()) + { + Assert.Inconclusive("Initial compilation unsuccessful"); + } + } + + var actualNode = _target.Mutate(syntaxTree, compilation.GetSemanticModel(syntaxTree)); + actual = (await actualNode.GetRootAsync()).ToFullString(); + actual = actual.Replace(_injector.HelperNamespace, "StrykerNamespace"); + actualNode = CSharpSyntaxTree.ParseText(actual, cSharpParseOptions); + actualNode.ShouldNotContainErrors(); + await Verifier.Verify(actual, "cs").UseMethodName(methodName).IgnoreParameters(); + } + + public static IEnumerable Tests => + [ + ["SimpleSingleRegexInDedicatedClass", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + } + """], + ["SimpleSingleRegexInDedicatedStruct", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial struct R { + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + } + """], + ["SimpleSingleRegexInDedicatedRecord", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial record R { + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + } + """], + ["SimpleSingleRegexInDedicatedRecordStruct", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial record struct R { + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + } + """], + ["SingleRegexInDedicatedClassNamedParameter", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(RegexOptions.IgnoreCase, pattern: @"^abc$", "en-US")] + private static partial Regex AbcGeneratedRegex(); + } + """], + ["MultipleRegexInDedicatedClass", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + + [GeneratedRegex(@"^[abc]\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex(); + } + """], + ["MultipleRegexInSharedClass", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + + static string Value => "test ".Substring(2); + + [GeneratedRegex(@"^[abc]\d?")] + private static partial Regex AbcdGeneratedRegex(); + } + """], + ["MultipleRegexInMultipleClasses", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R1 { + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abc1GeneratedRegex(); + + [GeneratedRegex(@"^[abc]\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex(); + } + public partial class R2 { + [GeneratedRegex(@"^abc\b$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abc2GeneratedRegex(); + + [GeneratedRegex(@"^\d[abc]\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex(); + } + """], + ["ComplexSingleRegexInDedicatedClass", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"^[abc]\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + } + """], + ["SimpleSingleRegexInNestedClass", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + public partial class R2 { + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + } + } + """], + ["RealTest", + """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"(?\w{3}), 0?(?\d{1,2})-(?\w{3})-(?\d{2}) 0?(?\d{1,2}):0?(?\d{1,2}):0?(?\d{1,2}) (?\w{3})")] + private static partial Regex SpecificDateTimeRegex(); + } + """], + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Cheatsheet + ["EveryRegexNodeType", + """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"[xyz][a-c][^xyz][^a-c].\d\D\w\W\s\S\t\r\n\v\f[\b]\0\cM\cJ\x4A\u1234\p{Ll}\P{IsLatinExtended-A}+(?:\p{Sc}|\p{P})\*\\\.^$\b\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\1\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex(); + } + """], + ["GeneratedRegexProperty", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"\b\w{5}\b")] + private static partial Regex AbcGeneratedRegex { get; } + } + """], + ["SupportsStrykerComments", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + // stryker disable Regex + [GeneratedRegex(@"\b\w{5}\b")] + private static partial Regex AbcGeneratedRegex(); + } + """] + ]; + + public static IEnumerable RequiresCompilationTests => + [ + ["RegexAsConstField", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + public const string Regex = @"^abc$"; + + [GeneratedRegex(Regex)] + private static partial Regex AbcGeneratedRegex(); + } + """], + ["RegexAsInterpolatedConstField", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(C.Regex)] + private static partial Regex AbcdeGeneratedRegex(); + } + public static class C { + public const string Inner = @"abcde"; + public const string Regex = $@"^{Inner}$"; + } + """], +#if NET9_0_OR_GREATER + // https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-9/libraries#regular-expressions + ["GeneratedRegexProperty", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"\b\w{5}\b")] + private static partial Regex AbcGeneratedRegex { get; } + } + """], +#endif + ["RegexInIfDefBlock", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + #if GENERATED_REGEX + [GeneratedRegex(@"^abc$")] + private static partial Regex AbcGeneratedRegex(); + #else + private static readonly Regex _abcGeneratedRegex = new Regex(@"^abc$"); + private static Regex AbcGeneratedRegex() => _abcGeneratedRegex; + #endif + } + """], + ["RegexInIfDefBlockInverted", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + #if !GENERATED_REGEX + private static readonly Regex _abcGeneratedRegex = new Regex(@"^abc$"); + private static Regex AbcGeneratedRegex() => _abcGeneratedRegex; + #else + [GeneratedRegex(@"^abc$")] + private static partial Regex AbcGeneratedRegex(); + #endif + } + """], + ["OtherMutations", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + + public void M() { + var toMutate = "a string is here"; + var mutation2 = toMutate.PadLeft(5); + } + } + """] + ]; + + public static IEnumerable NoMutationTests => + [ + [ + "NoMutationRegex", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + [GeneratedRegex(@"a", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + } + """ + ], + [ + "NoMutationInterface", """ + using System.Text.RegularExpressions; + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial interface R { + [GeneratedRegex(@"a", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); + } + """ + ], + [ + "EmptyPartialClass", """ + namespace StrykerNet.UnitTest.Mutants.TestResources; + public partial class R { + } + """ + ] + ]; + + [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0060:Remove unused parameter", Justification = "Required for DynamicDataDisplayName")] + public static string GetCustomDynamicDataDisplayName(MethodInfo methodInfo, object[] data) => $"{data[0]}"; + + [TestMethod] + [DynamicData(nameof(Tests), DynamicDataDisplayName = nameof(GetCustomDynamicDataDisplayName))] + public Task ShouldMutateGeneratedRegex(string testName, string code) => ShouldMutateSourceToExpectedAsync(testName, code); + + [TestMethod] + [DynamicData(nameof(RequiresCompilationTests), DynamicDataDisplayName = nameof(GetCustomDynamicDataDisplayName))] + public Task ShouldMutateGeneratedRegexWithCompilation(string testName, string code) => ShouldMutateCompiledSourceToExpectedAsync(testName, code); + + [TestMethod] + [DynamicData(nameof(NoMutationTests), DynamicDataDisplayName = nameof(GetCustomDynamicDataDisplayName))] + public Task ShouldNotMutatedMutateGeneratedRegex(string testName, string code) => ShouldNotMutateSourceAsync(code); +} + +public static class StaticSettingsUsage +{ + [ModuleInitializer] + public static void Initialize() + { + VerifierSettings.RegisterStringComparer("cs", CompareSyntaxTrees); + Verifier.UseSourceFileRelativeDirectory("Verified"); + } + + private static Task CompareSyntaxTrees(string received, string verified, + IReadOnlyDictionary context) => + Task.FromResult(CSharpSyntaxTree.ParseText(SourceText.From(received)) + .IsEquivalentTo(CSharpSyntaxTree.ParseText(SourceText.From(verified))) + ? CompareResult.Equal + : CompareResult.NotEqual()); +} diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.ComplexSingleRegexInDedicatedClass.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.ComplexSingleRegexInDedicatedClass.verified.cs new file mode 100644 index 000000000..b8937b83a --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.ComplexSingleRegexInDedicatedClass.verified.cs @@ -0,0 +1,35 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(13)?AbcGeneratedRegex_RegexQuantifierRemovalMutation_uJA6aLkSDZf1nNEqTTrmUwkVMpUC():(StrykerNamespace.MutantControl.IsActive(12)?AbcGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_MDzkRwclKiIgJcKRendsP7fvRxsC():(StrykerNamespace.MutantControl.IsActive(11)?AbcGeneratedRegex_RegexPredefinedCharacterClassNullification_zvabPNkNXi5E4WVy9DbXSDBtJBcC():(StrykerNamespace.MutantControl.IsActive(10)?AbcGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w4583iXfF3f5E1wYY0vUHvf89GsC():(StrykerNamespace.MutantControl.IsActive(9)?AbcGeneratedRegex_RegexGreedyQuantifierQuantityMutation_SxSBojTcWfK90GNEzOYCcKxKPEMC():(StrykerNamespace.MutantControl.IsActive(8)?AbcGeneratedRegex_RegexGreedyQuantifierQuantityMutation_EemMBA83KH5r9vsxwuYTbZItICIC():(StrykerNamespace.MutantControl.IsActive(7)?AbcGeneratedRegex_RegexGreedyQuantifierQuantityMutation_0IPy0NkuaZuus5vyaBNObDf8YBEC():(StrykerNamespace.MutantControl.IsActive(6)?AbcGeneratedRegex_RegexCharacterClassToAnycharChange_ChZb0RJfdWiCoO7uZWgXV9GKRWoC():(StrykerNamespace.MutantControl.IsActive(5)?AbcGeneratedRegex_RegexCharacterClassShorthandNegationMutation_MlYZgMyXCSRTuWJOS9wBgXbB5tcC():(StrykerNamespace.MutantControl.IsActive(4)?AbcGeneratedRegex_RegexCharacterClassNegationMutation_sUNdnI9ukFndVf8l6TkBoumJJRQC():(StrykerNamespace.MutantControl.IsActive(3)?AbcGeneratedRegex_RegexCharacterClassChildRemoval_yxJAlmw5XA356qagdqMKq3btNCEC():(StrykerNamespace.MutantControl.IsActive(2)?AbcGeneratedRegex_RegexCharacterClassChildRemoval_e4iNMNHMRl5IY1AYBopi97YjMQwC():(StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexCharacterClassChildRemoval_5XPHLFUGLBs4SAQEaHNXnV9D4MkC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_SdtdlVHq9QAJyltvbdr0AfzHrW4C():AbcGeneratedRegex_Original())))))))))))))); + [GeneratedRegex(@"^[abc]\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("[abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_SdtdlVHq9QAJyltvbdr0AfzHrW4C(); + [GeneratedRegex("^[ab]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexCharacterClassChildRemoval_5XPHLFUGLBs4SAQEaHNXnV9D4MkC(); + [GeneratedRegex("^[ac]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexCharacterClassChildRemoval_e4iNMNHMRl5IY1AYBopi97YjMQwC(); + [GeneratedRegex("^[bc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexCharacterClassChildRemoval_yxJAlmw5XA356qagdqMKq3btNCEC(); + [GeneratedRegex("^[^abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexCharacterClassNegationMutation_sUNdnI9ukFndVf8l6TkBoumJJRQC(); + [GeneratedRegex("^[abc]\\D?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexCharacterClassShorthandNegationMutation_MlYZgMyXCSRTuWJOS9wBgXbB5tcC(); + [GeneratedRegex("^[\\w\\W]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexCharacterClassToAnycharChange_ChZb0RJfdWiCoO7uZWgXV9GKRWoC(); + [GeneratedRegex("^[abc]\\d{0,0}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexGreedyQuantifierQuantityMutation_0IPy0NkuaZuus5vyaBNObDf8YBEC(); + [GeneratedRegex("^[abc]\\d{0,2}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexGreedyQuantifierQuantityMutation_EemMBA83KH5r9vsxwuYTbZItICIC(); + [GeneratedRegex("^[abc]\\d{1,1}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexGreedyQuantifierQuantityMutation_SxSBojTcWfK90GNEzOYCcKxKPEMC(); + [GeneratedRegex("^[abc]\\d??", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w4583iXfF3f5E1wYY0vUHvf89GsC(); + [GeneratedRegex("^[abc]d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexPredefinedCharacterClassNullification_zvabPNkNXi5E4WVy9DbXSDBtJBcC(); + [GeneratedRegex("^[abc][\\d\\D]?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_MDzkRwclKiIgJcKRendsP7fvRxsC(); + [GeneratedRegex("^[abc]\\d", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexQuantifierRemovalMutation_uJA6aLkSDZf1nNEqTTrmUwkVMpUC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.EveryRegexNodeType.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.EveryRegexNodeType.verified.cs new file mode 100644 index 000000000..20371299e --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.EveryRegexNodeType.verified.cs @@ -0,0 +1,203 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex EveryGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(97)?EveryGeneratedRegex_RegexUnicodeCharacterClassNegationMutation_nIwxBSmUgeefAQfsaorG3TSYDqQC():(StrykerNamespace.MutantControl.IsActive(96)?EveryGeneratedRegex_RegexUnicodeCharacterClassNegationMutation_MACM5kH7IMU9dZGBX1zFGO5w9PsC():(StrykerNamespace.MutantControl.IsActive(95)?EveryGeneratedRegex_RegexUnicodeCharacterClassNegationMutation_m3A0GUA4V1AzmhUI6hKzrTgwBuQC():(StrykerNamespace.MutantControl.IsActive(94)?EveryGeneratedRegex_RegexUnicodeCharacterClassNegationMutation_BBA33zw46D8thiyQGhq1yd0ZKsoC():(StrykerNamespace.MutantControl.IsActive(93)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_zleFM7Swrz45BLOyikSBjB5BtGUC():(StrykerNamespace.MutantControl.IsActive(92)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_zjA2vrqW2o6NAviTK980yBaAz6wC():(StrykerNamespace.MutantControl.IsActive(91)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_ZczKWs9a5VnxIV1okXo2J9oYOK0C():(StrykerNamespace.MutantControl.IsActive(90)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_Y45xf5yuaVUoDOsBBRKJFQCXjwkC():(StrykerNamespace.MutantControl.IsActive(89)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_lYII6xUzrOWAD7Chk9EwpvOa7CMC():(StrykerNamespace.MutantControl.IsActive(88)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_llC1qsNmFlOB9IEwB2TvXlXn3KQC():(StrykerNamespace.MutantControl.IsActive(87)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_K6CmS2GukAE3BT0yw0fxJAS6htAC():(StrykerNamespace.MutantControl.IsActive(86)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_jb2hezMQR4L9JVqHxkbXLGMiSAAC():(StrykerNamespace.MutantControl.IsActive(85)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_iU4RPB7rAktBxgNrBHby7aigczAC():(StrykerNamespace.MutantControl.IsActive(84)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_Hqg0wlGgVguBm7sBfil6GYvzYKoC():(StrykerNamespace.MutantControl.IsActive(83)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_AsQ73WQzkR79v34AY4s0s8KjuYIC():(StrykerNamespace.MutantControl.IsActive(82)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_5m0kCw41L0hBrmBczpJdzF6sL80C():(StrykerNamespace.MutantControl.IsActive(81)?EveryGeneratedRegex_RegexQuantifierRemovalMutation_4BSak9URuSxNOf1YzYTFr2j9e90C():(StrykerNamespace.MutantControl.IsActive(80)?EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_U9sfMApCkZWqpnpCsERY3dcyKGoC():(StrykerNamespace.MutantControl.IsActive(79)?EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_oWGwFkE2RyeoOKt3RdRTcUxPJUEC():(StrykerNamespace.MutantControl.IsActive(78)?EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_klAf6zrGgm6br9hShGolvLz7mgAC():(StrykerNamespace.MutantControl.IsActive(77)?EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_Ety3yH3jZuY7mdB8bOoOuoyG8vUC():(StrykerNamespace.MutantControl.IsActive(76)?EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_3HyAq20udGzJOBIHB1ru2F4sAuIC():(StrykerNamespace.MutantControl.IsActive(75)?EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_3bflAx5U1clw7EnnnE4bHKOBeA4C():(StrykerNamespace.MutantControl.IsActive(74)?EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_xlm5s9he6nU4ko6Ew6X3PA2MmfUC():(StrykerNamespace.MutantControl.IsActive(73)?EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_WJ2SJBXE2kc9j6wOdvF6B4ro7nYC():(StrykerNamespace.MutantControl.IsActive(72)?EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_UYuI2CpMqYMrPWgbn5vVFXOQlMMC():(StrykerNamespace.MutantControl.IsActive(71)?EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_C245tRgIkvSQa2ilBCjvPdaocREC():(StrykerNamespace.MutantControl.IsActive(70)?EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_5nrEBVfQQ5wu8Ju2lPVQwXiUs0IC():(StrykerNamespace.MutantControl.IsActive(69)?EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_34j2F8655cEg5EfRve2thHb3Nj0C():(StrykerNamespace.MutantControl.IsActive(68)?EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_ShtEXMslAlu9e25H1B5ZgCeVsL0C():(StrykerNamespace.MutantControl.IsActive(67)?EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_PTBm3XgKAumc80klGYqyxFx18VsC():(StrykerNamespace.MutantControl.IsActive(66)?EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_H5VAgonGR3AuAJzmtyU2l5YEqbUC():(StrykerNamespace.MutantControl.IsActive(65)?EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_EGSIwYyhX3kanyrE6ARnzDSh9xUC():(StrykerNamespace.MutantControl.IsActive(64)?EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_dcukJo0xdxRmvK2YPuoyAgvYs7wC():(StrykerNamespace.MutantControl.IsActive(63)?EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_BlZrqzVjBTkuz4kHWkWGn3HEuMIC():(StrykerNamespace.MutantControl.IsActive(62)?EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_42hebkL8zg1FqGzfLEsra6qwUN4C():(StrykerNamespace.MutantControl.IsActive(61)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_znoiq8qgLI5h8UUchwpJu22xnzEC():(StrykerNamespace.MutantControl.IsActive(60)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_ytSzAPMFqzNg4Zc8LqMMDWGJuAoC():(StrykerNamespace.MutantControl.IsActive(59)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_xgGWAepCfdldwn20tWSuIktRMRQC():(StrykerNamespace.MutantControl.IsActive(58)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_wcyeFlVBIHPeIgdWA5egRMwEbgwC():(StrykerNamespace.MutantControl.IsActive(57)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_wBKCF9aJZBn1zTssORDnNgeLj3QC():(StrykerNamespace.MutantControl.IsActive(56)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_vsuuEBz0BZGG5Zb1TeiLyn5BhLkC():(StrykerNamespace.MutantControl.IsActive(55)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_ViS8ESkILqtW0OBoWBCBgX2tfDoC():(StrykerNamespace.MutantControl.IsActive(54)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_VBLfW4ZzjZhFexul88YBhRBRHV0C():(StrykerNamespace.MutantControl.IsActive(53)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_uydaC0EDOgUrGEcBu25g8GoXlloC():(StrykerNamespace.MutantControl.IsActive(52)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_TzJhXFoLP9N2SqAS5f7nBpuMNxYC():(StrykerNamespace.MutantControl.IsActive(51)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_SoptGKphf0QSrirjO2yMaGmRyvUC():(StrykerNamespace.MutantControl.IsActive(50)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_sBkPG6x2a2KWj2VtzjLuZeeYO3gC():(StrykerNamespace.MutantControl.IsActive(49)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_Q55ITlc2BX48XX5heDBlnAcnrKEC():(StrykerNamespace.MutantControl.IsActive(48)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_q02jTy04WUYcNeEwGOMJeXab5isC():(StrykerNamespace.MutantControl.IsActive(47)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_prjBSTTZ5JbH3NharhXLgqowfasC():(StrykerNamespace.MutantControl.IsActive(46)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_oYkBt9OrQ6lBySBadKMF0QtwQ34C():(StrykerNamespace.MutantControl.IsActive(45)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_NwKn9UKIjkQiGiywozhQ9B9eQzUC():(StrykerNamespace.MutantControl.IsActive(44)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_MnXLAz8Dq0jBgYgMTwLlY5lr6gsC():(StrykerNamespace.MutantControl.IsActive(43)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_KG0CrwMRAJETfQxiLdyc8s6eU2cC():(StrykerNamespace.MutantControl.IsActive(42)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_INToSTbm44zJUQ0TBZVKioV6fgwC():(StrykerNamespace.MutantControl.IsActive(41)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_iBELtKoLJS7XwolhG0tYAXuk3XQC():(StrykerNamespace.MutantControl.IsActive(40)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_dk7GdFyFOAxREWicOjSWQuiIWW8C():(StrykerNamespace.MutantControl.IsActive(39)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_AxYhcRt6U6D0Rcf06bbfvWFr6eMC():(StrykerNamespace.MutantControl.IsActive(38)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_APay1eH8qqYOSl4Y6wxKoJqLjkMC():(StrykerNamespace.MutantControl.IsActive(37)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_7KBFtwYEK2IVZZ3GGGNNlQGajDEC():(StrykerNamespace.MutantControl.IsActive(36)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_35sJGcPbJ8VRJAyUewek0UWASG4C():(StrykerNamespace.MutantControl.IsActive(35)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_2K1uDjNTSLj1TSZhAdm2bKxhqZ4C():(StrykerNamespace.MutantControl.IsActive(34)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_1MjF7ZWsX2MfKfKAA7hGKeBhua8C():(StrykerNamespace.MutantControl.IsActive(33)?EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_1c7NnXHt9z8fsgx06Le1l5vTIggC():(StrykerNamespace.MutantControl.IsActive(32)?EveryGeneratedRegex_RegexCharacterClassToAnycharChange_ygeNW0h7YDBo4g2pwkNktYu4niMC():(StrykerNamespace.MutantControl.IsActive(31)?EveryGeneratedRegex_RegexCharacterClassToAnycharChange_Pe1S7QczESKvymG65xqAF9ghkZMC():(StrykerNamespace.MutantControl.IsActive(30)?EveryGeneratedRegex_RegexCharacterClassToAnycharChange_kYBwvFVrAcQTJIl5sMgoeBzEDOkC():(StrykerNamespace.MutantControl.IsActive(29)?EveryGeneratedRegex_RegexCharacterClassToAnycharChange_DCKDaZ0TlAY5byqPwbODBbIkAZIC():(StrykerNamespace.MutantControl.IsActive(28)?EveryGeneratedRegex_RegexCharacterClassToAnycharChange_AcROccRMJ1UA3FuAjb8AzmSXZKcC():(StrykerNamespace.MutantControl.IsActive(27)?EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_y1i3HJMzxFY7gJWhm5CtbZ7V2K0C():(StrykerNamespace.MutantControl.IsActive(26)?EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_MoKdACze8Rlx0gV0Nn9APAF34ekC():(StrykerNamespace.MutantControl.IsActive(25)?EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_EG1vJwuxBxVq2m4hIUkHUNMo7tYC():(StrykerNamespace.MutantControl.IsActive(24)?EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_Bae9RUgNKRxRKFgRqKvDLpjRA1YC():(StrykerNamespace.MutantControl.IsActive(23)?EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_AA7dX74sep52koVN831bXn4u17UC():(StrykerNamespace.MutantControl.IsActive(22)?EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_1HbIK0ImZxFQSvsV30cFNRv8eOUC():(StrykerNamespace.MutantControl.IsActive(21)?EveryGeneratedRegex_RegexCharacterClassRangeModification_v8cAazPitekMon0D7bB9Q4IZ9EEC():(StrykerNamespace.MutantControl.IsActive(20)?EveryGeneratedRegex_RegexCharacterClassRangeModification_p5WdctKUWBxauqnnfDx2QcE5dsUC():(StrykerNamespace.MutantControl.IsActive(19)?EveryGeneratedRegex_RegexCharacterClassRangeModification_EDAKvlKhPBFf87BfZ3CUFA499eoC():(StrykerNamespace.MutantControl.IsActive(18)?EveryGeneratedRegex_RegexCharacterClassRangeModification_ECl6NWEwfqeisJAPgit0Dmj4nlIC():(StrykerNamespace.MutantControl.IsActive(17)?EveryGeneratedRegex_RegexCharacterClassRangeModification_DIDF6kiZATimAcD7hfvywVSLeYQC():(StrykerNamespace.MutantControl.IsActive(16)?EveryGeneratedRegex_RegexCharacterClassRangeModification_BJkj8Ze94RlaFtUpHV35kELpQMMC():(StrykerNamespace.MutantControl.IsActive(15)?EveryGeneratedRegex_RegexCharacterClassNegationMutation_qTODhf0q0Al7fFXsixABMg16q2MC():(StrykerNamespace.MutantControl.IsActive(14)?EveryGeneratedRegex_RegexCharacterClassNegationMutation_oBK9EvEpyApSWG4ZKvQciP6ab7cC():(StrykerNamespace.MutantControl.IsActive(13)?EveryGeneratedRegex_RegexCharacterClassNegationMutation_iZDswEwAWLkWKQI90owJx6b9qOwC():(StrykerNamespace.MutantControl.IsActive(12)?EveryGeneratedRegex_RegexCharacterClassNegationMutation_addWmS094qXCIDeDk44l54dXxGIC():(StrykerNamespace.MutantControl.IsActive(11)?EveryGeneratedRegex_RegexCharacterClassNegationMutation_3MZuBItCMFfszK4IkW0NdddVO78C():(StrykerNamespace.MutantControl.IsActive(10)?EveryGeneratedRegex_RegexCharacterClassChildRemoval_wxhQuKK4AZIOPy2AcmPQfRNP7oYC():(StrykerNamespace.MutantControl.IsActive(9)?EveryGeneratedRegex_RegexCharacterClassChildRemoval_V50VtGHAvm736YAzrZdtSUsLBmwC():(StrykerNamespace.MutantControl.IsActive(8)?EveryGeneratedRegex_RegexCharacterClassChildRemoval_QGGKipw10MwTH46bXjRrvSBSVgMC():(StrykerNamespace.MutantControl.IsActive(7)?EveryGeneratedRegex_RegexCharacterClassChildRemoval_PXA9CRiW7E7gkFemIOQ5dZOpAhYC():(StrykerNamespace.MutantControl.IsActive(6)?EveryGeneratedRegex_RegexCharacterClassChildRemoval_G6wecagynWaFBOPgBYyG18Vtff8C():(StrykerNamespace.MutantControl.IsActive(5)?EveryGeneratedRegex_RegexCharacterClassChildRemoval_A5pd1BYAPXD3bIfbzGzbYBsxjKEC():(StrykerNamespace.MutantControl.IsActive(4)?EveryGeneratedRegex_RegexCapturingGroupToNoncapturingGroupModification_iwA8brTOw8GRDyzqJhwBpIanaWoC():(StrykerNamespace.MutantControl.IsActive(3)?EveryGeneratedRegex_RegexAnchorRemovalMutation_s40RURZ5ModKr4q8mKSnqCFAsSkC():(StrykerNamespace.MutantControl.IsActive(2)?EveryGeneratedRegex_RegexAnchorRemovalMutation_h4jQ2GSuRTBi5xuqBOdhOAtEn2AC():(StrykerNamespace.MutantControl.IsActive(1)?EveryGeneratedRegex_RegexAnchorRemovalMutation_gbYQJRADS1BjsYlWPvzRBG5aWhwC():(StrykerNamespace.MutantControl.IsActive(0)?EveryGeneratedRegex_RegexAnchorRemovalMutation_1AiYS8Vt78muldVLvjyXyRyZJBcC():EveryGeneratedRegex_Original())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))); + [GeneratedRegex(@"[xyz][a-c][^xyz][^a-c].\d\D\w\W\s\S\t\r\n\v\f[\b]\0\cM\cJ\x4A\u1234\p{Ll}\P{IsLatinExtended-A}+(?:\p{Sc}|\p{P})\*\\\.^$\b\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\1\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_Original(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexAnchorRemovalMutation_1AiYS8Vt78muldVLvjyXyRyZJBcC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexAnchorRemovalMutation_gbYQJRADS1BjsYlWPvzRBG5aWhwC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexAnchorRemovalMutation_h4jQ2GSuRTBi5xuqBOdhOAtEn2AC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexAnchorRemovalMutation_s40RURZ5ModKr4q8mKSnqCFAsSkC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(?:x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCapturingGroupToNoncapturingGroupModification_iwA8brTOw8GRDyzqJhwBpIanaWoC(); + [GeneratedRegex("[xyz][a-c][^xz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassChildRemoval_A5pd1BYAPXD3bIfbzGzbYBsxjKEC(); + [GeneratedRegex("[xy][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassChildRemoval_G6wecagynWaFBOPgBYyG18Vtff8C(); + [GeneratedRegex("[yz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassChildRemoval_PXA9CRiW7E7gkFemIOQ5dZOpAhYC(); + [GeneratedRegex("[xyz][a-c][^xy][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassChildRemoval_QGGKipw10MwTH46bXjRrvSBSVgMC(); + [GeneratedRegex("[xz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassChildRemoval_V50VtGHAvm736YAzrZdtSUsLBmwC(); + [GeneratedRegex("[xyz][a-c][^yz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassChildRemoval_wxhQuKK4AZIOPy2AcmPQfRNP7oYC(); + [GeneratedRegex("[xyz][a-c][^xyz][a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassNegationMutation_3MZuBItCMFfszK4IkW0NdddVO78C(); + [GeneratedRegex("[xyz][^a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassNegationMutation_addWmS094qXCIDeDk44l54dXxGIC(); + [GeneratedRegex("[^xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassNegationMutation_iZDswEwAWLkWKQI90owJx6b9qOwC(); + [GeneratedRegex("[xyz][a-c][xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassNegationMutation_oBK9EvEpyApSWG4ZKvQciP6ab7cC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[^\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassNegationMutation_qTODhf0q0Al7fFXsixABMg16q2MC(); + [GeneratedRegex("[xyz][a-b][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassRangeModification_BJkj8Ze94RlaFtUpHV35kELpQMMC(); + [GeneratedRegex("[xyz][a-c][^xyz][^b-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassRangeModification_DIDF6kiZATimAcD7hfvywVSLeYQC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-d].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassRangeModification_ECl6NWEwfqeisJAPgit0Dmj4nlIC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-b].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassRangeModification_EDAKvlKhPBFf87BfZ3CUFA499eoC(); + [GeneratedRegex("[xyz][a-d][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassRangeModification_p5WdctKUWBxauqnnfDx2QcE5dsUC(); + [GeneratedRegex("[xyz][b-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassRangeModification_v8cAazPitekMon0D7bB9Q4IZ9EEC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\d\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_1HbIK0ImZxFQSvsV30cFNRv8eOUC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\s\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_AA7dX74sep52koVN831bXn4u17UC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\W\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_Bae9RUgNKRxRKFgRqKvDLpjRA1YC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\S\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_EG1vJwuxBxVq2m4hIUkHUNMo7tYC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\w\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_MoKdACze8Rlx0gV0Nn9APAF34ekC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\D\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassShorthandNegationMutation_y1i3HJMzxFY7gJWhm5CtbZ7V2K0C(); + [GeneratedRegex("[xyz][a-c][^xyz][\\w\\W].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassToAnycharChange_AcROccRMJ1UA3FuAjb8AzmSXZKcC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\w\\W]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassToAnycharChange_DCKDaZ0TlAY5byqPwbODBbIkAZIC(); + [GeneratedRegex("[\\w\\W][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassToAnycharChange_kYBwvFVrAcQTJIl5sMgoeBzEDOkC(); + [GeneratedRegex("[xyz][\\w\\W][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassToAnycharChange_Pe1S7QczESKvymG65xqAF9ghkZMC(); + [GeneratedRegex("[xyz][a-c][\\w\\W][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexCharacterClassToAnycharChange_ygeNW0h7YDBo4g2pwkNktYu4niMC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}{2,}(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_1c7NnXHt9z8fsgx06Le1l5vTIggC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x{0,2}?x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_1MjF7ZWsX2MfKfKAA7hGKeBhua8C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{3,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_2K1uDjNTSLj1TSZhAdm2bKxhqZ4C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,6}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_35sJGcPbJ8VRJAyUewek0UWASG4C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x{1,1}?x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_7KBFtwYEK2IVZZ3GGGNNlQGajDEC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x{1,1}x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_APay1eH8qqYOSl4Y6wxKoJqLjkMC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_AxYhcRt6U6D0Rcf06bbfvWFr6eMC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}{0,}(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_dk7GdFyFOAxREWicOjSWQuiIWW8C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x{0,0}x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_iBELtKoLJS7XwolhG0tYAXuk3XQC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{3,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_INToSTbm44zJUQ0TBZVKioV6fgwC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,4}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_KG0CrwMRAJETfQxiLdyc8s6eU2cC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x{0,0}?x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_MnXLAz8Dq0jBgYgMTwLlY5lr6gsC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?=y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_NwKn9UKIjkQiGiywozhQ9B9eQzUC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x{0,}x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_oYkBt9OrQ6lBySBadKMF0QtwQ34C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx{1,}x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_prjBSTTZ5JbH3NharhXLgqowfasC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x{2,}x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_q02jTy04WUYcNeEwGOMJeXab5isC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,4}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_Q55ITlc2BX48XX5heDBlnAcnrKEC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x{0,}?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_sBkPG6x2a2KWj2VtzjLuZeeYO3gC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{1,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_SoptGKphf0QSrirjO2yMaGmRyvUC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x{2,}?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_TzJhXFoLP9N2SqAS5f7nBpuMNxYC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{3,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_uydaC0EDOgUrGEcBu25g8GoXlloC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,6}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_VBLfW4ZzjZhFexul88YBhRBRHV0C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{5,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_ViS8ESkILqtW0OBoWBCBgX2tfDoC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?!y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_vsuuEBz0BZGG5Zb1TeiLyn5BhLkC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{5,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_wBKCF9aJZBn1zTssORDnNgeLj3QC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{3,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_wcyeFlVBIHPeIgdWA5egRMwEbgwC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x{0,2}x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_xgGWAepCfdldwn20tWSuIktRMRQC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{1,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_ytSzAPMFqzNg4Zc8LqMMDWGJuAoC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x{1,}?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierQuantityMutation_znoiq8qgLI5h8UUchwpJu22xnzEC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}?x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_42hebkL8zg1FqGzfLEsra6qwUN4C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}?x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_BlZrqzVjBTkuz4kHWkWGn3HEuMIC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x??x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_dcukJo0xdxRmvK2YPuoyAgvYs7wC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+?x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_EGSIwYyhX3kanyrE6ARnzDSh9xUC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+?(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_H5VAgonGR3AuAJzmtyU2l5YEqbUC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*?x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_PTBm3XgKAumc80klGYqyxFx18VsC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}?x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_ShtEXMslAlu9e25H1B5ZgCeVsL0C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\sS\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_34j2F8655cEg5EfRve2thHb3Nj0C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\dD\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_5nrEBVfQQ5wu8Ju2lPVQwXiUs0IC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\wW\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_C245tRgIkvSQa2ilBCjvPdaocREC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_UYuI2CpMqYMrPWgbn5vVFXOQlMMC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\Dw\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_WJ2SJBXE2kc9j6wOdvF6B4ro7nYC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\Ws\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassNullification_xlm5s9he6nU4ko6Ew6X3PA2MmfUC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D[\\w\\W]\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_3bflAx5U1clw7EnnnE4bHKOBeA4C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].[\\d\\D]\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_3HyAq20udGzJOBIHB1ru2F4sAuIC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s[\\S\\s]\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_Ety3yH3jZuY7mdB8bOoOuoyG8vUC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W[\\s\\S]\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_klAf6zrGgm6br9hShGolvLz7mgAC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w[\\W\\w]\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_oWGwFkE2RyeoOKt3RdRTcUxPJUEC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d[\\D\\d]\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_U9sfMApCkZWqpnpCsERY3dcyKGoC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?xx??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_4BSak9URuSxNOf1YzYTFr2j9e90C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?xx{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_5m0kCw41L0hBrmBczpJdzF6sL80C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}xx*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_AsQ73WQzkR79v34AY4s0s8KjuYIC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??xx{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_Hqg0wlGgVguBm7sBfil6GYvzYKoC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_iU4RPB7rAktBxgNrBHby7aigczAC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}xx+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_jb2hezMQR4L9JVqHxkbXLGMiSAAC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_K6CmS2GukAE3BT0yw0fxJAS6htAC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?xx{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_llC1qsNmFlOB9IEwB2TvXlXn3KQC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}xx{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_lYII6xUzrOWAD7Chk9EwpvOa7CMC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*xx?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_Y45xf5yuaVUoDOsBBRKJFQCXjwkC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kxx+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_ZczKWs9a5VnxIV1okXo2J9oYOK0C(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?xx{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_zjA2vrqW2o6NAviTK980yBaAz6wC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+xx{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexQuantifierRemovalMutation_zleFM7Swrz45BLOyikSBjB5BtGUC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\p{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexUnicodeCharacterClassNegationMutation_BBA33zw46D8thiyQGhq1yd0ZKsoC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\P{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexUnicodeCharacterClassNegationMutation_m3A0GUA4V1AzmhUI6hKzrTgwBuQC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\p{Sc}|\\P{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexUnicodeCharacterClassNegationMutation_MACM5kH7IMU9dZGBX1zFGO5w9PsC(); + [GeneratedRegex("[xyz][a-c][^xyz][^a-c].\\d\\D\\w\\W\\s\\S\\t\\r\\n\\v\\f[\\b]\\0\\cM\\cJ\\x4A\\u1234\\p{Ll}\\P{IsLatinExtended-A}+(?:\\P{Sc}|\\p{P})\\*\\\\\\.^$\\b\\Bx(?=y)x(?!y)(?<=y)(x)x(?x)(?:x)\\1\\kx*x+x?x{2}x{2,}x{4,5}x*?x+?x??x{2}?x{2,}?x{4,5}?")] + private static partial Regex EveryGeneratedRegex_RegexUnicodeCharacterClassNegationMutation_nIwxBSmUgeefAQfsaorG3TSYDqQC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.GeneratedRegexProperty.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.GeneratedRegexProperty.verified.cs new file mode 100644 index 000000000..2d6027567 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.GeneratedRegexProperty.verified.cs @@ -0,0 +1,21 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex AbcGeneratedRegex => (StrykerNamespace.MutantControl.IsActive(6)?AbcGeneratedRegex_RegexQuantifierRemovalMutation_wRDyzHH2CJ7sUB0tpS8lR26p8WUC:(StrykerNamespace.MutantControl.IsActive(5)?AbcGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_1luZwUASUXVZkgVBGCAx1ChgkVgC:(StrykerNamespace.MutantControl.IsActive(4)?AbcGeneratedRegex_RegexPredefinedCharacterClassNullification_DO1jh3gLUbqKucZGFaAiP5s6FBAC:(StrykerNamespace.MutantControl.IsActive(3)?AbcGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_mI5VM2LQbh8xoAzLnPAhj32mXecC:(StrykerNamespace.MutantControl.IsActive(2)?AbcGeneratedRegex_RegexCharacterClassShorthandNegationMutation_NLOKz2w30PQRgJAAgumztVCC96gC:(StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_QUnzaJ2FZicwB8ov7nGGyh3tpl8C:(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_B3qcxCMGyAqchkutVdC9fBZzdU8C:AbcGeneratedRegex_Original))))))); + [GeneratedRegex(@"\b\w{5}\b")] + private static partial Regex AbcGeneratedRegex_Original{ get; } + [GeneratedRegex("\\w{5}\\b")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_B3qcxCMGyAqchkutVdC9fBZzdU8C{ get; } + [GeneratedRegex("\\b\\w{5}")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_QUnzaJ2FZicwB8ov7nGGyh3tpl8C{ get; } + [GeneratedRegex("\\b\\W{5}\\b")] + private static partial Regex AbcGeneratedRegex_RegexCharacterClassShorthandNegationMutation_NLOKz2w30PQRgJAAgumztVCC96gC{ get; } + [GeneratedRegex("\\b\\w{5}?\\b")] + private static partial Regex AbcGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_mI5VM2LQbh8xoAzLnPAhj32mXecC{ get; } + [GeneratedRegex("\\bw{5}\\b")] + private static partial Regex AbcGeneratedRegex_RegexPredefinedCharacterClassNullification_DO1jh3gLUbqKucZGFaAiP5s6FBAC{ get; } + [GeneratedRegex("\\b[\\w\\W]{5}\\b")] + private static partial Regex AbcGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_1luZwUASUXVZkgVBGCAx1ChgkVgC{ get; } + [GeneratedRegex("\\b\\w\\b")] + private static partial Regex AbcGeneratedRegex_RegexQuantifierRemovalMutation_wRDyzHH2CJ7sUB0tpS8lR26p8WUC{ get; } +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.MultipleRegexInDedicatedClass.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.MultipleRegexInDedicatedClass.verified.cs new file mode 100644 index 000000000..f25d81c81 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.MultipleRegexInDedicatedClass.verified.cs @@ -0,0 +1,58 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("^abc", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex("abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); + + private static Regex AbcdGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(15)?AbcdGeneratedRegex_RegexQuantifierRemovalMutation_uJA6aLkSDZf1nNEqTTrmUwkVMpUC():(StrykerNamespace.MutantControl.IsActive(14)?AbcdGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_MDzkRwclKiIgJcKRendsP7fvRxsC():(StrykerNamespace.MutantControl.IsActive(13)?AbcdGeneratedRegex_RegexPredefinedCharacterClassNullification_zvabPNkNXi5E4WVy9DbXSDBtJBcC():(StrykerNamespace.MutantControl.IsActive(12)?AbcdGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w4583iXfF3f5E1wYY0vUHvf89GsC():(StrykerNamespace.MutantControl.IsActive(11)?AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_SxSBojTcWfK90GNEzOYCcKxKPEMC():(StrykerNamespace.MutantControl.IsActive(10)?AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_EemMBA83KH5r9vsxwuYTbZItICIC():(StrykerNamespace.MutantControl.IsActive(9)?AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_0IPy0NkuaZuus5vyaBNObDf8YBEC():(StrykerNamespace.MutantControl.IsActive(8)?AbcdGeneratedRegex_RegexCharacterClassToAnycharChange_ChZb0RJfdWiCoO7uZWgXV9GKRWoC():(StrykerNamespace.MutantControl.IsActive(7)?AbcdGeneratedRegex_RegexCharacterClassShorthandNegationMutation_MlYZgMyXCSRTuWJOS9wBgXbB5tcC():(StrykerNamespace.MutantControl.IsActive(6)?AbcdGeneratedRegex_RegexCharacterClassNegationMutation_sUNdnI9ukFndVf8l6TkBoumJJRQC():(StrykerNamespace.MutantControl.IsActive(5)?AbcdGeneratedRegex_RegexCharacterClassChildRemoval_yxJAlmw5XA356qagdqMKq3btNCEC():(StrykerNamespace.MutantControl.IsActive(4)?AbcdGeneratedRegex_RegexCharacterClassChildRemoval_e4iNMNHMRl5IY1AYBopi97YjMQwC():(StrykerNamespace.MutantControl.IsActive(3)?AbcdGeneratedRegex_RegexCharacterClassChildRemoval_5XPHLFUGLBs4SAQEaHNXnV9D4MkC():(StrykerNamespace.MutantControl.IsActive(2)?AbcdGeneratedRegex_RegexAnchorRemovalMutation_SdtdlVHq9QAJyltvbdr0AfzHrW4C():AbcdGeneratedRegex_Original())))))))))))))); + + [GeneratedRegex(@"^[abc]\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_Original(); + + [GeneratedRegex("[abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexAnchorRemovalMutation_SdtdlVHq9QAJyltvbdr0AfzHrW4C(); + + [GeneratedRegex("^[ab]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassChildRemoval_5XPHLFUGLBs4SAQEaHNXnV9D4MkC(); + + [GeneratedRegex("^[ac]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassChildRemoval_e4iNMNHMRl5IY1AYBopi97YjMQwC(); + + [GeneratedRegex("^[bc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassChildRemoval_yxJAlmw5XA356qagdqMKq3btNCEC(); + + [GeneratedRegex("^[^abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassNegationMutation_sUNdnI9ukFndVf8l6TkBoumJJRQC(); + + [GeneratedRegex("^[abc]\\D?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassShorthandNegationMutation_MlYZgMyXCSRTuWJOS9wBgXbB5tcC(); + + [GeneratedRegex("^[\\w\\W]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassToAnycharChange_ChZb0RJfdWiCoO7uZWgXV9GKRWoC(); + + [GeneratedRegex("^[abc]\\d{0,0}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_0IPy0NkuaZuus5vyaBNObDf8YBEC(); + + [GeneratedRegex("^[abc]\\d{0,2}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_EemMBA83KH5r9vsxwuYTbZItICIC(); + + [GeneratedRegex("^[abc]\\d{1,1}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_SxSBojTcWfK90GNEzOYCcKxKPEMC(); + + [GeneratedRegex("^[abc]\\d??", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w4583iXfF3f5E1wYY0vUHvf89GsC(); + + [GeneratedRegex("^[abc]d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexPredefinedCharacterClassNullification_zvabPNkNXi5E4WVy9DbXSDBtJBcC(); + + [GeneratedRegex("^[abc][\\d\\D]?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_MDzkRwclKiIgJcKRendsP7fvRxsC(); + + [GeneratedRegex("^[abc]\\d", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcdGeneratedRegex_RegexQuantifierRemovalMutation_uJA6aLkSDZf1nNEqTTrmUwkVMpUC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.MultipleRegexInMultipleClasses.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.MultipleRegexInMultipleClasses.verified.cs new file mode 100644 index 000000000..b2af35e6d --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.MultipleRegexInMultipleClasses.verified.cs @@ -0,0 +1,125 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R1 { + private static Regex Abc1GeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?Abc1GeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(0)?Abc1GeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():Abc1GeneratedRegex_Original())); + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abc1GeneratedRegex_Original(); + [GeneratedRegex("^abc", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abc1GeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex("abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abc1GeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); + + private static Regex Abcd1GeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(15)?Abcd1GeneratedRegex_RegexQuantifierRemovalMutation_uJA6aLkSDZf1nNEqTTrmUwkVMpUC():(StrykerNamespace.MutantControl.IsActive(14)?Abcd1GeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_MDzkRwclKiIgJcKRendsP7fvRxsC():(StrykerNamespace.MutantControl.IsActive(13)?Abcd1GeneratedRegex_RegexPredefinedCharacterClassNullification_zvabPNkNXi5E4WVy9DbXSDBtJBcC():(StrykerNamespace.MutantControl.IsActive(12)?Abcd1GeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w4583iXfF3f5E1wYY0vUHvf89GsC():(StrykerNamespace.MutantControl.IsActive(11)?Abcd1GeneratedRegex_RegexGreedyQuantifierQuantityMutation_SxSBojTcWfK90GNEzOYCcKxKPEMC():(StrykerNamespace.MutantControl.IsActive(10)?Abcd1GeneratedRegex_RegexGreedyQuantifierQuantityMutation_EemMBA83KH5r9vsxwuYTbZItICIC():(StrykerNamespace.MutantControl.IsActive(9)?Abcd1GeneratedRegex_RegexGreedyQuantifierQuantityMutation_0IPy0NkuaZuus5vyaBNObDf8YBEC():(StrykerNamespace.MutantControl.IsActive(8)?Abcd1GeneratedRegex_RegexCharacterClassToAnycharChange_ChZb0RJfdWiCoO7uZWgXV9GKRWoC():(StrykerNamespace.MutantControl.IsActive(7)?Abcd1GeneratedRegex_RegexCharacterClassShorthandNegationMutation_MlYZgMyXCSRTuWJOS9wBgXbB5tcC():(StrykerNamespace.MutantControl.IsActive(6)?Abcd1GeneratedRegex_RegexCharacterClassNegationMutation_sUNdnI9ukFndVf8l6TkBoumJJRQC():(StrykerNamespace.MutantControl.IsActive(5)?Abcd1GeneratedRegex_RegexCharacterClassChildRemoval_yxJAlmw5XA356qagdqMKq3btNCEC():(StrykerNamespace.MutantControl.IsActive(4)?Abcd1GeneratedRegex_RegexCharacterClassChildRemoval_e4iNMNHMRl5IY1AYBopi97YjMQwC():(StrykerNamespace.MutantControl.IsActive(3)?Abcd1GeneratedRegex_RegexCharacterClassChildRemoval_5XPHLFUGLBs4SAQEaHNXnV9D4MkC():(StrykerNamespace.MutantControl.IsActive(2)?Abcd1GeneratedRegex_RegexAnchorRemovalMutation_SdtdlVHq9QAJyltvbdr0AfzHrW4C():Abcd1GeneratedRegex_Original())))))))))))))); + + [GeneratedRegex(@"^[abc]\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_Original(); + + [GeneratedRegex("[abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexAnchorRemovalMutation_SdtdlVHq9QAJyltvbdr0AfzHrW4C(); + + [GeneratedRegex("^[ab]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexCharacterClassChildRemoval_5XPHLFUGLBs4SAQEaHNXnV9D4MkC(); + + [GeneratedRegex("^[ac]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexCharacterClassChildRemoval_e4iNMNHMRl5IY1AYBopi97YjMQwC(); + + [GeneratedRegex("^[bc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexCharacterClassChildRemoval_yxJAlmw5XA356qagdqMKq3btNCEC(); + + [GeneratedRegex("^[^abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexCharacterClassNegationMutation_sUNdnI9ukFndVf8l6TkBoumJJRQC(); + + [GeneratedRegex("^[abc]\\D?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexCharacterClassShorthandNegationMutation_MlYZgMyXCSRTuWJOS9wBgXbB5tcC(); + + [GeneratedRegex("^[\\w\\W]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexCharacterClassToAnycharChange_ChZb0RJfdWiCoO7uZWgXV9GKRWoC(); + + [GeneratedRegex("^[abc]\\d{0,0}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexGreedyQuantifierQuantityMutation_0IPy0NkuaZuus5vyaBNObDf8YBEC(); + + [GeneratedRegex("^[abc]\\d{0,2}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexGreedyQuantifierQuantityMutation_EemMBA83KH5r9vsxwuYTbZItICIC(); + + [GeneratedRegex("^[abc]\\d{1,1}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexGreedyQuantifierQuantityMutation_SxSBojTcWfK90GNEzOYCcKxKPEMC(); + + [GeneratedRegex("^[abc]\\d??", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w4583iXfF3f5E1wYY0vUHvf89GsC(); + + [GeneratedRegex("^[abc]d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexPredefinedCharacterClassNullification_zvabPNkNXi5E4WVy9DbXSDBtJBcC(); + + [GeneratedRegex("^[abc][\\d\\D]?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_MDzkRwclKiIgJcKRendsP7fvRxsC(); + + [GeneratedRegex("^[abc]\\d", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd1GeneratedRegex_RegexQuantifierRemovalMutation_uJA6aLkSDZf1nNEqTTrmUwkVMpUC(); +} +public partial class R2 { + private static Regex Abc2GeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(18)?Abc2GeneratedRegex_RegexAnchorRemovalMutation_zGamrKwW6ANBC778udllQZ1MR7QC():(StrykerNamespace.MutantControl.IsActive(17)?Abc2GeneratedRegex_RegexAnchorRemovalMutation_SWsP0ttxcvtw60j1d0lOMxgnqR8C():(StrykerNamespace.MutantControl.IsActive(16)?Abc2GeneratedRegex_RegexAnchorRemovalMutation_oUokMRf9irbrUFWAuW1GF0UYUmEC():Abc2GeneratedRegex_Original()))); + [GeneratedRegex(@"^abc\b$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abc2GeneratedRegex_Original(); + [GeneratedRegex("abc\\b$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abc2GeneratedRegex_RegexAnchorRemovalMutation_oUokMRf9irbrUFWAuW1GF0UYUmEC(); + [GeneratedRegex("^abc\\b", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abc2GeneratedRegex_RegexAnchorRemovalMutation_SWsP0ttxcvtw60j1d0lOMxgnqR8C(); + [GeneratedRegex("^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abc2GeneratedRegex_RegexAnchorRemovalMutation_zGamrKwW6ANBC778udllQZ1MR7QC(); + + private static Regex Abcd2GeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(35)?Abcd2GeneratedRegex_RegexQuantifierRemovalMutation_KBl0fhby530iRtCWz8NjzdsGEVkC():(StrykerNamespace.MutantControl.IsActive(34)?Abcd2GeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_iXmXZGuK8Hx41XA1lnPmpjPknBsC():(StrykerNamespace.MutantControl.IsActive(33)?Abcd2GeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_agkiVP4RSi4UdRJIbItUiEnIup0C():(StrykerNamespace.MutantControl.IsActive(32)?Abcd2GeneratedRegex_RegexPredefinedCharacterClassNullification_ZEhYNkswW6B197LW5QCAEdF9nqMC():(StrykerNamespace.MutantControl.IsActive(31)?Abcd2GeneratedRegex_RegexPredefinedCharacterClassNullification_7eoO374QTRVGuB0S0klaEHAi9I4C():(StrykerNamespace.MutantControl.IsActive(30)?Abcd2GeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_xGhG3l5tSJUDy5Ifrk4lioWoRGYC():(StrykerNamespace.MutantControl.IsActive(29)?Abcd2GeneratedRegex_RegexGreedyQuantifierQuantityMutation_bW7wM7kgBZDh9DzrLDA38dt5ELcC():(StrykerNamespace.MutantControl.IsActive(28)?Abcd2GeneratedRegex_RegexGreedyQuantifierQuantityMutation_8D7T7YM8npB9DR3uvuLjBKGBfFwC():(StrykerNamespace.MutantControl.IsActive(27)?Abcd2GeneratedRegex_RegexGreedyQuantifierQuantityMutation_40dpPAGrBhiVjyajOobno7aAFlwC():(StrykerNamespace.MutantControl.IsActive(26)?Abcd2GeneratedRegex_RegexCharacterClassToAnycharChange_IlcC0WBD6RTPHTWzzI8h7GR6yDEC():(StrykerNamespace.MutantControl.IsActive(25)?Abcd2GeneratedRegex_RegexCharacterClassShorthandNegationMutation_JT1uBo8WX3bw1WvAlBzY08lwAdAC():(StrykerNamespace.MutantControl.IsActive(24)?Abcd2GeneratedRegex_RegexCharacterClassShorthandNegationMutation_cy4mCbUGK1XhyZGp20URzeZ16WwC():(StrykerNamespace.MutantControl.IsActive(23)?Abcd2GeneratedRegex_RegexCharacterClassNegationMutation_R1njA5T5mqbQX4QdgTtA84aAUf4C():(StrykerNamespace.MutantControl.IsActive(22)?Abcd2GeneratedRegex_RegexCharacterClassChildRemoval_YtvHnV0PYI0PHlPJvL6JKMfBS8sC():(StrykerNamespace.MutantControl.IsActive(21)?Abcd2GeneratedRegex_RegexCharacterClassChildRemoval_fVOHtzA3yf7EQENon6OG8iqeVrsC():(StrykerNamespace.MutantControl.IsActive(20)?Abcd2GeneratedRegex_RegexCharacterClassChildRemoval_4tRJqEzhSAWdB01rQVeDsQaY998C():(StrykerNamespace.MutantControl.IsActive(19)?Abcd2GeneratedRegex_RegexAnchorRemovalMutation_nrttgUdiLHGmkMufZczT1IN3JbcC():Abcd2GeneratedRegex_Original()))))))))))))))))); + + [GeneratedRegex(@"^\d[abc]\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_Original(); + + [GeneratedRegex("\\d[abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexAnchorRemovalMutation_nrttgUdiLHGmkMufZczT1IN3JbcC(); + + [GeneratedRegex("^\\d[ab]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexCharacterClassChildRemoval_4tRJqEzhSAWdB01rQVeDsQaY998C(); + + [GeneratedRegex("^\\d[bc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexCharacterClassChildRemoval_fVOHtzA3yf7EQENon6OG8iqeVrsC(); + + [GeneratedRegex("^\\d[ac]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexCharacterClassChildRemoval_YtvHnV0PYI0PHlPJvL6JKMfBS8sC(); + + [GeneratedRegex("^\\d[^abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexCharacterClassNegationMutation_R1njA5T5mqbQX4QdgTtA84aAUf4C(); + + [GeneratedRegex("^\\D[abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexCharacterClassShorthandNegationMutation_cy4mCbUGK1XhyZGp20URzeZ16WwC(); + + [GeneratedRegex("^\\d[abc]\\D?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexCharacterClassShorthandNegationMutation_JT1uBo8WX3bw1WvAlBzY08lwAdAC(); + + [GeneratedRegex("^\\d[\\w\\W]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexCharacterClassToAnycharChange_IlcC0WBD6RTPHTWzzI8h7GR6yDEC(); + + [GeneratedRegex("^\\d[abc]\\d{1,1}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexGreedyQuantifierQuantityMutation_40dpPAGrBhiVjyajOobno7aAFlwC(); + + [GeneratedRegex("^\\d[abc]\\d{0,0}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexGreedyQuantifierQuantityMutation_8D7T7YM8npB9DR3uvuLjBKGBfFwC(); + + [GeneratedRegex("^\\d[abc]\\d{0,2}", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexGreedyQuantifierQuantityMutation_bW7wM7kgBZDh9DzrLDA38dt5ELcC(); + + [GeneratedRegex("^\\d[abc]\\d??", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_xGhG3l5tSJUDy5Ifrk4lioWoRGYC(); + + [GeneratedRegex("^\\d[abc]d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexPredefinedCharacterClassNullification_7eoO374QTRVGuB0S0klaEHAi9I4C(); + + [GeneratedRegex("^d[abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexPredefinedCharacterClassNullification_ZEhYNkswW6B197LW5QCAEdF9nqMC(); + + [GeneratedRegex("^\\d[abc][\\d\\D]?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_agkiVP4RSi4UdRJIbItUiEnIup0C(); + + [GeneratedRegex("^[\\d\\D][abc]\\d?", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_iXmXZGuK8Hx41XA1lnPmpjPknBsC(); + + [GeneratedRegex("^\\d[abc]\\d", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex Abcd2GeneratedRegex_RegexQuantifierRemovalMutation_KBl0fhby530iRtCWz8NjzdsGEVkC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.MultipleRegexInSharedClass.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.MultipleRegexInSharedClass.verified.cs new file mode 100644 index 000000000..ae22a5ecb --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.MultipleRegexInSharedClass.verified.cs @@ -0,0 +1,60 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(3)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(2)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("^abc", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex("abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); + + static string Value => (StrykerNamespace.MutantControl.IsActive(0)?"":(StrykerNamespace.MutantControl.IsActive(1)?"":"test ").Substring(2)); + + private static Regex AbcdGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(17)?AbcdGeneratedRegex_RegexQuantifierRemovalMutation_uJA6aLkSDZf1nNEqTTrmUwkVMpUC():(StrykerNamespace.MutantControl.IsActive(16)?AbcdGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_MDzkRwclKiIgJcKRendsP7fvRxsC():(StrykerNamespace.MutantControl.IsActive(15)?AbcdGeneratedRegex_RegexPredefinedCharacterClassNullification_zvabPNkNXi5E4WVy9DbXSDBtJBcC():(StrykerNamespace.MutantControl.IsActive(14)?AbcdGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w4583iXfF3f5E1wYY0vUHvf89GsC():(StrykerNamespace.MutantControl.IsActive(13)?AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_SxSBojTcWfK90GNEzOYCcKxKPEMC():(StrykerNamespace.MutantControl.IsActive(12)?AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_EemMBA83KH5r9vsxwuYTbZItICIC():(StrykerNamespace.MutantControl.IsActive(11)?AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_0IPy0NkuaZuus5vyaBNObDf8YBEC():(StrykerNamespace.MutantControl.IsActive(10)?AbcdGeneratedRegex_RegexCharacterClassToAnycharChange_ChZb0RJfdWiCoO7uZWgXV9GKRWoC():(StrykerNamespace.MutantControl.IsActive(9)?AbcdGeneratedRegex_RegexCharacterClassShorthandNegationMutation_MlYZgMyXCSRTuWJOS9wBgXbB5tcC():(StrykerNamespace.MutantControl.IsActive(8)?AbcdGeneratedRegex_RegexCharacterClassNegationMutation_sUNdnI9ukFndVf8l6TkBoumJJRQC():(StrykerNamespace.MutantControl.IsActive(7)?AbcdGeneratedRegex_RegexCharacterClassChildRemoval_yxJAlmw5XA356qagdqMKq3btNCEC():(StrykerNamespace.MutantControl.IsActive(6)?AbcdGeneratedRegex_RegexCharacterClassChildRemoval_e4iNMNHMRl5IY1AYBopi97YjMQwC():(StrykerNamespace.MutantControl.IsActive(5)?AbcdGeneratedRegex_RegexCharacterClassChildRemoval_5XPHLFUGLBs4SAQEaHNXnV9D4MkC():(StrykerNamespace.MutantControl.IsActive(4)?AbcdGeneratedRegex_RegexAnchorRemovalMutation_SdtdlVHq9QAJyltvbdr0AfzHrW4C():AbcdGeneratedRegex_Original())))))))))))))); + + [GeneratedRegex(@"^[abc]\d?")] + private static partial Regex AbcdGeneratedRegex_Original(); + + [GeneratedRegex("[abc]\\d?")] + private static partial Regex AbcdGeneratedRegex_RegexAnchorRemovalMutation_SdtdlVHq9QAJyltvbdr0AfzHrW4C(); + + [GeneratedRegex("^[ab]\\d?")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassChildRemoval_5XPHLFUGLBs4SAQEaHNXnV9D4MkC(); + + [GeneratedRegex("^[ac]\\d?")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassChildRemoval_e4iNMNHMRl5IY1AYBopi97YjMQwC(); + + [GeneratedRegex("^[bc]\\d?")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassChildRemoval_yxJAlmw5XA356qagdqMKq3btNCEC(); + + [GeneratedRegex("^[^abc]\\d?")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassNegationMutation_sUNdnI9ukFndVf8l6TkBoumJJRQC(); + + [GeneratedRegex("^[abc]\\D?")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassShorthandNegationMutation_MlYZgMyXCSRTuWJOS9wBgXbB5tcC(); + + [GeneratedRegex("^[\\w\\W]\\d?")] + private static partial Regex AbcdGeneratedRegex_RegexCharacterClassToAnycharChange_ChZb0RJfdWiCoO7uZWgXV9GKRWoC(); + + [GeneratedRegex("^[abc]\\d{0,0}")] + private static partial Regex AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_0IPy0NkuaZuus5vyaBNObDf8YBEC(); + + [GeneratedRegex("^[abc]\\d{0,2}")] + private static partial Regex AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_EemMBA83KH5r9vsxwuYTbZItICIC(); + + [GeneratedRegex("^[abc]\\d{1,1}")] + private static partial Regex AbcdGeneratedRegex_RegexGreedyQuantifierQuantityMutation_SxSBojTcWfK90GNEzOYCcKxKPEMC(); + + [GeneratedRegex("^[abc]\\d??")] + private static partial Regex AbcdGeneratedRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w4583iXfF3f5E1wYY0vUHvf89GsC(); + + [GeneratedRegex("^[abc]d?")] + private static partial Regex AbcdGeneratedRegex_RegexPredefinedCharacterClassNullification_zvabPNkNXi5E4WVy9DbXSDBtJBcC(); + + [GeneratedRegex("^[abc][\\d\\D]?")] + private static partial Regex AbcdGeneratedRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_MDzkRwclKiIgJcKRendsP7fvRxsC(); + + [GeneratedRegex("^[abc]\\d")] + private static partial Regex AbcdGeneratedRegex_RegexQuantifierRemovalMutation_uJA6aLkSDZf1nNEqTTrmUwkVMpUC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.NoMutationInterface.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.NoMutationInterface.verified.cs new file mode 100644 index 000000000..397f0f425 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.NoMutationInterface.verified.cs @@ -0,0 +1,6 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial interface R { + [GeneratedRegex(@"a", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.NoMutationRegex.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.NoMutationRegex.verified.cs new file mode 100644 index 000000000..790d62729 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.NoMutationRegex.verified.cs @@ -0,0 +1,6 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + [GeneratedRegex(@"a", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.OtherMutations.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.OtherMutations.verified.cs new file mode 100644 index 000000000..5fd303993 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.OtherMutations.verified.cs @@ -0,0 +1,16 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(4)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(3)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("^abc", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex("abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); + + public void M() {if(StrykerNamespace.MutantControl.IsActive(0)){}else{ + var toMutate = (StrykerNamespace.MutantControl.IsActive(1)?"":"a string is here"); + var mutation2 = (StrykerNamespace.MutantControl.IsActive(2)?toMutate.PadRight(5):toMutate.PadLeft(5)); + } +}} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RealTest.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RealTest.verified.cs new file mode 100644 index 000000000..c8cc44017 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RealTest.verified.cs @@ -0,0 +1,159 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex SpecificDateTimeRegex() => (StrykerNamespace.MutantControl.IsActive(75)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_UTQ4NQfcG3Igoe2ZkiqfhLi1lnYC():(StrykerNamespace.MutantControl.IsActive(74)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_o32zdwVIPAved3tAm0ua46dnaNEC():(StrykerNamespace.MutantControl.IsActive(73)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_MXUuVB55iXgTBu4d0tkIh2fBKwMC():(StrykerNamespace.MutantControl.IsActive(72)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_LT6NdIwtbC8MJk5baODJcQh9Qo4C():(StrykerNamespace.MutantControl.IsActive(71)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_EdaQhMIIXC8AjxL8950KSSWT73sC():(StrykerNamespace.MutantControl.IsActive(70)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_DWVIpKH3ZLXaJrANeLaVAD4D3tgC():(StrykerNamespace.MutantControl.IsActive(69)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_D3gK9XHuD2TsjrLsOH3q5tjLSdkC():(StrykerNamespace.MutantControl.IsActive(68)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_B7DJJaPNEqRBNeoQGVNoRBBt2ecC():(StrykerNamespace.MutantControl.IsActive(67)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_B0E3vO8A9Ajd50yxIltUuFr6f4AC():(StrykerNamespace.MutantControl.IsActive(66)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_Ab7BcozwdIhWNnMwINSyIUZE0vMC():(StrykerNamespace.MutantControl.IsActive(65)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_2qFqveinrcM2uZNGC6A2MDQYgNgC():(StrykerNamespace.MutantControl.IsActive(64)?SpecificDateTimeRegex_RegexQuantifierRemovalMutation_1mOVokWuoGlKkDH7BxEu9GD7VOgC():(StrykerNamespace.MutantControl.IsActive(63)?SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_ziZFJ1ns0omp2pt13C1WejF8stAC():(StrykerNamespace.MutantControl.IsActive(62)?SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_XarM1Y51DGwByY6SAD0175tfEBIC():(StrykerNamespace.MutantControl.IsActive(61)?SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_WDylgShcR4nhp68AEKavcBGA6skC():(StrykerNamespace.MutantControl.IsActive(60)?SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_QVZeF1hd1OI5A9D3u3KktJ470ssC():(StrykerNamespace.MutantControl.IsActive(59)?SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_Q1DTW5c0NLhgKesWHB1j0iFV5MIC():(StrykerNamespace.MutantControl.IsActive(58)?SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_KHYkydCzQpDDWjx95tOLBibwWgwC():(StrykerNamespace.MutantControl.IsActive(57)?SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_BiUr01AULAEo7GUa9wzuUKL58IAC():(StrykerNamespace.MutantControl.IsActive(56)?SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_0GCXudo59Ag62LO5cm8nae8PQgIC():(StrykerNamespace.MutantControl.IsActive(55)?SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_xYlXfacckKcdEC8pedYes04hocEC():(StrykerNamespace.MutantControl.IsActive(54)?SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_sfHj7kyweVEBcwm48rr9vwn99RwC():(StrykerNamespace.MutantControl.IsActive(53)?SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_PXUjzW5aiWBN3vIqx57eH3J7cZIC():(StrykerNamespace.MutantControl.IsActive(52)?SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_piHA6BnkQKAZiAG3VWpe5hDG894C():(StrykerNamespace.MutantControl.IsActive(51)?SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_Mn9NSaAeNJml4xiIB63BJABuyAcC():(StrykerNamespace.MutantControl.IsActive(50)?SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_kEtAOLgfuPARMxzOwOtJzIggIUcC():(StrykerNamespace.MutantControl.IsActive(49)?SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_BZBrvszKBqYbRpWoSpfwTk4pZ0wC():(StrykerNamespace.MutantControl.IsActive(48)?SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_a0X9n6rsXOKBnA7mhwowYDAS4T0C():(StrykerNamespace.MutantControl.IsActive(47)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w9mhXAEDVws4fMzx8JV0jLnnAecC():(StrykerNamespace.MutantControl.IsActive(46)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_t7nOObaZ0Xfb9n0MhOCdZCbIJ5sC():(StrykerNamespace.MutantControl.IsActive(45)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_simfJzSoS7RzQ9TWlQABBxUwXvIC():(StrykerNamespace.MutantControl.IsActive(44)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_pIen4Qy2gutALDZD8iChwsJ5GDYC():(StrykerNamespace.MutantControl.IsActive(43)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_oVPuWb11pujQENhEolY4hOynMPQC():(StrykerNamespace.MutantControl.IsActive(42)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_okzDnmOQATLW2oyymirAhMs8RoMC():(StrykerNamespace.MutantControl.IsActive(41)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_He8fDLjMV3WsmSHN1fro7UbbsLAC():(StrykerNamespace.MutantControl.IsActive(40)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_gQ93j5ge2WBKbOyOHS7n5CWl3cgC():(StrykerNamespace.MutantControl.IsActive(39)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_DgGDpD3bio3XftFkW9ibM02Jc0YC():(StrykerNamespace.MutantControl.IsActive(38)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_c5ghRBvqeWILdtvNy5iu9Ow73R8C():(StrykerNamespace.MutantControl.IsActive(37)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_bDecMmOmUli9sBQX8kQipzN8q08C():(StrykerNamespace.MutantControl.IsActive(36)?SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_6yPpnRYL56pYihallWBUA9dtWu0C():(StrykerNamespace.MutantControl.IsActive(35)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_YbAKs0cnht82P5MwTwaN6p8OBVgC():(StrykerNamespace.MutantControl.IsActive(34)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_wmBqaa766EU2z4b9KouOjeB1x0sC():(StrykerNamespace.MutantControl.IsActive(33)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_wlO8rBtSsANAkZ2BVpUerxGXmkoC():(StrykerNamespace.MutantControl.IsActive(32)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_VeQwne5qMImfSZV5cWWuPxUB43IC():(StrykerNamespace.MutantControl.IsActive(31)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_TmoFkOuhG34PCWtWgYLYYyTqLcMC():(StrykerNamespace.MutantControl.IsActive(30)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_SzTng8sYzv8Kl9fd2BUAN8sMlRcC():(StrykerNamespace.MutantControl.IsActive(29)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_QVCCP6PTbHOSKIwxhS8v6EwBCBoC():(StrykerNamespace.MutantControl.IsActive(28)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_QCjfIyoQUqyCbBkfVExl7GSmUYcC():(StrykerNamespace.MutantControl.IsActive(27)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_mCVre3eTJkh9cpj49rOFKTS9H6cC():(StrykerNamespace.MutantControl.IsActive(26)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_MBI2WUV2sgDIxKFzuuwDEIcXK14C():(StrykerNamespace.MutantControl.IsActive(25)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_lanrIGXqjPBdl7rulZhOjdL6QeYC():(StrykerNamespace.MutantControl.IsActive(24)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_JZpWzF1AnFl0G5rC8zwvHn84lt0C():(StrykerNamespace.MutantControl.IsActive(23)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_JPzRlKNLByslfB2YQd1Z4ps916EC():(StrykerNamespace.MutantControl.IsActive(22)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_IOxBINgPI80BoeorHsEDMcb7vvQC():(StrykerNamespace.MutantControl.IsActive(21)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_FyrX28TOlA3L2Qd7BN5hqO5h4wwC():(StrykerNamespace.MutantControl.IsActive(20)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_FSDmuvAq8D9QVctl4elpj8yzfmwC():(StrykerNamespace.MutantControl.IsActive(19)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_flMhp23UVIKfraDMtOWAtAUroTYC():(StrykerNamespace.MutantControl.IsActive(18)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_efE0zZHei4eB77slODILIlArMo4C():(StrykerNamespace.MutantControl.IsActive(17)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_dBtt3KcRlAc2i4ZlfW5ceseqbEEC():(StrykerNamespace.MutantControl.IsActive(16)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_C06nDx1xQX0MxftUFwgBlJUMrloC():(StrykerNamespace.MutantControl.IsActive(15)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_bGJaOQOt3TnPGAICaPC6xcnidvcC():(StrykerNamespace.MutantControl.IsActive(14)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_beMhofAW1YLDhhXriT6ipUgB8bUC():(StrykerNamespace.MutantControl.IsActive(13)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_AIfGxj39uA5eIHvDuYl56mbYO8UC():(StrykerNamespace.MutantControl.IsActive(12)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_Af4Xu7B7DjWpbLT5Pu9nVPod4gAC():(StrykerNamespace.MutantControl.IsActive(11)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_9cNv66G24PcIrOsNTm18fzRktckC():(StrykerNamespace.MutantControl.IsActive(10)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_8HZQvutsEgbYBXrbQwZUrdpyiL8C():(StrykerNamespace.MutantControl.IsActive(9)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_55BFkVmnf3GkjKnjPBcepf5i3a0C():(StrykerNamespace.MutantControl.IsActive(8)?SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_4MFABXVc2jhxaoI1wA96G0N3rPkC():(StrykerNamespace.MutantControl.IsActive(7)?SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_xQwAyYAy1mAniTYqBKIsvxhlgjUC():(StrykerNamespace.MutantControl.IsActive(6)?SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_xBKngBzyCAreaI5wmnOf38ecwzQC():(StrykerNamespace.MutantControl.IsActive(5)?SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_q2VM9hXVPggoSQ1Fni4d155BGb8C():(StrykerNamespace.MutantControl.IsActive(4)?SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_nQmT9U6yxHSLoLHfkjBPA6Hp5HsC():(StrykerNamespace.MutantControl.IsActive(3)?SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_l3hxzO7rMl1cAzlAN67zw6J7AMYC():(StrykerNamespace.MutantControl.IsActive(2)?SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_dmQj7uBWKwK8byxOT72JlDegySwC():(StrykerNamespace.MutantControl.IsActive(1)?SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_AspE6KXq6q2GNLV75JBOb0lgKAMC():(StrykerNamespace.MutantControl.IsActive(0)?SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_4KOF3hIlAsyyVoW8e8d6nr2so7UC():SpecificDateTimeRegex_Original())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))); + [GeneratedRegex(@"(?\w{3}), 0?(?\d{1,2})-(?\w{3})-(?\d{2}) 0?(?\d{1,2}):0?(?\d{1,2}):0?(?\d{1,2}) (?\w{3})")] + private static partial Regex SpecificDateTimeRegex_Original(); + [GeneratedRegex("(?\\w{3}), 0?(?\\D{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_4KOF3hIlAsyyVoW8e8d6nr2so7UC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\D{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_AspE6KXq6q2GNLV75JBOb0lgKAMC(); + [GeneratedRegex("(?\\W{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_dmQj7uBWKwK8byxOT72JlDegySwC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\D{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_l3hxzO7rMl1cAzlAN67zw6J7AMYC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\D{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_nQmT9U6yxHSLoLHfkjBPA6Hp5HsC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\D{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_q2VM9hXVPggoSQ1Fni4d155BGb8C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\W{3})")] + private static partial Regex SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_xBKngBzyCAreaI5wmnOf38ecwzQC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\W{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexCharacterClassShorthandNegationMutation_xQwAyYAy1mAniTYqBKIsvxhlgjUC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{0,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_4MFABXVc2jhxaoI1wA96G0N3rPkC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0{0,2}(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_55BFkVmnf3GkjKnjPBcepf5i3a0C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,1}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_8HZQvutsEgbYBXrbQwZUrdpyiL8C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,3}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_9cNv66G24PcIrOsNTm18fzRktckC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0{0,2}(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_Af4Xu7B7DjWpbLT5Pu9nVPod4gAC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{2,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_AIfGxj39uA5eIHvDuYl56mbYO8UC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0{0,0}(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_beMhofAW1YLDhhXriT6ipUgB8bUC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0{1,1}(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_bGJaOQOt3TnPGAICaPC6xcnidvcC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,1})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_C06nDx1xQX0MxftUFwgBlJUMrloC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,1}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_dBtt3KcRlAc2i4ZlfW5ceseqbEEC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,3})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_efE0zZHei4eB77slODILIlArMo4C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{0,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_flMhp23UVIKfraDMtOWAtAUroTYC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0{0,0}(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_FSDmuvAq8D9QVctl4elpj8yzfmwC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{0,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_FyrX28TOlA3L2Qd7BN5hqO5h4wwC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0{1,1}(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_IOxBINgPI80BoeorHsEDMcb7vvQC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0{0,2}(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_JPzRlKNLByslfB2YQd1Z4ps916EC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{2,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_JZpWzF1AnFl0G5rC8zwvHn84lt0C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{2,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_lanrIGXqjPBdl7rulZhOjdL6QeYC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{0,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_MBI2WUV2sgDIxKFzuuwDEIcXK14C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{2,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_mCVre3eTJkh9cpj49rOFKTS9H6cC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0{0,0}(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_QCjfIyoQUqyCbBkfVExl7GSmUYcC(); + [GeneratedRegex("(?\\w{3}), 0{0,2}(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_QVCCP6PTbHOSKIwxhS8v6EwBCBoC(); + [GeneratedRegex("(?\\w{3}), 0{0,0}(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_SzTng8sYzv8Kl9fd2BUAN8sMlRcC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,1}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_TmoFkOuhG34PCWtWgYLYYyTqLcMC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0{1,1}(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_VeQwne5qMImfSZV5cWWuPxUB43IC(); + [GeneratedRegex("(?\\w{3}), 0{1,1}(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_wlO8rBtSsANAkZ2BVpUerxGXmkoC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,3}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_wmBqaa766EU2z4b9KouOjeB1x0sC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,3}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierQuantityMutation_YbAKs0cnht82P5MwTwaN6p8OBVgC(); + [GeneratedRegex("(?\\w{3}), 0??(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_6yPpnRYL56pYihallWBUA9dtWu0C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}?):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_bDecMmOmUli9sBQX8kQipzN8q08C(); + [GeneratedRegex("(?\\w{3}?), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_c5ghRBvqeWILdtvNy5iu9Ow73R8C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}?) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_DgGDpD3bio3XftFkW9ibM02Jc0YC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2}?)-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_gQ93j5ge2WBKbOyOHS7n5CWl3cgC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0??(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_He8fDLjMV3WsmSHN1fro7UbbsLAC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}?):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_okzDnmOQATLW2oyymirAhMs8RoMC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3}?)")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_oVPuWb11pujQENhEolY4hOynMPQC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3}?)-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_pIen4Qy2gutALDZD8iChwsJ5GDYC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0??(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_simfJzSoS7RzQ9TWlQABBxUwXvIC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0??(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_t7nOObaZ0Xfb9n0MhOCdZCbIJ5sC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}?) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexGreedyQuantifierToReluctantQuantifierModification_w9mhXAEDVws4fMzx8JV0jLnnAecC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_a0X9n6rsXOKBnA7mhwowYDAS4T0C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_BZBrvszKBqYbRpWoSpfwTk4pZ0wC(); + [GeneratedRegex("(?w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_kEtAOLgfuPARMxzOwOtJzIggIUcC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_Mn9NSaAeNJml4xiIB63BJABuyAcC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_piHA6BnkQKAZiAG3VWpe5hDG894C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_PXUjzW5aiWBN3vIqx57eH3J7cZIC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_sfHj7kyweVEBcwm48rr9vwn99RwC(); + [GeneratedRegex("(?\\w{3}), 0?(?d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassNullification_xYlXfacckKcdEC8pedYes04hocEC(); + [GeneratedRegex("(?\\w{3}), 0?(?[\\d\\D]{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_0GCXudo59Ag62LO5cm8nae8PQgIC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?[\\d\\D]{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_BiUr01AULAEo7GUa9wzuUKL58IAC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?[\\d\\D]{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_KHYkydCzQpDDWjx95tOLBibwWgwC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?[\\w\\W]{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_Q1DTW5c0NLhgKesWHB1j0iFV5MIC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?[\\d\\D]{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_QVZeF1hd1OI5A9D3u3KktJ470ssC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?[\\w\\W]{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_WDylgShcR4nhp68AEKavcBGA6skC(); + [GeneratedRegex("(?[\\w\\W]{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_XarM1Y51DGwByY6SAD0175tfEBIC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?[\\d\\D]{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexPredefinedCharacterClassToCharacterClassWithItsNegationChange_ziZFJ1ns0omp2pt13C1WejF8stAC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_1mOVokWuoGlKkDH7BxEu9GD7VOgC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_2qFqveinrcM2uZNGC6A2MDQYgNgC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_Ab7BcozwdIhWNnMwINSyIUZE0vMC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_B0E3vO8A9Ajd50yxIltUuFr6f4AC(); + [GeneratedRegex("(?\\w{3}), 0(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_B7DJJaPNEqRBNeoQGVNoRBBt2ecC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w)-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_D3gK9XHuD2TsjrLsOH3q5tjLSdkC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_DWVIpKH3ZLXaJrANeLaVAD4D3tgC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d)-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_EdaQhMIIXC8AjxL8950KSSWT73sC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w)")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_LT6NdIwtbC8MJk5baODJcQh9Qo4C(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_MXUuVB55iXgTBu4d0tkIh2fBKwMC(); + [GeneratedRegex("(?\\w), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d{1,2}) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_o32zdwVIPAved3tAm0ua46dnaNEC(); + [GeneratedRegex("(?\\w{3}), 0?(?\\d{1,2})-(?\\w{3})-(?\\d{2}) 0?(?\\d{1,2}):0?(?\\d{1,2}):0?(?\\d) (?\\w{3})")] + private static partial Regex SpecificDateTimeRegex_RegexQuantifierRemovalMutation_UTQ4NQfcG3Igoe2ZkiqfhLi1lnYC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexAsConstField.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexAsConstField.verified.cs new file mode 100644 index 000000000..73755427b --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexAsConstField.verified.cs @@ -0,0 +1,16 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + public const string Regex = @"^abc$"; + + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + + [GeneratedRegex(Regex)] + private static partial Regex AbcGeneratedRegex_Original(); + + [GeneratedRegex("^abc")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + + [GeneratedRegex("abc$")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexAsInterpolatedConstField.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexAsInterpolatedConstField.verified.cs new file mode 100644 index 000000000..269fe70b3 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexAsInterpolatedConstField.verified.cs @@ -0,0 +1,15 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex AbcdeGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcdeGeneratedRegex_RegexAnchorRemovalMutation_yKlpAr1znwWgUdVhsnWjVnBCAZgC():(StrykerNamespace.MutantControl.IsActive(0)?AbcdeGeneratedRegex_RegexAnchorRemovalMutation_NmuwH41sWWaN87b6mJOyDYbGGhEC():AbcdeGeneratedRegex_Original())); + [GeneratedRegex(C.Regex)] + private static partial Regex AbcdeGeneratedRegex_Original(); + [GeneratedRegex("^abcde")] + private static partial Regex AbcdeGeneratedRegex_RegexAnchorRemovalMutation_NmuwH41sWWaN87b6mJOyDYbGGhEC(); + [GeneratedRegex("abcde$")] + private static partial Regex AbcdeGeneratedRegex_RegexAnchorRemovalMutation_yKlpAr1znwWgUdVhsnWjVnBCAZgC(); +} +public static class C { + public const string Inner = @"abcde"; + public const string Regex = $@"^{Inner}$"; +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexInIfDefBlock.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexInIfDefBlock.verified.cs new file mode 100644 index 000000000..4a34cbbd8 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexInIfDefBlock.verified.cs @@ -0,0 +1,16 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { +#if GENERATED_REGEX + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():AbcGeneratedRegex_Original())); + [GeneratedRegex(@"^abc$")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("abc$")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); + [GeneratedRegex("^abc")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); +#else + private static readonly Regex _abcGeneratedRegex = new Regex(@"^abc$"); + private static Regex AbcGeneratedRegex() => _abcGeneratedRegex; +#endif +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexInIfDefBlockInverted.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexInIfDefBlockInverted.verified.cs new file mode 100644 index 000000000..18dd1d967 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.RegexInIfDefBlockInverted.verified.cs @@ -0,0 +1,22 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { +#if !GENERATED_REGEX + private static readonly Regex _abcGeneratedRegex = new Regex(@"^abc$"); + private static Regex AbcGeneratedRegex() => _abcGeneratedRegex; +#else + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():AbcGeneratedRegex_Original())); + private static readonly Regex _abcGeneratedRegex = new Regex(@"^abc$"); + private static Regex AbcGeneratedRegex() => _abcGeneratedRegex; + [GeneratedRegex(@"^abc$")] + private static partial Regex AbcGeneratedRegex_Original(); + private static readonly Regex _abcGeneratedRegex = new Regex(@"^abc$"); + private static Regex AbcGeneratedRegex() => _abcGeneratedRegex; + [GeneratedRegex("abc$")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); + private static readonly Regex _abcGeneratedRegex = new Regex(@"^abc$"); + private static Regex AbcGeneratedRegex() => _abcGeneratedRegex; + [GeneratedRegex("^abc")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); +#endif +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedClass.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedClass.verified.cs new file mode 100644 index 000000000..da0f988b7 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedClass.verified.cs @@ -0,0 +1,11 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("^abc", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex("abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedRecord.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedRecord.verified.cs new file mode 100644 index 000000000..1ed497426 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedRecord.verified.cs @@ -0,0 +1,11 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial record R { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("^abc", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex("abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedRecordStruct.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedRecordStruct.verified.cs new file mode 100644 index 000000000..1ea05e747 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedRecordStruct.verified.cs @@ -0,0 +1,11 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial record struct R { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("^abc", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex("abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedStruct.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedStruct.verified.cs new file mode 100644 index 000000000..5240d4766 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInDedicatedStruct.verified.cs @@ -0,0 +1,11 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial struct R { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("^abc", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex("abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInNestedClass.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInNestedClass.verified.cs new file mode 100644 index 000000000..8a1e758f0 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SimpleSingleRegexInNestedClass.verified.cs @@ -0,0 +1,13 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + public partial class R2 { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + [GeneratedRegex(@"^abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex("^abc", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex("abc$", RegexOptions.IgnoreCase, "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); + } +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SingleRegexInDedicatedClassNamedParameter.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SingleRegexInDedicatedClassNamedParameter.verified.cs new file mode 100644 index 000000000..05041f174 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SingleRegexInDedicatedClassNamedParameter.verified.cs @@ -0,0 +1,11 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + private static Regex AbcGeneratedRegex() => (StrykerNamespace.MutantControl.IsActive(1)?AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC():(StrykerNamespace.MutantControl.IsActive(0)?AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC():AbcGeneratedRegex_Original())); + [GeneratedRegex(RegexOptions.IgnoreCase, pattern: @"^abc$", "en-US")] + private static partial Regex AbcGeneratedRegex_Original(); + [GeneratedRegex(RegexOptions.IgnoreCase, pattern: "^abc", "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_KqIxB18xYu8ALD4NBR827tks3jYC(); + [GeneratedRegex(RegexOptions.IgnoreCase, pattern: "abc$", "en-US")] + private static partial Regex AbcGeneratedRegex_RegexAnchorRemovalMutation_XvqOBYS3t1u4AI1iIc6VTTMEhssC(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SupportsStrykerComments.verified.cs b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SupportsStrykerComments.verified.cs new file mode 100644 index 000000000..0c9af45cc --- /dev/null +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Mutants/Verified/GeneratedRegexOrchestratorTests.SupportsStrykerComments.verified.cs @@ -0,0 +1,7 @@ +using System.Text.RegularExpressions; +namespace StrykerNet.UnitTest.Mutants.TestResources; +public partial class R { + // stryker disable Regex + [GeneratedRegex(@"\b\w{5}\b")] + private static partial Regex AbcGeneratedRegex(); +} \ No newline at end of file diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/StringExtensions.cs b/src/Stryker.Core/Stryker.Core.UnitTest/StringExtensions.cs index 3acca459f..2ec8444bb 100644 --- a/src/Stryker.Core/Stryker.Core.UnitTest/StringExtensions.cs +++ b/src/Stryker.Core/Stryker.Core.UnitTest/StringExtensions.cs @@ -4,19 +4,17 @@ namespace Stryker.Core.UnitTest; -internal static class StringExtensions +internal static partial class StringExtensions { private const string Escape = "\u001b"; - private static readonly Regex Ansi = new(Escape + "\\[[\\d;]+m", RegexOptions.ECMAScript); - /// /// Removes ANSI escape sequences from the . /// /// A basic string without ANSI escape sequences. public static string RemoveAnsi(this string value) { - return Ansi.Replace(value.ToString(), string.Empty); + return AnsiRegex().Replace(value, string.Empty); } /// @@ -72,4 +70,7 @@ public static int AnyForegroundColorSpanCount(this string value) { return value.Split(Escape).Count(s => s.StartsWith("[3", StringComparison.Ordinal)); } + + [GeneratedRegex(@"\[[\d;]+m", RegexOptions.ECMAScript)] + private static partial Regex AnsiRegex(); } diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/Stryker.Core.UnitTest.csproj b/src/Stryker.Core/Stryker.Core.UnitTest/Stryker.Core.UnitTest.csproj index 8f07b6c82..3f73f0f9b 100644 --- a/src/Stryker.Core/Stryker.Core.UnitTest/Stryker.Core.UnitTest.csproj +++ b/src/Stryker.Core/Stryker.Core.UnitTest/Stryker.Core.UnitTest.csproj @@ -2,6 +2,11 @@ false + + + + + @@ -56,6 +61,7 @@ + diff --git a/src/Stryker.Core/Stryker.Core.UnitTest/packages.lock.json b/src/Stryker.Core/Stryker.Core.UnitTest/packages.lock.json index a50e41a36..5bdeed355 100644 --- a/src/Stryker.Core/Stryker.Core.UnitTest/packages.lock.json +++ b/src/Stryker.Core/Stryker.Core.UnitTest/packages.lock.json @@ -108,6 +108,21 @@ "TestableIO.System.IO.Abstractions.Wrappers": "21.1.3" } }, + "Verify.MSTest": { + "type": "Direct", + "requested": "[26.6.0, )", + "resolved": "26.6.0", + "contentHash": "Rr4Dj0Z665q0kZidsemcjxecO/jmi8t4Ubndd6q6nMASeFi7J+p+DWJU2Cc+k7ej43JHnVL9l+YhSObhsfUxwQ==", + "dependencies": { + "MSTest.TestFramework": "3.6.0", + "Verify": "26.6.0" + } + }, + "Argon": { + "type": "Transitive", + "resolved": "0.21.0", + "contentHash": "c515pzYDOmF3o8TywrIsTjxbc5KJwSdZW3I7JkhhduLz15wAlxo53nLg2UnD+dqTAT838LcuawRNgneK83A30Q==" + }, "Azure.Core": { "type": "Transitive", "resolved": "1.41.0", @@ -147,17 +162,17 @@ }, "DiffEngine": { "type": "Transitive", - "resolved": "11.3.0", - "contentHash": "k0ZgZqd09jLZQjR8FyQbSQE86Q7QZnjEzq1LPHtj1R2AoWO8sjV5x+jlSisL7NZAbUOI4y+7Bog8gkr9WIRBGw==", + "resolved": "15.5.1", + "contentHash": "8j7Ke8odgqsflzwhdNYek6XHCGAL8sACuxJbzm7luvKrPubLPbTwppidvHe++rbJoVBh9Jj2BiF8b00U+TT35Q==", "dependencies": { - "EmptyFiles": "4.4.0", - "System.Management": "6.0.1" + "EmptyFiles": "8.4.0", + "System.Management": "8.0.0" } }, "EmptyFiles": { "type": "Transitive", - "resolved": "4.4.0", - "contentHash": "gwJEfIGS7FhykvtZoscwXj/XwW+mJY6UbAZk+qtLKFUGWC95kfKXnj8VkxsZQnWBxJemM/q664rGLN5nf+OHZw==" + "resolved": "8.4.0", + "contentHash": "M+GhsRIbqmfoGqB4XYya1ikuVb5GLT+F2bjitGAOs1Mg14Ojt9+MkEKWU3Kf3tse/2TuM5ozhxi3TBmPaSQ6GA==" }, "FSharp.Core": { "type": "Transitive", @@ -593,6 +608,11 @@ "System.Text.Encoding.Extensions": "4.0.11" } }, + "SimpleInfoName": { + "type": "Transitive", + "resolved": "2.3.0", + "contentHash": "oasLpQjcW+x3/EEgAmFI1NkrSmjIuXGgxm9dbzTY8XHgv05324QJZb4dh07PzHjKOUK28ImObtXGF7h4pEbpaA==" + }, "Spectre.Console.Cli": { "type": "Transitive", "resolved": "0.49.1", @@ -617,8 +637,8 @@ }, "System.CodeDom": { "type": "Transitive", - "resolved": "6.0.0", - "contentHash": "CPc6tWO1LAer3IzfZufDBRL+UZQcj5uS207NHALQzP84Vp/z6wF0Aa0YZImOQY8iStY0A2zI/e3ihKNPfUm8XA==" + "resolved": "8.0.0", + "contentHash": "WTlRjL6KWIMr/pAaq3rYqh0TJlzpouaQ/W1eelssHgtlwHAH25jXTkUphTYx9HaIIf7XA6qs/0+YhtLEQRkJ+Q==" }, "System.Collections": { "type": "Transitive", @@ -815,8 +835,8 @@ }, "System.IO.Hashing": { "type": "Transitive", - "resolved": "6.0.0", - "contentHash": "Rfm2jYCaUeGysFEZjDe7j1R4x6Z6BzumS/vUT5a1AA/AWJuGX71PoGB0RmpyX3VmrGqVnAwtfMn39OHR8Y/5+g==" + "resolved": "8.0.0", + "contentHash": "ne1843evDugl0md7Fjzy6QjJrzsjh46ZKbhf8GwBXb5f/gw97J4bxMs0NQKifDuThh/f0bZ0e62NPl1jzTuRqA==" }, "System.Linq": { "type": "Transitive", @@ -871,10 +891,10 @@ }, "System.Management": { "type": "Transitive", - "resolved": "6.0.1", - "contentHash": "10J1D0h/lioojphfJ4Fuh5ZUThT/xOVHdV9roGBittKKNP2PMjrvibEdbVTGZcPra1399Ja3tqIJLyQrc5Wmhg==", + "resolved": "8.0.0", + "contentHash": "jrK22i5LRzxZCfGb+tGmke2VH7oE0DvcDlJ1HAKYU8cPmD8XnpUT0bYn2Gy98GEhGjtfbR/sxKTVb+dE770pfA==", "dependencies": { - "System.CodeDom": "6.0.0" + "System.CodeDom": "8.0.0" } }, "System.Memory": { @@ -1532,6 +1552,17 @@ "resolved": "21.1.3", "contentHash": "qe/gIjOPCoyiSCToouJx/vCvcTQXVGj/eJVRK/7s2F8yIv0zvEpjByfXZvS3yqmcpg0/S6x6w7DvNyPrLe/RRw==" }, + "Verify": { + "type": "Transitive", + "resolved": "26.6.0", + "contentHash": "n1lR8znqqFqvx6EA8M602B7TYm7RDk9QlFb77l2moCqIZ9/sKm2wKijmJlgYR2KueQjt3eUvm7nWKJjjdPQX9Q==", + "dependencies": { + "Argon": "0.21.0", + "DiffEngine": "15.5.1", + "SimpleInfoName": "2.3.0", + "System.IO.Hashing": "8.0.0" + } + }, "stryker": { "type": "Project", "dependencies": { diff --git a/src/Stryker.Core/Stryker.Core/Initialisation/ProjectComponentsBuilder.cs b/src/Stryker.Core/Stryker.Core/Initialisation/ProjectComponentsBuilder.cs index ac7bdfc8b..475ef5b73 100644 --- a/src/Stryker.Core/Stryker.Core/Initialisation/ProjectComponentsBuilder.cs +++ b/src/Stryker.Core/Stryker.Core/Initialisation/ProjectComponentsBuilder.cs @@ -12,7 +12,7 @@ namespace Stryker.Core.Initialisation; -public abstract class ProjectComponentsBuilder +public abstract partial class ProjectComponentsBuilder { protected readonly IFileSystem FileSystem; @@ -60,10 +60,9 @@ private static IEnumerable FindSharedProjects(XDocument document) private static string ReplaceMsbuildProperties(string projectReference, IAnalyzerResult projectAnalyzerResult) { - var propertyRegex = new Regex(@"\$\(([a-zA-Z_][a-zA-Z0-9_\-.]*)\)"); var properties = projectAnalyzerResult.Properties; - return propertyRegex.Replace(projectReference, + return PropertyRegex().Replace(projectReference, m => { var property = m.Groups[1].Value; @@ -79,4 +78,7 @@ private static string ReplaceMsbuildProperties(string projectReference, IAnalyze public abstract void InjectHelpers(IReadOnlyProjectComponent inputFiles); public abstract Action PostBuildAction(); + + [GeneratedRegex(@"\$\(([a-zA-Z_][a-zA-Z0-9_\-.]*)\)")] + private static partial Regex PropertyRegex(); } diff --git a/src/Stryker.Core/Stryker.Core/InjectedHelpers/CodeInjection.cs b/src/Stryker.Core/Stryker.Core/InjectedHelpers/CodeInjection.cs index 3762bdeb7..ddae6d87f 100644 --- a/src/Stryker.Core/Stryker.Core/InjectedHelpers/CodeInjection.cs +++ b/src/Stryker.Core/Stryker.Core/InjectedHelpers/CodeInjection.cs @@ -8,12 +8,12 @@ namespace Stryker.Core.InjectedHelpers; -public class CodeInjection +public partial class CodeInjection { // files to be injected into the mutated assembly private static readonly string[] Files = {"Stryker.Core.InjectedHelpers.MutantControl.cs", "Stryker.Core.InjectedHelpers.Coverage.MutantContext.cs"}; - private const string PatternForCheck = "\\/\\/ *check with: *([^\\r\\n]+)"; + private const string MutantContextClassName = "MutantContext"; private const string StrykerNamespace = "Stryker"; private static readonly string Selector; @@ -21,7 +21,7 @@ public class CodeInjection static CodeInjection() //NOSONAR : no way to get read of static constructors { var helper = GetSourceFromResource("Stryker.Core.InjectedHelpers.MutantControl.cs"); - var extractor = new Regex(PatternForCheck); + var extractor = PatternForCheckRegex(); var result = extractor.Match(helper); if (!result.Success) { @@ -114,4 +114,7 @@ private static string GetSourceFromResource(string sourceResourceName) using var reader = new StreamReader(stream!); return reader.ReadToEnd(); } + + [GeneratedRegex(@"\/\/ *check with: *([^\r\n]+)")] + private static partial Regex PatternForCheckRegex(); } diff --git a/src/Stryker.Core/Stryker.Core/MutantFilters/ExcludeFromCodeCoverageFilter.cs b/src/Stryker.Core/Stryker.Core/MutantFilters/ExcludeFromCodeCoverageFilter.cs index 8cf229d02..bb49eb522 100644 --- a/src/Stryker.Core/Stryker.Core/MutantFilters/ExcludeFromCodeCoverageFilter.cs +++ b/src/Stryker.Core/Stryker.Core/MutantFilters/ExcludeFromCodeCoverageFilter.cs @@ -9,7 +9,7 @@ namespace Stryker.Core.MutantFilters; -public class ExcludeFromCodeCoverageFilter : IMutantFilter +public partial class ExcludeFromCodeCoverageFilter : IMutantFilter { public MutantFilter Type => MutantFilter.ExcludeFromCodeCoverage; public string DisplayName => "exclude from code coverage filter"; @@ -39,7 +39,9 @@ private static bool HasExcludeFromCodeCoverageAttribute(MemberDeclarationSyntax { return m.AttributeLists .SelectMany(attr => attr.Attributes) - .Any(attr => Regex.IsMatch(attr.Name.ToString(), - @"^(?:System\.Diagnostics\.CodeAnalysis\.)?ExcludeFromCodeCoverage(?:Attribute)?$")); + .Any(attr => ExcludeFromCodeCoverageRegex().IsMatch(attr.Name.ToString())); } + + [GeneratedRegex(@"^(?:System\.Diagnostics\.CodeAnalysis\.)?ExcludeFromCodeCoverage(?:Attribute)?$")] + private static partial Regex ExcludeFromCodeCoverageRegex(); } diff --git a/src/Stryker.Core/Stryker.Core/Mutants/CsharpMutantOrchestrator.cs b/src/Stryker.Core/Stryker.Core/Mutants/CsharpMutantOrchestrator.cs index 09b193245..da847081f 100644 --- a/src/Stryker.Core/Stryker.Core/Mutants/CsharpMutantOrchestrator.cs +++ b/src/Stryker.Core/Stryker.Core/Mutants/CsharpMutantOrchestrator.cs @@ -1,3 +1,4 @@ +using System; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Linq; @@ -70,6 +71,7 @@ private static List BuildOrchestratorList() => // ensure static constructs are marked properly new StaticFieldDeclarationOrchestrator(), new StaticConstructorOrchestrator(), + new GeneratedRegexOrchestrator(), // ensure array initializer mutations are controlled at statement level new MutateAtStatementLevelOrchestrator(t => t.Kind() == SyntaxKind.ArrayInitializerExpression && t.Expressions.Count > 0), @@ -143,23 +145,30 @@ internal IEnumerable GenerateMutationsForNode(SyntaxNode current, Semant { foreach (var mutation in mutator.Mutate(current, semanticModel, Options)) { - var newMutant = CreateNewMutant(mutation, context); - // Skip if the mutant is a duplicate - if (IsMutantDuplicate(newMutant, mutation)) + if (GenerateMutation(context, mutation, mutator.GetType()) is {} m) { - continue; + mutations.Add(m); } - newMutant.Id = GetNextId(); - Logger.LogDebug("Mutant {MutantId} created {OriginalNode} -> {ReplacementNode} using {Mutator}", newMutant.Id, mutation.OriginalNode, - mutation.ReplacementNode, mutator.GetType()); - Mutants.Add(newMutant); - mutations.Add(newMutant); } } return mutations; } + internal Mutant GenerateMutation(MutationContext context, Mutation mutation, Type mutator) { + var newMutant = CreateNewMutant(mutation, context); + // Skip if the mutant is a duplicate + if (IsMutantDuplicate(newMutant, mutation)) + { + return null; + } + newMutant.Id = GetNextId(); + Logger.LogDebug("Mutant {MutantId} created {OriginalNode} -> {ReplacementNode} using {Mutator}", newMutant.Id, mutation.OriginalNode, + mutation.ReplacementNode, mutator); + Mutants.Add(newMutant); + return newMutant; + } + /// /// Creates a new mutant for the given mutation, mutator and context. Returns null if the mutant /// is a duplicate. @@ -169,10 +178,12 @@ private Mutant CreateNewMutant(Mutation mutation, MutationContext context) var mutantIgnored = context.FilteredMutators?.Contains(mutation.Type) ?? false; return new Mutant { - Mutation = mutation, - ResultStatus = mutantIgnored ? MutantStatus.Ignored : MutantStatus.Pending, - IsStaticValue = context.InStaticValue, - ResultStatusReason = mutantIgnored ? context.FilterComment : null + Mutation = mutation, + ResultStatus = mutantIgnored ? MutantStatus.Ignored : MutantStatus.Pending, + IsStaticValue = context.InStaticValue, + ResultStatusReason = mutantIgnored ? context.FilterComment : null, + OriginalLocation = mutation.OriginalLocation ?? mutation.OriginalNode.GetLocation().GetMappedLineSpan(), + ReplacementText = mutation.ReplacementText ?? mutation.ReplacementNode.ToString() }; } diff --git a/src/Stryker.Core/Stryker.Core/Mutants/CsharpNodeOrchestrators/GeneratedRegexOrchestrator.cs b/src/Stryker.Core/Stryker.Core/Mutants/CsharpNodeOrchestrators/GeneratedRegexOrchestrator.cs new file mode 100644 index 000000000..16b390f78 --- /dev/null +++ b/src/Stryker.Core/Stryker.Core/Mutants/CsharpNodeOrchestrators/GeneratedRegexOrchestrator.cs @@ -0,0 +1,435 @@ +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Globalization; +using System.Linq; +using System.Security.Cryptography; +using System.Text; +using System.Text.RegularExpressions; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.Extensions.Logging; +using Stryker.Abstractions.Logging; +using Stryker.Abstractions.Mutants; +using Stryker.Abstractions.Mutators; +using Stryker.RegexMutators; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; + +namespace Stryker.Core.Mutants.CsharpNodeOrchestrators; + +internal sealed class GeneratedRegexOrchestrator : MemberDefinitionOrchestrator +{ + private ILogger Logger { get; } = ApplicationLogging.LoggerFactory.CreateLogger(); + + private static readonly SyntaxAnnotation _tempAnnotationMarker = new (Guid.NewGuid().ToString()); + + /// + protected override bool CanHandle(TypeDeclarationSyntax t) => + t is ClassDeclarationSyntax or StructDeclarationSyntax or RecordDeclarationSyntax && + t.Modifiers.Any(static a => a.IsKind(SyntaxKind.PartialKeyword)); + + /// + public override SyntaxNode Mutate(SyntaxNode node, SemanticModel semanticModel, MutationContext context) + { + var toProcess = ((TypeDeclarationSyntax)node).Members + .Select(a => GenerateNewMethods(a, semanticModel)) + .Where(static a => a.HasValue) + .Select(static a => a.Value) + .ToImmutableArray(); + + if (toProcess.Length == 0) + { + return base.Mutate(node, semanticModel, context); + } + + var originalNode = node; + var correctSemanticModel = semanticModel; + + node = node.TrackNodes(toProcess.Select(static SyntaxNode (a) => a.OriginalNode)).WithAdditionalAnnotations(_tempAnnotationMarker); + + if (semanticModel is not null) + { + // Obtain new SemanticModel for modified syntax tree + var newSyntaxTree = originalNode.SyntaxTree.GetRoot().ReplaceNode(originalNode, node).SyntaxTree; + correctSemanticModel = semanticModel.Compilation.AddSyntaxTrees(newSyntaxTree).GetSemanticModel(newSyntaxTree); + node = newSyntaxTree.GetRoot().GetAnnotatedNodes(_tempAnnotationMarker).First(); + } + + return InnerMutate(base.Mutate(node, correctSemanticModel, context), context, toProcess); + } + + private static SyntaxNode InnerMutate(SyntaxNode node, MutationContext context, ImmutableArray toProcess) { + context = context.Enter(MutationControl.Expression); + + foreach (var (oldNode, marker, (proxyMethod, renamedMethod, _), mutations2) in toProcess) + { + var newContext = CommentParser.ParseNodeLeadingComments(oldNode.RawNode, context); + var l = new List<(Mutant, ExpressionSyntax)>(mutations2.Length); + + foreach (var mutation in mutations2.OrderBy(static a => a.Name)) + { + if (newContext.GenerateMutant(mutation.Mutation, typeof(GeneratedRegexOrchestrator)) is { } m) + { + l.Add((m, (ExpressionSyntax)mutation.Mutation.ReplacementNode)); + } + } + + if (context.FilteredMutators?.Contains(Mutator.Regex) ?? false) + { + continue; + } + + node = node.ReplaceNode(node.GetCurrentNode(oldNode)!, [ + proxyMethod, + renamedMethod, + ..mutations2.OrderBy(static a => a.Name).Select(static a => a.NewMethod) + ]); + + var nodeToMutate = node.GetAnnotatedNodes(marker).OfType().First(); + node = node.ReplaceNode(nodeToMutate, context.Placer.PlaceExpressionControlledMutations(nodeToMutate, l)); + } + + context.Leave(); + return node; + } + + private RegexMutationBatch? GenerateNewMethods(MemberDeclarationSyntax method, SemanticModel semanticModel) + { + var mpds = method switch + { + MethodDeclarationSyntax mds => new MethodOrPropertyDeclarationSyntax(mds), + PropertyDeclarationSyntax pds => new MethodOrPropertyDeclarationSyntax(pds), + _ => null + }; + + var regexAttribute = mpds?.GetRegexAttribute(); + + if (regexAttribute is null) + { + return null; + } + + var marker = new SyntaxAnnotation(Guid.NewGuid().ToString()); + var proxyInfo = MutatePartialRegexMethod(mpds, marker); + + var regexMutations = GenerateNewMethods(mpds, regexAttribute, semanticModel, proxyInfo.NodeToMutate).ToArray(); + + if (regexMutations.Length == 0) + { + return null; + } + + return new RegexMutationBatch(mpds, marker, proxyInfo, regexMutations); + } + + private IEnumerable GenerateNewMethods(MethodOrPropertyDeclarationSyntax method, + AttributeSyntax regexAttribute, + SemanticModel model, + ExpressionSyntax nodeToMutate) + { + var arguments = regexAttribute.ArgumentList?.Arguments; + + var namedArgument = arguments?.FirstOrDefault(static argument => + argument.NameColon?.Name.Identifier.ValueText == + "pattern"); + var patternArgument = namedArgument ?? arguments?.FirstOrDefault(); + var patternExpression = patternArgument?.Expression; + + string currentValue = null; + + if (patternExpression.IsKind(SyntaxKind.IdentifierName) && model is not null) + { + var constantValue = model.GetConstantValue(patternExpression); + + if (constantValue.HasValue) + { + currentValue = constantValue.Value as string; + } + else + { + currentValue = (model.GetSymbolInfo(patternExpression).Symbol as IFieldSymbol)?.OriginalDefinition + .ConstantValue as string; + } + } + + if (patternExpression.IsKind(SyntaxKind.SimpleMemberAccessExpression)) + { + currentValue = model?.GetConstantValue(patternExpression).Value as string; + } + + if (patternExpression.IsKind(SyntaxKind.StringLiteralExpression)) + { + currentValue = ((LiteralExpressionSyntax)patternExpression).Token.ValueText; + } + + if (currentValue is null) + { + yield break; + } + + var patternExpressionLineSpan = patternExpression.GetLocation().GetLineSpan(); + var regexMutantOrchestrator = new RegexMutantOrchestrator(currentValue); + var replacementValues = regexMutantOrchestrator.Mutate(); + + foreach (var regexMutation in replacementValues) + { + try + { + _ = new Regex(regexMutation.ReplacementPattern); + } + catch (ArgumentException exception) + { + Logger.LogDebug( + "RegexMutator created mutation {CurrentValue} -> {ReplacementPattern} which is an invalid regular expression:\n{Message}", + currentValue, regexMutation.ReplacementPattern, exception.Message); + continue; + } + + var hashData = SHA1.HashData(Encoding.UTF8.GetBytes(regexMutation.ReplacementPattern)); + var hash = Convert.ToBase64String(hashData).Replace('+', 'A').Replace('/', 'B').Replace('=', 'C'); + + var newName = + $"{method.Identifier.ValueText}_{CultureInfo.InvariantCulture.TextInfo.ToTitleCase(regexMutation.DisplayName.Replace("\"[\\w\\W]\"", "AnyChar").Replace("-", "")).Replace(" ", "")}_{hash}"; + + SyntaxNode replacementNode = nodeToMutate is InvocationExpressionSyntax + ? InvocationExpression(IdentifierName(newName), ArgumentList()) + : IdentifierName(newName); + + yield return + new MutationInfo(newName, + new Mutation + { + OriginalNode = nodeToMutate, + ReplacementNode = replacementNode, + DisplayName = regexMutation.DisplayName, + Type = Mutator.Regex, + Description = regexMutation.Description, + ReplacementText = $"\"{regexMutation.ReplacementPattern}\"", + OriginalLocation = patternExpressionLineSpan + }, + method.ReplaceNode(patternExpression, + LiteralExpression(SyntaxKind.StringLiteralExpression, + Literal(regexMutation.ReplacementPattern))) + .WithIdentifier(Identifier(newName)) + .RemoveIfDirectives()); + } + } + + private static ProxyInfo MutatePartialRegexMethod(MethodOrPropertyDeclarationSyntax originalMethod, + SyntaxAnnotation marker) + { + var newName = Identifier($"{originalMethod.Identifier.ValueText}_Original"); + + var regexAttribute = originalMethod.GetRegexAttribute(); + + var nodeToMutate = originalMethod.CreateCall(newName).WithAdditionalAnnotations(marker); + + var proxyMethod = originalMethod + .RemoveNode(regexAttribute, SyntaxRemoveOptions.KeepNoTrivia)! + .WithExpressionBody(ArrowExpressionClause(Token(TriviaList(Space), SyntaxKind.EqualsGreaterThanToken, TriviaList(Space)), + nodeToMutate)) + .WithSemicolonToken(Token(SyntaxTriviaList.Empty, SyntaxKind.SemicolonToken, ";", ";", + TriviaList(LineFeed))) + .WithModifiers(originalMethod.Modifiers.Remove(originalMethod.Modifiers.First(static a => + a.IsKind(SyntaxKind.PartialKeyword)))); + + proxyMethod = proxyMethod.RemoveNodes(proxyMethod.AttributeLists.Where(static a => a.Attributes.Count == 0), + SyntaxRemoveOptions.KeepNoTrivia)!.WithTriviaFrom(regexAttribute.Parent); + var newMethod = originalMethod.WithIdentifier(newName).RemoveIfDirectives(); + + return new ProxyInfo(proxyMethod, newMethod, nodeToMutate); + } + + /// + /// Contains info about the modification of the original regex method/property that is now proxied through a method + /// that can be mutated. + /// + /// + /// The method that the original code calls, which was a method marked with a + /// that has now been removed. Body is now an invocation of + /// + /// + /// A copy of the original method, with a new name + /// + /// The call from to that will be the + /// code that is mutated + /// + private record struct ProxyInfo( + MethodOrPropertyDeclarationSyntax ProxyMethod, + MethodOrPropertyDeclarationSyntax RenamedMethod, + ExpressionSyntax NodeToMutate); + + /// + /// Contains info about a mutation to be applied, along with the method that the mutation will use. + /// + /// The full name of the generated method + /// The to apply + /// A copy of the original regex method with a applied + private record struct MutationInfo( + string Name, + Mutation Mutation, + MethodOrPropertyDeclarationSyntax NewMethod); + + /// + /// All info needed about the mutations for a single . + /// + /// The original method or property marked with a + /// The marker of the node to mutate + /// The for this batch of mutations + /// All of the s for this batch + private record struct RegexMutationBatch( + MethodOrPropertyDeclarationSyntax OriginalNode, + SyntaxAnnotation Marker, + ProxyInfo ProxyInfo, + MutationInfo[] Mutations); +} + +internal sealed class MethodOrPropertyDeclarationSyntax +{ + private readonly MemberDeclarationSyntax _memberDeclaration; + + public SyntaxNode RawNode => _memberDeclaration; + + public SyntaxToken Identifier => _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.Identifier, + PropertyDeclarationSyntax pds => pds.Identifier, + _ => throw new UnreachableException() + }; + + public SyntaxTokenList Modifiers => _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.Modifiers, + PropertyDeclarationSyntax pds => pds.Modifiers, + _ => throw new UnreachableException() + }; + + public SyntaxList AttributeLists => _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.AttributeLists, + PropertyDeclarationSyntax pds => pds.AttributeLists, + _ => throw new UnreachableException() + }; + + public MethodOrPropertyDeclarationSyntax(MethodDeclarationSyntax memberDeclaration) => + _memberDeclaration = memberDeclaration; + + public MethodOrPropertyDeclarationSyntax(PropertyDeclarationSyntax memberDeclaration) => + _memberDeclaration = memberDeclaration; + + public MethodOrPropertyDeclarationSyntax WithIdentifier(SyntaxToken identifier) => _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.WithIdentifier(identifier), + PropertyDeclarationSyntax pds => pds.WithIdentifier(identifier), + _ => throw new UnreachableException() + }; + + public MethodOrPropertyDeclarationSyntax ReplaceNode(SyntaxNode oldNode, SyntaxNode newNode) => + _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.ReplaceNode(oldNode, newNode), + PropertyDeclarationSyntax pds => pds.ReplaceNode(oldNode, newNode), + _ => throw new UnreachableException() + }; + + public MethodOrPropertyDeclarationSyntax RemoveNodes(IEnumerable nodes, SyntaxRemoveOptions options) => + _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.RemoveNodes(nodes, options), + PropertyDeclarationSyntax pds => pds.RemoveNodes(nodes, options), + _ => throw new UnreachableException() + }; + + public MethodOrPropertyDeclarationSyntax RemoveNode(SyntaxNode node, SyntaxRemoveOptions options) => + _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.RemoveNode(node, options), + PropertyDeclarationSyntax pds => pds.RemoveNode(node, options), + _ => throw new UnreachableException() + }; + + public MethodOrPropertyDeclarationSyntax + WithExpressionBody(ArrowExpressionClauseSyntax arrowExpressionClauseSyntax) => _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.WithExpressionBody(arrowExpressionClauseSyntax), + PropertyDeclarationSyntax pds => pds.WithExpressionBody(arrowExpressionClauseSyntax).WithAccessorList(default), + _ => throw new UnreachableException() + }; + + public MethodOrPropertyDeclarationSyntax WithSemicolonToken(SyntaxToken semicolonToken) => _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.WithSemicolonToken(semicolonToken), + PropertyDeclarationSyntax pds => pds.WithSemicolonToken(semicolonToken), + _ => throw new UnreachableException() + }; + + public MethodOrPropertyDeclarationSyntax WithModifiers(SyntaxTokenList modifiers) => _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.WithModifiers(modifiers), + PropertyDeclarationSyntax pds => pds.WithModifiers(modifiers), + _ => throw new UnreachableException() + }; + + public MethodOrPropertyDeclarationSyntax WithTriviaFrom(SyntaxNode node) => + _memberDeclaration switch + { + MethodDeclarationSyntax mds => mds.WithTriviaFrom(node), + PropertyDeclarationSyntax pds => pds.WithTriviaFrom(node), + _ => throw new UnreachableException() + }; + + public ExpressionSyntax CreateCall(SyntaxToken newName) => + _memberDeclaration switch + { + MethodDeclarationSyntax => InvocationExpression(IdentifierName(newName), ArgumentList()), + PropertyDeclarationSyntax => IdentifierName(newName), + _ => throw new UnreachableException() + }; + + public MethodOrPropertyDeclarationSyntax RemoveIfDirectives() => IfDirectiveRemover.Instance.Visit(this); + + public AttributeSyntax GetRegexAttribute() + { + if (!Modifiers.Any(static a => a.IsKind(SyntaxKind.PartialKeyword))) + { + return null; + } + + return AttributeLists.SelectMany(static a => a.Attributes) + .FirstOrDefault(static a => a.Name is IdentifierNameSyntax + { + Identifier.Value: "GeneratedRegex" or "GeneratedRegexAttribute" + }); + } + + public static implicit operator MethodOrPropertyDeclarationSyntax(MethodDeclarationSyntax mds) => new(mds); + + public static implicit operator MethodOrPropertyDeclarationSyntax(PropertyDeclarationSyntax mds) => new(mds); + + public static implicit operator MemberDeclarationSyntax(MethodOrPropertyDeclarationSyntax mpds) => + mpds._memberDeclaration; + + private sealed class IfDirectiveRemover() : CSharpSyntaxRewriter(true) + { + public static IfDirectiveRemover Instance { get; } = new(); + + /// + public override SyntaxNode VisitIfDirectiveTrivia(IfDirectiveTriviaSyntax node) => null; + + /// + public override SyntaxNode VisitElseDirectiveTrivia(ElseDirectiveTriviaSyntax node) => null; + + /// + public override SyntaxNode VisitElifDirectiveTrivia(ElifDirectiveTriviaSyntax node) => null; + + public MethodOrPropertyDeclarationSyntax Visit(MethodOrPropertyDeclarationSyntax mpds) => + base.Visit(mpds) switch + { + MethodDeclarationSyntax mds => mds, + PropertyDeclarationSyntax pds => pds, + _ => throw new UnreachableException() + }; + } +} diff --git a/src/Stryker.Core/Stryker.Core/Mutants/Mutant.cs b/src/Stryker.Core/Stryker.Core/Mutants/Mutant.cs index b82a81cab..59a37b520 100644 --- a/src/Stryker.Core/Stryker.Core/Mutants/Mutant.cs +++ b/src/Stryker.Core/Stryker.Core/Mutants/Mutant.cs @@ -1,3 +1,4 @@ +using Microsoft.CodeAnalysis; using Stryker.Abstractions.Mutants; using Stryker.Abstractions.TestRunners; @@ -30,6 +31,10 @@ public class Mutant : IMutant public string DisplayName => $"{Id}: {Mutation?.DisplayName}"; + public string ReplacementText { get; init; } + + public FileLinePositionSpan OriginalLocation { get; init; } + public void AnalyzeTestRun(ITestGuids failedTests, ITestGuids resultRanTests, ITestGuids timedOutTests, bool sessionTimedOut) { if (AssessingTests.ContainsAny(failedTests)) diff --git a/src/Stryker.Core/Stryker.Core/Mutants/MutationContext.cs b/src/Stryker.Core/Stryker.Core/Mutants/MutationContext.cs index e19e50425..e66604d07 100644 --- a/src/Stryker.Core/Stryker.Core/Mutants/MutationContext.cs +++ b/src/Stryker.Core/Stryker.Core/Mutants/MutationContext.cs @@ -1,7 +1,9 @@ +using System; using System.Collections.Generic; using System.Linq; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; +using Stryker.Abstractions.Mutants; using Stryker.Abstractions.Mutators; namespace Stryker.Core.Mutants; @@ -64,6 +66,8 @@ private MutationContext(MutationContext parent) /// public MutationControl CurrentControl => _mutation.CurrentControl; + public MutantPlacer Placer => _mainOrchestrator.Placer; + /// /// Call this to generate mutations using active mutators. /// @@ -73,6 +77,9 @@ private MutationContext(MutationContext parent) public IEnumerable GenerateMutantsForNode(SyntaxNode node, SemanticModel semanticModel) => _mainOrchestrator.GenerateMutationsForNode(node, semanticModel, this); + public Mutant GenerateMutant(Mutation mutation, Type mutator) => + _mainOrchestrator.GenerateMutation(this, mutation, mutator); + /// /// Find the appropriate node handler for the given node. /// diff --git a/src/Stryker.Core/Stryker.Core/Reporters/Json/SourceFiles/JsonMutant.cs b/src/Stryker.Core/Stryker.Core/Reporters/Json/SourceFiles/JsonMutant.cs index fb6b90cbb..b057ffd42 100644 --- a/src/Stryker.Core/Stryker.Core/Reporters/Json/SourceFiles/JsonMutant.cs +++ b/src/Stryker.Core/Stryker.Core/Reporters/Json/SourceFiles/JsonMutant.cs @@ -35,8 +35,8 @@ public JsonMutant(IReadOnlyMutant mutant) MutatorName = mutant.Mutation.DisplayName; Description = mutant.Mutation.Description; - Replacement = mutant.Mutation.ReplacementNode.ToString(); - Location = new Location(mutant.Mutation.OriginalNode.GetLocation().GetMappedLineSpan()); + Replacement = mutant.ReplacementText; + Location = new Location(mutant.OriginalLocation); Status = mutant.ResultStatus.ToString(); StatusReason = mutant.ResultStatusReason; diff --git a/src/Stryker.Options/ExclusionPattern.cs b/src/Stryker.Options/ExclusionPattern.cs index 61e1096bf..839082841 100644 --- a/src/Stryker.Options/ExclusionPattern.cs +++ b/src/Stryker.Options/ExclusionPattern.cs @@ -7,11 +7,8 @@ namespace Stryker.Abstractions.Options; -public readonly struct ExclusionPattern : IExclusionPattern +public readonly partial struct ExclusionPattern : IExclusionPattern { - private static readonly Regex _mutantSpanGroupRegex = new("(\\{(\\d+)\\.\\.(\\d+)\\})+$"); - private static readonly Regex _mutantSpanRegex = new Regex("\\{(\\d+)\\.\\.(\\d+)\\}"); - public ExclusionPattern(string s) { if (s is null) @@ -22,14 +19,14 @@ public ExclusionPattern(string s) IsExcluded = s.StartsWith('!'); var pattern = IsExcluded ? s[1..] : s; - var mutantSpansRegex = _mutantSpanGroupRegex.Match(pattern); + var mutantSpansRegex = MutantSpanGroupRegex().Match(pattern); if (mutantSpansRegex.Success) { var filePathPart = pattern[..^mutantSpansRegex.Length]; var normalized = FilePathUtils.NormalizePathSeparators(filePathPart); Glob = Glob.Parse(normalized); - MutantSpans = _mutantSpanRegex + MutantSpans = MutantSpanRegex() .Matches(mutantSpansRegex.Value) .Select(x => (int.Parse(x.Groups[1].Value), int.Parse(x.Groups[2].Value))); } @@ -46,4 +43,10 @@ public ExclusionPattern(string s) public Glob Glob { get; } public IEnumerable<(int Start, int End)> MutantSpans { get; } + + [GeneratedRegex(@"(\{(\d+)\.\.(\d+)\})+$")] + private static partial Regex MutantSpanGroupRegex(); + + [GeneratedRegex(@"\{(\d+)\.\.(\d+)\}")] + private static partial Regex MutantSpanRegex(); }