diogo
/
symfony
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

modified tests to use better PHPUnit methods

This commit is contained in:
Pascal Borreli 2010-04-10 21:23:20 +00:00 committed by Fabien Potencier
parent 97be2ac2b7
commit b9fe42238a
49 changed files with 428 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Symfony/Components/Console/Command/Command.php
View File

@ -294,7 +294,7 @@ class Command
if (!$name)
{
throw new \InvalidArgumentException('A command name cannot be empty');
throw new \InvalidArgumentException('A command name cannot be empty.');
}
$this->namespace = $namespace;

13
src/Symfony/Components/Console/Input/ArrayInput.php
View File

@ -124,7 +124,7 @@ class ArrayInput extends Input
{
if (!$this->definition->hasShortcut($shortcut))
{
throw new \RuntimeException(sprintf('The "-%s" option does not exist.', $shortcut));
throw new \InvalidArgumentException(sprintf('The "-%s" option does not exist.', $shortcut));
}
$this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
@ -136,13 +136,14 @@ class ArrayInput extends Input
* @param string $name The long option key
* @param mixed $value The value for the option
*
* @throws \RuntimeException When option given doesn't exist
* @throws \InvalidArgumentException When option given doesn't exist
* @throws \InvalidArgumentException When a required value is missing
*/
protected function addLongOption($name, $value)
{
if (!$this->definition->hasOption($name))
{
throw new \RuntimeException(sprintf('The "--%s" option does not exist.', $name));
throw new \InvalidArgumentException(sprintf('The "--%s" option does not exist.', $name));
}
$option = $this->definition->getOption($name);
@ -151,7 +152,7 @@ class ArrayInput extends Input
{
if ($option->isParameterRequired())
{
throw new \RuntimeException(sprintf('The "--%s" option requires a value.', $name));
throw new \InvalidArgumentException(sprintf('The "--%s" option requires a value.', $name));
}
$value = $option->isParameterOptional() ? $option->getDefault() : true;
@ -166,13 +167,13 @@ class ArrayInput extends Input
* @param string $name The argument name
* @param mixed $value The value for the argument
*
* @throws \RuntimeException When option given doesn't exist
* @throws \InvalidArgumentException When argument given doesn't exist
*/
protected function addArgument($name, $value)
{
if (!$this->definition->hasArgument($name))
{
throw new \RuntimeException(sprintf('The "%s" argument does not exist.', $name));
throw new \InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
}
$this->arguments[$name] = $value;

52
tests/Symfony/Tests/Components/Console/ApplicationTest.php
View File

@ -59,7 +59,7 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
public function testHelp()
{
$application = new Application();
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_gethelp.txt'), $application->getHelp(), '->setHelp() returns a help message');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_gethelp.txt', $application->getHelp(), '->setHelp() returns a help message');
}
public function testGetCommands()
@ -97,7 +97,7 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
{
$application = new Application();
$this->assertTrue($application->hasCommand('list'), '->hasCommand() returns true if a named command is registered');
$this->assertTrue(!$application->hasCommand('afoobar'), '->hasCommand() returns false if a named command is not registered');
$this->assertFalse($application->hasCommand('afoobar'), '->hasCommand() returns false if a named command is not registered');
$application->addCommand($foo = new \FooCommand());
$this->assertTrue($application->hasCommand('afoobar'), '->hasCommand() returns true if an alias is registered');
@ -109,8 +109,10 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$application->getCommand('foofoo');
$this->fail('->getCommand() throws an \InvalidArgumentException if the command does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getCommand() throws an \InvalidArgumentException if the command does not exist');
$this->assertEquals('The command "foofoo" does not exist.', $e->getMessage(), '->getCommand() throws an \InvalidArgumentException if the command does not exist');
}
$application = new TestApplication();
@ -141,8 +143,10 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$application->findNamespace('f');
$this->fail('->findNamespace() throws an \InvalidArgumentException if the abbreviation is ambiguous');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->findNamespace() throws an \InvalidArgumentException if the abbreviation is ambiguous');
$this->assertEquals('The namespace "f" is ambiguous (foo, foo1).', $e->getMessage(), '->findNamespace() throws an \InvalidArgumentException if the abbreviation is ambiguous');
}
try
@ -150,8 +154,10 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$application->findNamespace('bar');
$this->fail('->findNamespace() throws an \InvalidArgumentException if no command is in the given namespace');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->findNamespace() throws an \InvalidArgumentException if no command is in the given namespace');
$this->assertEquals('There are no commands defined in the "bar" namespace.', $e->getMessage(), '->findNamespace() throws an \InvalidArgumentException if no command is in the given namespace');
}
}
@ -173,8 +179,10 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$application->findCommand('f');
$this->fail('->findCommand() throws an \InvalidArgumentException if the abbreviation is ambiguous for a namespace');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->findCommand() throws an \InvalidArgumentException if the abbreviation is ambiguous for a namespace');
$this->assertEquals('Command "f" is not defined.', $e->getMessage(), '->findCommand() throws an \InvalidArgumentException if the abbreviation is ambiguous for a namespace');
}
try
@ -182,8 +190,10 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$application->findCommand('a');
$this->fail('->findCommand() throws an \InvalidArgumentException if the abbreviation is ambiguous for an alias');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->findCommand() throws an \InvalidArgumentException if the abbreviation is ambiguous for an alias');
$this->assertEquals('Command "a" is ambiguous (afoobar, afoobar1 and 1 more).', $e->getMessage(), '->findCommand() throws an \InvalidArgumentException if the abbreviation is ambiguous for an alias');
}
try
@ -191,8 +201,10 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$application->findCommand('foo:b');
$this->fail('->findCommand() throws an \InvalidArgumentException if the abbreviation is ambiguous for a command');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->findCommand() throws an \InvalidArgumentException if the abbreviation is ambiguous for a command');
$this->assertEquals('Command "foo:b" is ambiguous (foo:bar, foo:bar1).', $e->getMessage(), '->findCommand() throws an \InvalidArgumentException if the abbreviation is ambiguous for a command');
}
}
@ -204,7 +216,7 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$application->setCatchExceptions(true);
$tester->run(array('command' => 'foo'));
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_renderexception1.txt'), $tester->getDisplay(), '->setCatchExceptions() sets the catch exception flag');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_renderexception1.txt', $tester->getDisplay(), '->setCatchExceptions() sets the catch exception flag');
$application->setCatchExceptions(false);
try
@ -214,6 +226,8 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->setCatchExceptions() sets the catch exception flag');
$this->assertEquals('Command "foo" is not defined.', $e->getMessage(), '->setCatchExceptions() sets the catch exception flag');
}
}
@ -221,16 +235,16 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
{
$application = new Application();
$application->addCommand(new \FooCommand);
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_astext1.txt'), $application->asText(), '->asText() returns a text representation of the application');
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_astext2.txt'), $application->asText('foo'), '->asText() returns a text representation of the application');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_astext1.txt', $application->asText(), '->asText() returns a text representation of the application');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_astext2.txt', $application->asText('foo'), '->asText() returns a text representation of the application');
}
public function testAsXml()
{
$application = new Application();
$application->addCommand(new \FooCommand);
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_asxml1.txt'), $application->asXml(), '->asXml() returns an XML representation of the application');
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_asxml2.txt'), $application->asXml('foo'), '->asXml() returns an XML representation of the application');
$this->assertXmlStringEqualsXmlFile(self::$fixturesPath.'/application_asxml1.txt', $application->asXml(), '->asXml() returns an XML representation of the application');
$this->assertXmlStringEqualsXmlFile(self::$fixturesPath.'/application_asxml2.txt', $application->asXml('foo'), '->asXml() returns an XML representation of the application');
}
public function testRenderException()
@ -240,13 +254,13 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$tester = new ApplicationTester($application);
$tester->run(array('command' => 'foo'));
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_renderexception1.txt'), $tester->getDisplay(), '->renderException() renders a pretty exception');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_renderexception1.txt', $tester->getDisplay(), '->renderException() renders a pretty exception');
$tester->run(array('command' => 'foo'), array('verbosity' => Output::VERBOSITY_VERBOSE));
$this->assertRegExp('/Exception trace/', $tester->getDisplay(), '->renderException() renders a pretty exception with a stack trace when verbosity is verbose');
$tester->run(array('command' => 'list', '--foo' => true));
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_renderexception2.txt'), $tester->getDisplay(), '->renderException() renders the command synopsis when an exception occurs in the context of a command');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_renderexception2.txt', $tester->getDisplay(), '->renderException() renders the command synopsis when an exception occurs in the context of a command');
}
public function testRun()
@ -269,17 +283,17 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$application->setCatchExceptions(false);
$tester = new ApplicationTester($application);
$tester->run(array());
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_run1.txt'), $tester->getDisplay(), '->run() runs the list command if no argument is passed');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_run1.txt', $tester->getDisplay(), '->run() runs the list command if no argument is passed');
$tester->run(array('--help' => true));
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_run2.txt'), $tester->getDisplay(), '->run() runs the help command if --help is passed');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_run2.txt', $tester->getDisplay(), '->run() runs the help command if --help is passed');
$application = new Application();
$application->setAutoExit(false);
$application->setCatchExceptions(false);
$tester = new ApplicationTester($application);
$tester->run(array('command' => 'list', '--help' => true));
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_run3.txt'), $tester->getDisplay(), '->run() displays the help if --help is passed');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_run3.txt', $tester->getDisplay(), '->run() displays the help if --help is passed');
$application = new Application();
$application->setAutoExit(false);
@ -293,7 +307,7 @@ class ApplicationTest extends \PHPUnit_Framework_TestCase
$application->setCatchExceptions(false);
$tester = new ApplicationTester($application);
$tester->run(array('--version' => true));
$this->assertEquals(file_get_contents(self::$fixturesPath.'/application_run4.txt'), $tester->getDisplay(), '->run() displays the program version if --version is passed');
$this->assertStringEqualsFile(self::$fixturesPath.'/application_run4.txt', $tester->getDisplay(), '->run() displays the program version if --version is passed');
$application = new Application();
$application->setAutoExit(false);

32
tests/Symfony/Tests/Components/Console/Command/CommandTest.php
View File

@ -41,8 +41,10 @@ class CommandTest extends \PHPUnit_Framework_TestCase
$command = new Command();
$this->fail('__construct() throws a \LogicException if the name is null');
}
catch (\LogicException $e)
catch (\Exception $e)
{
$this->assertType('\LogicException', $e, '__construct() throws a \LogicException if the name is null');
$this->assertEquals('The command name cannot be empty.', $e->getMessage(), '__construct() throws a \LogicException if the name is null');
}
$command = new Command('foo:bar');
$this->assertEquals('foo:bar', $command->getFullName(), '__construct() takes the command name as its first argument');
@ -107,8 +109,10 @@ class CommandTest extends \PHPUnit_Framework_TestCase
$command->setName('');
$this->fail('->setName() throws an \InvalidArgumentException if the name is empty');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->setName() throws an \InvalidArgumentException if the name is empty');
$this->assertEquals('A command name cannot be empty.', $e->getMessage(), '->setName() throws an \InvalidArgumentException if the name is empty');
}
try
@ -116,8 +120,10 @@ class CommandTest extends \PHPUnit_Framework_TestCase
$command->setName('foo:');
$this->fail('->setName() throws an \InvalidArgumentException if the name is empty');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->setName() throws an \InvalidArgumentException if the name is empty');
$this->assertEquals('A command name cannot be empty.', $e->getMessage(), '->setName() throws an \InvalidArgumentException if the name is empty');
}
}
@ -204,14 +210,16 @@ class CommandTest extends \PHPUnit_Framework_TestCase
try
{
$tester->execute(array('--bar' => true));
$this->fail('->run() throws a \RuntimeException when the input does not validate the current InputDefinition');
$this->fail('->run() throws a \InvalidArgumentException when the input does not validate the current InputDefinition');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->run() throws a \InvalidArgumentException when the input does not validate the current InputDefinition');
$this->assertEquals('The "--bar" option does not exist.', $e->getMessage(), '->run() throws a \InvalidArgumentException when the input does not validate the current InputDefinition');
}
$this->assertEquals("interact called\nexecute called\n", $tester->execute(array(), array('interactive' => true)), '->run() calls the interact() method if the input is interactive');
$this->assertEquals("execute called\n", $tester->execute(array(), array('interactive' => false)), '->run() does not call the interact() method if the input is not interactive');
$this->assertEquals('interact called'.PHP_EOL.'execute called'.PHP_EOL, $tester->execute(array(), array('interactive' => true)), '->run() calls the interact() method if the input is interactive');
$this->assertEquals('execute called'.PHP_EOL, $tester->execute(array(), array('interactive' => false)), '->run() does not call the interact() method if the input is not interactive');
$command = new Command('foo');
try
@ -219,8 +227,10 @@ class CommandTest extends \PHPUnit_Framework_TestCase
$command->run(new StringInput(''), new NullOutput());
$this->fail('->run() throws a \LogicException if the execute() method has not been overriden and no code has been provided');
}
catch (\LogicException $e)
catch (\Exception $e)
{
$this->assertType('\LogicException', $e, '->run() throws a \LogicException if the execute() method has not been overriden and no code has been provided');
$this->assertEquals('You must override the execute() method in the concrete command class.', $e->getMessage(), '->run() throws a \LogicException if the execute() method has not been overriden and no code has been provided');
}
}
@ -236,7 +246,7 @@ class CommandTest extends \PHPUnit_Framework_TestCase
$this->assertEquals($command, $ret, '->setCode() implements a fluent interface');
$tester = new CommandTester($command);
$tester->execute(array());
$this->assertEquals("interact called\nfrom the code...\n", $tester->getDisplay());
$this->assertEquals('interact called'.PHP_EOL.'from the code...'.PHP_EOL, $tester->getDisplay());
}
public function testAsText()
@ -245,7 +255,7 @@ class CommandTest extends \PHPUnit_Framework_TestCase
$command->setApplication(new Application());
$tester = new CommandTester($command);
$tester->execute(array());
$this->assertEquals(file_get_contents(self::$fixturesPath.'/command_astext.txt'), $command->asText(), '->asText() returns a text representation of the command');
$this->assertStringEqualsFile(self::$fixturesPath.'/command_astext.txt', $command->asText(), '->asText() returns a text representation of the command');
}
public function testAsXml()
@ -254,6 +264,6 @@ class CommandTest extends \PHPUnit_Framework_TestCase
$command->setApplication(new Application());
$tester = new CommandTester($command);
$tester->execute(array());
$this->assertEquals(file_get_contents(self::$fixturesPath.'/command_asxml.txt'), $command->asXml(), '->asXml() returns an XML representation of the command');
$this->assertXmlStringEqualsXmlFile(self::$fixturesPath.'/command_asxml.txt', $command->asXml(), '->asXml() returns an XML representation of the command');
}
}

