Eris

https://eris.readthedocs.io/en/latest
Admin
Eris is a property-based testing framework for PHP that generates hundreds of test cases...
Tokens:22,991
Snippets:151
Trust Score:9.6
Update:11 hours ago
Show doc for...
Tokens:
Raw
### Run Eris example tests

Source: https://eris.readthedocs.io/en/latest/installation.html

Use this command to run the example tests included with Eris.

```bash
vendor/bin/phpunit vendor/giorgiosironi/eris/examples
```

--------------------------------

### Install Eris via Composer

Source: https://eris.readthedocs.io/en/latest/installation.html

Run this command in your terminal to install Eris as a development dependency using Composer.

```bash
composer require --dev giorgiosironi/eris
```

--------------------------------

### Bind Example: Creating a Vector and a Random Element

Source: https://eris.readthedocs.io/en/latest/generators/composite.html

This example demonstrates using Generator\bind to create a new generator from a generated vector. It generates a vector of natural numbers, then uses that vector to create a tuple containing a random element from the vector and the vector itself. The test asserts that the chosen element is contained in the vector.

```php
<?php
use Eris\Generator;

class BindTest extends PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testCreatingABrandNewGeneratorFromAGeneratedValueSingle()
    {
        $this->forAll(
            Generator\bind(
                Generator\vector(4, Generator\nat()),
                function ($vector) {
                    return Generator\tuple(
                        Generator\elements($vector),
                        Generator\constant($vector)
                    );
                }
            )
        )
            ->then(function ($tuple) {
                list($element, $vector) = $tuple;
                $this->assertContains($element, $vector);
            });
    }

    // TODO: multiple generators means multiple values passed to the
    // outer Generator factory
}
```

--------------------------------

### Output for testGeneratedDataCollectionWithCustomMapper

Source: https://eris.readthedocs.io/en/latest/listeners.html

Example output showing the distribution of array lengths when using a custom mapper. In this example, 10% of generated arrays have length 3.

```text
39%  0
26%  1
10%  3
5%  4
5%  2
4%  5
3%  7
3%  6
3%  8
1%  10
1%  9
```

--------------------------------

### Sample Log File Output

Source: https://eris.readthedocs.io/en/latest/listeners.html

Example contents of the log file written during a test run, showing iteration lines, a failure line, and shrinking lines. The format is not advised for parsing as it is only for human readability.

```text
...
[2016-03-24T09:14:20+00:00][2593] iteration 12: [-9]
[2016-03-24T09:14:20+00:00][2593] iteration 13: [-59]
[2016-03-24T09:14:20+00:00][2593] iteration 14: [-51]
[2016-03-24T09:14:20+00:00][2593] iteration 15: [-52]
[2016-03-24T09:14:20+00:00][2593] iteration 16: [-83]
[2016-03-24T09:14:20+00:00][2593] iteration 17: [78]
[2016-03-24T09:14:20+00:00][2593] failure: [78]. Failed asserting that 78 is equal
to 42 or is less than 42.
[2016-03-24T09:14:20+00:00][2593] shrinking: [77]
[2016-03-24T09:14:20+00:00][2593] shrinking: [76]
[2016-03-24T09:14:20+00:00][2593] shrinking: [75]
[2016-03-24T09:14:20+00:00][2593] shrinking: [74]
[
...
```

--------------------------------

### Example sequence of generated values during shrinking

Source: https://eris.readthedocs.io/en/latest/shrinking.html

Shows a sample sequence of generated strings from the testShrinkingAString test, illustrating how values are shrunk by removing characters from the end until the simplest failing input is found.

```text
string(0) ""
string(1) "K"
string(2) "g,"
string(3) "=%, "
string(7) "jGHr38i"
string(15) "L(uw^K)/&hf!mQK"
string(9) ":W}W[+<GR"
string(20) ":e|$dI,[Bj(Kx-4`-"3X"
string(19) ":e|$dI,[Bj(Kx-4`-"3"
string(18) ":e|$dI,[Bj(Kx-4`-""
string(17) ":e|$dI,[Bj(Kx-4`-"
string(16) ":e|$dI,[Bj(Kx-4`"
string(15) ":e|$dI,[Bj(Kx-4"
string(14) ":e|$dI,[Bj(Kx-"
string(13) ":e|$dI,[Bj(Kx"
string(12) ":e|$dI,[Bj(K"
string(11) ":e|$dI,[Bj("
string(10) ":e|$dI,[Bj"
string(9) ":e|$dI,[B"
string(8) ":e|$dI,["
```

--------------------------------

### Sample generated values from testStringsMatchingAParticularRegex

Source: https://eris.readthedocs.io/en/latest/generators/domain.html

Output from the test showing six example strings generated by the regex() Generator, each of length 10 and matching [a-z]{10}.

```text
string(10) "ylunkcebou"
string(10) "whkjewwhud"
string(10) "pwirjzhbdw"
string(10) "dxsdwnsmyi"
string(10) "ttgczpimxs"
string(10) "jdsmlexlau"
```

--------------------------------

### Output for testGeneratedDataCollectionOnScalars

Source: https://eris.readthedocs.io/en/latest/listeners.html

Example output showing the statistical distribution of collected integers. The percentages represent the frequency of each generated value.

```text
12%  -1
6%  -2
4%  -5
4%  -18
4%  -11
3%  -4
...
```

--------------------------------

### PHP example using collectFrequencies() Listener

Source: https://eris.readthedocs.io/en/latest/listeners.html

Shows how to use the collectFrequencies() Listener in Eris to gather generated values. Includes three test methods: one for scalars, one for complex data structures, and one with a custom mapper. The custom mapper receives arguments in the same way as then().

```php
<?php
use Eris\Generator;
use Eris\TestTrait;
use Eris\Listener;

