Poodle’s Mutators#

    /''\,,,,,
   |    |    \           ___
    \   /  ^ |        __/_  `.  .-"""-.
   / \_/   0  \       \_,` | \-'  /   )`-')
  /            \       "") `"`    \  ((`"`
 /    ____      0     ___Y  ,    .'7 /|
/      /  \___ _/    (_,___/...-` (_/_/
“What do you call a labradoodle that can do Magic?”

“A Labra-cadabra-doodle”

Builtin Mutator Names#

Binary Operation Mutator#

Name: BinOp

Replaces operators used in binary expressions. For example x + y becomes x * y

See operator_level for a list of all replacements included in this mutator.

If multiple operations are listed, the mutator will create multiple mutations for that location, one for each alternate operator.

Augmented Assignment Mutator#

Name: AugAssign

This mutator always creates multiple mutations for each location.

First it creates a mutation changing the Augmented Assignment to Assignment.

  • For example: x += 3 becomes x = 3

Then it creates a mutation for each alternate operator in the operator_level mapping

  • For example, x += 3 becomes x *= 3

Operation Mutator Options#

There are two mutators that share the same operator mutation settings. Both the Binary Operation Mutator and Augmented Assignment Mutator work by modifying the operator in the expression. Both share the same operator_level option to determine how many replacements to use for each operator.

operator_level#

Default: “std”

Allowed Values: “min”, “std”, “max”

Operator

Symbol

“min”

“std”

“max”

Addition

+

*

-, *

-, *, /, //, %, **

Subtraction

-

/

+, /

+, *, /, //, %, **

Multiplication

*

+

/, +

+, -, /, //, %, **

Division

/

-

*, -

+, -, *, //, %, **

Floor Division

//

/

*, /

+, -, *, /, %, **

Modulus

%

-

//, -

+, -, *, /, //, **

Power

**

*

*, /

+, -, *, /, //, %

Left Shift

<<

>>

>>

>>, |, ^, &

Right Shift

>>

<<

<<

<<, |, ^, &

Bitwise OR

|

&

&

<<, >>, ^, &

Bitwise XOR

^

|

|, &

<<, >>, |, &

Bitwise AND

&

^

|

<<, >>, |, ^

Matrix Mult.

@

N/A

N/A

N/A

 
mutator_opts = {"operator_level":"min"}

[poodle.mutator_opts]
operator_level = "min"

[tool.poodle.mutator_opts]
operator_level = "min"

Unary Operation Mutator#

Name: UnaryOp

This mutator modifies unary operators Add, Subtract, Not, and Invert.

Examples:

  • x = +2 becomes x = -2

  • x = -2 becomes x = +2

  • if not x: becomes if x:

  • x = ~2 becomes x = 2

Comparison Mutator#

Name: Compare

This mutator modifies comparison operators including some binary comparison operators.

However changing some comparisons can cause problems for testing tools, the mutator maintains a list of comparisons that should NOT be mutated. In addition, compare_filters can be provided for additional patterns of comparisons that should not be mutated. See compare_filters

Operator

Symbol

Replacement(s)

Equality

==

!=

Not Equal

!=

==

Less Than

<

>=, <=

Less Than or Equal

<=

>, <

Greater Than

>

<=, >=

Greater Than or Equal

>=

<, >

is

is

is not

is not

is not

is

in

in

not in

not in

not in

in

or

or

and

and

and

or

Options#

compare_filters#

Additional regex filters to prevent mutation of specific comparisons.

Default Filters:

  • r"__name__ == '__main__'"

The default filters are always used, in addition to the ones specified in compare_filters.

mutator_opts = {"compare_filters":[r"sys.version_info.minor\s*>\s*10"]}

[poodle.mutator_opts]
compare_filters = ["sys.version_info.minor\s*>\s*10"]

[tool.poodle.mutator_opts]
compare_filters = ["sys.version_info.minor\s*>\s*10"]

Tip

Modules are first parsed to ast, then unparsed to text before comparing to the compare_filters. For example, __name__=="__main__" is unparsed as __name__ == '__main__'

See how something is unparsed with a statement like:

import ast
ast.unparse(ast.parse('__name__=="__main__"',mode='eval'))

Keyword Mutator#

Name: Keyword

This mutator modifies specific keywords:

  • break becomes continue

  • continue becomes break

  • True becomes False

  • False becomes True

  • None becomes ' '

Number Mutator#

Name: Number

This mutator modifies numbers that are hard coded in the code. This can include int, octal int, hex int, binary int, float, complex. Most numbers are mutated twice.

  • int values are mutated as value + 1 and value - 1

  • complex values are mutated as value + 1j and value - 1j

  • float values are mutated as value / 2 and value * 2 Unless the float == 0, then it’s mutated to 1.0

String Mutator#

Name: String

The string mutator adds “XX” to the beginning and end of strings. It automatically skips docstrings.

Function Call Mutator#

Name: FuncCall

This mutator replaces calls to a function with the keyword None.

Examples:

  • my_func(123) becomes None

  • x = my_func(123) becomes x = None

Dict Array Call Mutator#

Name: DictArray

This mutator replaces calls to retrieve data from a dict or array/list object with None.

Examples:

  • abcd[1] becomes None

  • abcd["efg"] becomes None

  • x = abcd[1] becomes x = None

  • x = abcd["efg"] becomes x = None

Lambda Return Mutator#

Name: Lambda

This mutator changes the body of a lambda statement to return either "" or None.

Examples:

  • lambda x,y: x+y becomes lambda x,y: None

  • lambda z: None becomes lambda z: ""

Return Mutator#

Name: Return

This mutator replaces the value being returned from a function with "" or None.

Examples:

  • return 3 becomes return None

  • return my_variable becomes return None

  • return None becomes return ""

Decorator Mutator#

Name: Decorator

This mutator creates mutations where decorators are removed.

Example Input:

@log_input()
@cache
def my function(a,b):
    ...

Mutation 1:

@cache
def my function(a,b):
    ...

Mutation 2:

@log_input()
def my function(a,b):
    ...