26
tests/Symfony/Tests/Components/Console/Input/ArgvInputTest.php
View File

@ -51,8 +51,10 @@ class ArgvInputTest extends \PHPUnit_Framework_TestCase
$input->bind(new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_REQUIRED))));
$this->fail('->parse() throws a \RuntimeException if no parameter is passed to an option when it is required');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->parse() throws a \RuntimeException if no parameter is passed to an option when it is required');
$this->assertEquals('The "--foo" option requires a value.', $e->getMessage(), '->parse() throws a \RuntimeException if no parameter is passed to an option when it is required');
}
$input = new TestInput(array('cli.php', '-f'));
@ -77,8 +79,10 @@ class ArgvInputTest extends \PHPUnit_Framework_TestCase
$input->bind(new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_REQUIRED))));
$this->fail('->parse() throws a \RuntimeException if no parameter is passed to an option when it is required');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->parse() throws a \RuntimeException if no parameter is passed to an option when it is required');
$this->assertEquals('The "--foo" option requires a value.', $e->getMessage(), '->parse() throws a \RuntimeException if no parameter is passed to an option when it is required');
}
try
@ -87,8 +91,10 @@ class ArgvInputTest extends \PHPUnit_Framework_TestCase
$input->bind(new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_NONE))));
$this->fail('->parse() throws a \RuntimeException if a value is passed to an option which does not take one');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->parse() throws a \RuntimeException if a value is passed to an option which does not take one');
$this->assertEquals('The "-o" option does not exist.', $e->getMessage(), '->parse() throws a \RuntimeException if a value is passed to an option which does not take one');
}
try
@ -97,8 +103,10 @@ class ArgvInputTest extends \PHPUnit_Framework_TestCase
$input->bind(new InputDefinition());
$this->fail('->parse() throws a \RuntimeException if too many arguments are passed');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->parse() throws a \RuntimeException if too many arguments are passed');
$this->assertEquals('Too many arguments.', $e->getMessage(), '->parse() throws a \RuntimeException if too many arguments are passed');
}
try
@ -107,8 +115,10 @@ class ArgvInputTest extends \PHPUnit_Framework_TestCase
$input->bind(new InputDefinition());
$this->fail('->parse() throws a \RuntimeException if an unknown long option is passed');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->parse() throws a \RuntimeException if an unknown long option is passed');
$this->assertEquals('The "--foo" option does not exist.', $e->getMessage(), '->parse() throws a \RuntimeException if an unknown long option is passed');
}
try
@ -117,8 +127,10 @@ class ArgvInputTest extends \PHPUnit_Framework_TestCase
$input->bind(new InputDefinition());
$this->fail('->parse() throws a \RuntimeException if an unknown short option is passed');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->parse() throws a \RuntimeException if an unknown short option is passed');
$this->assertEquals('The "-f" option does not exist.', $e->getMessage(), '->parse() throws a \RuntimeException if an unknown short option is passed');
}
$input = new TestInput(array('cli.php', '-fb'));
@ -160,7 +172,7 @@ class ArgvInputTest extends \PHPUnit_Framework_TestCase
$this->assertTrue($input->hasParameterOption('--foo'), '->hasParameterOption() returns true if the given short option is in the raw input');
$input = new TestInput(array('cli.php', 'foo'));
$this->assertTrue(!$input->hasParameterOption('--foo'), '->hasParameterOption() returns false if the given short option is not in the raw input');
$this->assertFalse($input->hasParameterOption('--foo'), '->hasParameterOption() returns false if the given short option is not in the raw input');
}
}

20
tests/Symfony/Tests/Components/Console/Input/ArrayInputTest.php
View File

@ -20,7 +20,7 @@ class ArrayInputTest extends \PHPUnit_Framework_TestCase
public function testGetFirstArgument()
{
$input = new ArrayInput(array());
$this->assertEquals(null, $input->getFirstArgument(), '->getFirstArgument() returns null if no argument were passed');
$this->assertNull($input->getFirstArgument(), '->getFirstArgument() returns null if no argument were passed');
$input = new ArrayInput(array('name' => 'Fabien'));
$this->assertEquals('Fabien', $input->getFirstArgument(), '->getFirstArgument() returns the first passed argument');
$input = new ArrayInput(array('--foo' => 'bar', 'name' => 'Fabien'));
@ -31,7 +31,7 @@ class ArrayInputTest extends \PHPUnit_Framework_TestCase
{
$input = new ArrayInput(array('name' => 'Fabien', '--foo' => 'bar'));
$this->assertTrue($input->hasParameterOption('--foo'), '->hasParameterOption() returns true if an option is present in the passed parameters');
$this->assertTrue(!$input->hasParameterOption('--bar'), '->hasParameterOption() returns false if an option is not present in the passed parameters');
$this->assertFalse($input->hasParameterOption('--bar'), '->hasParameterOption() returns false if an option is not present in the passed parameters');
$input = new ArrayInput(array('--foo'));
$this->assertTrue($input->hasParameterOption('--foo'), '->hasParameterOption() returns true if an option is present in the passed parameters');
@ -47,8 +47,10 @@ class ArrayInputTest extends \PHPUnit_Framework_TestCase
$input = new ArrayInput(array('foo' => 'foo'), new InputDefinition(array(new InputArgument('name'))));
$this->fail('->parse() throws an \InvalidArgumentException exception if an invalid argument is passed');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->parse() throws an \InvalidArgumentException exception if an invalid argument is passed');
$this->assertEquals('The "foo" argument does not exist.', $e->getMessage(), '->parse() throws an \InvalidArgumentException exception if an invalid argument is passed');
}
$input = new ArrayInput(array('--foo' => 'bar'), new InputDefinition(array(new InputOption('foo'))));
@ -65,8 +67,10 @@ class ArrayInputTest extends \PHPUnit_Framework_TestCase
$input = new ArrayInput(array('--foo' => null), new InputDefinition(array(new InputOption('foo', 'f', InputOption::PARAMETER_REQUIRED))));
$this->fail('->parse() throws an \InvalidArgumentException exception if a required option is passed without a value');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->parse() throws an \InvalidArgumentException exception if a required option is passed without a value');
$this->assertEquals('The "--foo" option requires a value.', $e->getMessage(), '->parse() throws an \InvalidArgumentException exception if a required option is passed without a value');
}
try
@ -74,8 +78,10 @@ class ArrayInputTest extends \PHPUnit_Framework_TestCase
$input = new ArrayInput(array('--foo' => 'foo'), new InputDefinition());
$this->fail('->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
$this->assertEquals('The "--foo" option does not exist.', $e->getMessage(), '->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
}
$input = new ArrayInput(array('-f' => 'bar'), new InputDefinition(array(new InputOption('foo', 'f'))));
@ -86,8 +92,10 @@ class ArrayInputTest extends \PHPUnit_Framework_TestCase
$input = new ArrayInput(array('-o' => 'foo'), new InputDefinition());
$this->fail('->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
$this->assertEquals('The "-o" option does not exist.', $e->getMessage(), '->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
}
}
}

18
tests/Symfony/Tests/Components/Console/Input/InputArgumentTest.php
View File

@ -22,16 +22,16 @@ class InputArgumentTest extends \PHPUnit_Framework_TestCase
// mode argument
$argument = new InputArgument('foo');
$this->assertEquals(false, $argument->isRequired(), '__construct() gives a "Argument::OPTIONAL" mode by default');
$this->assertFalse($argument->isRequired(), '__construct() gives a "Argument::OPTIONAL" mode by default');
$argument = new InputArgument('foo', null);
$this->assertEquals(false, $argument->isRequired(), '__construct() can take "Argument::OPTIONAL" as its mode');
$this->assertFalse($argument->isRequired(), '__construct() can take "Argument::OPTIONAL" as its mode');
$argument = new InputArgument('foo', InputArgument::OPTIONAL);
$this->assertEquals(false, $argument->isRequired(), '__construct() can take "Argument::PARAMETER_OPTIONAL" as its mode');
$this->assertFalse($argument->isRequired(), '__construct() can take "Argument::PARAMETER_OPTIONAL" as its mode');
$argument = new InputArgument('foo', InputArgument::REQUIRED);
$this->assertEquals(true, $argument->isRequired(), '__construct() can take "Argument::PARAMETER_REQUIRED" as its mode');
$this->assertTrue($argument->isRequired(), '__construct() can take "Argument::PARAMETER_REQUIRED" as its mode');
try
{
@ -40,6 +40,8 @@ class InputArgumentTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '__construct() throws an Exception if the mode is not valid');
$this->assertEquals('Argument mode "ANOTHER_ONE" is not valid.', $e->getMessage());
}
}
@ -50,7 +52,7 @@ class InputArgumentTest extends \PHPUnit_Framework_TestCase
$argument = new InputArgument('foo', InputArgument::OPTIONAL | InputArgument::IS_ARRAY);
$this->assertTrue($argument->isArray(), '->isArray() returns true if the argument can be an array');
$argument = new InputArgument('foo', InputArgument::OPTIONAL);
$this->assertTrue(!$argument->isArray(), '->isArray() returns false if the argument can not be an array');
$this->assertFalse($argument->isArray(), '->isArray() returns false if the argument can not be an array');
}
public function testGetDescription()
@ -69,7 +71,7 @@ class InputArgumentTest extends \PHPUnit_Framework_TestCase
{
$argument = new InputArgument('foo', InputArgument::OPTIONAL, '', 'default');
$argument->setDefault(null);
$this->assertTrue(is_null($argument->getDefault()), '->setDefault() can reset the default value by passing null');
$this->assertNull($argument->getDefault(), '->setDefault() can reset the default value by passing null');
$argument->setDefault('another');
$this->assertEquals('another', $argument->getDefault(), '->setDefault() changes the default value');
@ -85,6 +87,8 @@ class InputArgumentTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->parse() throws an \InvalidArgumentException exception if an invalid option is passed');
$this->assertEquals('Cannot set a default value except for Parameter::OPTIONAL mode.', $e->getMessage());
}
try
@ -95,6 +99,8 @@ class InputArgumentTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->setDefault() throws an Exception if you give a default value which is not an array for a IS_ARRAY option');
$this->assertEquals('A default value for an array argument must be an array.', $e->getMessage());
}
}
}

35
tests/Symfony/Tests/Components/Console/Input/InputDefinitionTest.php
View File

@ -86,6 +86,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->addArgument() throws a Exception if another argument is already registered with the same name');
$this->assertEquals('An argument with name "foo" already exist.', $e->getMessage());
}
// cannot add a parameter after an array parameter
@ -97,8 +99,11 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->addArgument() throws a Exception if there is an array parameter already registered');
$this->assertEquals('Cannot add an argument after an array argument.', $e->getMessage());
}
// cannot add a required argument after an optional one
$definition = new InputDefinition();
$definition->addArgument($this->foo);
@ -109,6 +114,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->addArgument() throws an exception if you try to add a required argument after an optional one');
$this->assertEquals('Cannot add a required argument after an optional one.', $e->getMessage());
}
}
@ -126,6 +133,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->getArgument() throws an exception if the InputArgument name does not exist');
$this->assertEquals('The "bar" argument does not exist.', $e->getMessage());
}
}
@ -135,8 +144,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
$definition = new InputDefinition();
$definition->addArguments(array($this->foo));
$this->assertEquals(true, $definition->hasArgument('foo'), '->hasArgument() returns true if a InputArgument exists for the given name');
$this->assertEquals(false, $definition->hasArgument('bar'), '->hasArgument() returns false if a InputArgument exists for the given name');
$this->assertTrue($definition->hasArgument('foo'), '->hasArgument() returns true if a InputArgument exists for the given name');
$this->assertFalse($definition->hasArgument('bar'), '->hasArgument() returns false if a InputArgument exists for the given name');
}
public function testGetArgumentRequiredCount()
@ -192,6 +201,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->setOptions() clears all InputOption objects');
$this->assertEquals('The "-f" option does not exist.', $e->getMessage());
}
}
@ -221,6 +232,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->addOption() throws a Exception if the another option is already registered with the same name');
$this->assertEquals('An option named "foo" already exist.', $e->getMessage());
}
try
{
@ -229,6 +242,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->addOption() throws a Exception if the another option is already registered with the same shortcut');
$this->assertEquals('An option with shortcut "f" already exist.', $e->getMessage());
}
}
@ -245,6 +260,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->getOption() throws an exception if the option name does not exist');
$this->assertEquals('The "--bar" option does not exist.', $e->getMessage());
}
}
@ -253,8 +270,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
$this->initializeOptions();
$definition = new InputDefinition(array($this->foo));
$this->assertEquals(true, $definition->hasOption('foo'), '->hasOption() returns true if a InputOption exists for the given name');
$this->assertEquals(false, $definition->hasOption('bar'), '->hasOption() returns false if a InputOption exists for the given name');
$this->assertTrue($definition->hasOption('foo'), '->hasOption() returns true if a InputOption exists for the given name');
$this->assertFalse($definition->hasOption('bar'), '->hasOption() returns false if a InputOption exists for the given name');
}
public function testHasShortcut()
@ -262,8 +279,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
$this->initializeOptions();
$definition = new InputDefinition(array($this->foo));
$this->assertEquals(true, $definition->hasShortcut('f'), '->hasShortcut() returns true if a InputOption exists for the given shortcut');
$this->assertEquals(false, $definition->hasShortcut('b'), '->hasShortcut() returns false if a InputOption exists for the given shortcut');
$this->assertTrue($definition->hasShortcut('f'), '->hasShortcut() returns true if a InputOption exists for the given shortcut');
$this->assertFalse($definition->hasShortcut('b'), '->hasShortcut() returns false if a InputOption exists for the given shortcut');
}
public function testGetOptionForShortcut()
@ -279,6 +296,8 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->getOption() throws an exception if the shortcut does not exist');
$this->assertEquals('The "-l" option does not exist.', $e->getMessage());
}
}
@ -334,7 +353,7 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
new InputOption('foo', 'f', InputOption::PARAMETER_REQUIRED, 'The foo option'),
new InputOption('bar', 'b', InputOption::PARAMETER_OPTIONAL, 'The foo option', 'bar'),
));
$this->assertEquals(file_get_contents(self::$fixtures.'/definition_astext.txt'), $definition->asText(), '->asText() returns a textual representation of the InputDefinition');
$this->assertStringEqualsFile(self::$fixtures.'/definition_astext.txt', $definition->asText(), '->asText() returns a textual representation of the InputDefinition');
}
public function testAsXml()
@ -345,7 +364,7 @@ class InputDefinitionTest extends \PHPUnit_Framework_TestCase
new InputOption('foo', 'f', InputOption::PARAMETER_REQUIRED, 'The foo option'),
new InputOption('bar', 'b', InputOption::PARAMETER_OPTIONAL, 'The foo option', 'bar'),
));
$this->assertEquals(file_get_contents(self::$fixtures.'/definition_asxml.txt'), $definition->asXml(), '->asText() returns a textual representation of the InputDefinition');
$this->assertXmlStringEqualsXmlFile(self::$fixtures.'/definition_asxml.txt', $definition->asXml(), '->asText() returns a textual representation of the InputDefinition');
}
protected function initializeArguments()