class CollectTest extends PHPUnit_Framework_TestCase
{
    use TestTrait;

    public function testGeneratedDataCollectionOnScalars()
    {
        $this
            ->forAll(Generator\neg())
            ->hook(Listener\collectFrequencies())
            ->then(function ($x) {
                $this->assertTrue($x < $x + 1);
            });
    }

    public function testGeneratedDataCollectionOnMoreComplexDataStructures()
    {
        $this
            ->forAll(
                Generator\vector(2, Generator\int()),
                Generator\char()
            )
            ->hook(Listener\collectFrequencies())
            ->then(function ($vector) {
                $this->assertEquals(2, count($vector));
            });
    }

    public function testGeneratedDataCollectionWithCustomMapper()
    {
        $this
            ->forAll(
                Generator\seq(Generator\nat())
            )
            ->withMaxSize(10)
            ->hook(Listener\collectFrequencies(function ($array) {
                return count($array);
            }))
            ->then(function ($array) {
                $this->assertEquals(count($array), count(array_reverse($array)));
            });
    }
}
```

--------------------------------

### Custom integer ranges with Generator\choose()

Source: https://eris.readthedocs.io/en/latest/generators/scalar.html

Shows how to use Generator\choose() with lower and upper bounds to generate integers from custom ranges. The example tests commutativity of addition with two choose() generators, including a reversed range (230, -30000).

```php
<?php
use Eris\Generator;
use Eris\TestTrait;

class ChooseTest extends PHPUnit_Framework_TestCase
{
    use TestTrait;

    public function testSumOfTwoIntegersFromBoundedRangesIsCommutative()
    {
        $this->forAll(
            Generator\choose(-1000, 430),
            Generator\choose(230, -30000)
        )
            ->then(function ($first, $second) {
                $x = $first + $second;
                $y = $second + $first;
                $this->assertEquals(
                    $x,
                    $y,
                    "Sum between {$first} and {$second} should be commutative"
                );
            });
    }
}
```

--------------------------------

### SuchThatTest PHP class with Eris Such That examples

Source: https://eris.readthedocs.io/en/latest/generators/composite.html

A PHPUnit test class using Eris\TestTrait that demonstrates the Generator\suchThat() and Generator\filter() generators. It includes tests for filtering with callables, PHPUnit constraints, and shrinking behavior. The test methods show how to compose suchThat with vector, choose, oneOf, and seq generators. Note that the testSuchThatShrinkingRespectsTheCondition test will fail for numbers <= 100, but the minimum example found is 43.

```php
<?php
use Eris\Generator;
use Eris\Listener;

