public function build(\reflectionClass $class, &$instance = null) { $this->factory = null; if ($class->isInterface() === false && $class->isAbstract() === false) { $constructor = $class->getConstructor(); if ($constructor === null || $constructor->isPublic() === true) { $constructorParameters = $closureParameters = array(); if ($constructor !== null) { $this->allArgumentsAreOptional = $constructor->getNumberOfRequiredParameters() === 0; foreach ($constructor->getParameters() as $position => $parameter) { $closureParameters[$position] = ($parameter->isPassedByReference() === false ? '' : '& ') . ($constructorParameters[$position] = '$' . $parameter->getName()); if (self::isVariadic($parameter)) { $closureParameters[$position] = '...' . $closureParameters[$position]; $constructorParameters[$position] = '...' . $constructorParameters[$position]; } switch (true) { case $parameter->isDefaultValueAvailable(): $defaultValue = var_export($parameter->getDefaultValue(), true); break; case $parameter->isOptional() && self::isVariadic($parameter) === false: $defaultValue = 'null'; break; default: $defaultValue = null; } if ($defaultValue !== null) { $closureParameters[$position] .= ' = ' . $defaultValue; } } } if ($constructor === null || sizeof($closureParameters) <= 0) { $this->factory = function () use(&$instance, $class) { return $instance = $class->newInstanceArgs(func_get_args()); }; } else { $this->factory = eval('return function(' . join(', ', $closureParameters) . ') use (& $instance) { return ($instance = new ' . $class->getName() . '(' . join(', ', $constructorParameters) . ')); };'); } } } return $this; }
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', $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; }