46
tests/Symfony/Tests/Components/Console/Input/InputOptionTest.php
View File

@ -29,6 +29,8 @@ class InputOptionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->setDefault() throws an Exception if PARAMETER_IS_ARRAY option is used when an option does not accept a value');
$this->assertEquals('Impossible to have an option mode PARAMETER_IS_ARRAY if the option does not accept a parameter.', $e->getMessage());
}
// shortcut argument
@ -39,29 +41,29 @@ class InputOptionTest extends \PHPUnit_Framework_TestCase
// mode argument
$option = new InputOption('foo', 'f');
$this->assertEquals(false, $option->acceptParameter(), '__construct() gives a "Option::PARAMETER_NONE" mode by default');
$this->assertEquals(false, $option->isParameterRequired(), '__construct() gives a "Option::PARAMETER_NONE" mode by default');
$this->assertEquals(false, $option->isParameterOptional(), '__construct() gives a "Option::PARAMETER_NONE" mode by default');
$this->assertFalse($option->acceptParameter(), '__construct() gives a "Option::PARAMETER_NONE" mode by default');
$this->assertFalse($option->isParameterRequired(), '__construct() gives a "Option::PARAMETER_NONE" mode by default');
$this->assertFalse($option->isParameterOptional(), '__construct() gives a "Option::PARAMETER_NONE" mode by default');
$option = new InputOption('foo', 'f', null);
$this->assertEquals(false, $option->acceptParameter(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertEquals(false, $option->isParameterRequired(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertEquals(false, $option->isParameterOptional(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertFalse($option->acceptParameter(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertFalse($option->isParameterRequired(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertFalse($option->isParameterOptional(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$option = new InputOption('foo', 'f', InputOption::PARAMETER_NONE);
$this->assertEquals(false, $option->acceptParameter(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertEquals(false, $option->isParameterRequired(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertEquals(false, $option->isParameterOptional(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertFalse($option->acceptParameter(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertFalse($option->isParameterRequired(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$this->assertFalse($option->isParameterOptional(), '__construct() can take "Option::PARAMETER_NONE" as its mode');
$option = new InputOption('foo', 'f', InputOption::PARAMETER_REQUIRED);
$this->assertEquals(true, $option->acceptParameter(), '__construct() can take "Option::PARAMETER_REQUIRED" as its mode');
$this->assertEquals(true, $option->isParameterRequired(), '__construct() can take "Option::PARAMETER_REQUIRED" as its mode');
$this->assertEquals(false, $option->isParameterOptional(), '__construct() can take "Option::PARAMETER_REQUIRED" as its mode');
$this->assertTrue($option->acceptParameter(), '__construct() can take "Option::PARAMETER_REQUIRED" as its mode');
$this->assertTrue($option->isParameterRequired(), '__construct() can take "Option::PARAMETER_REQUIRED" as its mode');
$this->assertFalse($option->isParameterOptional(), '__construct() can take "Option::PARAMETER_REQUIRED" as its mode');
$option = new InputOption('foo', 'f', InputOption::PARAMETER_OPTIONAL);
$this->assertEquals(true, $option->acceptParameter(), '__construct() can take "Option::PARAMETER_OPTIONAL" as its mode');
$this->assertEquals(false, $option->isParameterRequired(), '__construct() can take "Option::PARAMETER_OPTIONAL" as its mode');
$this->assertEquals(true, $option->isParameterOptional(), '__construct() can take "Option::PARAMETER_OPTIONAL" as its mode');
$this->assertTrue($option->acceptParameter(), '__construct() can take "Option::PARAMETER_OPTIONAL" as its mode');
$this->assertFalse($option->isParameterRequired(), '__construct() can take "Option::PARAMETER_OPTIONAL" as its mode');
$this->assertTrue($option->isParameterOptional(), '__construct() can take "Option::PARAMETER_OPTIONAL" as its mode');
try
{
@ -70,6 +72,8 @@ class InputOptionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '__construct() throws an Exception if the mode is not valid');
$this->assertEquals('Option mode "ANOTHER_ONE" is not valid.', $e->getMessage());
}
}
@ -78,7 +82,7 @@ class InputOptionTest extends \PHPUnit_Framework_TestCase
$option = new InputOption('foo', null, InputOption::PARAMETER_OPTIONAL | InputOption::PARAMETER_IS_ARRAY);
$this->assertTrue($option->isArray(), '->isArray() returns true if the option can be an array');
$option = new InputOption('foo', null, InputOption::PARAMETER_NONE);
$this->assertTrue(!$option->isArray(), '->isArray() returns false if the option can not be an array');
$this->assertFalse($option->isArray(), '->isArray() returns false if the option can not be an array');
}
public function testGetDescription()
@ -96,20 +100,20 @@ class InputOptionTest extends \PHPUnit_Framework_TestCase
$this->assertEquals('default', $option->getDefault(), '->getDefault() returns the default value');
$option = new InputOption('foo', null, InputOption::PARAMETER_REQUIRED);
$this->assertTrue(is_null($option->getDefault()), '->getDefault() returns null if no default value is configured');
$this->assertNull($option->getDefault(), '->getDefault() returns null if no default value is configured');
$option = new InputOption('foo', null, InputOption::PARAMETER_OPTIONAL | InputOption::PARAMETER_IS_ARRAY);
$this->assertEquals(array(), $option->getDefault(), '->getDefault() returns an empty array if option is an array');
$option = new InputOption('foo', null, InputOption::PARAMETER_NONE);
$this->assertTrue($option->getDefault() === false, '->getDefault() returns false if the option does not take a parameter');
$this->assertFalse($option->getDefault(), '->getDefault() returns false if the option does not take a parameter');
}
public function testSetDefault()
{
$option = new InputOption('foo', null, InputOption::PARAMETER_REQUIRED, '', 'default');
$option->setDefault(null);
$this->assertTrue(is_null($option->getDefault()), '->setDefault() can reset the default value by passing null');
$this->assertNull($option->getDefault(), '->setDefault() can reset the default value by passing null');
$option->setDefault('another');
$this->assertEquals('another', $option->getDefault(), '->setDefault() changes the default value');
@ -125,6 +129,8 @@ class InputOptionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->setDefault() throws an Exception if you give a default value for a PARAMETER_NONE option');
$this->assertEquals('Cannot set a default value when using Option::PARAMETER_NONE mode.', $e->getMessage());
}
$option = new InputOption('foo', 'f', InputOption::PARAMETER_OPTIONAL | InputOption::PARAMETER_IS_ARRAY);
@ -135,6 +141,8 @@ class InputOptionTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Exception', $e, '->setDefault() throws an Exception if you give a default value which is not an array for a PARAMETER_IS_ARRAY option');
$this->assertEquals('A default value for an array option must be an array.', $e->getMessage());
}
}
}

22
tests/Symfony/Tests/Components/Console/Input/InputTest.php
View File

@ -41,8 +41,10 @@ class InputTest extends \PHPUnit_Framework_TestCase
$input->setOption('foo', 'bar');
$this->fail('->setOption() throws a \InvalidArgumentException if the option does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->setOption() throws a \InvalidArgumentException if the option does not exist');
$this->assertEquals('The "foo" option does not exist.', $e->getMessage());
}
try
@ -50,8 +52,10 @@ class InputTest extends \PHPUnit_Framework_TestCase
$input->getOption('foo');
$this->fail('->getOption() throws a \InvalidArgumentException if the option does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->setOption() throws a \InvalidArgumentException if the option does not exist');
$this->assertEquals('The "foo" option does not exist.', $e->getMessage());
}
}
@ -73,8 +77,10 @@ class InputTest extends \PHPUnit_Framework_TestCase
$input->setArgument('foo', 'bar');
$this->fail('->setArgument() throws a \InvalidArgumentException if the argument does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->setOption() throws a \InvalidArgumentException if the option does not exist');
$this->assertEquals('The "foo" argument does not exist.', $e->getMessage());
}
try
@ -82,8 +88,10 @@ class InputTest extends \PHPUnit_Framework_TestCase
$input->getArgument('foo');
$this->fail('->getArgument() throws a \InvalidArgumentException if the argument does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->setOption() throws a \InvalidArgumentException if the option does not exist');
$this->assertEquals('The "foo" argument does not exist.', $e->getMessage());
}
}
@ -97,8 +105,10 @@ class InputTest extends \PHPUnit_Framework_TestCase
$input->validate();
$this->fail('->validate() throws a \RuntimeException if not enough arguments are given');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->validate() throws a \RuntimeException if not enough arguments are given');
$this->assertEquals('Not enough arguments.', $e->getMessage());
}
$input = new ArrayInput(array('name' => 'foo'));
@ -119,6 +129,6 @@ class InputTest extends \PHPUnit_Framework_TestCase
$input = new ArrayInput(array());
$this->assertTrue($input->isInteractive(), '->isInteractive() returns whether the input should be interactive or not');
$input->setInteractive(false);
$this->assertTrue(!$input->isInteractive(), '->setInteractive() changes the interactive flag');
$this->assertFalse($input->isInteractive(), '->setInteractive() changes the interactive flag');
}
}

2
tests/Symfony/Tests/Components/Console/Output/NullOutputTest.php
View File

@ -18,6 +18,6 @@ class NullOutputTest extends \PHPUnit_Framework_TestCase
{
$output = new NullOutput();
$output->write('foo');
$this->assertTrue(true, '->write() does nothing');
$this->assertTrue(true, '->write() does nothing'); // FIXME
}
}

12
tests/Symfony/Tests/Components/Console/Output/OutputTest.php
View File

@ -18,14 +18,14 @@ class OutputTest extends \PHPUnit_Framework_TestCase
{
$output = new TestOutput(Output::VERBOSITY_QUIET, true);
$this->assertEquals(Output::VERBOSITY_QUIET, $output->getVerbosity(), '__construct() takes the verbosity as its first argument');
$this->assertEquals(true, $output->isDecorated(), '__construct() takes the decorated flag as its second argument');
$this->assertTrue($output->isDecorated(), '__construct() takes the decorated flag as its second argument');
}
public function testSetIsDecorated()
{
$output = new TestOutput();
$output->setDecorated(true);
$this->assertEquals(true, 'setDecorated() sets the decorated flag', $output->isDecorated());
$this->assertTrue($output->isDecorated(), 'setDecorated() sets the decorated flag');
}
public function testSetGetVerbosity()
@ -74,8 +74,10 @@ class OutputTest extends \PHPUnit_Framework_TestCase
$output->writeln('<foo>foo</foo>', 24);
$this->fail('->writeln() throws an \InvalidArgumentException when the type does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->writeln() throws an \InvalidArgumentException when the type does not exist');
$this->assertEquals('Unknown output type given (24)', $e->getMessage());
}
try
@ -83,8 +85,10 @@ class OutputTest extends \PHPUnit_Framework_TestCase
$output->writeln('<bar>foo</bar>');
$this->fail('->writeln() throws an \InvalidArgumentException when a style does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->writeln() throws an \InvalidArgumentException when a style does not exist');
$this->assertEquals('Unknown style "bar".', $e->getMessage());
}
}
}

8
tests/Symfony/Tests/Components/Console/Output/StreamOutputTest.php
View File

@ -29,13 +29,15 @@ class StreamOutputTest extends \PHPUnit_Framework_TestCase
$output = new StreamOutput('foo');
$this->fail('__construct() throws an \InvalidArgumentException if the first argument is not a stream');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '__construct() throws an \InvalidArgumentException if the first argument is not a stream');
$this->assertEquals('The StreamOutput class needs a stream as its first argument.', $e->getMessage());
}
$output = new StreamOutput($this->stream, Output::VERBOSITY_QUIET, true);
$this->assertEquals(Output::VERBOSITY_QUIET, $output->getVerbosity(), '__construct() takes the verbosity as its first argument');
$this->assertEquals(true, $output->isDecorated(), '__construct() takes the decorated flag as its second argument');
$this->assertTrue($output->isDecorated(), '__construct() takes the decorated flag as its second argument');
}
public function testGetStream()
@ -49,6 +51,6 @@ class StreamOutputTest extends \PHPUnit_Framework_TestCase
$output = new StreamOutput($this->stream);
$output->writeln('foo');
rewind($output->getStream());
$this->assertEquals("foo\n", stream_get_contents($output->getStream()), '->doWrite() writes to the stream');
$this->assertEquals('foo'.PHP_EOL, stream_get_contents($output->getStream()), '->doWrite() writes to the stream');
}
}

8
tests/Symfony/Tests/Components/Console/Tester/ApplicationTesterTest.php
View File