class SuchThatTest extends \PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testSuchThatBuildsANewGeneratorFilteringTheInnerOne()
    {
        $this
            ->forAll(
                Generator\vector(
                    5,
                    Generator\suchThat(
                        function ($n) {
                            return $n > 42;
                        },
                        Generator\choose(0, 1000)
                    )
                )
            )
            ->then($this->allNumbersAreBiggerThan(42));
    }

    public function testFilterSyntax()
    {
        $this
            ->forAll(
                Generator\vector(
                    5,
                    Generator\filter(
                        function ($n) {
                            return $n > 42;
                        },
                        Generator\choose(0, 1000)
                    )
                )
            )
            ->then($this->allNumbersAreBiggerThan(42));
    }

    public function testSuchThatAcceptsPHPUnitConstraints()
    {
        $this
            ->forAll(
                Generator\vector(
                    5,
                    Generator\suchThat(
                        $this->isType('integer'),
                        Generator\oneOf(
                            Generator\choose(0, 1000),
                            Generator\string()
                        )
                    )
                )
            )
            ->hook(Listener\log(sys_get_temp_dir().'/eris-such-that.log'))
            ->then($this->allNumbersAreBiggerThan(42));
    }


    public function testSuchThatShrinkingRespectsTheCondition()
    {
        $this
            ->forAll(
                Generator\suchThat(
                    function ($n) {
                        return $n > 42;
                    },
                    Generator\choose(0, 1000)
                )
            )
            ->then($this->numberIsBiggerThan(100));
    }

    public function testSuchThatShrinkingRespectsTheConditionButTriesToSkipOverTheNotAllowedSet()
    {
        $this
            ->forAll(
                Generator\suchThat(
                    function ($n) {
                        return $n <> 42;
                    },
                    Generator\choose(0, 1000)
                )
            )
            ->then($this->numberIsBiggerThan(100));
    }

    public function testSuchThatAvoidingTheEmptyListDoesNotGetStuckOnASmallGeneratorSize()
    {
        $this
            ->forAll(
                Generator\suchThat(
                    function (array $ints) {
                        return count($ints) > 0;
                    },
                    Generator\seq(Generator\int())
                )
            )
            ->then(function (array $ints) use (&$i) {
                $this->assertGreaterThanOrEqual(1, count($ints));
            })
        ;
    }

    public function allNumbersAreBiggerThan($lowerLimit)
    {
        return function ($vector) use ($lowerLimit) {
            foreach ($vector as $number) {
                $this->assertTrue(
                    $number > $lowerLimit,
                    "\$number was asserted to be more than $lowerLimit, but it's $number"
                );
            }
        };
    }

    public function numberIsBiggerThan($lowerLimit)
    {
        return function ($number) use ($lowerLimit) {
            $this->assertTrue(
                $number > $lowerLimit,
                "\$number was asserted to be more than $lowerLimit, but it's $number"
            );
        };
    }
}
```

--------------------------------

### Output for testGeneratedDataCollectionOnMoreComplexDataStructures

Source: https://eris.readthedocs.io/en/latest/listeners.html

Example output showing how complex structures are encoded into JSON values by default, used as bin keys in the map of values to counters.

```text
1%  [[-19,-16],"m"]
1%  [[-3,-30],";"]
1%  [[-9,1],"\f"]
1%  [[-7,-1],"P"]
1%  [[-1,-9],"^"]
1%  [[1,18],"8"]
1%  [[-53,-1],"."]
...
```

--------------------------------

### Shrinking output for testShrinkingMappedValuesInsideOtherGenerators

Source: https://eris.readthedocs.io/en/latest/generators/composite.html

PHPUnit failure output showing the minimal failing triple (sum 102) for the testShrinkingMappedValuesInsideOtherGenerators example. The test fails when the sum of the triple is greater than 100.

```text
1) MapTest::testShrinkingMappedValuesInsideOtherGenerators
The triple sum array (
  0 => 52,
  1 => 36,
  2 => 14,
) is not less than 100
Failed asserting that 102 is equal to 100 or is less than 100.

/home/giorgio/code/eris/examples/MapTest.php:62
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:51
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:130
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:158
/home/giorgio/code/eris/examples/MapTest.php:63
/home/giorgio/code/eris/examples/MapTest.php:63

FAILURES!
Tests: 1, Assertions: 216, Failures: 1.
```

--------------------------------

### Error Message for Low Evaluation Ratio

Source: https://eris.readthedocs.io/en/latest/listeners.html

Example error output when the evaluation ratio falls below the default threshold of 0.5. The actual ratio may vary depending on generated inputs.

```text
...
There was 1 error:

1) MinimumEvaluationsTest::testFailsBecauseOfTheLowEvaluationRatio
OutOfBoundsException: Evaluation ratio 0.05 is under the threshold 0.5
...
```

--------------------------------

### Shrinking time limit - test output

Source: https://eris.readthedocs.io/en/latest/shrinking.html

Example output from ShrinkingTimeLimitTest::testLengthPreservation showing that shrinking stops after 2 seconds and presents the simplest failure case. The error message suggests increasing the limit with '@eris-shrink {seconds}' or $this->shrinkingTimeLimit($seconds).

```text
1) ShrinkingTimeLimitTest::testLengthPreservation
RuntimeException: Eris has reached the time limit for shrinking (2s elapsed of 2s), here it is presenting the simplest failure case.
If you can afford to spend more time to find a simpler failing input, increase it with the annotation '@eris-shrink {seconds}' or $this->shrinkingTimeLimit($seconds).

/home/giorgio/code/eris/src/Eris/Shrinker/Random.php:71
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:128
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:53
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:130
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:158
/home/giorgio/code/eris/examples/ShrinkingTimeLimitTest.php:32
/home/giorgio/code/eris/examples/ShrinkingTimeLimitTest.php:32

Caused by
PHPUnit_Framework_ExpectationFailedException: Concatenating 'hW4N*:fD0&%+D_' to 'p:\(,N\7A6' gives 'hW4N*:fD0&%+D_p:\(,N\7A6ERROR'

Failed asserting that 29 matches expected 24.

/home/giorgio/code/eris/examples/ShrinkingTimeLimitTest.php:31
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:51
/home/giorgio/code/eris/src/Eris/Shrinker/Random.php:68
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:128
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:53
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:130
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:158
/home/giorgio/code/eris/examples/ShrinkingTimeLimitTest.php:32
/home/giorgio/code/eris/examples/ShrinkingTimeLimitTest.php:32

