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

Merge branch '2.8' into 3.3

Browse Source 
* 2.8:
  Refactoring tests.
This commit is contained in:
Nicolas Grekas 2017-12-12 12:20:26 +01:00
commit 05ab1cd00d
42 changed files with 146 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Symfony/Bundle/SecurityBundle/Tests/DependencyInjection/CompleteConfigurationTest.php
View File

@ -225,7 +225,7 @@ abstract class CompleteConfigurationTest extends TestCase
foreach ($rules as list($matcherId, $attributes, $channel)) {
$requestMatcher = $container->getDefinition($matcherId);
$this->assertFalse(isset($matcherIds[$matcherId]));
$this->assertArrayNotHasKey($matcherId, $matcherIds);
$matcherIds[$matcherId] = true;
$i = count($matcherIds);

2
src/Symfony/Component/Config/Tests/Definition/Builder/ArrayNodeDefinitionTest.php
View File

@ -32,7 +32,7 @@ class ArrayNodeDefinitionTest extends TestCase
->append($child);
$this->assertCount(3, $this->getField($parent, 'children'));
$this->assertTrue(in_array($child, $this->getField($parent, 'children')));
$this->assertContains($child, $this->getField($parent, 'children'));
}
/**

2
src/Symfony/Component/Config/Tests/Resource/DirectoryResourceTest.php
View File

@ -178,6 +178,6 @@ class DirectoryResourceTest extends TestCase
$resourceA = new DirectoryResource($this->directory, '/.xml$/');
$resourceB = new DirectoryResource($this->directory, '/.yaml$/');
$this->assertEquals(2, count(array_unique(array($resourceA, $resourceB))));
$this->assertCount(2, array_unique(array($resourceA, $resourceB)));
}
}

2
src/Symfony/Component/CssSelector/Tests/XPath/TranslatorTest.php
View File

@ -37,7 +37,7 @@ class TranslatorTest extends TestCase
$translator = new Translator();
$document = new \SimpleXMLElement(file_get_contents(__DIR__.'/Fixtures/lang.xml'));
$elements = $document->xpath($translator->cssToXPath($css));
$this->assertEquals(count($elementsId), count($elements));
$this->assertCount(count($elementsId), $elements);
foreach ($elements as $element) {
$this->assertTrue(in_array($element->attributes()->id, $elementsId));
}

16
src/Symfony/Component/DependencyInjection/Tests/ContainerBuilderTest.php
View File

@ -72,7 +72,7 @@ class ContainerBuilderTest extends TestCase
$builder->setDefinition('foobar', $foo = new Definition('FooBarClass'));
$this->assertEquals($foo, $builder->getDefinition('foobar'), '->getDefinition() returns a service definition if defined');
$this->assertTrue($builder->setDefinition('foobar', $foo = new Definition('FooBarClass')) === $foo, '->setDefinition() implements a fluid interface by returning the service reference');
$this->assertSame($builder->setDefinition('foobar', $foo = new Definition('FooBarClass')), $foo, '->setDefinition() implements a fluid interface by returning the service reference');
$builder->addDefinitions($defs = array('foobar' => new Definition('FooBarClass')));
$this->assertEquals(array_merge($definitions, $defs), $builder->getDefinitions(), '->addDefinitions() adds the service definitions');
@ -241,7 +241,7 @@ class ContainerBuilderTest extends TestCase
$this->assertFalse($builder->hasAlias('foobar'), '->hasAlias() returns false if the alias does not exist');
$this->assertEquals('foo', (string) $builder->getAlias('bar'), '->getAlias() returns the aliased service');
$this->assertTrue($builder->has('bar'), '->setAlias() defines a new service');
$this->assertTrue($builder->get('bar') === $builder->get('foo'), '->setAlias() creates a service that is an alias to another one');
$this->assertSame($builder->get('bar'), $builder->get('foo'), '->setAlias() creates a service that is an alias to another one');
try {
$builder->setAlias('foobar', 'foobar');
@ -286,8 +286,8 @@ class ContainerBuilderTest extends TestCase
$builder->setAliases(array('bar' => 'foo', 'foobar' => 'foo'));
$aliases = $builder->getAliases();
$this->assertTrue(isset($aliases['bar']));
$this->assertTrue(isset($aliases['foobar']));
$this->assertArrayHasKey('bar', $aliases);
$this->assertArrayHasKey('foobar', $aliases);
}
public function testAddAliases()
@ -297,8 +297,8 @@ class ContainerBuilderTest extends TestCase
$builder->addAliases(array('foobar' => 'foo'));
$aliases = $builder->getAliases();
$this->assertTrue(isset($aliases['bar']));
$this->assertTrue(isset($aliases['foobar']));
$this->assertArrayHasKey('bar', $aliases);
$this->assertArrayHasKey('foobar', $aliases);
}
public function testSetReplacesAlias()
@ -561,7 +561,7 @@ class ContainerBuilderTest extends TestCase
$this->assertEquals(array('service_container', 'foo', 'bar', 'baz'), array_keys($container->getDefinitions()), '->merge() merges definitions already defined ones');
$aliases = $container->getAliases();
$this->assertTrue(isset($aliases['alias_for_foo']));
$this->assertArrayHasKey('alias_for_foo', $aliases);
$this->assertEquals('foo', (string) $aliases['alias_for_foo']);
$container = new ContainerBuilder();
@ -891,7 +891,7 @@ class ContainerBuilderTest extends TestCase
$container->setResourceTracking(false);
$container->registerExtension($extension = new \ProjectExtension());
$this->assertTrue($container->getExtension('project') === $extension, '->registerExtension() registers an extension');
$this->assertSame($container->getExtension('project'), $extension, '->registerExtension() registers an extension');
$this->{method_exists($this, $_ = 'expectException') ? $_ : 'setExpectedException'}('LogicException');
$container->getExtension('no_registered');

26
src/Symfony/Component/DependencyInjection/Tests/Loader/XmlFileLoaderTest.php
View File

@ -99,7 +99,7 @@ class XmlFileLoaderTest extends TestCase
libxml_disable_entity_loader($disableEntities);
$this->assertTrue(count($containerBuilder->getParameterBag()->all()) > 0, 'Parameters can be read from the config file.');
$this->assertGreaterThan(0, $containerBuilder->getParameterBag()->all(), 'Parameters can be read from the config file.');
}
public function testLoadParameters()
@ -189,7 +189,7 @@ class XmlFileLoaderTest extends TestCase
$args = $services['foo']->getArguments();
$this->assertCount(1, $args, '->load() references anonymous services as "normal" ones');
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $args[0], '->load() converts anonymous services to references to "normal" services');
$this->assertTrue(isset($services[(string) $args[0]]), '->load() makes a reference to the created ones');
$this->assertArrayHasKey((string) $args[0], $services, '->load() makes a reference to the created ones');
$inner = $services[(string) $args[0]];
$this->assertEquals('BarClass', $inner->getClass(), '->load() uses the same configuration as for the anonymous ones');
$this->assertFalse($inner->isPublic());
@ -198,7 +198,7 @@ class XmlFileLoaderTest extends TestCase
$args = $inner->getArguments();
$this->assertCount(1, $args, '->load() references anonymous services as "normal" ones');
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $args[0], '->load() converts anonymous services to references to "normal" services');
$this->assertTrue(isset($services[(string) $args[0]]), '->load() makes a reference to the created ones');
$this->assertArrayHasKey((string) $args[0], $services, '->load() makes a reference to the created ones');
$inner = $services[(string) $args[0]];
$this->assertEquals('BazClass', $inner->getClass(), '->load() uses the same configuration as for the anonymous ones');
$this->assertFalse($inner->isPublic());
@ -207,7 +207,7 @@ class XmlFileLoaderTest extends TestCase
$properties = $services['foo']->getProperties();
$property = $properties['p'];
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $property, '->load() converts anonymous services to references to "normal" services');
$this->assertTrue(isset($services[(string) $property]), '->load() makes a reference to the created ones');
$this->assertArrayHasKey((string) $property, $services, '->load() makes a reference to the created ones');
$inner = $services[(string) $property];
$this->assertEquals('BuzClass', $inner->getClass(), '->load() uses the same configuration as for the anonymous ones');
$this->assertFalse($inner->isPublic());
@ -236,7 +236,7 @@ class XmlFileLoaderTest extends TestCase
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath.'/xml'));
$loader->load('services6.xml');
$services = $container->getDefinitions();
$this->assertTrue(isset($services['foo']), '->load() parses <service> elements');
$this->assertArrayHasKey('foo', $services, '->load() parses <service> elements');
$this->assertFalse($services['not_shared']->isShared(), '->load() parses shared flag');
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Definition', $services['foo'], '->load() converts <service> element to Definition instances');
$this->assertEquals('FooClass', $services['foo']->getClass(), '->load() parses the class attribute');
@ -253,10 +253,10 @@ class XmlFileLoaderTest extends TestCase
$this->assertSame(array(null, 'getInstance'), $services['new_factory4']->getFactory(), '->load() accepts factory tag without class');
$aliases = $container->getAliases();
$this->assertTrue(isset($aliases['alias_for_foo']), '->load() parses <service> elements');
$this->assertArrayHasKey('alias_for_foo', $aliases, '->load() parses <service> elements');
$this->assertEquals('foo', (string) $aliases['alias_for_foo'], '->load() parses aliases');
$this->assertTrue($aliases['alias_for_foo']->isPublic());
$this->assertTrue(isset($aliases['another_alias_for_foo']));
$this->assertArrayHasKey('another_alias_for_foo', $aliases);
$this->assertEquals('foo', (string) $aliases['another_alias_for_foo']);
$this->assertFalse($aliases['another_alias_for_foo']->isPublic());
@ -379,8 +379,8 @@ class XmlFileLoaderTest extends TestCase
$services = $container->getDefinitions();
$parameters = $container->getParameterBag()->all();
$this->assertTrue(isset($services['project.service.bar']), '->load() parses extension elements');
$this->assertTrue(isset($parameters['project.parameter.bar']), '->load() parses extension elements');
$this->assertArrayHasKey('project.service.bar', $services, '->load() parses extension elements');
$this->assertArrayHasKey('project.parameter.bar', $parameters, '->load() parses extension elements');
$this->assertEquals('BAR', $services['project.service.foo']->getClass(), '->load() parses extension elements');
$this->assertEquals('BAR', $parameters['project.parameter.foo'], '->load() parses extension elements');
@ -395,8 +395,8 @@ class XmlFileLoaderTest extends TestCase
$services = $container->getDefinitions();
$parameters = $container->getParameterBag()->all();
$this->assertTrue(isset($services['project.service.bar']), '->load() parses extension elements');
$this->assertTrue(isset($parameters['project.parameter.bar']), '->load() parses extension elements');
$this->assertArrayHasKey('project.service.bar', $services, '->load() parses extension elements');
$this->assertArrayHasKey('project.parameter.bar', $parameters, '->load() parses extension elements');
$this->assertEquals('BAR', $services['project.service.foo']->getClass(), '->load() parses extension elements');
$this->assertEquals('BAR', $parameters['project.parameter.foo'], '->load() parses extension elements');
@ -518,8 +518,8 @@ class XmlFileLoaderTest extends TestCase
$loader->load('namespaces.xml');
$services = $container->getDefinitions();
$this->assertTrue(isset($services['foo']), '->load() parses <srv:service> elements');
$this->assertEquals(1, count($services['foo']->getTag('foo.tag')), '->load parses <srv:tag> elements');
$this->assertArrayHasKey('foo', $services, '->load() parses <srv:service> elements');
$this->assertCount(1, $services['foo']->getTag('foo.tag'), '->load parses <srv:tag> elements');
$this->assertEquals(array(array('setBar', array('foo'))), $services['foo']->getMethodCalls(), '->load() parses the <srv:call> tag');
}

10
src/Symfony/Component/DependencyInjection/Tests/Loader/YamlFileLoaderTest.php
View File

@ -139,7 +139,7 @@ class YamlFileLoaderTest extends TestCase
$loader = new YamlFileLoader($container, new FileLocator(self::$fixturesPath.'/yaml'));
$loader->load('services6.yml');
$services = $container->getDefinitions();
$this->assertTrue(isset($services['foo']), '->load() parses service elements');
$this->assertArrayHasKey('foo', $services, '->load() parses service elements');
$this->assertFalse($services['not_shared']->isShared(), '->load() parses the shared flag');
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Definition', $services['foo'], '->load() converts service element to Definition instances');
$this->assertEquals('FooClass', $services['foo']->getClass(), '->load() parses the class attribute');
@ -157,10 +157,10 @@ class YamlFileLoaderTest extends TestCase
$this->assertEquals(array('foo', new Reference('baz')), $services['Acme\WithShortCutArgs']->getArguments(), '->load() parses short service definition');
$aliases = $container->getAliases();
$this->assertTrue(isset($aliases['alias_for_foo']), '->load() parses aliases');
$this->assertArrayHasKey('alias_for_foo', $aliases, '->load() parses aliases');
$this->assertEquals('foo', (string) $aliases['alias_for_foo'], '->load() parses aliases');
$this->assertTrue($aliases['alias_for_foo']->isPublic());
$this->assertTrue(isset($aliases['another_alias_for_foo']));
$this->assertArrayHasKey('another_alias_for_foo', $aliases);
$this->assertEquals('foo', (string) $aliases['another_alias_for_foo']);
$this->assertFalse($aliases['another_alias_for_foo']->isPublic());
$this->assertTrue(isset($aliases['another_third_alias_for_foo']));
@ -204,8 +204,8 @@ class YamlFileLoaderTest extends TestCase
$services = $container->getDefinitions();
$parameters = $container->getParameterBag()->all();
$this->assertTrue(isset($services['project.service.bar']), '->load() parses extension elements');
$this->assertTrue(isset($parameters['project.parameter.bar']), '->load() parses extension elements');
$this->assertArrayHasKey('project.service.bar', $services, '->load() parses extension elements');
$this->assertArrayHasKey('project.parameter.bar', $parameters, '->load() parses extension elements');
$this->assertEquals('BAR', $services['project.service.foo']->getClass(), '->load() parses extension elements');
$this->assertEquals('BAR', $parameters['project.parameter.foo'], '->load() parses extension elements');

2
src/Symfony/Component/DomCrawler/Tests/CrawlerTest.php
View File

@ -204,7 +204,7 @@ EOF
EOF
, 'UTF-8');
$this->assertTrue(count(libxml_get_errors()) > 1);
$this->assertGreaterThan(1, libxml_get_errors());
libxml_clear_errors();
libxml_use_internal_errors($internalErrors);

6
src/Symfony/Component/DomCrawler/Tests/FormTest.php
View File

@ -376,15 +376,15 @@ class FormTest extends TestCase
{
$form = $this->createForm('<form><input type="text" name="foo" value="foo" /><input type="submit" /></form>');
unset($form['foo']);
$this->assertFalse(isset($form['foo']), '->offsetUnset() removes a field');
$this->assertArrayNotHasKey('foo', $form, '->offsetUnset() removes a field');
}
public function testOffsetExists()
{
$form = $this->createForm('<form><input type="text" name="foo" value="foo" /><input type="submit" /></form>');
$this->assertTrue(isset($form['foo']), '->offsetExists() return true if the field exists');
$this->assertFalse(isset($form['bar']), '->offsetExists() return false if the field does not exist');
$this->assertArrayHasKey('foo', $form, '->offsetExists() return true if the field exists');
$this->assertArrayNotHasKey('bar', $form, '->offsetExists() return false if the field does not exist');
}
public function testGetValues()

2
src/Symfony/Component/EventDispatcher/Tests/ContainerAwareEventDispatcherTest.php
View File

@ -143,7 +143,7 @@ class ContainerAwareEventDispatcherTest extends AbstractEventDispatcherTest
$listeners = $dispatcher->getListeners();
$this->assertTrue(isset($listeners['onEvent']));
$this->assertArrayHasKey('onEvent', $listeners);
$this->assertCount(1, $dispatcher->getListeners('onEvent'));
}

4
src/Symfony/Component/EventDispatcher/Tests/GenericEventTest.php
View File

@ -114,8 +114,8 @@ class GenericEventTest extends TestCase
public function testOffsetIsset()
{
$this->assertTrue(isset($this->event['name']));
$this->assertFalse(isset($this->event['nameNotExist']));
$this->assertArrayHasKey('name', $this->event);
$this->assertArrayNotHasKey('nameNotExist', $this->event);
}
public function testHasArgument()

36
src/Symfony/Component/Filesystem/Tests/FilesystemTest.php
View File

@ -26,7 +26,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->copy($sourceFilePath, $targetFilePath);
$this->assertFileExists($targetFilePath);
$this->assertEquals('SOURCE FILE', file_get_contents($targetFilePath));
$this->assertStringEqualsFile($targetFilePath, 'SOURCE FILE');
}
/**
@ -73,7 +73,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->copy($sourceFilePath, $targetFilePath);
$this->assertFileExists($targetFilePath);
$this->assertEquals('SOURCE FILE', file_get_contents($targetFilePath));
$this->assertStringEqualsFile($targetFilePath, 'SOURCE FILE');
}
public function testCopyDoesNotOverrideExistingFileByDefault()
@ -92,7 +92,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->copy($sourceFilePath, $targetFilePath);
$this->assertFileExists($targetFilePath);
$this->assertEquals('TARGET FILE', file_get_contents($targetFilePath));
$this->assertStringEqualsFile($targetFilePath, 'TARGET FILE');
}
public function testCopyOverridesExistingFileIfForced()
@ -111,7 +111,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->copy($sourceFilePath, $targetFilePath, true);
$this->assertFileExists($targetFilePath);
$this->assertEquals('SOURCE FILE', file_get_contents($targetFilePath));
$this->assertStringEqualsFile($targetFilePath, 'SOURCE FILE');
}
/**
@ -153,7 +153,7 @@ class FilesystemTest extends FilesystemTestCase
$this->assertTrue(is_dir($targetFileDirectory));
$this->assertFileExists($targetFilePath);
$this->assertEquals('SOURCE FILE', file_get_contents($targetFilePath));
$this->assertStringEqualsFile($targetFilePath, 'SOURCE FILE');
}
/**
@ -169,7 +169,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->copy($sourceFilePath, $targetFilePath, false);
$this->assertFileExists($targetFilePath);
$this->assertEquals(file_get_contents($sourceFilePath), file_get_contents($targetFilePath));
$this->assertFileEquals($sourceFilePath, $targetFilePath);
}
public function testMkdirCreatesDirectoriesRecursively()
@ -840,9 +840,9 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->remove($link);
$this->assertTrue(!is_link($link));
$this->assertTrue(!is_file($link));
$this->assertTrue(!is_dir($link));
$this->assertFalse(is_link($link));
$this->assertFalse(is_file($link));
$this->assertFalse(is_dir($link));
}
public function testSymlinkIsOverwrittenIfPointsToDifferentTarget()
@ -1457,7 +1457,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->dumpFile($filename, 'bar');
$this->assertFileExists($filename);
$this->assertSame('bar', file_get_contents($filename));
$this->assertStringEqualsFile($filename, 'bar');
// skip mode check on Windows
if ('\\' !== DIRECTORY_SEPARATOR) {
@ -1474,7 +1474,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->dumpFile($filename, 'bar');
$this->assertFileExists($filename);
$this->assertSame('bar', file_get_contents($filename));
$this->assertStringEqualsFile($filename, 'bar');
}
public function testDumpFileWithFileScheme()
@ -1489,7 +1489,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->dumpFile($filename, 'bar');
$this->assertFileExists($filename);
$this->assertSame('bar', file_get_contents($filename));
$this->assertStringEqualsFile($filename, 'bar');
}
public function testDumpFileWithZlibScheme()
@ -1501,7 +1501,7 @@ class FilesystemTest extends FilesystemTestCase
// Zlib stat uses file:// wrapper so remove scheme
$this->assertFileExists(str_replace($scheme, '', $filename));
$this->assertSame('bar', file_get_contents($filename));
$this->assertStringEqualsFile($filename, 'bar');
}
public function testAppendToFile()
@ -1518,7 +1518,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->appendToFile($filename, 'bar');
$this->assertFileExists($filename);
$this->assertSame('foobar', file_get_contents($filename));
$this->assertStringEqualsFile($filename, 'bar');
// skip mode check on Windows
if ('\\' !== DIRECTORY_SEPARATOR) {
@ -1540,7 +1540,7 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->appendToFile($filename, 'bar');
$this->assertFileExists($filename);
$this->assertSame('foobar', file_get_contents($filename));
$this->assertStringEqualsFile($filename, 'foobar');
}
public function testAppendToFileWithZlibScheme()
@ -1550,12 +1550,12 @@ class FilesystemTest extends FilesystemTestCase
$this->filesystem->dumpFile($filename, 'foo');
// Zlib stat uses file:// wrapper so remove it
$this->assertSame('foo', file_get_contents(str_replace($scheme, '', $filename)));
$this->assertStringEqualsFile(str_replace($scheme, '', $filename), 'foo');
$this->filesystem->appendToFile($filename, 'bar');
$this->assertFileExists($filename);
$this->assertSame('foobar', file_get_contents($filename));
$this->assertStringEqualsFile($filename, 'foobar');
}
public function testAppendToFileCreateTheFileIfNotExists()
@ -1576,7 +1576,7 @@ class FilesystemTest extends FilesystemTestCase
}
$this->assertFileExists($filename);
$this->assertSame('bar', file_get_contents($filename));
$this->assertStringEqualsFile($filename, 'bar');
}
public function testDumpKeepsExistingPermissionsWhenOverwritingAnExistingFile()

4
src/Symfony/Component/Form/Tests/CompoundFormTest.php
View File

@ -308,12 +308,12 @@ class CompoundFormTest extends AbstractFormTest
$this->form[] = $child;
$this->assertTrue(isset($this->form['foo']));
$this->assertArrayHasKey('foo', $this->form);
$this->assertSame($child, $this->form['foo']);
unset($this->form['foo']);
$this->assertFalse(isset($this->form['foo']));
$this->assertArrayNotHasKey('foo', $this->form);
}
public function testCountable()

12
src/Symfony/Component/Form/Tests/Extension/Core/Type/ChoiceTypeTest.php
View File

@ -196,7 +196,7 @@ class ChoiceTypeTest extends BaseTypeTest
'choices' => $this->choices,
));
$this->assertTrue(isset($form['placeholder']));
$this->assertArrayHasKey('placeholder', $form);
$this->assertCount(count($this->choices) + 1, $form, 'Each choice should become a new field');
}
@ -209,7 +209,7 @@ class ChoiceTypeTest extends BaseTypeTest
'choices' => $this->choices,
));
$this->assertFalse(isset($form['placeholder']));
$this->assertArrayNotHasKey('placeholder', $form);
$this->assertCount(count($this->choices), $form, 'Each choice should become a new field');
}
@ -222,7 +222,7 @@ class ChoiceTypeTest extends BaseTypeTest
'choices' => $this->choices,
));
$this->assertFalse(isset($form['placeholder']));
$this->assertArrayNotHasKey('placeholder', $form);
$this->assertCount(count($this->choices), $form, 'Each choice should become a new field');
}
@ -238,7 +238,7 @@ class ChoiceTypeTest extends BaseTypeTest
),
));
$this->assertFalse(isset($form['placeholder']));
$this->assertArrayNotHasKey('placeholder', $form);
$this->assertCount(2, $form, 'Each choice should become a new field');
}
@ -295,7 +295,7 @@ class ChoiceTypeTest extends BaseTypeTest
'placeholder' => 'Select an option',
));
$this->assertTrue(isset($form['placeholder']), 'Placeholder should be set');
$this->assertArrayHasKey('placeholder', $form, 'Placeholder should be set');
$this->assertCount(3, $form, 'Each choice should become a new field, placeholder included');
$view = $form->createView();
@ -319,7 +319,7 @@ class ChoiceTypeTest extends BaseTypeTest
'placeholder' => 'Select an option',
));
$this->assertTrue(isset($form['placeholder']), 'Placeholder should be set');
$this->assertArrayHasKey('placeholder', $form, 'Placeholder should be set');
$this->assertCount(3, $form, 'Each choice should become a new field, placeholder included');
$view = $form->createView();

6
src/Symfony/Component/Form/Tests/Extension/Core/Type/CollectionTypeTest.php
View File

@ -48,7 +48,7 @@ class CollectionTypeTest extends BaseTypeTest
$form->setData(array('foo@baz.com'));
$this->assertInstanceOf('Symfony\Component\Form\Form', $form[0]);
$this->assertFalse(isset($form[1]));
$this->assertArrayNotHasKey(1, $form);
$this->assertCount(1, $form);
$this->assertEquals('foo@baz.com', $form[0]->getData());
$formAttrs0 = $form[0]->getConfig()->getOption('attr');
@ -227,7 +227,7 @@ class CollectionTypeTest extends BaseTypeTest
));
$data = $form->getData();
$this->assertFalse(isset($data['__name__']));
$this->assertArrayNotHasKey('__name__', $data);
}
public function testGetDataDoesNotContainsPrototypeNameAfterDataAreSet()
@ -240,7 +240,7 @@ class CollectionTypeTest extends BaseTypeTest
$form->setData(array('foobar.png'));
$data = $form->getData();
$this->assertFalse(isset($data['__name__']));
$this->assertArrayNotHasKey('__name__', $data);
}
public function testPrototypeNameOption()

6
src/Symfony/Component/Form/Tests/Extension/Core/Type/DateTimeTypeTest.php
View File

@ -419,7 +419,7 @@ class DateTimeTypeTest extends BaseTypeTest
))
->createView();
$this->assertFalse(isset($view->vars['type']));
$this->assertArrayNotHasKey('type', $view->vars);
}
public function testDontPassHtml5TypeIfNotHtml5Format()
@ -430,7 +430,7 @@ class DateTimeTypeTest extends BaseTypeTest
))
->createView();
$this->assertFalse(isset($view->vars['type']));
$this->assertArrayNotHasKey('type', $view->vars);
}
public function testDontPassHtml5TypeIfNotSingleText()
@ -440,7 +440,7 @@ class DateTimeTypeTest extends BaseTypeTest
))
->createView();
$this->assertFalse(isset($view->vars['type']));
$this->assertArrayNotHasKey('type', $view->vars);
}
public function testDateTypeChoiceErrorsBubbleUp()

8
src/Symfony/Component/Form/Tests/Extension/Core/Type/DateTypeTest.php
View File

@ -678,7 +678,7 @@ class DateTypeTest extends BaseTypeTest
))
->createView();
$this->assertFalse(isset($view->vars['date_pattern']));
$this->assertArrayNotHasKey('date_pattern', $view->vars);
}
public function testDatePatternFormatWithQuotedStrings()
@ -826,7 +826,7 @@ class DateTypeTest extends BaseTypeTest
))
->createView();
$this->assertFalse(isset($view->vars['type']));
$this->assertArrayNotHasKey('type', $view->vars);
}
public function testDontPassHtml5TypeIfNotHtml5Format()
@ -837,7 +837,7 @@ class DateTypeTest extends BaseTypeTest
))
->createView();
$this->assertFalse(isset($view->vars['type']));
$this->assertArrayNotHasKey('type', $view->vars);
}
public function testDontPassHtml5TypeIfNotSingleText()
@ -847,7 +847,7 @@ class DateTypeTest extends BaseTypeTest
))
->createView();
$this->assertFalse(isset($view->vars['type']));
$this->assertArrayNotHasKey('type', $view->vars);
}
public function provideCompoundWidgets()

2
src/Symfony/Component/Form/Tests/Extension/Core/Type/TimeTypeTest.php
View File

@ -536,7 +536,7 @@ class TimeTypeTest extends BaseTypeTest
));
$view = $form->createView();
$this->assertFalse(isset($view->vars['type']));
$this->assertArrayNotHasKey('type', $view->vars);
}
public function testPassDefaultPlaceholderToViewIfNotRequired()

10
src/Symfony/Component/Form/Tests/Extension/Csrf/Type/FormTypeCsrfExtensionTest.php
View File

@ -72,7 +72,7 @@ class FormTypeCsrfExtensionTest extends TypeTestCase
))
->createView();
$this->assertTrue(isset($view['csrf']));
$this->assertArrayHasKey('csrf', $view);
}
public function testNoCsrfProtectionByDefaultIfCompoundButNotRoot()
@ -89,7 +89,7 @@ class FormTypeCsrfExtensionTest extends TypeTestCase
->get('form')
->createView();
$this->assertFalse(isset($view['csrf']));
$this->assertArrayNotHasKey('csrf', $view);
}
public function testNoCsrfProtectionByDefaultIfRootButNotCompound()
@ -101,7 +101,7 @@ class FormTypeCsrfExtensionTest extends TypeTestCase
))
->createView();
$this->assertFalse(isset($view['csrf']));
$this->assertArrayNotHasKey('csrf', $view);
}
public function testCsrfProtectionCanBeDisabled()
@ -114,7 +114,7 @@ class FormTypeCsrfExtensionTest extends TypeTestCase
))
->createView();
$this->assertFalse(isset($view['csrf']));
$this->assertArrayNotHasKey('csrf', $view);
}
public function testGenerateCsrfToken()
@ -357,7 +357,7 @@ class FormTypeCsrfExtensionTest extends TypeTestCase
->createView()
->vars['prototype'];
$this->assertFalse(isset($prototypeView['csrf']));
$this->assertArrayNotHasKey('csrf', $prototypeView);
$this->assertCount(1, $prototypeView);
}

2
src/Symfony/Component/Form/Tests/Extension/Validator/ViolationMapper/ViolationPathTest.php
View File

@ -96,7 +96,7 @@ class ViolationPathTest extends TestCase
$path = new ViolationPath($string);
$this->assertSame($slicedPath, $path->__toString());
$this->assertSame(count($entries), count($path->getElements()));
$this->assertCount(count($entries), $path->getElements());
$this->assertSame(count($entries), $path->getLength());
foreach ($entries as $index => $entry) {

6
src/Symfony/Component/Form/Tests/Util/OrderedHashMapTest.php
View File

@ -91,14 +91,14 @@ class OrderedHashMapTest extends TestCase
$map = new OrderedHashMap();
$map['first'] = 1;
$this->assertTrue(isset($map['first']));
$this->assertArrayHasKey('first', $map);
}
public function testIssetReturnsFalseForNonExisting()
{
$map = new OrderedHashMap();
$this->assertFalse(isset($map['first']));
$this->assertArrayNotHasKey('first', $map);
}
public function testIssetReturnsFalseForNull()
@ -106,7 +106,7 @@ class OrderedHashMapTest extends TestCase
$map = new OrderedHashMap();
$map['first'] = null;
$this->assertFalse(isset($map['first']));
$this->assertArrayNotHasKey('first', $map);
}
public function testUnset()

2
src/Symfony/Component/HttpFoundation/Tests/HeaderBagTest.php
View File

@ -200,6 +200,6 @@ class HeaderBagTest extends TestCase
$headers = array('foo' => 'bar', 'HELLO' => 'WORLD');
$headerBag = new HeaderBag($headers);
$this->assertEquals(count($headers), count($headerBag));
$this->assertCount(count($headers), $headerBag);
}
}

2
src/Symfony/Component/HttpFoundation/Tests/ParameterBagTest.php
View File

@ -179,7 +179,7 @@ class ParameterBagTest extends TestCase
$parameters = array('foo' => 'bar', 'hello' => 'world');
$bag = new ParameterBag($parameters);
$this->assertEquals(count($parameters), count($bag));
$this->assertCount(count($parameters), $bag);
}
public function testGetBoolean()

18
src/Symfony/Component/HttpFoundation/Tests/ResponseHeaderBagTest.php
View File

@ -199,10 +199,10 @@ class ResponseHeaderBagTest extends TestCase
$cookies = $bag->getCookies(ResponseHeaderBag::COOKIES_ARRAY);
$this->assertTrue(isset($cookies['foo.bar']['/path/foo']['foo']));
$this->assertTrue(isset($cookies['foo.bar']['/path/bar']['foo']));
$this->assertTrue(isset($cookies['bar.foo']['/path/bar']['foo']));
$this->assertTrue(isset($cookies['']['/']['foo']));
$this->assertArrayHasKey('foo', $cookies['foo.bar']['/path/foo']));
$this->assertArrayHasKey('foo', $cookies['foo.bar']['/path/bar']));
$this->assertArrayHasKey('foo', $cookies['bar.foo']['/path/bar']));
$this->assertArrayHasKey('foo', $cookies['']['/']));
}
public function testRemoveCookie()
@ -215,19 +215,19 @@ class ResponseHeaderBagTest extends TestCase
$this->assertTrue($bag->has('set-cookie'));
$cookies = $bag->getCookies(ResponseHeaderBag::COOKIES_ARRAY);
$this->assertTrue(isset($cookies['foo.bar']['/path/foo']));
$this->assertArrayHasKey('/path/foo', $cookies['foo.bar']);
$bag->removeCookie('foo', '/path/foo', 'foo.bar');
$this->assertTrue($bag->has('set-cookie'));
$cookies = $bag->getCookies(ResponseHeaderBag::COOKIES_ARRAY);
$this->assertFalse(isset($cookies['foo.bar']['/path/foo']));
$this->assertArrayNotHasKey('/path/foo', $cookies['foo.bar']);
$bag->removeCookie('bar', '/path/bar', 'foo.bar');
$this->assertFalse($bag->has('set-cookie'));
$cookies = $bag->getCookies(ResponseHeaderBag::COOKIES_ARRAY);
$this->assertFalse(isset($cookies['foo.bar']));
$this->assertArrayNotHasKey('foo.bar', $cookies);
}
public function testRemoveCookieWithNullRemove()
@ -237,11 +237,11 @@ class ResponseHeaderBagTest extends TestCase
$bag->setCookie(new Cookie('bar', 'foo', 0));
$cookies = $bag->getCookies(ResponseHeaderBag::COOKIES_ARRAY);
$this->assertTrue(isset($cookies['']['/']));
$this->assertArrayHasKey('/', $cookies['']);
$bag->removeCookie('foo', null);
$cookies = $bag->getCookies(ResponseHeaderBag::COOKIES_ARRAY);
$this->assertFalse(isset($cookies['']['/']['foo']));
$this->assertArrayNotHasKey('foo', $cookies['']['/']);
$bag->removeCookie('bar', null);
$cookies = $bag->getCookies(ResponseHeaderBag::COOKIES_ARRAY);

8
src/Symfony/Component/HttpFoundation/Tests/ServerBagTest.php
View File

@ -74,8 +74,8 @@ class ServerBagTest extends TestCase
// Username and passwords should not be set as the header is bogus
$headers = $bag->getHeaders();
$this->assertFalse(isset($headers['PHP_AUTH_USER']));
$this->assertFalse(isset($headers['PHP_AUTH_PW']));
$this->assertArrayNotHasKey('PHP_AUTH_USER', $headers);
$this->assertArrayNotHasKey('PHP_AUTH_PW', $headers);
}
public function testHttpBasicAuthWithPhpCgiRedirect()
@ -118,8 +118,8 @@ class ServerBagTest extends TestCase
// Username and passwords should not be set as the header is bogus
$headers = $bag->getHeaders();
$this->assertFalse(isset($headers['PHP_AUTH_USER']));
$this->assertFalse(isset($headers['PHP_AUTH_PW']));
$this->assertArrayNotHasKey('PHP_AUTH_USER', $headers);
$this->assertArrayNotHasKey('PHP_AUTH_PW', $headers);
}
public function testHttpDigestAuthWithPhpCgiRedirect()

2
src/Symfony/Component/HttpFoundation/Tests/Session/Attribute/AttributeBagTest.php
View File

@ -181,6 +181,6 @@ class AttributeBagTest extends TestCase
public function testCount()
{
$this->assertEquals(count($this->array), count($this->bag));
$this->assertCount(count($this->array), $this->bag);
}
}

2
src/Symfony/Component/HttpFoundation/Tests/Session/Storage/NativeSessionStorageTest.php
View File

@ -227,7 +227,7 @@ class NativeSessionStorageTest extends TestCase
$this->assertFalse($storage->isStarted());
$key = $storage->getMetadataBag()->getStorageKey();
$this->assertFalse(isset($_SESSION[$key]));
$this->assertArrayNotHasKey($key, $_SESSION);
$storage->start();
}

4
src/Symfony/Component/HttpFoundation/Tests/Session/Storage/PhpBridgeSessionStorageTest.php
View File

@ -75,9 +75,9 @@ class PhpBridgeSessionStorageTest extends TestCase
$this->assertFalse($storage->isStarted());
$key = $storage->getMetadataBag()->getStorageKey();
$this->assertFalse(isset($_SESSION[$key]));
$this->assertArrayNotHasKey($key, $_SESSION);
$storage->start();
$this->assertTrue(isset($_SESSION[$key]));
$this->assertArrayHasKey($key, $_SESSION);
}
public function testClear()

2
src/Symfony/Component/HttpKernel/Tests/DataCollector/DumpDataCollectorTest.php
View File

@ -35,7 +35,7 @@ class DumpDataCollectorTest extends TestCase
$this->assertSame(1, $collector->getDumpsCount());
$dump = $collector->getDumps('html');
$this->assertTrue(isset($dump[0]['data']));
$this->assertArrayHasKey('data', $dump[0]);
$dump[0]['data'] = preg_replace('/^.*?<pre/', '<pre', $dump[0]['data']);
$dump[0]['data'] = preg_replace('/sf-dump-\d+/', 'sf-dump', $dump[0]['data']);

18
src/Symfony/Component/HttpKernel/Tests/HttpCache/HttpCacheTest.php
View File

@ -530,8 +530,8 @@ class HttpCacheTest extends HttpCacheTestCase
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTrue(strtotime($this->responses[0]->headers->get('Date')) - strtotime($this->response->headers->get('Date')) < 2);
$this->assertTrue($this->response->headers->get('Age') > 0);
$this->assertLessThan(2, strtotime($this->responses[0]->headers->get('Date')) - strtotime($this->response->headers->get('Date')));
$this->assertGreaterThan(0, $this->response->headers->get('Age'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
@ -554,8 +554,8 @@ class HttpCacheTest extends HttpCacheTestCase
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTrue(strtotime($this->responses[0]->headers->get('Date')) - strtotime($this->response->headers->get('Date')) < 2);
$this->assertTrue($this->response->headers->get('Age') > 0);
$this->assertLessThan(2, strtotime($this->responses[0]->headers->get('Date')) - strtotime($this->response->headers->get('Date')));
$this->assertGreaterThan(0, $this->response->headers->get('Age'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
@ -618,8 +618,8 @@ class HttpCacheTest extends HttpCacheTestCase
$this->request('GET', '/');
$this->assertHttpKernelIsNotCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTrue(strtotime($this->responses[0]->headers->get('Date')) - strtotime($this->response->headers->get('Date')) < 2);
$this->assertTrue($this->response->headers->get('Age') > 0);
$this->assertLessThan(2, strtotime($this->responses[0]->headers->get('Date')) - strtotime($this->response->headers->get('Date')));
$this->assertGreaterThan(0, $this->response->headers->get('Age'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('fresh');
$this->assertTraceNotContains('store');
@ -793,7 +793,7 @@ class HttpCacheTest extends HttpCacheTestCase
$this->request('GET', '/');
$this->assertHttpKernelIsCalled();
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertTrue($this->response->headers->get('Age') <= 1);
$this->assertLessThanOrEqual(1, $this->response->headers->get('Age'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTraceContains('stale');
$this->assertTraceNotContains('fresh');
@ -831,7 +831,7 @@ class HttpCacheTest extends HttpCacheTestCase
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('Last-Modified'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTrue($this->response->headers->get('Age') <= 1);
$this->assertLessThanOrEqual(1, $this->response->headers->get('Age'));
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('stale');
$this->assertTraceContains('valid');
@ -881,7 +881,7 @@ class HttpCacheTest extends HttpCacheTestCase
$this->assertEquals(200, $this->response->getStatusCode());
$this->assertNotNull($this->response->headers->get('ETag'));
$this->assertNotNull($this->response->headers->get('X-Content-Digest'));
$this->assertTrue($this->response->headers->get('Age') <= 1);
$this->assertLessThanOrEqual(1, $this->response->headers->get('Age'));
$this->assertEquals('Hello World', $this->response->getContent());
$this->assertTraceContains('stale');
$this->assertTraceContains('valid');

2
src/Symfony/Component/HttpKernel/Tests/UriSignerTest.php
View File

@ -36,7 +36,7 @@ class UriSignerTest extends TestCase
$this->assertTrue($signer->check($signer->sign('http://example.com/foo?foo=bar')));
$this->assertTrue($signer->check($signer->sign('http://example.com/foo?foo=bar&0=integer')));
$this->assertTrue($signer->sign('http://example.com/foo?foo=bar&bar=foo') === $signer->sign('http://example.com/foo?bar=foo&foo=bar'));
$this->assertSame($signer->sign('http://example.com/foo?foo=bar&bar=foo'), $signer->sign('http://example.com/foo?bar=foo&foo=bar'));
}
public function testCheckWithDifferentArgSeparator()

12
src/Symfony/Component/Intl/Tests/Data/Bundle/Reader/IntlBundleReaderTest.php
View File

@ -36,7 +36,7 @@ class IntlBundleReaderTest extends TestCase
$this->assertInstanceOf('\ArrayAccess', $data);
$this->assertSame('Bar', $data['Foo']);
$this->assertFalse(isset($data['ExistsNot']));
$this->assertArrayNotHasKey('ExistsNot', $data);
}
public function testReadFollowsAlias()
@ -46,7 +46,7 @@ class IntlBundleReaderTest extends TestCase
$this->assertInstanceOf('\ArrayAccess', $data);
$this->assertSame('Bar', $data['Foo']);
$this->assertFalse(isset($data['ExistsNot']));
$this->assertArrayNotHasKey('ExistsNot', $data);
}
public function testReadDoesNotFollowFallback()
@ -60,9 +60,9 @@ class IntlBundleReaderTest extends TestCase
$this->assertInstanceOf('\ArrayAccess', $data);
$this->assertSame('Bam', $data['Baz']);
$this->assertFalse(isset($data['Foo']));
$this->assertArrayNotHasKey('Foo', $data);
$this->assertNull($data['Foo']);
$this->assertFalse(isset($data['ExistsNot']));
$this->assertArrayNotHasKey('ExistsNot', $data);
}
public function testReadDoesNotFollowFallbackAlias()
@ -76,9 +76,9 @@ class IntlBundleReaderTest extends TestCase
$this->assertInstanceOf('\ArrayAccess', $data);
$this->assertSame('Bam', $data['Baz'], 'data from the aliased locale can be accessed');
$this->assertFalse(isset($data['Foo']));
$this->assertArrayNotHasKey('Foo', $data);
$this->assertNull($data['Foo']);
$this->assertFalse(isset($data['ExistsNot']));
$this->assertArrayNotHasKey('ExistsNot', $data);
}
/**

2
src/Symfony/Component/Intl/Tests/Data/Bundle/Reader/JsonBundleReaderTest.php
View File

@ -35,7 +35,7 @@ class JsonBundleReaderTest extends TestCase
$this->assertInternalType('array', $data);
$this->assertSame('Bar', $data['Foo']);
$this->assertFalse(isset($data['ExistsNot']));
$this->assertArrayNotHasKey('ExistsNot', $data);
}
/**

2
src/Symfony/Component/Intl/Tests/Data/Bundle/Reader/PhpBundleReaderTest.php
View File

@ -35,7 +35,7 @@ class PhpBundleReaderTest extends TestCase
$this->assertInternalType('array', $data);
$this->assertSame('Bar', $data['Foo']);
$this->assertFalse(isset($data['ExistsNot']));
$this->assertArrayNotHasKey('ExistsNot', $data);
}
/**

16
src/Symfony/Component/Intl/Tests/Data/Util/RingBufferTest.php
View File

@ -34,8 +34,8 @@ class RingBufferTest extends TestCase
$this->buffer[0] = 'foo';
$this->buffer['bar'] = 'baz';
$this->assertTrue(isset($this->buffer[0]));
$this->assertTrue(isset($this->buffer['bar']));
$this->assertArrayHasKey(0, $this->buffer);
$this->assertArrayHasKey('bar', $this->buffer);
$this->assertSame('foo', $this->buffer[0]);
$this->assertSame('baz', $this->buffer['bar']);
}
@ -46,8 +46,8 @@ class RingBufferTest extends TestCase
$this->buffer['bar'] = 'baz';
$this->buffer[2] = 'bam';
$this->assertTrue(isset($this->buffer['bar']));
$this->assertTrue(isset($this->buffer[2]));
$this->assertArrayHasKey('bar', $this->buffer);
$this->assertArrayHasKey(2, $this->buffer);
$this->assertSame('baz', $this->buffer['bar']);
$this->assertSame('bam', $this->buffer[2]);
}
@ -62,14 +62,14 @@ class RingBufferTest extends TestCase
public function testQueryNonExisting()
{
$this->assertFalse(isset($this->buffer['foo']));
$this->assertArrayNotHasKey('foo', $this->buffer);
}
public function testUnsetNonExistingSucceeds()
{
unset($this->buffer['foo']);
$this->assertFalse(isset($this->buffer['foo']));
$this->assertArrayNotHasKey('foo', $this->buffer);
}
/**
@ -86,7 +86,7 @@ class RingBufferTest extends TestCase
public function testQueryOverwritten()
{
$this->assertFalse(isset($this->buffer[0]));
$this->assertArrayNotHasKey(0, $this->buffer);
}
public function testUnsetOverwrittenSucceeds()
@ -97,6 +97,6 @@ class RingBufferTest extends TestCase
unset($this->buffer[0]);
$this->assertFalse(isset($this->buffer[0]));
$this->assertArrayNotHasKey(0, $this->buffer);
}
}

12
src/Symfony/Component/OptionsResolver/Tests/OptionsResolverTest.php
View File

@ -1419,12 +1419,12 @@ class OptionsResolverTest extends TestCase
});
$this->resolver->setDefault('lazy2', function (Options $options) {
Assert::assertTrue(isset($options['default1']));
Assert::assertTrue(isset($options['default2']));
Assert::assertTrue(isset($options['required']));
Assert::assertTrue(isset($options['lazy1']));
Assert::assertTrue(isset($options['lazy2']));
Assert::assertFalse(isset($options['defined']));
Assert::assertArrayHasKey('default1', $options);
Assert::assertArrayHasKey('default2', $options);
Assert::assertArrayHasKey('required', $options);
Assert::assertArrayHasKey('lazy1', $options);
Assert::assertArrayHasKey('lazy2', $options);
Assert::assertArrayNotHasKey('defined', $options);
Assert::assertSame(0, $options['default1']);
Assert::assertSame(42, $options['default2']);

2
src/Symfony/Component/Process/Tests/ProcessTest.php
View File

@ -557,7 +557,7 @@ class ProcessTest extends TestCase
{
$process = $this->getProcess('echo foo');
$process->run();
$this->assertTrue(strlen($process->getOutput()) > 0);
$this->assertGreaterThan(0, strlen($process->getOutput()));
}
public function testGetExitCodeIsNullOnStart()

6
src/Symfony/Component/Security/Core/Tests/Authorization/AuthorizationCheckerTest.php
View File

@ -61,9 +61,9 @@ class AuthorizationCheckerTest extends TestCase
->will($this->returnValue(true));
// first run the token has not been re-authenticated yet, after isGranted is called, it should be equal
$this->assertFalse($newToken === $this->tokenStorage->getToken());
$this->assertNotSame($newToken, $this->tokenStorage->getToken());
$this->assertTrue($this->authorizationChecker->isGranted('foo'));
$this->assertTrue($newToken === $this->tokenStorage->getToken());
$this->assertSame($newToken, $this->tokenStorage->getToken());
}
/**
@ -90,7 +90,7 @@ class AuthorizationCheckerTest extends TestCase
->method('decide')
->will($this->returnValue($decide));
$this->tokenStorage->setToken($token);
$this->assertTrue($decide === $this->authorizationChecker->isGranted('ROLE_FOO'));
$this->assertSame($decide, $this->authorizationChecker->isGranted('ROLE_FOO'));
}
public function isGrantedProvider()

2
src/Symfony/Component/Templating/Tests/Helper/HelperTest.php
View File

@ -20,7 +20,7 @@ class HelperTest extends TestCase
{
$helper = new ProjectTemplateHelper();
$helper->setCharset('ISO-8859-1');
$this->assertTrue('ISO-8859-1' === $helper->getCharset(), '->setCharset() sets the charset set related to this helper');
$this->assertSame('ISO-8859-1', $helper->getCharset(), '->setCharset() sets the charset set related to this helper');
}
}

2
src/Symfony/Component/Templating/Tests/Loader/CacheLoaderTest.php
View File

@ -23,7 +23,7 @@ class CacheLoaderTest extends TestCase
public function testConstructor()
{
$loader = new ProjectTemplateLoader($varLoader = new ProjectTemplateLoaderVar(), sys_get_temp_dir());
$this->assertTrue($loader->getLoader() === $varLoader, '__construct() takes a template loader as its first argument');
$this->assertSame($loader->getLoader(), $varLoader, '__construct() takes a template loader as its first argument');
$this->assertEquals(sys_get_temp_dir(), $loader->getDir(), '__construct() takes a directory where to store the cache as its second argument');
}

4
src/Symfony/Component/Templating/Tests/PhpEngineTest.php
View File

@ -65,7 +65,7 @@ class PhpEngineTest extends TestCase
$engine[$foo] = 'bar';
$this->assertEquals($foo, $engine->get('bar'), '->set() takes an alias as a second argument');
$this->assertTrue(isset($engine['bar']));
$this->assertArrayHasKey('bar', $engine);
try {
$engine->get('foobar');
@ -75,7 +75,7 @@ class PhpEngineTest extends TestCase
$this->assertEquals('The helper "foobar" is not defined.', $e->getMessage(), '->get() throws an InvalidArgumentException if the helper is not defined');
}
$this->assertTrue(isset($engine['bar']));
$this->assertArrayHasKey('bar', $engine);
$this->assertTrue($engine->has('foo'), '->has() returns true if the helper exists');
$this->assertFalse($engine->has('foobar'), '->has() returns false if the helper does not exist');
}

6
src/Symfony/Component/Validator/Tests/ConstraintViolationListTest.php
View File

@ -89,16 +89,16 @@ class ConstraintViolationListTest extends TestCase
$this->list[] = $violation;
$this->assertSame($violation, $this->list[0]);
$this->assertTrue(isset($this->list[0]));
$this->assertArrayHasKey(0, $this->list);
unset($this->list[0]);
$this->assertFalse(isset($this->list[0]));
$this->assertArrayNotHasKey(0, $this->list);
$this->list[10] = $violation;
$this->assertSame($violation, $this->list[10]);
$this->assertTrue(isset($this->list[10]));
$this->assertArrayHasKey(10, $this->list);
}
public function testToString()