mageekguy\atoum\test::setAssertionManager PHP Метод

    public function setAssertionManager(test\assertion\manager $assertionManager = null)
    {
        $this->assertionManager = $assertionManager ?: new test\assertion\manager();
        $test = $this;
        $this->assertionManager->setHandler('when', function ($mixed) use($test) {
            if ($mixed instanceof \closure) {
                $mixed($test);
            }
            return $test;
        })->setHandler('assert', function ($case = null) use($test) {
            $test->stopCase();
            if ($case !== null) {
                $test->startCase($case);
            }
            return $test;
        })->setHandler('mockGenerator', function () use($test) {
            return $test->getMockGenerator();
        })->setHandler('mockClass', function ($class, $mockNamespace = null, $mockClass = null) use($test) {
            $test->getMockGenerator()->generate($class, $mockNamespace, $mockClass);
            return $test;
        })->setHandler('mockTestedClass', function ($mockNamespace = null, $mockClass = null) use($test) {
            $test->getMockGenerator()->generate($test->getTestedClassName(), $mockNamespace, $mockClass);
            return $test;
        })->setHandler('newMockInstance', function ($class, $mockNamespace = null, $mockClass = null, array $constructorArguments = null) use($test) {
            $mockNamespace = trim($mockNamespace ?: $test->getMockGenerator()->getDefaultNamespace(), '\\');
            $mockClass = trim($mockClass ?: $class, '\\');
            $className = $mockNamespace . '\\' . $mockClass;
            if (class_exists($className) === false) {
                $test->mockClass($class, $mockNamespace, $mockClass);
            }
            if ($constructorArguments !== null) {
                $reflectionClass = new \reflectionClass($className);
                return $reflectionClass->newInstanceArgs($constructorArguments);
            }
            return new $className();
        })->setHandler('dump', function () use($test) {
            if ($test->debugModeIsEnabled() === true) {
                call_user_func_array('var_dump', func_get_args());
            }
            return $test;
        })->setHandler('stop', function () use($test) {
            if ($test->debugModeIsEnabled() === true) {
                throw new test\exceptions\stop();
            }
            return $test;
        })->setHandler('executeOnFailure', function ($callback) use($test) {
            if ($test->debugModeIsEnabled() === true) {
                $test->executeOnFailure($callback);
            }
            return $test;
        })->setHandler('dumpOnFailure', function ($variable) use($test) {
            if ($test->debugModeIsEnabled() === true) {
                $test->executeOnFailure(function () use($variable) {
                    var_dump($variable);
                });
            }
            return $test;
        })->setPropertyHandler('function', function () use($test) {
            return $test->getPhpFunctionMocker();
        })->setPropertyHandler('constant', function () use($test) {
            return $test->getPhpConstantMocker();
        })->setPropertyHandler('exception', function () {
            return asserters\exception::getLastValue();
        });
        $this->assertionManager->setHandler('callStaticOnTestedClass', function () use($test) {
            $args = func_get_args();
            $method = array_shift($args);
            return call_user_func_array(array($test->getTestedClassName(), $method), $args);
        });
        $mockGenerator = $this->mockGenerator;
        $this->assertionManager->setPropertyHandler('nextMockedMethod', function () use($mockGenerator) {
            return $mockGenerator->getMethod();
        });
        $returnTest = function () use($test) {
            return $test;
        };
        $this->assertionManager->setHandler('if', $returnTest)->setHandler('and', $returnTest)->setHandler('then', $returnTest)->setHandler('given', function () use($returnTest) {
            return $returnTest();
        })->setMethodHandler('define', $returnTest)->setMethodHandler('let', $returnTest);
        $returnMockController = function (mock\aggregator $mock) {
            return $mock->getMockController();
        };
        $this->assertionManager->setHandler('calling', $returnMockController)->setHandler('ƒ', $returnMockController);
        $this->assertionManager->setHandler('resetMock', function (mock\aggregator $mock) {
            return $mock->getMockController()->resetCalls();
        })->setHandler('resetAdapter', function (test\adapter $adapter) {
            return $adapter->resetCalls();
        });
        $phpFunctionMocker = $this->phpFunctionMocker;
        $this->assertionManager->setHandler('resetFunction', function (test\adapter\invoker $invoker) use($phpFunctionMocker) {
            $phpFunctionMocker->resetCalls($invoker->getFunction());
            return $invoker;
        });
        $assertionAliaser = $this->assertionManager->getAliaser();
        $this->assertionManager->setPropertyHandler('define', function () use($assertionAliaser, $test) {
            return $assertionAliaser;
        })->setHandler('from', function ($class) use($assertionAliaser, $test) {
            $assertionAliaser->from($class);
            return $test;
        })->setHandler('use', function ($target) use($assertionAliaser, $test) {
            $assertionAliaser->alias($target);
            return $test;
        })->setHandler('as', function ($alias) use($assertionAliaser, $test) {
            $assertionAliaser->to($alias);
            return $test;
        });
        $asserterGenerator = $this->asserterGenerator;
        $this->assertionManager->setDefaultHandler(function ($keyword, $arguments) use($asserterGenerator, $assertionAliaser, &$lastAsserter) {
            static $lastAsserter = null;
            if ($lastAsserter !== null) {
                $realKeyword = $assertionAliaser->resolveAlias($keyword, get_class($lastAsserter));
                if ($realKeyword !== $keyword) {
                    return call_user_func_array(array($lastAsserter, $realKeyword), $arguments);
                }
            }
            return $lastAsserter = $asserterGenerator->getAsserterInstance($keyword, $arguments);
        });
        $this->assertionManager->use('phpArray')->as('array')->use('phpArray')->as('in')->use('phpClass')->as('class')->use('phpFunction')->as('function')->use('phpFloat')->as('float')->use('phpString')->as('string')->use('phpResource')->as('resource')->use('calling')->as('method');
        return $this;
    }

 /**
  * @param atoum\test\assertion\manager $assertionManager
  *
  * @return $this
  */
 public function setAssertionManager(atoum\test\assertion\manager $assertionManager = null)
 {
     $self = $this;
     $returnFaker = function ($locale = 'en_US') use($self) {
         return $self->getFaker($locale);
     };
     parent::setAssertionManager($assertionManager)->getAssertionManager()->setHandler('faker', $returnFaker);
     return $this;
 }