FAILURES!
Tests: 1, Assertions: 8, Errors: 1.
```

--------------------------------

### Shrinking respects antecedents - test output

Source: https://eris.readthedocs.io/en/latest/shrinking.html

Example output from testShrinkingRespectsAntecedents showing that shrinking stops at 11 due to the when() antecedent, not 0. The test fails because 11 is not multiple of 29.

```text
1) ShrinkingTest::testShrinkingRespectsAntecedents
The number 11 is not multiple of 29
Failed asserting that false is true.

/home/giorgio/code/eris/examples/ShrinkingTest.php:18
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:51
/home/giorgio/code/eris/src/Eris/Shrinker/Random.php:68
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:128
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:53
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:130
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:158
/home/giorgio/code/eris/examples/ShrinkingTest.php:19
/home/giorgio/code/eris/examples/ShrinkingTest.php:19

FAILURES!
Tests: 1, Assertions: 4, Failures: 1.
```

--------------------------------

### Generate sequences with Generator\seq and test array operations

Source: https://eris.readthedocs.io/en/latest/generators/collections.html

Use Generator\seq(Generator\nat()) to generate numeric arrays of random length and values. The example includes three tests: array_reverse preserves length, double reversal returns the original array, and sorting is idempotent. These tests demonstrate typical properties for sequence generators.

```php
<?php
use Eris\Generator;

class SequenceTest extends PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testArrayReversePreserveLength()
    {
        $this
            ->forAll(
                Generator\seq(Generator\nat())
            )
            ->then(function ($array) {
                $this->assertEquals(count($array), count(array_reverse($array)));
            });
    }

    public function testArrayReverse()
    {
        $this
            ->forAll(
                Generator\seq(Generator\nat())
            )
            ->then(function ($array) {
                $this->assertEquals($array, array_reverse(array_reverse($array)));
            });
    }

    public function testArraySortingIsIdempotent()
    {
        $this
            ->forAll(
                Generator\seq(Generator\nat())
            )
            ->then(function ($array) {
                sort($array);
                $expected = $array;
                sort($array);
                $this->assertEquals($expected, $array);
            });
    }
}
```

--------------------------------

### Generate associative arrays with fixed keys using Generator\associative

Source: https://eris.readthedocs.io/en/latest/generators/collections.html

Use Generator\associative to create arrays with a fixed set of keys and varying values. The example defines keys 'letter' and 'cipher' with generators for elements and integers. The test asserts the array has exactly 2 elements and checks the types of the generated values.

```php
<?php
use Eris\Generator;

class AssociativeArrayTest extends PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testAssociativeArraysGeneratedOnStandardKeys()
    {
        $this->forAll(
            Generator\associative([
                'letter' => Generator\elements("A", "B", "C"),
                'cipher' => Generator\choose(0, 9),
            ])
        )
            ->then(function ($array) {
                $this->assertEquals(2, count($array));
                $letter = $array['letter'];
                $this->assertInternalType('string', $letter);
                $cipher = $array['cipher'];
                $this->assertInternalType('integer', $cipher);
            });
    }
}
```

--------------------------------

### PHPUnit test using Eris Generator\bool() to verify boolean values

Source: https://eris.readthedocs.io/en/latest/generators/scalar.html

This example defines a BooleanTest class using Eris\Generator\bool() to generate boolean values. The test asserts that the generated value is either true or false, and it is useful in conjunction with other generators.

```php
<?php
use Eris\Generator;
use Eris\TestTrait;

class BooleanTest extends PHPUnit_Framework_TestCase
{
    use TestTrait;

    public function testBooleanValueIsTrueOrFalse()
    {
        $this->forAll(
            Generator\bool()
        )
            ->then(function ($boolValue) {
                $this->assertTrue(
                    ($boolValue === true || $boolValue === false),
                    "$boolValue is not true nor false"
                );
            });
    }
}
```

--------------------------------

### PHP test class with shrinking examples

Source: https://eris.readthedocs.io/en/latest/shrinking.html

Defines ShrinkingTest with two test methods: testShrinkingAString checks that generated strings do not contain 'B', and testShrinkingRespectsAntecedents checks that numbers greater than 10 are multiples of 29. Uses Eris\Generator and TestTrait.

```php
<?php
use Eris\Generator;
use Eris\TestTrait;

class ShrinkingTest extends \PHPUnit_Framework_TestCase
{
    use TestTrait;

    public function testShrinkingAString()
    {
        $this->forAll(
                Generator\string()
            )
            ->then(function ($string) {
                var_dump($string);
                $this->assertNotContains('B', $string);
            });
    }

