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;
}