@ -35,8 +35,8 @@ class ApplicationTesterTest extends \PHPUnit_Framework_TestCase
public function testRun()
{
$this->assertEquals(false, $this->tester->getInput()->isInteractive(), '->execute() takes an interactive option');
$this->assertEquals(false, $this->tester->getOutput()->isDecorated(), '->execute() takes a decorated option');
$this->assertFalse($this->tester->getInput()->isInteractive(), '->execute() takes an interactive option');
$this->assertFalse($this->tester->getOutput()->isDecorated(), '->execute() takes a decorated option');
$this->assertEquals(Output::VERBOSITY_VERBOSE, $this->tester->getOutput()->getVerbosity(), '->execute() takes a verbosity option');
}
@ -48,11 +48,11 @@ class ApplicationTesterTest extends \PHPUnit_Framework_TestCase
public function testGetOutput()
{
rewind($this->tester->getOutput()->getStream());
$this->assertEquals("foo\n", stream_get_contents($this->tester->getOutput()->getStream()), '->getOutput() returns the current output instance');
$this->assertEquals('foo'.PHP_EOL, stream_get_contents($this->tester->getOutput()->getStream()), '->getOutput() returns the current output instance');
}
public function testGetDisplay()
{
$this->assertEquals("foo\n", $this->tester->getDisplay(), '->getDisplay() returns the display of the last execution');
$this->assertEquals('foo'.PHP_EOL, $this->tester->getDisplay(), '->getDisplay() returns the display of the last execution');
}
}

8
tests/Symfony/Tests/Components/Console/Tester/CommandTesterTest.php
View File

@ -32,8 +32,8 @@ class CommandTesterTest extends \PHPUnit_Framework_TestCase
public function testExecute()
{
$this->assertEquals(false, $this->tester->getInput()->isInteractive(), '->execute() takes an interactive option');
$this->assertEquals(false, $this->tester->getOutput()->isDecorated(), '->execute() takes a decorated option');
$this->assertFalse($this->tester->getInput()->isInteractive(), '->execute() takes an interactive option');
$this->assertFalse($this->tester->getOutput()->isDecorated(), '->execute() takes a decorated option');
$this->assertEquals(Output::VERBOSITY_VERBOSE, $this->tester->getOutput()->getVerbosity(), '->execute() takes a verbosity option');
}
@ -45,11 +45,11 @@ class CommandTesterTest extends \PHPUnit_Framework_TestCase
public function testGetOutput()
{
rewind($this->tester->getOutput()->getStream());
$this->assertEquals("foo\n", stream_get_contents($this->tester->getOutput()->getStream()), '->getOutput() returns the current output instance');
$this->assertEquals('foo'.PHP_EOL, stream_get_contents($this->tester->getOutput()->getStream()), '->getOutput() returns the current output instance');
}
public function testGetDisplay()
{
$this->assertEquals("foo\n", $this->tester->getDisplay(), '->getDisplay() returns the display of the last execution');
$this->assertEquals('foo'.PHP_EOL, $this->tester->getDisplay(), '->getDisplay() returns the display of the last execution');
}
}

1
tests/Symfony/Tests/Components/CssSelector/ParserTest.php
View File

@ -45,6 +45,7 @@ class ParserTest extends \PHPUnit_Framework_TestCase
}
catch (\Exception $e)
{
$this->assertType('\Symfony\Components\CssSelector\SyntaxError', $e, '->parse() throws an Exception if the css selector is not valid');
$this->assertEquals("Expected symbol, got '' at h1: -> ", $e->getMessage(), '->parse() throws an Exception if the css selector is not valid');
}
}

18
tests/Symfony/Tests/Components/DependencyInjection/BuilderConfigurationTest.php
View File

@ -110,8 +110,10 @@ class BuilderConfigurationTest extends \PHPUnit_Framework_TestCase
$configuration->getParameter('baba');
$this->fail('->getParameter() throws an \InvalidArgumentException if the key does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getParameter() throws an \InvalidArgumentException if the key does not exist');
$this->assertEquals('The parameter "baba" must be defined.', $e->getMessage(), '->getParameter() throws an \InvalidArgumentException if the key does not exist');
}
}
@ -120,7 +122,7 @@ class BuilderConfigurationTest extends \PHPUnit_Framework_TestCase
$configuration = new BuilderConfiguration(array(), array('foo' => 'bar'));
$this->assertTrue($configuration->hasParameter('foo'), '->hasParameter() returns true if a parameter is defined');
$this->assertTrue($configuration->hasParameter('Foo'), '->hasParameter() converts the key to lowercase');
$this->assertTrue(!$configuration->hasParameter('bar'), '->hasParameter() returns false if a parameter is not defined');
$this->assertFalse($configuration->hasParameter('bar'), '->hasParameter() returns false if a parameter is not defined');
}
public function testAddParameters()
@ -138,15 +140,17 @@ class BuilderConfigurationTest extends \PHPUnit_Framework_TestCase
$configuration->setAlias('bar', 'foo');
$this->assertEquals('foo', $configuration->getAlias('bar'), '->setAlias() defines a new alias');
$this->assertTrue($configuration->hasAlias('bar'), '->hasAlias() returns true if the alias is defined');
$this->assertTrue(!$configuration->hasAlias('baba'), '->hasAlias() returns false if the alias is not defined');
$this->assertFalse($configuration->hasAlias('baba'), '->hasAlias() returns false if the alias is not defined');
try
{
$configuration->getAlias('baba');
$this->fail('->getAlias() throws an \InvalidArgumentException if the alias does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getAlias() throws an \InvalidArgumentException if the alias does not exist');
$this->assertEquals('The service alias "baba" does not exist.', $e->getMessage(), '->getAlias() throws an \InvalidArgumentException if the alias does not exist');
}
$configuration->setAlias('barbar', 'foofoo');
@ -166,7 +170,7 @@ class BuilderConfigurationTest extends \PHPUnit_Framework_TestCase
$configuration->setDefinitions($definitions);
$this->assertEquals($definitions, $configuration->getDefinitions(), '->setDefinitions() sets the service definitions');
$this->assertTrue($configuration->hasDefinition('foo'), '->hasDefinition() returns true if a service definition exists');
$this->assertTrue(!$configuration->hasDefinition('foobar'), '->hasDefinition() returns false if a service definition does not exist');
$this->assertFalse($configuration->hasDefinition('foobar'), '->hasDefinition() returns false if a service definition does not exist');
$configuration->setDefinition('foobar', $foo = new Definition('FooBarClass'));
$this->assertEquals($foo, $configuration->getDefinition('foobar'), '->getDefinition() returns a service definition if defined');
@ -180,8 +184,10 @@ class BuilderConfigurationTest extends \PHPUnit_Framework_TestCase
$configuration->getDefinition('baz');
$this->fail('->getDefinition() throws an InvalidArgumentException if the service definition does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getDefinition() throws an InvalidArgumentException if the service definition does not exist');
$this->assertEquals('The service definition "baz" does not exist.', $e->getMessage(), '->getDefinition() throws an InvalidArgumentException if the service definition does not exist');
}
}

44
tests/Symfony/Tests/Components/DependencyInjection/BuilderTest.php
View File

@ -34,7 +34,7 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
$builder->setDefinitions($definitions);
$this->assertEquals($definitions, $builder->getDefinitions(), '->setDefinitions() sets the service definitions');
$this->assertTrue($builder->hasDefinition('foo'), '->hasDefinition() returns true if a service definition exists');
$this->assertTrue(!$builder->hasDefinition('foobar'), '->hasDefinition() returns false if a service definition does not exist');
$this->assertFalse($builder->hasDefinition('foobar'), '->hasDefinition() returns false if a service definition does not exist');
$builder->setDefinition('foobar', $foo = new Definition('FooBarClass'));
$this->assertEquals($foo, $builder->getDefinition('foobar'), '->getDefinition() returns a service definition if defined');
@ -48,8 +48,10 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
$builder->getDefinition('baz');
$this->fail('->getDefinition() throws an InvalidArgumentException if the service definition does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getDefinition() throws an InvalidArgumentException if the service definition does not exist');
$this->assertEquals('The service definition "baz" does not exist.', $e->getMessage(), '->getDefinition() throws an InvalidArgumentException if the service definition does not exist');
}
}
@ -58,13 +60,13 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
$builder = new Builder();
$builder->register('foo', 'FooClass');
$this->assertTrue($builder->hasDefinition('foo'), '->register() registers a new service definition');
$this->assertTrue($builder->getDefinition('foo') instanceof Definition, '->register() returns the newly created Definition instance');
$this->assertType('Symfony\Components\DependencyInjection\Definition', $builder->getDefinition('foo'), '->register() returns the newly created Definition instance');
}
public function testHasService()
{
$builder = new Builder();
$this->assertTrue(!$builder->hasService('foo'), '->hasService() returns false if the service does not exist');
$this->assertFalse($builder->hasService('foo'), '->hasService() returns false if the service does not exist');
$builder->register('foo', 'FooClass');
$this->assertTrue($builder->hasService('foo'), '->hasService() returns true if a service definition exists');
$builder->bar = new \stdClass();
@ -79,11 +81,13 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
$builder->getService('foo');
$this->fail('->getService() throws an InvalidArgumentException if the service does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getService() throws an InvalidArgumentException if the service does not exist');
$this->assertEquals('The service definition "foo" does not exist.', $e->getMessage(), '->getService() throws an InvalidArgumentException if the service does not exist');
}
$builder->register('foo', 'stdClass');
$this->assertTrue(is_object($builder->getService('foo')), '->getService() returns the service definition associated with the id');
$this->assertType('object', $builder->getService('foo'), '->getService() returns the service definition associated with the id');
$builder->bar = $bar = new \stdClass();
$this->assertEquals($bar, $builder->getService('bar'), '->getService() returns the service associated with the id');
$builder->register('bar', 'stdClass');
@ -95,8 +99,10 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
@$builder->getService('baz');
$this->fail('->getService() throws a LogicException if the service has a circular reference to itself');
}
catch (\LogicException $e)
catch (\Exception $e)
{
$this->assertType('\LogicException', $e, '->getService() throws a LogicException if the service has a circular reference to itself');
$this->assertEquals('The service "baz" has a circular reference to itself.', $e->getMessage(), '->getService() throws a LogicException if the service has a circular reference to itself');
}
$builder->register('foobar', 'stdClass')->setShared(true);
@ -118,7 +124,7 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
$builder->register('foo', 'stdClass');
$builder->setAlias('bar', 'foo');
$this->assertTrue($builder->hasAlias('bar'), '->hasAlias() returns true if the alias exists');
$this->assertTrue(!$builder->hasAlias('foobar'), '->hasAlias() returns false if the alias does not exist');
$this->assertFalse($builder->hasAlias('foobar'), '->hasAlias() returns false if the alias does not exist');
$this->assertEquals('foo', $builder->getAlias('bar'), '->getAlias() returns the aliased service');
$this->assertTrue($builder->hasService('bar'), '->setAlias() defines a new service');
$this->assertTrue($builder->getService('bar') === $builder->getService('foo'), '->setAlias() creates a service that is an alias to another one');
@ -128,8 +134,10 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
$builder->getAlias('foobar');
$this->fail('->getAlias() throws an InvalidArgumentException if the alias does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getAlias() throws an InvalidArgumentException if the alias does not exist');
$this->assertEquals('The service alias "foobar" does not exist.', $e->getMessage(), '->getAlias() throws an InvalidArgumentException if the alias does not exist');
}
}
@ -149,10 +157,10 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
{
$builder = new Builder();
$builder->register('foo1', 'FooClass')->setFile(self::$fixturesPath.'/includes/foo.php');
$this->assertTrue($builder->getService('foo1') instanceof \FooClass, '->createService() requires the file defined by the service definition');
$this->assertType('\FooClass', $builder->getService('foo1'), '->createService() requires the file defined by the service definition');
$builder->register('foo2', 'FooClass')->setFile(self::$fixturesPath.'/includes/%file%.php');
$builder->setParameter('file', 'foo');
$this->assertTrue($builder->getService('foo2') instanceof \FooClass, '->createService() replaces parameters in the file provided by the service definition');
$this->assertType('\FooClass', $builder->getService('foo2'), '->createService() replaces parameters in the file provided by the service definition');
}
public function testCreateServiceClass()
@ -160,7 +168,7 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
$builder = new Builder();
$builder->register('foo1', '%class%');
$builder->setParameter('class', 'stdClass');
$this->assertTrue($builder->getService('foo1') instanceof \stdClass, '->createService() replaces parameters in the class provided by the service definition');
$this->assertType('\stdClass', $builder->getService('foo1'), '->createService() replaces parameters in the class provided by the service definition');
}
public function testCreateServiceArguments()
@ -213,8 +221,10 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
$builder->getService('foo4');
$this->fail('->createService() throws an InvalidArgumentException if the configure callable is not a valid callable');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->createService() throws an InvalidArgumentException if the configure callable is not a valid callable');
$this->assertEquals('The configure callable for class "FooClass" is not a callable.', $e->getMessage(), '->createService() throws an InvalidArgumentException if the configure callable is not a valid callable');
}
}
@ -236,8 +246,10 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
Builder::resolveValue('%foobar%', array());
$this->fail('->resolveValue() throws a RuntimeException if a placeholder references a non-existant parameter');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->resolveValue() throws a RuntimeException if a placeholder references a non-existant parameter');
$this->assertEquals('The parameter "foobar" must be defined.', $e->getMessage(), '->resolveValue() throws a RuntimeException if a placeholder references a non-existant parameter');
}
try
@ -245,8 +257,10 @@ class BuilderTest extends \PHPUnit_Framework_TestCase
Builder::resolveValue('foo %foobar% bar', array());
$this->fail('->resolveValue() throws a RuntimeException if a placeholder references a non-existant parameter');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->resolveValue() throws a RuntimeException if a placeholder references a non-existant parameter');
$this->assertEquals('The parameter "foobar" must be defined (used in the following expression: "foo %foobar% bar").', $e->getMessage(), '->resolveValue() throws a RuntimeException if a placeholder references a non-existant parameter');
}
}

40
tests/Symfony/Tests/Components/DependencyInjection/ContainerTest.php
View File