    public function testShrinkingRespectsAntecedents()
    {
        $this->forAll(
                Generator\choose(0, 20)
            )
            ->when(function ($number) {
                return $number > 10;
            })
            ->then(function ($number) {
                $this->assertTrue($number % 29 == 0, "The number $number is not multiple of 29");
            });
    }
}
```

--------------------------------

### PHPUnit test using Eris Generator\float() for all numbers and positive numbers

Source: https://eris.readthedocs.io/en/latest/generators/scalar.html

This example defines a FloatTest class using Eris\Generator\float() to generate float values. The first test verifies that the absolute difference of a number with itself is zero, which holds for all numbers. The second test asserts that the generated number is non-negative, which fails quickly for negative floats.

```php
<?php
use Eris\Generator;

class FloatTest extends \PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testAPropertyHoldingForAllNumbers()
    {
        $this->forAll(Generator\float())
            ->then(function ($number) {
                $this->assertEquals(
                    0.0,
                    abs($number) - abs($number)
                );
            });
    }

    public function testAPropertyHoldingOnlyForPositiveNumbers()
    {
        $this->forAll(Generator\float())
            ->then(function ($number) {
                $this->assertTrue(
                    $number >= 0,
                    "$number is not a (loosely) positive number"
                );
            });
    }
}
```

--------------------------------

### PHPUnit output for failing ReadmeTest

Source: https://eris.readthedocs.io/en/latest/getting_started.html

Command-line output from running vendor/bin/phpunit examples/ReadmeTest.php, showing the failure message '42 is not less than 42 apparently' and the stack trace. Demonstrates Eris shrinking the input to the smallest failing value.

```text
[10:34:32][giorgio@Bipbip:~/code/eris]$ vendor/bin/phpunit examples/ReadmeTest.php
PHPUnit 4.3.5 by Sebastian Bergmann.

Configuration read from /home/giorgio/code/eris/phpunit.xml

F

Time: 234 ms, Memory: 3.25Mb

There was 1 failure:

1) ReadmeTest::testNaturalNumbersMagnitude
42 is not less than 42 apparently
Failed asserting that false is true.

/home/giorgio/code/eris/examples/ReadmeTest.php:15
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:48
/home/giorgio/code/eris/src/Eris/Quantifier/RoundRobinShrinking.php:45
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:69
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:50
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:71
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:87
/home/giorgio/code/eris/examples/ReadmeTest.php:16
/home/giorgio/code/eris/examples/ReadmeTest.php:16

FAILURES!
Tests: 1, Assertions: 826, Failures: 1.
```

--------------------------------

### Sample output of generated names

Source: https://eris.readthedocs.io/en/latest/generators/domain.html

Shows the output of testGeneratingNames, listing generated names with their lengths. The length increases with the size passed to the generator.

```text
string(0) ""
string(0) ""
string(3) "Ita"
string(6) "Teresa"
string(8) "Raimunde"
string(7) "Laelius"
string(5) "Fanny"
string(6) "Aileen"
string(11) "Marie-Elise"
string(7) "Ignacio"
string(8) "Hendrick"
```

--------------------------------

### LogFileTest with log() Listener

Source: https://eris.readthedocs.io/en/latest/listeners.html

PHPUnit test class using Eris TestTrait and the log() listener to write iteration progress to a log file. Two test methods demonstrate logging during normal execution and during failure/shrinking.

```php
<?php
use Eris\Generator;
use Eris\TestTrait;
use Eris\Listener;

class LogFileTest extends PHPUnit_Framework_TestCase
{
    use TestTrait;

    public function testWritingIterationsOnALogFile()
    {
        $this
            ->forAll(
                Generator\int()
            )
            ->hook(Listener\log(sys_get_temp_dir().'/eris-log-file-test.log'))
            ->then(function ($number) {
                $this->assertInternalType('integer', $number);
            });
    }

    public function testLogOfFailuresAndShrinking()
    {
        $this
            ->forAll(
                Generator\int()
            )
            ->hook(Listener\log(sys_get_temp_dir().'/eris-log-file-shrinking.log'))
            ->then(function ($number) {
                $this->assertLessThanOrEqual(42, $number);
            });
    }
}
```

--------------------------------

### Sample output of shrunk names

Source: https://eris.readthedocs.io/en/latest/generators/domain.html

Shows the output of testSamplingShrinkingOfNames, demonstrating how names are shrunk to a slightly shorter, more similar name in the data set.

```text
array(8) {
  [0]=>
  string(9) "Gwenaelle"
  [1]=>
  string(8) "Ganaelle"
  [2]=>
  string(7) "Anaelle"
  [3]=>
  string(6) "Abelle"
  [4]=>
  string(5) "Abele"
  [5]=>
  string(4) "Abel"
  [6]=>
  string(3) "Abe"
  [7]=>
  string(2) "Di"
}
```

--------------------------------

### PHPUnit test class using Eris date() Generator with interval bounds and factory method

Source: https://eris.readthedocs.io/en/latest/generators/domain.html

Shows three test methods: testYearOfADate specifies an inclusive date interval, testDefaultValuesForTheInterval relies on the default 1970-2038 range, and testFromDayOfYearFactoryMethodRespectsDistanceBetweenDays uses choose() to build DateTime objects, demonstrating a leap-year off-by-one bug in PHP's datetime extension.

```php
<?php
use Eris\Generator;

