comparison vendor/symfony/event-dispatcher/Tests/AbstractEventDispatcherTest.php @ 17:129ea1e6d783

Update, including to Drupal core 8.6.10

 
     abstract protected function createEventDispatcher();
 
     public function testInitialState()
     {
-        $this->assertEquals(array(), $this->dispatcher->getListeners());
+        $this->assertEquals([], $this->dispatcher->getListeners());
         $this->assertFalse($this->dispatcher->hasListeners(self::preFoo));
         $this->assertFalse($this->dispatcher->hasListeners(self::postFoo));
     }
 
     public function testAddListener()
     {
-        $this->dispatcher->addListener('pre.foo', array($this->listener, 'preFoo'));
-        $this->dispatcher->addListener('post.foo', array($this->listener, 'postFoo'));
+        $this->dispatcher->addListener('pre.foo', [$this->listener, 'preFoo']);
+        $this->dispatcher->addListener('post.foo', [$this->listener, 'postFoo']);
         $this->assertTrue($this->dispatcher->hasListeners());
         $this->assertTrue($this->dispatcher->hasListeners(self::preFoo));
         $this->assertTrue($this->dispatcher->hasListeners(self::postFoo));
         $this->assertCount(1, $this->dispatcher->getListeners(self::preFoo));
         $this->assertCount(1, $this->dispatcher->getListeners(self::postFoo));

         $listener3 = new TestEventListener();
         $listener1->name = '1';
         $listener2->name = '2';
         $listener3->name = '3';
 
-        $this->dispatcher->addListener('pre.foo', array($listener1, 'preFoo'), -10);
-        $this->dispatcher->addListener('pre.foo', array($listener2, 'preFoo'), 10);
-        $this->dispatcher->addListener('pre.foo', array($listener3, 'preFoo'));
-
-        $expected = array(
-            array($listener2, 'preFoo'),
-            array($listener3, 'preFoo'),
-            array($listener1, 'preFoo'),
-        );
+        $this->dispatcher->addListener('pre.foo', [$listener1, 'preFoo'], -10);
+        $this->dispatcher->addListener('pre.foo', [$listener2, 'preFoo'], 10);
+        $this->dispatcher->addListener('pre.foo', [$listener3, 'preFoo']);
+
+        $expected = [
+            [$listener2, 'preFoo'],
+            [$listener3, 'preFoo'],
+            [$listener1, 'preFoo'],
+        ];
 
         $this->assertSame($expected, $this->dispatcher->getListeners('pre.foo'));
     }
 
     public function testGetAllListenersSortsByPriority()

         $this->dispatcher->addListener('pre.foo', $listener3, 10);
         $this->dispatcher->addListener('post.foo', $listener4, -10);
         $this->dispatcher->addListener('post.foo', $listener5);
         $this->dispatcher->addListener('post.foo', $listener6, 10);
 