@ -49,7 +49,7 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
$this->assertEquals('foo1', $sc['bar1'], '->offsetset() sets the value of a parameter');
unset($sc['bar1']);
$this->assertTrue(!isset($sc['bar1']), '->offsetUnset() removes a parameter');
$this->assertFalse(isset($sc['bar1']), '->offsetUnset() removes a parameter');
$sc->setParameter('foo', 'baz');
$this->assertEquals('baz', $sc->getParameter('foo'), '->setParameter() overrides previously set parameter');
@ -64,8 +64,10 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
$sc->getParameter('baba');
$this->fail('->getParameter() thrown an \InvalidArgumentException if the key does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getParameter() thrown an \InvalidArgumentException if the key does not exist');
$this->assertEquals('The parameter "baba" must be defined.', $e->getMessage(), '->getParameter() thrown an \InvalidArgumentException if the key does not exist');
}
try
@ -73,8 +75,10 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
$sc['baba'];
$this->fail('->offsetGet() thrown an \InvalidArgumentException if the key does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->offsetGet() thrown an \InvalidArgumentException if the key does not exist');
$this->assertEquals('The parameter "baba" must be defined.', $e->getMessage(), '->offsetGet() thrown an \InvalidArgumentException if the key does not exist');
}
}
@ -84,9 +88,9 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
$this->assertTrue($sc->hasParameter('foo'), '->hasParameter() returns true if a parameter is defined');
$this->assertTrue($sc->hasParameter('Foo'), '->hasParameter() converts the key to lowercase');
$this->assertTrue(isset($sc['Foo']), '->offsetExists() converts the key to lowercase');
$this->assertTrue(!$sc->hasParameter('bar'), '->hasParameter() returns false if a parameter is not defined');
$this->assertFalse($sc->hasParameter('bar'), '->hasParameter() returns false if a parameter is not defined');
$this->assertTrue(isset($sc['foo']), '->offsetExists() returns true if a parameter is defined');
$this->assertTrue(!isset($sc['bar']), '->offsetExists() returns false if a parameter is not defined');
$this->assertFalse(isset($sc['bar']), '->offsetExists() returns false if a parameter is not defined');
}
public function testAddParameters()
@ -110,8 +114,8 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
$this->assertEquals(spl_object_hash($obj), spl_object_hash($sc->foo), '->__get() gets a service by name');
$this->assertTrue($sc->hasService('foo'), '->hasService() returns true if the service is defined');
$this->assertTrue(isset($sc->foo), '->__isset() returns true if the service is defined');
$this->assertTrue(!$sc->hasService('bar'), '->hasService() returns false if the service is not defined');
$this->assertTrue(!isset($sc->bar), '->__isset() returns false if the service is not defined');
$this->assertFalse($sc->hasService('bar'), '->hasService() returns false if the service is not defined');
$this->assertFalse(isset($sc->bar), '->__isset() returns false if the service is not defined');
}
public function testGetServiceIds()
@ -133,8 +137,10 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
$sc->getService('baba');
$this->fail('->getService() thrown an \InvalidArgumentException if the service does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getService() thrown an \InvalidArgumentException if the service does not exist');
$this->assertEquals('The service "baba" does not exist.', $e->getMessage(), '->getService() thrown an \InvalidArgumentException if the service does not exist');
}
try
@ -142,8 +148,10 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
$sc->baba;
$this->fail('->__get() thrown an \InvalidArgumentException if the service does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->__get() thrown an \InvalidArgumentException if the service does not exist');
$this->assertEquals('The service "baba" does not exist.', $e->getMessage(), '->__get() thrown an \InvalidArgumentException if the service does not exist');
}
try
@ -151,8 +159,10 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
unset($sc->baba);
$this->fail('->__unset() thrown an LogicException if you try to remove a service');
}
catch (\LogicException $e)
catch (\Exception $e)
{
$this->assertType('\LogicException', $e, '->__unset() thrown an LogicException if you try to remove a service');
$this->assertEquals('You can\'t unset a service.', $e->getMessage(), '->__unset() thrown an LogicException if you try to remove a service');
}
$this->assertEquals(spl_object_hash($sc->__foo_bar), spl_object_hash($sc->getService('foo_bar')), '->getService() camelizes the service id when looking for a method');
@ -168,10 +178,12 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
try
{
$sc->getFooBar_Foo();
$this->fail('__call() throws a \RuntimeException exception if the method is not a service method');
$this->fail('__call() throws a \BadMethodCallException exception if the method is not a service method');
}
catch (\BadMethodCallException $e)
catch (\Exception $e)
{
$this->assertType('\BadMethodCallException', $e, '__call() throws a \BadMethodCallException exception if the method is not a service method');
$this->assertEquals('Call to undefined method Symfony\Components\DependencyInjection\Container::getFooBar_Foo.', $e->getMessage(), '__call() throws a \BadMethodCallException exception if the method is not a service method');
}
}
@ -184,8 +196,10 @@ class ContainerTest extends \PHPUnit_Framework_TestCase
$sc->getService('');
$this->fail('->getService() throws a \InvalidArgumentException exception if the service is empty');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getService() throws a \InvalidArgumentException exception if the service is empty');
$this->assertEquals('The service "" does not exist.', $e->getMessage(), '->getService() throws a \InvalidArgumentException exception if the service is empty');
}
}
}

4
tests/Symfony/Tests/Components/DependencyInjection/DefinitionTest.php
View File

@ -65,9 +65,9 @@ class DefinitionTest extends \PHPUnit_Framework_TestCase
public function testSetIsShared()
{
$def = new Definition('stdClass');
$this->assertEquals(true, $def->isShared(), '->isShared() returns true by default');
$this->assertTrue($def->isShared(), '->isShared() returns true by default');
$this->assertEquals(spl_object_hash($def), spl_object_hash($def->setShared(false)), '->setShared() implements a fluent interface');
$this->assertEquals(false, $def->isShared(), '->isShared() returns false if the instance must not be shared');
$this->assertFalse($def->isShared(), '->isShared() returns false if the instance must not be shared');
}
public function testSetGetConfigurator()

4
tests/Symfony/Tests/Components/DependencyInjection/Dumper/DumperTest.php
View File

@ -24,8 +24,10 @@ class DumperTest extends \PHPUnit_Framework_TestCase
$dumper->dump();
$this->fail('->dump() returns a LogicException if the dump() method has not been overriden by a children class');
}
catch (\LogicException $e)
catch (\Exception $e)
{
$this->assertType('\LogicException', $e, '->dump() returns a LogicException if the dump() method has not been overriden by a children class');
$this->assertEquals('You must extend this abstract class and implement the dump() method.', $e->getMessage(), '->dump() returns a LogicException if the dump() method has not been overriden by a children class');
}
}
}

2
tests/Symfony/Tests/Components/DependencyInjection/Dumper/GraphvizDumperTest.php
View File

@ -26,7 +26,7 @@ class GraphvizDumperTest extends \PHPUnit_Framework_TestCase
{
$dumper = new GraphvizDumper($container = new Builder());
$this->assertEquals(file_get_contents(self::$fixturesPath.'/graphviz/services1.dot'), $dumper->dump(), '->dump() dumps an empty container as an empty dot file');
$this->assertStringEqualsFile(self::$fixturesPath.'/graphviz/services1.dot', $dumper->dump(), '->dump() dumps an empty container as an empty dot file');
$container = new Builder();
$dumper = new GraphvizDumper($container);

12
tests/Symfony/Tests/Components/DependencyInjection/Dumper/PhpDumperTest.php
View File

@ -26,8 +26,8 @@ class PhpDumperTest extends \PHPUnit_Framework_TestCase
{
$dumper = new PhpDumper($container = new Builder());
$this->assertEquals(file_get_contents(self::$fixturesPath.'/php/services1.php'), $dumper->dump(), '->dump() dumps an empty container as an empty PHP class');
$this->assertEquals(file_get_contents(self::$fixturesPath.'/php/services1-1.php'), $dumper->dump(array('class' => 'Container', 'base_class' => 'AbstractContainer')), '->dump() takes a class and a base_class options');
$this->assertStringEqualsFile(self::$fixturesPath.'/php/services1.php', $dumper->dump(), '->dump() dumps an empty container as an empty PHP class');
$this->assertStringEqualsFile(self::$fixturesPath.'/php/services1-1.php', $dumper->dump(array('class' => 'Container', 'base_class' => 'AbstractContainer')), '->dump() takes a class and a base_class options');
$container = new Builder();
$dumper = new PhpDumper($container);
@ -37,14 +37,14 @@ class PhpDumperTest extends \PHPUnit_Framework_TestCase
{
$container = include self::$fixturesPath.'/containers/container8.php';
$dumper = new PhpDumper($container);
$this->assertEquals(file_get_contents(self::$fixturesPath.'/php/services8.php'), $dumper->dump(), '->dump() dumps parameters');
$this->assertStringEqualsFile(self::$fixturesPath.'/php/services8.php', $dumper->dump(), '->dump() dumps parameters');
}
public function testAddService()
{
$container = include self::$fixturesPath.'/containers/container9.php';
$dumper = new PhpDumper($container);
$this->assertEquals(str_replace('%path%', self::$fixturesPath.'/includes', file_get_contents(self::$fixturesPath.'/php/services9.php')), $dumper->dump(), '->dump() dumps services');
$this->assertEquals(str_replace('%path%', str_replace('\\','\\\\',self::$fixturesPath.DIRECTORY_SEPARATOR.'includes'.DIRECTORY_SEPARATOR), file_get_contents(self::$fixturesPath.'/php/services9.php')), $dumper->dump(), '->dump() dumps services');
$dumper = new PhpDumper($container = new Builder());
$container->register('foo', 'FooClass')->addArgument(new \stdClass());
@ -53,8 +53,10 @@ class PhpDumperTest extends \PHPUnit_Framework_TestCase
$dumper->dump();
$this->fail('->dump() throws a RuntimeException if the container to be dumped has reference to objects or resources');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->dump() returns a LogicException if the dump() method has not been overriden by a children class');
$this->assertEquals('Unable to dump a service container if a parameter is an object or a resource.', $e->getMessage(), '->dump() returns a LogicException if the dump() method has not been overriden by a children class');
}
}

10
tests/Symfony/Tests/Components/DependencyInjection/Dumper/XmlDumperTest.php
View File

@ -26,7 +26,7 @@ class XmlDumperTest extends \PHPUnit_Framework_TestCase
{
$dumper = new XmlDumper($container = new Builder());
$this->assertEquals(file_get_contents(self::$fixturesPath.'/xml/services1.xml'), $dumper->dump(), '->dump() dumps an empty container as an empty XML file');
$this->assertXmlStringEqualsXmlFile(self::$fixturesPath.'/xml/services1.xml', $dumper->dump(), '->dump() dumps an empty container as an empty XML file');
$container = new Builder();
$dumper = new XmlDumper($container);
@ -36,14 +36,14 @@ class XmlDumperTest extends \PHPUnit_Framework_TestCase
{
$container = include self::$fixturesPath.'//containers/container8.php';
$dumper = new XmlDumper($container);
$this->assertEquals(file_get_contents(self::$fixturesPath.'/xml/services8.xml'), $dumper->dump(), '->dump() dumps parameters');
$this->assertXmlStringEqualsXmlFile(self::$fixturesPath.'/xml/services8.xml', $dumper->dump(), '->dump() dumps parameters');
}
public function testAddService()
{
$container = include self::$fixturesPath.'/containers/container9.php';
$dumper = new XmlDumper($container);
$this->assertEquals(str_replace('%path%', self::$fixturesPath.'/includes', file_get_contents(self::$fixturesPath.'/xml/services9.xml')), $dumper->dump(), '->dump() dumps services');
$this->assertEquals(str_replace('%path%', self::$fixturesPath.DIRECTORY_SEPARATOR.'includes'.DIRECTORY_SEPARATOR, file_get_contents(self::$fixturesPath.'/xml/services9.xml')), $dumper->dump(), '->dump() dumps services');
$dumper = new XmlDumper($container = new Builder());
$container->register('foo', 'FooClass')->addArgument(new \stdClass());
@ -52,8 +52,10 @@ class XmlDumperTest extends \PHPUnit_Framework_TestCase
$dumper->dump();
$this->fail('->dump() throws a RuntimeException if the container to be dumped has reference to objects or resources');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->dump() throws a RuntimeException if the container to be dumped has reference to objects or resources');
$this->assertEquals('Unable to dump a service container if a parameter is an object or a resource.', $e->getMessage(), '->dump() throws a RuntimeException if the container to be dumped has reference to objects or resources');
}
}
}

10
tests/Symfony/Tests/Components/DependencyInjection/Dumper/YamlDumperTest.php
View File

@ -26,7 +26,7 @@ class YamlDumperTest extends \PHPUnit_Framework_TestCase
{
$dumper = new YamlDumper($container = new Builder());
$this->assertEquals(file_get_contents(self::$fixturesPath.'/yaml/services1.yml'), $dumper->dump(), '->dump() dumps an empty container as an empty YAML file');
$this->assertStringEqualsFile(self::$fixturesPath.'/yaml/services1.yml', $dumper->dump(), '->dump() dumps an empty container as an empty YAML file');
$container = new Builder();
$dumper = new YamlDumper($container);
@ -36,14 +36,14 @@ class YamlDumperTest extends \PHPUnit_Framework_TestCase
{
$container = include self::$fixturesPath.'/containers/container8.php';
$dumper = new YamlDumper($container);
$this->assertEquals(file_get_contents(self::$fixturesPath.'/yaml/services8.yml'), $dumper->dump(), '->dump() dumps parameters');
$this->assertStringEqualsFile(self::$fixturesPath.'/yaml/services8.yml', $dumper->dump(), '->dump() dumps parameters');
}
public function testAddService()
{
$container = include self::$fixturesPath.'/containers/container9.php';
$dumper = new YamlDumper($container);
$this->assertEquals(str_replace('%path%', self::$fixturesPath.'/includes', file_get_contents(self::$fixturesPath.'/yaml/services9.yml')), $dumper->dump(), '->dump() dumps services');
$this->assertEquals(str_replace('%path%', self::$fixturesPath.DIRECTORY_SEPARATOR.'includes'.DIRECTORY_SEPARATOR, file_get_contents(self::$fixturesPath.'/yaml/services9.yml')), $dumper->dump(), '->dump() dumps services');
$dumper = new YamlDumper($container = new Builder());
$container->register('foo', 'FooClass')->addArgument(new \stdClass());
@ -52,8 +52,10 @@ class YamlDumperTest extends \PHPUnit_Framework_TestCase
$dumper->dump();
$this->fail('->dump() throws a RuntimeException if the container to be dumped has reference to objects or resources');
}
catch (\RuntimeException $e)
catch (\Exception $e)
{
$this->assertType('\RuntimeException', $e, '->dump() throws a RuntimeException if the container to be dumped has reference to objects or resources');
$this->assertEquals('Unable to dump a service container if a parameter is an object or a resource.', $e->getMessage(), '->dump() throws a RuntimeException if the container to be dumped has reference to objects or resources');
}
}
}