class DateTest extends PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testYearOfADate()
    {
        $this->forAll(
            Generator\date("2014-01-01T00:00:00", "2014-12-31T23:59:59")
        )
            ->then(function (DateTime $date) {
                $this->assertEquals(
                    "2014",
                    $date->format('Y')
                );
            });
    }

    public function testDefaultValuesForTheInterval()
    {
        $this->forAll(
            Generator\date()
        )
            ->then(function (DateTime $date) {
                $this->assertGreaterThanOrEqual(
                    "1970",
                    $date->format('Y')
                );
                $this->assertLessThanOrEqual(
                    "2038",
                    $date->format('Y')
                );
            });
    }

    public function testFromDayOfYearFactoryMethodRespectsDistanceBetweenDays()
    {
        $this->forAll(
            Generator\choose(2000, 2020),
            Generator\choose(0, 364),
            Generator\choose(0, 364)
        )
        ->then(function ($year, $dayOfYear, $anotherDayOfYear) {
            $day = fromZeroBasedDayOfYear($year, $dayOfYear);
            $anotherDay = fromZeroBasedDayOfYear($year, $anotherDayOfYear);
            $this->assertEquals(
                abs($dayOfYear - $anotherDayOfYear) * 86400,
                abs($day->getTimestamp() - $anotherDay->getTimestamp()),
                "Days of the year $year: $dayOfYear, $anotherDayOfYear" . PHP_EOL
                . "{$day->format(DateTime::ISO8601)}, {$anotherDay->format(DateTime::ISO8601)}"
            );
        });
    }
}

function fromZeroBasedDayOfYear($year, $dayOfYear)
{
    return DateTime::createFromFormat(
        'z Y H i s',
        $dayOfYear . ' '. $year . ' 00 00 00',
        new DateTimeZone("UTC")
    );
}
```

--------------------------------

### Failing test with Eris\Generator\choose

Source: https://eris.readthedocs.io/en/latest/getting_started.html

PHPUnit test class using Eris\TestTrait and Generator\choose to generate integers from 0 to 1000, asserting each is less than 42. This test is designed to fail, showing an example error message.

```php
<?php
use Eris\Generator;

class ReadmeTest extends \PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testNaturalNumbersMagnitude()
    {
        $this->forAll(
            Generator\choose(0, 1000)
        )
            ->then(function ($number) {
                $this->assertTrue(
                    $number < 42,
                    "$number is not less than 42 apparently"
                );
            });
    }
}
```

--------------------------------

### Shrinking output for testShrinkingJustMappedValues

Source: https://eris.readthedocs.io/en/latest/generators/composite.html

PHPUnit failure output showing the minimal failing input (102) for the testShrinkingJustMappedValues example. The underlying Generator\nat() shrinks by decrementing, but the mapping function is still applied, so only even numbers are passed to then().

```text
1) MapTest::testShrinkingJustMappedValues
The number is not less than 100
Failed asserting that 102 is equal to 100 or is less than 100.

/home/giorgio/code/eris/examples/MapTest.php:42
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:51
/home/giorgio/code/eris/src/Eris/Shrinker/Random.php:68
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:128
/home/giorgio/code/eris/src/Eris/Quantifier/Evaluation.php:53
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:130
/home/giorgio/code/eris/src/Eris/Quantifier/ForAll.php:158
/home/giorgio/code/eris/examples/MapTest.php:43
/home/giorgio/code/eris/examples/MapTest.php:43

FAILURES!
Tests: 1, Assertions: 254, Failures: 1.
```

--------------------------------

### Configure Random Number Generators in PHPUnit Test

Source: https://eris.readthedocs.io/en/latest/randomness.html

Shows how to configure different PRNGs (rand, mt_rand, purePhpMtRand) in a PHPUnit test using withRand() or annotations. Includes a helper method isInteger() for assertions.

```PHP
<?php
use Eris\Generator;
use Eris\Random;
use Eris\TestTrait;

class RandConfigurationTest extends PHPUnit_Framework_TestCase
{
    use TestTrait;

    public function testUsingTheDefaultRandFunction()
    {
        $this
            ->withRand('rand')
            ->forAll(
                Generator\int()
            )
            ->withMaxSize(1000 * 1000* 1000)
            ->then($this->isInteger());
    }

    /**
     * @eris-method rand
     */
    public function testUsingTheDefaultRandFunctionFromAnnotation()
    {
        $this
            ->forAll(
                Generator\int()
            )
            ->withMaxSize(1000 * 1000* 1000)
            ->then($this->isInteger());
    }