-        $expected = array(
-            'pre.foo' => array($listener3, $listener2, $listener1),
-            'post.foo' => array($listener6, $listener5, $listener4),
-        );
+        $expected = [
+            'pre.foo' => [$listener3, $listener2, $listener1],
+            'post.foo' => [$listener6, $listener5, $listener4],
+        ];
 
         $this->assertSame($expected, $this->dispatcher->getListeners());
     }
 
     public function testGetListenerPriority()

         $this->assertNull($this->dispatcher->getListenerPriority('pre.foo', function () {}));
     }
 
     public function testDispatch()
     {
-        $this->dispatcher->addListener('pre.foo', array($this->listener, 'preFoo'));
-        $this->dispatcher->addListener('post.foo', array($this->listener, 'postFoo'));
+        $this->dispatcher->addListener('pre.foo', [$this->listener, 'preFoo']);
+        $this->dispatcher->addListener('post.foo', [$this->listener, 'postFoo']);
         $this->dispatcher->dispatch(self::preFoo);
         $this->assertTrue($this->listener->preFooInvoked);
         $this->assertFalse($this->listener->postFooInvoked);
         $this->assertInstanceOf('Symfony\Component\EventDispatcher\Event', $this->dispatcher->dispatch('noevent'));
         $this->assertInstanceOf('Symfony\Component\EventDispatcher\Event', $this->dispatcher->dispatch(self::preFoo));

         $otherListener = new TestEventListener();
 
         // postFoo() stops the propagation, so only one listener should
         // be executed
         // Manually set priority to enforce $this->listener to be called first
-        $this->dispatcher->addListener('post.foo', array($this->listener, 'postFoo'), 10);
-        $this->dispatcher->addListener('post.foo', array($otherListener, 'postFoo'));
+        $this->dispatcher->addListener('post.foo', [$this->listener, 'postFoo'], 10);
+        $this->dispatcher->addListener('post.foo', [$otherListener, 'postFoo']);
         $this->dispatcher->dispatch(self::postFoo);
         $this->assertTrue($this->listener->postFooInvoked);
         $this->assertFalse($otherListener->postFooInvoked);
     }
 
     public function testDispatchByPriority()
     {
-        $invoked = array();
+        $invoked = [];
         $listener1 = function () use (&$invoked) {
             $invoked[] = '1';
         };
         $listener2 = function () use (&$invoked) {
             $invoked[] = '2';

         };
         $this->dispatcher->addListener('pre.foo', $listener1, -10);
         $this->dispatcher->addListener('pre.foo', $listener2);
         $this->dispatcher->addListener('pre.foo', $listener3, 10);
         $this->dispatcher->dispatch(self::preFoo);
-        $this->assertEquals(array('3', '2', '1'), $invoked);
+        $this->assertEquals(['3', '2', '1'], $invoked);
     }
 
     public function testRemoveListener()
     {
         $this->dispatcher->addListener('pre.bar', $this->listener);

     }
 
     public function testEventReceivesTheDispatcherInstanceAsArgument()
     {
         $listener = new TestWithDispatcher();
-        $this->dispatcher->addListener('test', array($listener, 'foo'));
+        $this->dispatcher->addListener('test', [$listener, 'foo']);
         $this->assertNull($listener->name);
         $this->assertNull($listener->dispatcher);
         $this->dispatcher->dispatch('test');
         $this->assertEquals('test', $listener->name);
         $this->assertSame($this->dispatcher, $listener->dispatcher);

     public function testGetListenersWhenAddedCallbackListenerIsRemoved()
     {
         $listener = function () {};
         $this->dispatcher->addListener('foo', $listener);
         $this->dispatcher->removeListener('foo', $listener);
-        $this->assertSame(array(), $this->dispatcher->getListeners());
+        $this->assertSame([], $this->dispatcher->getListeners());
     }
 
     public function testHasListenersWithoutEventsReturnsFalseAfterHasListenersWithEventHasBeenCalled()
     {
         $this->assertFalse($this->dispatcher->hasListeners('foo'));

     }
 
     public function testHasListenersIsLazy()
     {
         $called = 0;
-        $listener = array(function () use (&$called) { ++$called; }, 'onFoo');
+        $listener = [function () use (&$called) { ++$called; }, 'onFoo'];
         $this->dispatcher->addListener('foo', $listener);
         $this->assertTrue($this->dispatcher->hasListeners());
         $this->assertTrue($this->dispatcher->hasListeners('foo'));
         $this->assertSame(0, $called);
     }

         $factory = function () use (&$called) {
             ++$called;
 
             return new TestWithDispatcher();
         };
-        $this->dispatcher->addListener('foo', array($factory, 'foo'));
+        $this->dispatcher->addListener('foo', [$factory, 'foo']);
         $this->assertSame(0, $called);
         $this->dispatcher->dispatch('foo', new Event());
         $this->dispatcher->dispatch('foo', new Event());
         $this->assertSame(1, $called);
     }

     public function testRemoveFindsLazyListeners()
     {
         $test = new TestWithDispatcher();
         $factory = function () use ($test) { return $test; };
 
-        $this->dispatcher->addListener('foo', array($factory, 'foo'));
+        $this->dispatcher->addListener('foo', [$factory, 'foo']);
         $this->assertTrue($this->dispatcher->hasListeners('foo'));
-        $this->dispatcher->removeListener('foo', array($test, 'foo'));
+        $this->dispatcher->removeListener('foo', [$test, 'foo']);
         $this->assertFalse($this->dispatcher->hasListeners('foo'));
 
-        $this->dispatcher->addListener('foo', array($test, 'foo'));
+        $this->dispatcher->addListener('foo', [$test, 'foo']);
         $this->assertTrue($this->dispatcher->hasListeners('foo'));
-        $this->dispatcher->removeListener('foo', array($factory, 'foo'));
+        $this->dispatcher->removeListener('foo', [$factory, 'foo']);
         $this->assertFalse($this->dispatcher->hasListeners('foo'));
     }
 
     public function testPriorityFindsLazyListeners()
     {
         $test = new TestWithDispatcher();
         $factory = function () use ($test) { return $test; };
 
-        $this->dispatcher->addListener('foo', array($factory, 'foo'), 3);
-        $this->assertSame(3, $this->dispatcher->getListenerPriority('foo', array($test, 'foo')));
-        $this->dispatcher->removeListener('foo', array($factory, 'foo'));
-
-        $this->dispatcher->addListener('foo', array($test, 'foo'), 5);
-        $this->assertSame(5, $this->dispatcher->getListenerPriority('foo', array($factory, 'foo')));
+        $this->dispatcher->addListener('foo', [$factory, 'foo'], 3);
+        $this->assertSame(3, $this->dispatcher->getListenerPriority('foo', [$test, 'foo']));
+        $this->dispatcher->removeListener('foo', [$factory, 'foo']);
+
+        $this->dispatcher->addListener('foo', [$test, 'foo'], 5);
+        $this->assertSame(5, $this->dispatcher->getListenerPriority('foo', [$factory, 'foo']));
     }
 
     public function testGetLazyListeners()
     {
         $test = new TestWithDispatcher();
         $factory = function () use ($test) { return $test; };
 
-        $this->dispatcher->addListener('foo', array($factory, 'foo'), 3);
-        $this->assertSame(array(array($test, 'foo')), $this->dispatcher->getListeners('foo'));
-
-        $this->dispatcher->removeListener('foo', array($test, 'foo'));
-        $this->dispatcher->addListener('bar', array($factory, 'foo'), 3);
-        $this->assertSame(array('bar' => array(array($test, 'foo'))), $this->dispatcher->getListeners());
+        $this->dispatcher->addListener('foo', [$factory, 'foo'], 3);
+        $this->assertSame([[$test, 'foo']], $this->dispatcher->getListeners('foo'));
+
+        $this->dispatcher->removeListener('foo', [$test, 'foo']);
+        $this->dispatcher->addListener('bar', [$factory, 'foo'], 3);
+        $this->assertSame(['bar' => [[$test, 'foo']]], $this->dispatcher->getListeners());
     }
 }
 
 class CallableClass
 {

 
 class TestEventSubscriber implements EventSubscriberInterface
 {
     public static function getSubscribedEvents()
     {
-        return array('pre.foo' => 'preFoo', 'post.foo' => 'postFoo');
+        return ['pre.foo' => 'preFoo', 'post.foo' => 'postFoo'];
     }
 }
 
 class TestEventSubscriberWithPriorities implements EventSubscriberInterface
 {
     public static function getSubscribedEvents()
     {
-        return array(
-            'pre.foo' => array('preFoo', 10),
-            'post.foo' => array('postFoo'),
-            );
+        return [
+            'pre.foo' => ['preFoo', 10],
+            'post.foo' => ['postFoo'],
+        ];
     }
 }
 
 class TestEventSubscriberWithMultipleListeners implements EventSubscriberInterface
 {
     public static function getSubscribedEvents()
     {
-        return array('pre.foo' => array(
-            array('preFoo1'),
-            array('preFoo2', 10),
-        ));
-    }
-}
+        return ['pre.foo' => [
+            ['preFoo1'],
+            ['preFoo2', 10],
+        ]];
+    }
+}