4
tests/Symfony/Tests/Components/DependencyInjection/FileResourceTest.php
View File

@ -37,9 +37,9 @@ class FileResourceTest extends \PHPUnit_Framework_TestCase
public function testIsUptodate()
{
$this->assertTrue($this->resource->isUptodate(time() + 10), '->isUptodate() returns true if the resource has not changed');
$this->assertTrue(!$this->resource->isUptodate(time() - 86400), '->isUptodate() returns false if the resource has been updated');
$this->assertFalse($this->resource->isUptodate(time() - 86400), '->isUptodate() returns false if the resource has been updated');
$resource = new FileResource('/____foo/foobar'.rand(1, 999999));
$this->assertTrue(!$resource->isUptodate(time()), '->isUptodate() returns false if the resource does not exist');
$this->assertFalse($resource->isUptodate(time()), '->isUptodate() returns false if the resource does not exist');
}
}

4
tests/Symfony/Tests/Components/DependencyInjection/Loader/FileLoaderTest.php
View File

@ -32,9 +32,9 @@ class XmlDumperTest extends \PHPUnit_Framework_TestCase
$this->assertEquals('c:/foo.xml', $loader->getAbsolutePath('c:/foo.xml'), '->getAbsolutePath() return the path unmodified if it is already an absolute path');
$this->assertEquals('\\server\\foo.xml', $loader->getAbsolutePath('\\server\\foo.xml'), '->getAbsolutePath() return the path unmodified if it is already an absolute path');
$this->assertEquals(__DIR__.'/FileLoaderTest.php', $loader->getAbsolutePath('FileLoaderTest.php', __DIR__), '->getAbsolutePath() returns an absolute filename if the file exists in the current path');
$this->assertEquals(__DIR__.DIRECTORY_SEPARATOR.'FileLoaderTest.php', $loader->getAbsolutePath('FileLoaderTest.php', __DIR__), '->getAbsolutePath() returns an absolute filename if the file exists in the current path');
$this->assertEquals(__DIR__.'/../../../../../fixtures/Symfony/Components/DependencyInjection/containers/container10.php', $loader->getAbsolutePath('container10.php', __DIR__), '->getAbsolutePath() returns an absolute filename if the file exists in one of the paths given in the constructor');
$this->assertEquals(__DIR__.'/../../../../../fixtures/Symfony/Components/DependencyInjection/containers'.DIRECTORY_SEPARATOR.'container10.php', $loader->getAbsolutePath('container10.php', __DIR__), '->getAbsolutePath() returns an absolute filename if the file exists in one of the paths given in the constructor');
$this->assertEquals('foo.xml', $loader->getAbsolutePath('foo.xml', __DIR__), '->getAbsolutePath() returns the path unmodified if it is unable to find it in the given paths');
}

8
tests/Symfony/Tests/Components/DependencyInjection/Loader/IniFileLoaderTest.php
View File

@ -33,8 +33,10 @@ class IniLoaderTest extends \PHPUnit_Framework_TestCase
$loader->load('foo.ini');
$this->fail('->load() throws an InvalidArgumentException if the loaded file does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file does not exist');
$this->assertStringStartsWith('The file "foo.ini" does not exist (in: ', $e->getMessage(), '->load() throws an InvalidArgumentException if the loaded file does not exist');
}
try
@ -42,8 +44,10 @@ class IniLoaderTest extends \PHPUnit_Framework_TestCase
@$loader->load('nonvalid.ini');
$this->fail('->load() throws an InvalidArgumentException if the loaded file is not parseable');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file is not parseable');
$this->assertEquals('The nonvalid.ini file is not valid.', $e->getMessage(), '->load() throws an InvalidArgumentException if the loaded file is not parseable');
}
}
}

4
tests/Symfony/Tests/Components/DependencyInjection/Loader/LoaderExtensionTest.php
View File

@ -23,8 +23,10 @@ class LoaderExtensionTest extends \PHPUnit_Framework_TestCase
$extension->load('foo', array());
$this->fail('->load() throws an InvalidArgumentException if the tag does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the tag does not exist');
$this->assertEquals('The tag "foo" is not defined in the "http://www.example.com/schema/project" extension.', $e->getMessage(), '->load() throws an InvalidArgumentException if the tag does not exist');
}
$config = $extension->load('bar', array('foo' => 'bar'));

22
tests/Symfony/Tests/Components/DependencyInjection/Loader/XmlFileLoaderTest.php
View File

@ -35,8 +35,10 @@ class XmlFileLoaderTest extends \PHPUnit_Framework_TestCase
$loader->load('foo.xml');
$this->fail('->load() throws an InvalidArgumentException if the loaded file does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file does not exist');
$this->assertStringStartsWith('The file "foo.xml" does not exist (in:', $e->getMessage(), '->load() throws an InvalidArgumentException if the loaded file does not exist');
}
}
@ -49,8 +51,10 @@ class XmlFileLoaderTest extends \PHPUnit_Framework_TestCase
$loader->parseFile(self::$fixturesPath.'/ini/parameters.ini');
$this->fail('->parseFile() throws an InvalidArgumentException if the loaded file is not a valid XML file');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->parseFile() throws an InvalidArgumentException if the loaded file is not a valid XML file');
$this->assertStringStartsWith('[ERROR 4] Start tag expected, \'<\' not found (in', $e->getMessage(), '->parseFile() throws an InvalidArgumentException if the loaded file is not a valid XML file');
}
$loader = new ProjectLoader2(self::$fixturesPath.'/xml');
@ -60,8 +64,10 @@ class XmlFileLoaderTest extends \PHPUnit_Framework_TestCase
$loader->parseFile(self::$fixturesPath.'/xml/nonvalid.xml');
$this->fail('->parseFile() throws an InvalidArgumentException if the loaded file does not validate the XSD');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->parseFile() throws an InvalidArgumentException if the loaded file does not validate the XSD');
$this->assertStringStartsWith('[ERROR 1845] Element \'nonvalid\': No matching global declaration available for the validation root. (in', $e->getMessage(), '->parseFile() throws an InvalidArgumentException if the loaded file does not validate the XSD');
}
$xml = $loader->parseFile(self::$fixturesPath.'/xml/services1.xml');
@ -120,7 +126,7 @@ class XmlFileLoaderTest extends \PHPUnit_Framework_TestCase
$this->assertEquals('Symfony\\Components\\DependencyInjection\\Definition', get_class($services['foo']), '->load() converts <service> element to Definition instances');
$this->assertEquals('FooClass', $services['foo']->getClass(), '->load() parses the class attribute');
$this->assertTrue($services['shared']->isShared(), '->load() parses the shared attribute');
$this->assertTrue(!$services['non_shared']->isShared(), '->load() parses the shared attribute');
$this->assertFalse($services['non_shared']->isShared(), '->load() parses the shared attribute');
$this->assertEquals('getInstance', $services['constructor']->getConstructor(), '->load() parses the constructor attribute');
$this->assertEquals('%path%/foo.php', $services['file']->getFile(), '->load() parses the file tag');
$this->assertEquals(array('foo', new Reference('foo'), array(true, false)), $services['arguments']->getArguments(), '->load() parses the argument tags');
@ -177,8 +183,10 @@ class XmlFileLoaderTest extends \PHPUnit_Framework_TestCase
$config = $loader->load('services11.xml');
$this->fail('->load() throws an InvalidArgumentException if the tag is not valid');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the tag is not valid');
$this->assertStringStartsWith('There is no extension able to load the configuration for "foobar:foobar" (in', $e->getMessage(), '->load() throws an InvalidArgumentException if the tag is not valid');
}
try
@ -186,8 +194,10 @@ class XmlFileLoaderTest extends \PHPUnit_Framework_TestCase
$config = $loader->load('services12.xml');
$this->fail('->load() throws an InvalidArgumentException if an extension is not loaded');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if an extension is not loaded');
$this->assertStringStartsWith('The "foobar" tag is not valid (in', $e->getMessage(), '->load() throws an InvalidArgumentException if an extension is not loaded');
}
}
}

22
tests/Symfony/Tests/Components/DependencyInjection/Loader/YamlFileLoaderTest.php
View File

@ -35,8 +35,10 @@ class YamlFileLoaderTest extends \PHPUnit_Framework_TestCase
$loader->loadFile('foo.yml');
$this->fail('->load() throws an InvalidArgumentException if the loaded file does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file does not exist');
$this->assertEquals('The service file "foo.yml" is not valid.', $e->getMessage(), '->load() throws an InvalidArgumentException if the loaded file does not exist');
}
try
@ -44,8 +46,10 @@ class YamlFileLoaderTest extends \PHPUnit_Framework_TestCase
$loader->loadFile('parameters.ini');
$this->fail('->load() throws an InvalidArgumentException if the loaded file is not a valid YAML file');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file is not a valid YAML file');
$this->assertEquals('The service file "parameters.ini" is not valid.', $e->getMessage(), '->load() throws an InvalidArgumentException if the loaded file is not a valid YAML file');
}
$loader = new ProjectLoader3(self::$fixturesPath.'/yaml');
@ -57,8 +61,10 @@ class YamlFileLoaderTest extends \PHPUnit_Framework_TestCase
$loader->loadFile($fixture.'.yml');
$this->fail('->load() throws an InvalidArgumentException if the loaded file does not validate');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file does not validate');
$this->assertStringMatchesFormat('The service file "nonvalid%d.yml" is not valid.', $e->getMessage(), '->load() throws an InvalidArgumentException if the loaded file does not validate');
}
}
}
@ -89,7 +95,7 @@ class YamlFileLoaderTest extends \PHPUnit_Framework_TestCase
$this->assertEquals('Symfony\\Components\\DependencyInjection\\Definition', get_class($services['foo']), '->load() converts service element to Definition instances');
$this->assertEquals('FooClass', $services['foo']->getClass(), '->load() parses the class attribute');
$this->assertTrue($services['shared']->isShared(), '->load() parses the shared attribute');
$this->assertTrue(!$services['non_shared']->isShared(), '->load() parses the shared attribute');
$this->assertFalse($services['non_shared']->isShared(), '->load() parses the shared attribute');
$this->assertEquals('getInstance', $services['constructor']->getConstructor(), '->load() parses the constructor attribute');
$this->assertEquals('%path%/foo.php', $services['file']->getFile(), '->load() parses the file tag');
$this->assertEquals(array('foo', new Reference('foo'), array(true, false)), $services['arguments']->getArguments(), '->load() parses the argument tags');
@ -119,8 +125,10 @@ class YamlFileLoaderTest extends \PHPUnit_Framework_TestCase
$config = $loader->load('services11.yml');
$this->fail('->load() throws an InvalidArgumentException if the tag is not valid');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the tag is not valid');
$this->assertStringStartsWith('There is no extension able to load the configuration for "foobar.foobar" (in', $e->getMessage(), '->load() throws an InvalidArgumentException if the tag is not valid');
}
try
@ -128,8 +136,10 @@ class YamlFileLoaderTest extends \PHPUnit_Framework_TestCase
$config = $loader->load('services12.yml');
$this->fail('->load() throws an InvalidArgumentException if an extension is not loaded');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if an extension is not loaded');
$this->assertStringStartsWith('The "foobar" tag is not valid (in', $e->getMessage(), '->load() throws an InvalidArgumentException if an extension is not loaded');
}
}
}

6
tests/Symfony/Tests/Components/EventDispatcher/EventDispatcherTest.php
View File

@ -29,18 +29,18 @@ class EventDispatcherTest extends \PHPUnit_Framework_TestCase
$this->assertEquals(array('listenToBar'), $dispatcher->getListeners('bar'), '->disconnect() disconnects a listener for an event name');
$this->assertEquals(array('listenToBarBar'), $dispatcher->getListeners('barbar'), '->disconnect() disconnects a listener for an event name');
$this->assertTrue($dispatcher->disconnect('foobar', 'listen') === false, '->disconnect() returns false if the listener does not exist');
$this->assertFalse($dispatcher->disconnect('foobar', 'listen'), '->disconnect() returns false if the listener does not exist');
}
public function testGetHasListeners()
{
$dispatcher = new EventDispatcher();
$this->assertEquals(false, $dispatcher->hasListeners('foo'), '->hasListeners() returns false if the event has no listener');
$this->assertFalse($dispatcher->hasListeners('foo'), '->hasListeners() returns false if the event has no listener');
$dispatcher->connect('foo', 'listenToFoo');
$this->assertEquals(true, $dispatcher->hasListeners('foo'), '->hasListeners() returns true if the event has some listeners');
$dispatcher->disconnect('foo', 'listenToFoo');
$this->assertEquals(false, $dispatcher->hasListeners('foo'), '->hasListeners() returns false if the event has no listener');
$this->assertFalse($dispatcher->hasListeners('foo'), '->hasListeners() returns false if the event has no listener');
$dispatcher->connect('bar', 'listenToBar');
$this->assertEquals(array('listenToBar'), $dispatcher->getListeners('bar'), '->getListeners() returns an array of listeners connected to the given event name');

16
tests/Symfony/Tests/Components/EventDispatcher/EventTest.php
View File

@ -38,15 +38,17 @@ class EventTest extends \PHPUnit_Framework_TestCase
$this->assertEquals('foo', $event->getParameter('foo'), '->setParameter() changes the value of a parameter');
$this->assertTrue($event->hasParameter('foo'), '->hasParameter() returns true if the parameter is defined');
unset($event['foo']);
$this->assertTrue(!$event->hasParameter('foo'), '->hasParameter() returns false if the parameter is not defined');
$this->assertFalse($event->hasParameter('foo'), '->hasParameter() returns false if the parameter is not defined');
try
{
$event->getParameter('foobar');
$this->fail('->getParameter() throws an \InvalidArgumentException exception when the parameter does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->getParameter() throws an \InvalidArgumentException exception when the parameter does not exist');
$this->assertEquals('The event "name" has no "foobar" parameter.', $e->getMessage(), '->getParameter() throws an \InvalidArgumentException exception when the parameter does not exist');
}
$event = new Event($this->subject, 'name', $this->parameters);
}
@ -62,9 +64,9 @@ class EventTest extends \PHPUnit_Framework_TestCase
{
$event = $this->createEvent();
$event->setProcessed(true);
$this->assertEquals(true, $event->isProcessed(), '->isProcessed() returns true if the event has been processed');
$this->assertTrue($event->isProcessed(), '->isProcessed() returns true if the event has been processed');
$event->setProcessed(false);
$this->assertEquals(false, $event->isProcessed(), '->setProcessed() changes the processed status');
$this->assertFalse($event->isProcessed(), '->setProcessed() changes the processed status');
}
public function testArrayAccessInterface()
@ -80,13 +82,15 @@ class EventTest extends \PHPUnit_Framework_TestCase
$event['foobar'];
$this->fail('::offsetGet() throws an \InvalidArgumentException exception when the parameter does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '::offsetGet() throws an \InvalidArgumentException exception when the parameter does not exist');
$this->assertEquals('The event "name" has no "foobar" parameter.', $e->getMessage(), '::offsetGet() throws an \InvalidArgumentException exception when the parameter does not exist');
}
$this->assertTrue(isset($event['foo']), 'Event implements the ArrayAccess interface');
unset($event['foo']);
$this->assertTrue(!isset($event['foo']), 'Event implements the ArrayAccess interface');
$this->assertFalse(isset($event['foo']), 'Event implements the ArrayAccess interface');
}
protected function createEvent()

