Weapon regeX

Weapon regeX mutates regular expressions for use in mutation testing. It has been designed from the ground up to support Stryker Mutator. Weapon regeX is available for both JavaScript and Scala and is used in Stryker4s and StrykerJS flavors of Stryker. The JavaScript version of the library is generated from Scala using Scala.js. The generated mutant regular expressions cover human errors, such as edge cases and typos. A list of provided mutators is given below. For an introduction to mutation testing, see Stryker's website.

The current supported versions for Scala are: 2.12, 2.13 and 3.

Getting started

In case you want to incorporate Weapon-regeX into your project.

Scala

Add Weapon regeX to your build.sbt :

libraryDependencies += "io.stryker-mutator" %% "weapon-regex" % weaponRegexVersion

Mutate!

import weaponregex.WeaponRegeX

WeaponRegeX.mutate("^abc(d+|[xyz])$") match {
    case Right(mutants) => mutants map (_.pattern)
    case Left(e)        => throw new RuntimeException(e)
}
// res0: Seq[String] = List(
//   "abc(d+|[xyz])$",
//   "^abc(d+|[xyz])",
//   "\\Aabc(d+|[xyz])$",
//   "^abc(?:d+|[xyz])$",
//   "^abc(d|[xyz])$",
//   "^abc(d{0,}|[xyz])$",
//   "^abc(d{2,}|[xyz])$",
//   "^abc(d{1}|[xyz])$",
//   "^abc(d+?|[xyz])$",
//   "^abc(d+|[^xyz])$",
//   "^abc(d+|[yz])$",
//   "^abc(d+|[xz])$",
//   "^abc(d+|[xy])$",
//   "^abc(d+|[\\w\\W])$",
//   "^abc(d+|[xyz])\\z"
// )

JavaScript

Install Weapon regeX with npm.

npm install weapon-regex

Mutate!

import wrx from 'weapon-regex';

let mutants = wrx.mutate('^abc(d+|[xyz])$');

mutants.forEach((mutant) => {
    console.log(mutant.pattern);
});

Note: as of 1.0.0 weapon-regex uses ES Modules.

API

Scala

The mutate function has the following signature:

import weaponregex.model.mutation._
import weaponregex.mutator.BuiltinMutators
import weaponregex.parser.{ParserFlavor, ParserFlavorJVM}

def mutate(
              pattern       : String,
              mutators      : Seq[TokenMutator] = BuiltinMutators.all,
              mutationLevels: Seq[Int] = null,
              flavor        : ParserFlavor = ParserFlavorJVM
          ): Either[String, Seq[Mutant]] = ???

With the mutators argument you can give a select list of mutators that should be used in the mutation process. If omitted, all built-in mutators will be used. This list will be filtered depending on the mutationLevels argument.

A list of mutationLevels can also be passed to the function. The mutators will be filtered based on the levels in the list. If omitted, no filtering takes place.

The flavor argument allows setting the parser flavor that will be used to parse the pattern. Currently, we support a ParserFlavorJVM and ParserFlavorJS. By default in Scala the JVM flavor is used.

This function will return a Right with Seq[Mutant] if it can be parsed, or a Left with the error message otherwise.

JavaScript

The mutate function can be called with regular expression flags and an options object to control which mutators and which parser flavor should be used in the mutation process:

import wrx from 'weapon-regex';

let mutants = wrx.mutate('^abc(d+|[xyz])$', 'u', {
    mutators: Array.from(wrx.mutators.values()),
    mutationLevels: [1, 2, 3],
    flavor: wrx.ParserFlavorJS,
});

Both options can be omitted, and have the same functionality as the options described in the Scala API section. By default in JS the JS parser flavor is used. You can get a map of mutators from the mutators attribute of the library. It is a Map<string, Mutator> from string (mutator name) to a mutator object.

This function will return a JavaScript Array of Mutant if it can be parsed, or throw an exception otherwise.

Supported mutators

All the supported mutators and at which mutation level they appear are shown in the table below.

Name	1	2	3
BOLRemoval	✅	✅	✅
EOLRemoval	✅	✅	✅
BOL2BOI		✅	✅
EOL2EOI		✅	✅
CharClassNegation	✅
CharClassChildRemoval		✅	✅
CharClassAnyChar		✅	✅
CharClassRangeModification			✅
PredefCharClassNegation	✅
PredefCharClassNullification		✅	✅
PredefCharClassAnyChar		✅	✅
UnicodeCharClassNegation	✅
QuantifierRemoval	✅
QuantifierNChange		✅	✅
QuantifierNOrMoreModification		✅	✅
QuantifierNOrMoreChange		✅	✅
QuantifierNMModification		✅	✅
QuantifierShortModification		✅	✅
QuantifierShortChange		✅	✅
QuantifierReluctantAddition			✅
GroupToNCGroup		✅	✅
LookaroundNegation	✅	✅	✅

Boundary Mutators

BOLRemoval

Remove the beginning of line character ^.

Original	Mutated
`^abc`	`abc`

Original	Mutated
`\d`	`[\d\D]`
`\D`	`[\D\d]`
`\s`	`[\s\S]`
`\S`	`[\S\s]`
`\w`	`[\w\W]`
`\W`	`[\W\w]`

Original	Mutated
`abc?`	`abc`
`abc*`	`abc`
`abc+`	`abc`
`abc{1,3}`	`abc`
`abc??`	`abc`
`abc*?`	`abc`
`abc+?`	`abc`
`abc{1,3}?`	`abc`
`abc?+`	`abc`
`abc*+`	`abc`
`abc++`	`abc`
`abc{1,3}+`	`abc`

Original	Mutated
`abc{3,9}`	`abc{2,9}`
`abc{3,9}`	`abc{4,9}`
`abc{3,9}`	`abc{3,8}`
`abc{3,9}`	`abc{3,10}`

Original	Mutated
`abc?`	`abc{1,1}`
`abc?`	`abc{0,0}`
`abc?`	`abc{0,2}`
`abc*`	`abc{1,}`
`abc+`	`abc{0,}`
`abc+`	`abc{2,}`

Original	Mutated
`(?=abc)`	`(?!abc)`
`(?!abc)`	`(?=abc)`
`(?<=abc)`	`(?<!abc)`
`(?<!abc)`	`(?<=abc)`

Original	Mutated
`[abc]`	`[^abc]`
`[^abc]`	`[abc]`

Original	Mutated
`[abc]`	`[bc]`
`[abc]`	`[ac]`
`[abc]`	`[ab]`

Original	Mutated
`[b-y]`	`[a-y]`
`[b-y]`	`[c-y]`
`[b-y]`	`[b-z]`
`[b-y]`	`[b-x]`

Original	Mutated
`\p{Alpha}`	`\P{Alpha}`
`\P{Alpha}`	`\p{Alpha}`

stryker-mutator/weapon-regex

Weapon regeX

Getting started

Scala

JavaScript

API

Scala

JavaScript

Supported mutators

Boundary Mutators

BOLRemoval

EOLRemoval

BOL2BOI

EOL2EOI

Character class mutators

CharClassNegation

CharClassChildRemoval

CharClassAnyChar

CharClassRangeModification

Predefined character class mutators

PredefCharClassNegation

PredefCharClassNullification

PredefCharClassAnyChar

UnicodeCharClassNegation

Quantifier mutators

QuantifierRemoval

QuantifierNChange

QuantifierNOrMoreModification

QuantifierNOrMoreChange

QuantifierNMModification

QuantifierShortModification

QuantifierShortChange

QuantifierReluctantAddition

Group-related construct mutators

GroupToNCGroup

LookaroundNegation