    public function testUsingTheDefaultMtRandFunction()
    {
        $this
            ->withRand('mt_rand')
            ->forAll(
                Generator\int()
            )
            ->then($this->isInteger());
    }


    /**
     * @eris-method mt_rand
     */
    public function testUsingTheDefaultMtRandFunctionFromAnnotation()
    {
        $this
            ->forAll(
                Generator\int()
            )
            ->then($this->isInteger());
    }

    public function testUsingThePurePhpMtRandFunction()
    {
        if (defined('HHVM_VERSION')) {
            $this->markTestSkipped('MersenneTwister class does not support HHVM');
        }

        $this
            ->withRand(Random\purePhpMtRand())
            ->forAll(
                Generator\int()
            )
            ->then($this->isInteger());
    }

    private function isInteger()
    {
        return function ($number) {
            $this->assertInternalType('integer', $number);
        };
    }
}
```

--------------------------------

### Integer generation with int(), neg(), pos(), and byte()

Source: https://eris.readthedocs.io/en/latest/generators/scalar.html

Shows how to use Generator\int(), Generator\neg(), Generator\pos(), and Generator\byte() in property-based tests. The testSumIsCommutative uses two int() generators, testSumIsAssociative uses int(), neg(), and pos(), and testByteData verifies byte values are between 0 and 255.

```php
<?php
use Eris\Generator;
use Eris\TestTrait;

class IntegerTest extends PHPUnit_Framework_TestCase
{
    use TestTrait;

    public function testSumIsCommutative()
    {
        $this->forAll(
            Generator\int(),
            Generator\int()
        )
            ->then(function ($first, $second) {
                $x = $first + $second;
                $y = $second + $first;
                $this->assertEquals(
                    $x,
                    $y,
                    "Sum between {$first} and {$second} should be commutative"
                );
            });
    }

    public function testSumIsAssociative()
    {
        $this->forAll(
            Generator\int(),
            Generator\neg(),
            Generator\pos()
        )
            ->then(function ($first, $second, $third) {
                $x = $first + ($second + $third);
                $y = ($first + $second) + $third;
                $this->assertEquals(
                    $x,
                    $y,
                    "Sum between {$first} and {$second} should be associative"
                );
            });
    }

    public function testByteData()
    {
        $this->forAll(
            Generator\byte()
        )
            ->then(function ($byte) {
                $this->assertTrue(
                    $byte >= 0 && $byte <= 255,
                    "$byte is not a valid value for a byte"
                );
            });
    }
}
```

--------------------------------

### MinimumEvaluationsTest with minimumEvaluationRatio and @eris-ratio

Source: https://eris.readthedocs.io/en/latest/listeners.html

PHPUnit test class demonstrating the minimum evaluations listener. Includes a test that fails due to low evaluation ratio, a test that passes with a lower ratio set via minimumEvaluationRatio(0.01), and a test using the @eris-ratio annotation.

```php
<?php
use Eris\Generator;

class MinimumEvaluationsTest extends PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testFailsBecauseOfTheLowEvaluationRatio()
    {
        $this
            ->forAll(
                Generator\choose(0, 100)
            )
            ->when(function ($n) {
                return $n > 90;
            })
            ->then(function ($number) {
                $this->assertTrue($number * 2 > 90 * 2);
            });
    }

    public function testPassesBecauseOfTheArtificiallyLowMinimumEvaluationRatio()
    {
        $this
            ->minimumEvaluationRatio(0.01)
            ->forAll(
                Generator\choose(0, 100)
            )
            ->when(function ($n) {
                return $n > 90;
            })
            ->then(function ($number) {
                $this->assertTrue($number * 2 > 90 * 2);
            });
    }

    /**
     * @eris-ratio 1
     */
    public function testPassesBecauseOfTheArtificiallyLowMinimumEvaluationRatioFromAnnotation()
    {
        $this
            ->forAll(
                Generator\choose(0, 100)
            )
            ->when(function ($n) {
                return $n > 90;
            })
            ->then(function ($number) {
                $this->assertTrue($number * 2 > 90 * 2);
            });
    }
}
```

--------------------------------

### Character Generator Test Class with Generator\char()

Source: https://eris.readthedocs.io/en/latest/generators/scalar.html

Complete PHPUnit test class demonstrating `Generator\char(['basic-latin'])` for generating characters. Includes tests for length, printable characters, multiple characters, and an annotation-based ratio. Uses `Eris\TestTrait` and `Antecedent\printableCharacter(s)`. Note the typo 'assertLenghtIs1' in the source.

```php
<?php
use Eris\Generator;
use Eris\Antecedent;

class CharacterTest extends PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testLengthOfAsciiCharactersInPhp()
    {
        $this->forAll(
            Generator\char(['basic-latin'])
        )
            ->then(function ($char) {
                $this->assertLenghtIs1($char);
            });
    }

    public function testLengthOfPrintableAsciiCharacters()
    {
        $this->forAll(
            Generator\char(['basic-latin'])
        )
            ->when(Antecedent\printableCharacter())
            ->then(function ($char) {
                $this->assertFalse(ord($char) < 32);
            });
    }

    public function testMultiplePrintableCharacters()
    {
        $this
            ->minimumEvaluationRatio(0.1)
            ->forAll(
                Generator\char(['basic-latin']),
                Generator\char(['basic-latin'])
            )
            ->when(Antecedent\printableCharacters())
            ->then(function ($first, $second) {
                $this->assertFalse(ord($first) < 32);
                $this->assertFalse(ord($second) < 32);
            });
    }

    /**
     * @eris-ratio 10
     */
    public function testMultiplePrintableCharactersFromAnnotation()
    {
        $this
            ->forAll(
                Generator\char(['basic-latin']),
                Generator\char(['basic-latin'])
            )
            ->when(Antecedent\printableCharacters())
            ->then(function ($first, $second) {
                $this->assertFalse(ord($first) < 32);
                $this->assertFalse(ord($second) < 32);
            });
    }

    private function assertLenghtIs1($char)
    {
        $length = strlen($char);
        $this->assertEquals(
            1,
            $length,
            "'$char' is too long: $length"
        );
    }
}
```

--------------------------------

### Increase max size with withMaxSize in PHPUnit test

Source: https://eris.readthedocs.io/en/latest/limits.html

Example test class using Eris\Generator and Eris\TestTrait. The test sets the maximum size to 1,000,000 via withMaxSize and asserts that generated numbers are less than 100,000. By default size is 1000, so this test fails when a number greater than 100,000 is generated.

```php
<?php
use Eris\Generator;
use Eris\TestTrait;

class SizeTest extends PHPUnit_Framework_TestCase
{
    use TestTrait;

    /**
     * With the default sizes this test would pass,
     * as numbers greater or equal than 100,000 would never be reached.
     */
    public function testMaxSizeCanBeIncreased()
    {
        $this
            ->forAll(
                Generator\int()
            )
            ->withMaxSize(1000 * 1000)
            ->then(function ($number) {
                $this->assertLessThan(100 * 1000, $number);
            });
    }
}
```

--------------------------------

### Generate random integers with Eris Facade

Source: https://eris.readthedocs.io/en/latest/outside_phpunit.html

Use this script to generate and echo 100 random integers outside PHPUnit. It requires the Eris autoloader and instantiates Eris\Facade, which offers the same interface as Eris\TestTrait. The Facade is automatically initialized; for reproducibility, set the ERIS_SEED environment variable.

```php
<?php
use Eris\Generator;

require __DIR__.'/../vendor/autoload.php';

$eris = new Eris\Facade();
$eris
    ->forAll(Generator\int())
    ->then(function ($integer) {
        echo var_export($integer, true) . PHP_EOL;
    });
```

--------------------------------

### PHPUnit test using Generator\string() for string concatenation properties

Source: https://eris.readthedocs.io/en/latest/generators/scalar.html

This example shows a PHPUnit test class using Eris\Generator\string() to test string concatenation properties. It includes two test methods: one for the right identity element and one for length preservation, with logging enabled for shrinking. The generator produces strings of arbitrary length with only printable UTF-8 characters, currently ASCII between 0x33 and 0x126.

```php
<?php
use Eris\Generator;
use Eris\Listener;

function string_concatenation($first, $second)
{
    if (strlen($second) > 5) {
        $second .= 'ERROR';
    }
    return $first . $second;
}

class StringTest extends PHPUnit_Framework_TestCase
{
    use Eris\TestTrait;

    public function testRightIdentityElement()
    {
        $this
            ->forAll(
                Generator\string()
            )
            ->then(function ($string) {
                $this->assertEquals(
                    $string,
                    string_concatenation($string, ''),
                    "Concatenating '$string' to ''"
                );
            });
    }

    public function testLengthPreservation()
    {
        $this
            ->forAll(
                Generator\string(),
                Generator\string()
            )
            ->hook(Listener\log(sys_get_temp_dir().'/eris-string-shrinking.log'))
            ->then(function ($first, $second) {
                $result = string_concatenation($first, $second);
                $this->assertEquals(
                    strlen($first) + strlen($second),
                    strlen($result),
                    "Concatenating '$first' to '$second' gives '$result'" . PHP_EOL
                    . var_export($first, true) . PHP_EOL
                    . "strlen(): " . strlen($first) . PHP_EOL
                    . var_export($second, true) . PHP_EOL
                    . "strlen(): " . strlen($second) . PHP_EOL
                    . var_export($result, true) . PHP_EOL
                    . "strlen(): " . strlen($result) . PHP_EOL
                    . "First hex: " . var_export(bin2hex($first), true) . PHP_EOL
                    . "Second hex: " . var_export(bin2hex($second), true) . PHP_EOL
                    . "Result hex: " . var_export(bin2hex($result), true) . PHP_EOL
                );
            });
    }
}
```
Tokens:
Raw