12
tests/Symfony/Tests/Components/OutputEscaper/ArrayDecoratorTest.php
View File

@ -32,7 +32,7 @@ class ArrayDecoratorTest extends \PHPUnit_Framework_TestCase
public function testArrayAccessInterface()
{
$this->assertEquals('&lt;strong&gt;escaped!&lt;/strong&gt;', self::$escaped[0], 'The escaped object behaves like an array');
$this->assertEquals(null, self::$escaped[2], 'The escaped object behaves like an array');
$this->assertNull(self::$escaped[2], 'The escaped object behaves like an array');
$this->assertEquals('&lt;strong&gt;escaped!&lt;/strong&gt;', self::$escaped[3][1], 'The escaped object behaves like an array');
$this->assertTrue(isset(self::$escaped[1]), 'The escaped object behaves like an array (isset)');
@ -43,8 +43,10 @@ class ArrayDecoratorTest extends \PHPUnit_Framework_TestCase
$this->fail('The escaped object is read only (unset)');
}
catch (\LogicException $e)
catch (\Exception $e)
{
$this->assertType('\LogicException', $e, 'The escaped object is read only (unset)');
$this->assertEquals('Cannot unset values.', $e->getMessage(), 'The escaped object is read only (unset)');
}
try
@ -53,8 +55,10 @@ class ArrayDecoratorTest extends \PHPUnit_Framework_TestCase
$this->fail('The escaped object is read only (set)');
}
catch (\LogicException $e)
catch (\Exception $e)
{
$this->assertType('\LogicException', $e, 'The escaped object is read only (set)');
$this->assertEquals('Cannot set values.', $e->getMessage(), 'The escaped object is read only (set)');
}
}
@ -71,7 +75,7 @@ class ArrayDecoratorTest extends \PHPUnit_Framework_TestCase
$this->assertEquals(1, $value, 'The escaped object behaves like an array');
break;
case 2:
$this->assertEquals(null, $value, 'The escaped object behaves like an array');
$this->assertNull($value, 'The escaped object behaves like an array');
break;
case 3:
break;

36
tests/Symfony/Tests/Components/OutputEscaper/EscaperTest.php
View File

@ -21,9 +21,9 @@ class EscaperTest extends \PHPUnit_Framework_TestCase
{
public function testEscapeDoesNotEscapeSpecialValues()
{
$this->assertSame(Escaper::escape('entities', null), null, '::escape() returns null if the value to escape is null');
$this->assertSame(Escaper::escape('entities', false), false, '::escape() returns false if the value to escape is false');
$this->assertSame(Escaper::escape('entities', true), true, '::escape() returns true if the value to escape is true');
$this->assertNull(Escaper::escape('entities', null), '::escape() returns null if the value to escape is null');
$this->assertFalse(Escaper::escape('entities', false), '::escape() returns false if the value to escape is false');
$this->assertTrue(Escaper::escape('entities', true), '::escape() returns true if the value to escape is true');
}
public function testEscapeDoesNotEscapeAValueWhenEscapingMethodIsRAW()
@ -44,7 +44,7 @@ class EscaperTest extends \PHPUnit_Framework_TestCase
'bar' => array('foo' => '<strong>escaped!</strong>'),
);
$output = Escaper::escape('entities', $input);
$this->assertTrue($output instanceof ArrayDecorator, '::escape() returns a ArrayDecorator object if the value to escape is an array');
$this->assertType('Symfony\Components\OutputEscaper\ArrayDecorator', $output, '::escape() returns a ArrayDecorator object if the value to escape is an array');
$this->assertEquals('&lt;strong&gt;escaped!&lt;/strong&gt;', $output['foo'], '::escape() escapes all elements of the original array');
$this->assertEquals('&lt;strong&gt;escaped!&lt;/strong&gt;', $output['bar']['foo'], '::escape() is recursive');
$this->assertEquals($input, $output->getRawValue(), '->getRawValue() returns the unescaped value');
@ -54,23 +54,23 @@ class EscaperTest extends \PHPUnit_Framework_TestCase
{
$input = new OutputEscaperTestClass();
$output = Escaper::escape('entities', $input);
$this->assertTrue($output instanceof ObjectDecorator, '::escape() returns a ObjectDecorator object if the value to escape is an object');
$this->assertType('Symfony\Components\OutputEscaper\ObjectDecorator', $output, '::escape() returns a ObjectDecorator object if the value to escape is an object');
$this->assertEquals('&lt;strong&gt;escaped!&lt;/strong&gt;', $output->getTitle(), '::escape() escapes all methods of the original object');
$this->assertEquals('&lt;strong&gt;escaped!&lt;/strong&gt;', $output->title, '::escape() escapes all properties of the original object');
$this->assertEquals('&lt;strong&gt;escaped!&lt;/strong&gt;', $output->getTitleTitle(), '::escape() is recursive');
$this->assertEquals($input, $output->getRawValue(), '->getRawValue() returns the unescaped value');
$this->assertEquals('&lt;strong&gt;escaped!&lt;/strong&gt;', Escaper::escape('entities', $output)->getTitle(), '::escape() does not double escape an object');
$this->assertTrue(Escaper::escape('entities', new \DirectoryIterator('.')) instanceof IteratorDecorator, '::escape() returns a IteratorDecorator object if the value to escape is an object that implements the ArrayAccess interface');
$this->assertType('Symfony\Components\OutputEscaper\IteratorDecorator', Escaper::escape('entities', new \DirectoryIterator('.')), '::escape() returns a IteratorDecorator object if the value to escape is an object that implements the ArrayAccess interface');
}
public function testEscapeDoesNotEscapeObjectMarkedAsBeingSafe()
{
$this->assertTrue(Escaper::escape('entities', new SafeDecorator(new OutputEscaperTestClass())) instanceof OutputEscaperTestClass, '::escape() returns the original value if it is marked as being safe');
$this->assertType('Symfony\Tests\Components\OutputEscaper\OutputEscaperTestClass', Escaper::escape('entities', new SafeDecorator(new OutputEscaperTestClass())), '::escape() returns the original value if it is marked as being safe');
Escaper::markClassAsSafe('Symfony\Tests\Components\OutputEscaper\OutputEscaperTestClass');
$this->assertTrue(Escaper::escape('entities', new OutputEscaperTestClass()) instanceof OutputEscaperTestClass, '::escape() returns the original value if the object class is marked as being safe');
$this->assertTrue(Escaper::escape('entities', new OutputEscaperTestClassChild()) instanceof OutputEscaperTestClassChild, '::escape() returns the original value if one of the object parent class is marked as being safe');
$this->assertType('Symfony\Tests\Components\OutputEscaper\OutputEscaperTestClass', Escaper::escape('entities', new OutputEscaperTestClass()), '::escape() returns the original value if the object class is marked as being safe');
$this->assertType('Symfony\Tests\Components\OutputEscaper\OutputEscaperTestClass', Escaper::escape('entities', new OutputEscaperTestClassChild()), '::escape() returns the original value if one of the object parent class is marked as being safe');
}
public function testEscapeCannotEscapeResources()
@ -90,9 +90,9 @@ class EscaperTest extends \PHPUnit_Framework_TestCase
public function testUnescapeDoesNotUnescapeSpecialValues()
{
$this->assertTrue(Escaper::unescape(null) === null, '::unescape() returns null if the value to unescape is null');
$this->assertTrue(Escaper::unescape(false) === false, '::unescape() returns false if the value to unescape is false');
$this->assertTrue(Escaper::unescape(true) === true, '::unescape() returns true if the value to unescape is true');
$this->assertNull(Escaper::unescape(null), '::unescape() returns null if the value to unescape is null');
$this->assertFalse(Escaper::unescape(false), '::unescape() returns false if the value to unescape is false');
$this->assertTrue(Escaper::unescape(true), '::unescape() returns true if the value to unescape is true');
}
public function testUnescapeUnescapesStrings()
@ -108,7 +108,7 @@ class EscaperTest extends \PHPUnit_Framework_TestCase
'bar' => array('foo' => '<strong>escaped!</strong>'),
));
$output = Escaper::unescape($input);
$this->assertTrue(is_array($output), '::unescape() returns an array if the input is a ArrayDecorator object');
$this->assertType('array', $output, '::unescape() returns an array if the input is a ArrayDecorator object');
$this->assertEquals('<strong>escaped!</strong>', $output['foo'], '::unescape() unescapes all elements of the original array');
$this->assertEquals('<strong>escaped!</strong>', $output['bar']['foo'], '::unescape() is recursive');
}
@ -118,21 +118,21 @@ class EscaperTest extends \PHPUnit_Framework_TestCase
$object = new OutputEscaperTestClass();
$input = Escaper::escape('entities', $object);
$output = Escaper::unescape($input);
$this->assertTrue($output instanceof OutputEscaperTestClass, '::unescape() returns the original object when a ObjectDecorator object is passed');
$this->assertType('Symfony\Tests\Components\OutputEscaper\OutputEscaperTestClass', $output, '::unescape() returns the original object when a ObjectDecorator object is passed');
$this->assertEquals('<strong>escaped!</strong>', $output->getTitle(), '::unescape() unescapes all methods of the original object');
$this->assertEquals('<strong>escaped!</strong>', $output->title, '::unescape() unescapes all properties of the original object');
$this->assertEquals('<strong>escaped!</strong>', $output->getTitleTitle(), '::unescape() is recursive');
$this->assertTrue(IteratorDecorator::unescape(Escaper::escape('entities', new \DirectoryIterator('.'))) instanceof \DirectoryIterator, '::unescape() unescapes IteratorDecorator objects');
$this->assertType('\DirectoryIterator', IteratorDecorator::unescape(Escaper::escape('entities', new \DirectoryIterator('.'))), '::unescape() unescapes IteratorDecorator objects');
}
public function testUnescapeDoesNotUnescapeObjectMarkedAsBeingSafe()
{
$this->assertTrue(Escaper::unescape(Escaper::escape('entities', new SafeDecorator(new OutputEscaperTestClass()))) instanceof OutputEscaperTestClass, '::unescape() returns the original value if it is marked as being safe');
$this->assertType('Symfony\Tests\Components\OutputEscaper\OutputEscaperTestClass', Escaper::unescape(Escaper::escape('entities', new SafeDecorator(new OutputEscaperTestClass()))), '::unescape() returns the original value if it is marked as being safe');
Escaper::markClassAsSafe('OutputEscaperTestClass');
$this->assertTrue(Escaper::unescape(Escaper::escape('entities', new OutputEscaperTestClass())) instanceof OutputEscaperTestClass, '::unescape() returns the original value if the object class is marked as being safe');
$this->assertTrue(Escaper::unescape(Escaper::escape('entities', new OutputEscaperTestClassChild())) instanceof OutputEscaperTestClassChild, '::unescape() returns the original value if one of the object parent class is marked as being safe');
$this->assertType('Symfony\Tests\Components\OutputEscaper\OutputEscaperTestClass', Escaper::unescape(Escaper::escape('entities', new OutputEscaperTestClass())), '::unescape() returns the original value if the object class is marked as being safe');
$this->assertType('Symfony\Tests\Components\OutputEscaper\OutputEscaperTestClass', Escaper::unescape(Escaper::escape('entities', new OutputEscaperTestClassChild())), '::unescape() returns the original value if one of the object parent class is marked as being safe');
}
public function testUnescapeDoesNothingToResources()

12
tests/Symfony/Tests/Components/OutputEscaper/SafeDecoratorTest.php
View File

@ -41,12 +41,12 @@ class SafeDecoratorTest extends \PHPUnit_Framework_TestCase
{
$safe = new SafeDecorator(new TestClass3());
$this->assertEquals(true, isset($safe->boolValue), '->__isset() returns true if the property is not null');
$this->assertEquals(false, isset($safe->nullValue), '->__isset() returns false if the property is null');
$this->assertEquals(false, isset($safe->undefinedValue), '->__isset() returns false if the property does not exist');
$this->assertTrue(isset($safe->boolValue), '->__isset() returns true if the property is not null');
$this->assertFalse(isset($safe->nullValue), '->__isset() returns false if the property is null');
$this->assertFalse(isset($safe->undefinedValue), '->__isset() returns false if the property does not exist');
unset($safe->boolValue);
$this->assertEquals(false, isset($safe->boolValue), '->__unset() unsets the embedded property');
$this->assertFalse(isset($safe->boolValue), '->__unset() unsets the embedded property');
}
public function testIteratorInterface()
@ -69,9 +69,9 @@ class SafeDecoratorTest extends \PHPUnit_Framework_TestCase
$this->assertEquals('bar', $safe['foo'], '"ArrayAccess" implementation returns a value from the embedded array');
$safe['foo'] = 'baz';
$this->assertEquals('baz', $safe['foo'], '"ArrayAccess" implementation sets a value on the embedded array');
$this->assertEquals(true, isset($safe['foo']), '"ArrayAccess" checks if a value is set on the embedded array');
$this->assertTrue(isset($safe['foo']), '"ArrayAccess" checks if a value is set on the embedded array');
unset($safe['foo']);
$this->assertEquals(false, isset($safe['foo']), '"ArrayAccess" unsets a value on the embedded array');
$this->assertFalse(isset($safe['foo']), '"ArrayAccess" unsets a value on the embedded array');
}
}

4
tests/Symfony/Tests/Components/RequestHandler/RequestTest.php
View File

@ -71,8 +71,8 @@ class RequestTest extends \PHPUnit_Framework_TestCase
{
$request = new Request();
$this->assertEquals(null, $request->getFormat(null), '->getFormat() returns null when mime-type is null');
$this->assertEquals(null, $request->getFormat('unexistant-mime-type'), '->getFormat() returns null when mime-type is unknown');
$this->assertNull($request->getFormat(null), '->getFormat() returns null when mime-type is null');
$this->assertNull($request->getFormat('unexistant-mime-type'), '->getFormat() returns null when mime-type is unknown');
$this->assertEquals('txt', $request->getFormat('text/plain'), '->getFormat() returns correct format when mime-type have one format only');
$this->assertEquals('js', $request->getFormat('application/javascript'), '->getFormat() returns correct format when format have multiple mime-type (first)');
$this->assertEquals('js', $request->getFormat('application/x-javascript'), '->getFormat() returns correct format when format have multiple mime-type');

18
tests/Symfony/Tests/Components/Templating/EngineTest.php
View File

@ -57,8 +57,10 @@ class EngineTest extends \PHPUnit_Framework_TestCase
$engine->bar;
$this->fail('->__get() throws an InvalidArgumentException if the helper is not defined');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->__get() throws an InvalidArgumentException if the helper is not defined');
$this->assertEquals('The helper "bar" is not defined.', $e->getMessage(), '->__get() throws an InvalidArgumentException if the helper is not defined');
}
}
@ -77,12 +79,14 @@ class EngineTest extends \PHPUnit_Framework_TestCase
$engine->get('foobar');
$this->fail('->get() throws an InvalidArgumentException if the helper is not defined');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->get() throws an InvalidArgumentException if the helper is not defined');
$this->assertEquals('The helper "foobar" is not defined.', $e->getMessage(), '->get() throws an InvalidArgumentException if the helper is not defined');
}
$this->assertTrue($engine->has('foo'), '->has() returns true if the helper exists');
$this->assertTrue(!$engine->has('foobar'), '->has() returns false if the helper does not exist');
$this->assertFalse($engine->has('foobar'), '->has() returns false if the helper does not exist');
}
public function testExtendRender()
@ -93,8 +97,10 @@ class EngineTest extends \PHPUnit_Framework_TestCase
$engine->render('name');
$this->fail('->render() throws an InvalidArgumentException if the template does not exist');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->render() throws an InvalidArgumentException if the template does not exist');
$this->assertEquals('The template "name" does not exist (renderer: php).', $e->getMessage(), '->render() throws an InvalidArgumentException if the template does not exist');
}
try
@ -103,8 +109,10 @@ class EngineTest extends \PHPUnit_Framework_TestCase
$engine->render('foo:name');
$this->fail('->render() throws an InvalidArgumentException if no renderer is registered for the given renderer');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$this->assertType('\InvalidArgumentException', $e, '->render() throws an InvalidArgumentException if no renderer is registered for the given renderer');
$this->assertEquals('The template "foo" does not exist (renderer: name).', $e->getMessage(), '->render() throws an InvalidArgumentException if no renderer is registered for the given renderer');
}
$engine = new ProjectTemplateEngine(self::$loader, array(), array(new SlotsHelper()));

16
tests/Symfony/Tests/Components/Templating/Helper/SlotsHelperTest.php
View File

@ -23,7 +23,7 @@ class SlotsHelperTest extends \PHPUnit_Framework_TestCase
$this->assertEquals('bar', $helper->get('bar', 'bar'), '->get() takes a default value to return if the slot does not exist');
$this->assertTrue($helper->has('foo'), '->has() returns true if the slot exists');
$this->assertTrue(!$helper->has('bar'), '->has() returns false if the slot does not exist');
$this->assertFalse($helper->has('bar'), '->has() returns false if the slot does not exist');
}
public function testOutput()
@ -34,19 +34,19 @@ class SlotsHelperTest extends \PHPUnit_Framework_TestCase
$ret = $helper->output('foo');
$output = ob_get_clean();
$this->assertEquals('bar', $output, '->output() outputs the content of a slot');
$this->assertEquals(true, $ret, '->output() returns true if the slot exists');
$this->assertTrue($ret, '->output() returns true if the slot exists');
ob_start();
$ret = $helper->output('bar', 'bar');
$output = ob_get_clean();
$this->assertEquals('bar', $output, '->output() takes a default value to return if the slot does not exist');
$this->assertEquals(true, $ret, '->output() returns true if the slot does not exist but a default value is provided');
$this->assertTrue($ret, '->output() returns true if the slot does not exist but a default value is provided');
ob_start();
$ret = $helper->output('bar');
$output = ob_get_clean();
$this->assertEquals('', $output, '->output() outputs nothing if the slot does not exist');
$this->assertEquals(false, $ret, '->output() returns false if the slot does not exist');
$this->assertFalse($ret, '->output() returns false if the slot does not exist');
}
public function testStartStop()
@ -65,9 +65,11 @@ class SlotsHelperTest extends \PHPUnit_Framework_TestCase
$helper->stop();
$this->fail('->start() throws an InvalidArgumentException if a slot with the same name is already started');
}
catch (\InvalidArgumentException $e)
catch (\Exception $e)
{
$helper->stop();
$this->assertType('\InvalidArgumentException', $e, '->start() throws an InvalidArgumentException if a slot with the same name is already started');
$this->assertEquals('A slot named "bar" is already started.', $e->getMessage(), '->start() throws an InvalidArgumentException if a slot with the same name is already started');
}
try
@ -75,8 +77,10 @@ class SlotsHelperTest extends \PHPUnit_Framework_TestCase
$helper->stop();
$this->fail('->stop() throws an LogicException if no slot is started');
}
catch (\LogicException $e)
catch (\Exception $e)
{
$this->assertType('\LogicException', $e, '->stop() throws an LogicException if no slot is started');
$this->assertEquals('No slot started.', $e->getMessage(), '->stop() throws an LogicException if no slot is started');
}
}
}

2
tests/Symfony/Tests/Components/Templating/Loader/CacheLoaderTest.php
View File

@ -34,7 +34,7 @@ class CacheLoaderTest extends \PHPUnit_Framework_TestCase
$loader = new ProjectTemplateLoader($varLoader = new ProjectTemplateLoaderVar(), $dir);
$loader->setDebugger($debugger = new \ProjectTemplateDebugger());
$this->assertTrue($loader->load('foo') === false, '->load() returns false if the embed loader is not able to load the template');
$this->assertFalse($loader->load('foo'), '->load() returns false if the embed loader is not able to load the template');
$loader->load('index');
$this->assertTrue($debugger->hasMessage('Storing template'), '->load() logs a "Storing template" message if the template is found');
$loader->load('index');

6
tests/Symfony/Tests/Components/Templating/Loader/ChainLoaderTest.php
View File

@ -44,9 +44,9 @@ class ChainLoaderTest extends \PHPUnit_Framework_TestCase
public function testLoad()
{
$loader = new ProjectTemplateLoader1(array(self::$loader1, self::$loader2));
$this->assertTrue($loader->load('bar') === false, '->load() returns false if the template is not found');
$this->assertTrue($loader->load('foo', array('renderer' => 'xml')) === false, '->load() returns false if the template does not exists for the given renderer');
$this->assertTrue($loader->load('foo') instanceof FileStorage, '->load() returns a FileStorage if the template exists');
$this->assertFalse($loader->load('bar'), '->load() returns false if the template is not found');
$this->assertFalse($loader->load('foo', array('renderer' => 'xml')), '->load() returns false if the template does not exists for the given renderer');
$this->assertType('Symfony\Components\Templating\Storage\FileStorage', $loader->load('foo'), '->load() returns a FileStorage if the template exists');
}
}

8
tests/Symfony/Tests/Components/Templating/Loader/FilesystemLoaderTest.php
View File

@ -49,18 +49,18 @@ class FilesystemLoaderTest extends \PHPUnit_Framework_TestCase
$path = self::$fixturesPath.'/templates';
$loader = new ProjectTemplateLoader2($pathPattern);
$storage = $loader->load($path.'/foo.php');
$this->assertTrue($storage instanceof FileStorage, '->load() returns a FileStorage if you pass an absolute path');
$this->assertType('Symfony\Components\Templating\Storage\FileStorage', $storage, '->load() returns a FileStorage if you pass an absolute path');
$this->assertEquals($path.'/foo.php', (string) $storage, '->load() returns a FileStorage pointing to the passed absolute path');
$this->assertTrue($loader->load('bar') === false, '->load() returns false if the template is not found');
$this->assertFalse($loader->load('bar'), '->load() returns false if the template is not found');
$storage = $loader->load('foo');
$this->assertTrue($storage instanceof FileStorage, '->load() returns a FileStorage if you pass a relative template that exists');
$this->assertType('Symfony\Components\Templating\Storage\FileStorage', $storage, '->load() returns a FileStorage if you pass a relative template that exists');
$this->assertEquals($path.'/foo.php', (string) $storage, '->load() returns a FileStorage pointing to the absolute path of the template');
$loader = new ProjectTemplateLoader2($pathPattern);
$loader->setDebugger($debugger = new \ProjectTemplateDebugger());
$this->assertTrue($loader->load('foo', array('renderer' => 'xml')) === false, '->load() returns false if the template does not exists for the given renderer');
$this->assertFalse($loader->load('foo', array('renderer' => 'xml')), '->load() returns false if the template does not exists for the given renderer');
$this->assertTrue($debugger->hasMessage('Failed loading template'), '->load() logs a "Failed loading template" message if the template is not found');
$loader = new ProjectTemplateLoader2(array(self::$fixturesPath.'/null/%name%', $pathPattern));

2
tests/Symfony/Tests/Components/Templating/Storage/FileStorageTest.php
View File

@ -19,7 +19,7 @@ class FileStorageTest extends \PHPUnit_Framework_TestCase
public function testGetContent()
{
$storage = new FileStorage('foo');
$this->assertTrue($storage instanceof Storage, 'FileStorage is an instance of Storage');
$this->assertType('Symfony\Components\Templating\Storage\Storage', $storage, 'FileStorage is an instance of Storage');
$storage = new FileStorage(__DIR__.'/../../../../../fixtures/Symfony/Components/Templating/templates/foo.php');
$this->assertEquals('<?php echo $foo ?>', $storage->getContent(), '->getContent() returns the content of the template');
}

2
tests/Symfony/Tests/Components/Templating/Storage/StringStorageTest.php
View File

@ -19,7 +19,7 @@ class StringStorageTest extends \PHPUnit_Framework_TestCase
public function testGetContent()
{
$storage = new StringStorage('foo');
$this->assertTrue($storage instanceof Storage, 'StringStorage is an instance of Storage');
$this->assertType('Symfony\Components\Templating\Storage\Storage', $storage, 'StringStorage is an instance of Storage');
$storage = new StringStorage('foo');
$this->assertEquals('foo', $storage->getContent(), '->getContent() returns the content of the template');
}

4
tests/Symfony/Tests/Components/Yaml/ParserTest.php
View File

@ -78,8 +78,10 @@ class ParserTest extends \PHPUnit_Framework_TestCase
$this->fail('YAML files must not contain tabs');
}
catch (ParserException $e)
catch (\Exception $e)
{
$this->assertType('\Exception', $e, 'YAML files must not contain tabs');
$this->assertEquals('A YAML file cannot contain tabs as indentation at line 2 ('.strpbrk($yaml, "\t").').', $e->getMessage(), 'YAML files must not contain tabs');
}
}
}

2
tests/fixtures/Symfony/Components/Console/application_renderexception2.txt vendored
View File

@ -1,7 +1,7 @@
[RuntimeException]
[InvalidArgumentException]
The "--foo" option does not exist.

8
tests/fixtures/Symfony/Components/DependencyInjection/php/services9.php vendored
View File

@ -38,7 +38,7 @@ class ProjectServiceContainer extends Container
*/
protected function getFooService()
{
require_once '%path%/foo.php';
require_once '%path%foo.php';
$instance = call_user_func(array('FooClass', 'getInstance'), 'foo', $this->getFoo_BazService(), array($this->getParameter('foo') => 'foo is '.$this->getParameter('foo'), 'bar' => $this->getParameter('foo')), true, $this);
$instance->setBar('bar');
@ -153,11 +153,11 @@ class ProjectServiceContainer extends Container
public function findAnnotatedServiceIds($name)
{
static $annotations = array (
'foo' =>
'foo' =>
array (
'foo' =>
'foo' =>
array (
0 =>
0 =>
array (
'foo' => 'foo',
),

2
tests/fixtures/Symfony/Components/DependencyInjection/xml/services9.xml vendored
View File

@ -12,7 +12,7 @@
<service id="foo" class="FooClass" constructor="getInstance" shared="false">
<annotation name="foo" foo="foo" />
<annotation name="foo" bar="bar" />
<file>%path%/foo.php</file>
<file>%path%foo.php</file>
<argument>foo</argument>
<argument type="service" id="foo.baz" />
<argument type="collection">

2
tests/fixtures/Symfony/Components/DependencyInjection/yaml/services9.yml vendored
View File

@ -9,7 +9,7 @@ services:
annotations:
- { name: foo, foo: foo }
- { name: foo, bar: bar }
file: %path%/foo.php
file: %path%foo.php
constructor: getInstance
arguments: [foo, '@foo.baz', { '%foo%': 'foo is %foo%', bar: '%foo%' }, true, '@service_container']
calls: