cross-solution / YAWIK

module/Core/test/CoreTest/Factory/EventManager/EventManagerAbstractFactory/AttachListenersTest.php

Indentation +72 added lines, -72 removed lines

@@ -45,13 +45,13 @@ 
     public function setUp()
     {
         $this->target = $this->getMockBuilder('\Core\Factory\EventManager\EventManagerAbstractFactory')
-                             ->setMethods([ 'createEventManager', 'getConfig' ])
-                             ->getMock();
+                                ->setMethods([ 'createEventManager', 'getConfig' ])
+                                ->getMock();
 
         $events = $this->getMockBuilder('\Zend\EventManager\EventManager')
-                       ->disableOriginalConstructor()
-                       ->setMethods(['attach'])
-                       ->getMock();
+                        ->disableOriginalConstructor()
+                        ->setMethods(['attach'])
+                        ->getMock();
 
         $this->target->expects($this->once())->method('createEventManager')->willReturn($events);
         $this->events = $events;
@@ -67,8 +67,8 @@ 
     protected function getServiceManagerMock($listeners, $expectLazyListeners = false)
     {
         $services = $this->getMockBuilder('\Zend\ServiceManager\ServiceManager')
-                         ->disableOriginalConstructor()
-                         ->getMock();
+                            ->disableOriginalConstructor()
+                            ->getMock();
 
 
         $hasMap = [ ];
@@ -96,13 +96,13 @@ 
         }
 
         $services->expects($this->atLeast(count($hasMap)))
-	        ->method('has')
-	        ->will($this->returnValueMap($hasMap))
+            ->method('has')
+            ->will($this->returnValueMap($hasMap))
         ;
 
         $services->expects($this->exactly(count($getMap)))
-                 ->method('get')
-                 ->will($this->returnValueMap($getMap))
+                    ->method('get')
+                    ->will($this->returnValueMap($getMap))
         ;
 
         return $services;
@@ -143,10 +143,10 @@ 
     public function testCreatesListenersInstances()
     {
         $this->setTargetListenerConfig(
-        	['\CoreTest\Factory\EventManager\EventManagerAbstractFactory\AttachListenerTestListenerMock' => ['test-event','doSomething',1]]
+            ['\CoreTest\Factory\EventManager\EventManagerAbstractFactory\AttachListenerTestListenerMock' => ['test-event','doSomething',1]]
         );
         $services = $this->getServiceManagerMock([
-        	'\CoreTest\Factory\EventManager\EventManagerAbstractFactory\AttachListenerTestListenerMock' => false
+            '\CoreTest\Factory\EventManager\EventManagerAbstractFactory\AttachListenerTestListenerMock' => false
         ]);
 
         $this->target->createServiceWithName($services, 'irrelevant', 'irrelevant');
@@ -162,36 +162,36 @@ 
         $this->target->createServiceWithName($services, 'irr', 'relevant');
     }
 	
-	public function testCallsAttachOnListenerAggregates()
-	{
-		$aggregateMock = $this->getMockBuilder('\Zend\EventManager\ListenerAggregateInterface')
-		                      ->getMockForAbstractClass();
-		$aggregateMock->expects($this->exactly(2))->method('attach')->withConsecutive([ $this->events, 1], [$this->events, -100]);
+    public function testCallsAttachOnListenerAggregates()
+    {
+        $aggregateMock = $this->getMockBuilder('\Zend\EventManager\ListenerAggregateInterface')
+                                ->getMockForAbstractClass();
+        $aggregateMock->expects($this->exactly(2))->method('attach')->withConsecutive([ $this->events, 1], [$this->events, -100]);
 		
-		$this->setTargetListenerConfig(['TestAggregate', 'TestAggregate2' => -100]);
-		$services = $this->getServiceManagerMock(['TestAggregate' => $aggregateMock, 'TestAggregate2' => $aggregateMock]);
+        $this->setTargetListenerConfig(['TestAggregate', 'TestAggregate2' => -100]);
+        $services = $this->getServiceManagerMock(['TestAggregate' => $aggregateMock, 'TestAggregate2' => $aggregateMock]);
 		
-		$this->target->createServiceWithName($services, 'no', 'no');
-	}
+        $this->target->createServiceWithName($services, 'no', 'no');
+    }
 
     public function testAttachsListenerToEventManager()
     {
         $listenerMock = new AttachListenerTestListenerMock();
         $this->setTargetListenerConfig([
-        	'TestListener1' => ['test-event1','doSomething',1],
-	        'TestListener2' => ['test-event2','doSomething',2]
+            'TestListener1' => ['test-event1','doSomething',1],
+            'TestListener2' => ['test-event2','doSomething',2]
         ]);
         $services = $this->getServiceManagerMock([
-        	'TestListener1' => $listenerMock,
-	        'TestListener2' => $listenerMock
+            'TestListener1' => $listenerMock,
+            'TestListener2' => $listenerMock
         ]);
         $this->events
-	        ->expects($this->exactly(2))
-	        ->method('attach')
-	        ->withConsecutive(
-	        	['test-event1', [$listenerMock,'doSomething'], 1 ],
-		        ['test-event2', [$listenerMock, 'doSomething'], 2 ]
-	        )
+            ->expects($this->exactly(2))
+            ->method('attach')
+            ->withConsecutive(
+                ['test-event1', [$listenerMock,'doSomething'], 1 ],
+                ['test-event2', [$listenerMock, 'doSomething'], 2 ]
+            )
         ;
 
         $this->target->createServiceWithName($services, '', '');
@@ -244,17 +244,17 @@ 
 
         $lazyAggregateMock = $this->getLazyAggregateMock();
         $lazyAggregateMock->expects($this->once())
-			->method('setListeners')
+            ->method('setListeners')
             ->with($expectedLazyListeners)
             ->willReturnSelf()
         ;
 
         $this->setTargetListenerConfig($listeners);
         $services = $this->getServiceManagerMock($servicesCfg, true);
-		$expectedCallback = [$listenerMock,'doSomething'];
+        $expectedCallback = [$listenerMock,'doSomething'];
         $this->events->expects($this->exactly(16))
-			->method('attach')
-			->withConsecutive(
+            ->method('attach')
+            ->withConsecutive(
             [ $expectSingleEvent, $expectedCallback, 1 ],
             [ $expectSingleEvent, $expectedCallback, 1 ],
             [ 'event1', $expectedCallback, 1],
@@ -264,9 +264,9 @@ 
             [ 'event2', $expectedCallback, 1],
             [ $expectSingleEvent, $expectedCallback, $priority],
             [ 'event1', $expectedCallback, $priority],
-	        [ 'event2', $expectedCallback, $priority],
+            [ 'event2', $expectedCallback, $priority],
             [ $expectSingleEvent, $expectedCallback, $priority ],
-	        [ 'event1', $expectedCallback, $priority ],
+            [ 'event1', $expectedCallback, $priority ],
             [ 'event2', $expectedCallback, $priority ],
             [ $expectSingleEvent, [$listenerMock,$additionalMethod], 1],
             [ 'event1', $expectedCallback, $additionalPriority ],
@@ -307,51 +307,51 @@ 
             'Test17' => [ 'events' => $multiEvent, 'method' => 'multiMethod' ],
         ];
 	
-	    $servicesCfg = array_fill_keys([
-		    'Test01', 'Test02', 'Test03', 'Test04', 'Test05', 'Test06', 'Test07',
-		    'Test08', 'Test09', 'Test10', 'Test11', 'Test12', 'Test13', 'Test14',
-		    'Test15', 'Test17',
-	    ], $listenerMock);
+        $servicesCfg = array_fill_keys([
+            'Test01', 'Test02', 'Test03', 'Test04', 'Test05', 'Test06', 'Test07',
+            'Test08', 'Test09', 'Test10', 'Test11', 'Test12', 'Test13', 'Test14',
+            'Test15', 'Test17',
+        ], $listenerMock);
         $expectedLazyListeners = [
             [ 'service' => 'Test16', 'event' => $singleEvent[0], 'method' => null, 'priority' => 1 ],
         ];
 
         $lazyAggregateMock = $this->getLazyAggregateMock();
         $lazyAggregateMock
-	        ->expects($this->once())
-	        ->method('setListeners')
-	        ->with($expectedLazyListeners)
-	        ->willReturnSelf()
+            ->expects($this->once())
+            ->method('setListeners')
+            ->with($expectedLazyListeners)
+            ->willReturnSelf()
         ;
 
         $this->setTargetListenerConfig($listeners);
         $services = $this->getServiceManagerMock($servicesCfg, true);
 		
         $callback1 = [$listenerMock,'doSomething'];
-	    $callback2 = [$listenerMock,'doSomethingElse'];
+        $callback2 = [$listenerMock,'doSomethingElse'];
         $this->events
-	        ->expects($this->exactly(20))
-	        ->method('attach')
-	        ->withConsecutive(
-		        [ $singleEvent[0], $callback1, 1 ],
-		        [ 'prioEvent', $callback1, 10 ],
-		        [ 'methodEvent', $callback1, 1],
-		        [ $singleEvent[0], $callback1, 12],
-		        [ 'prioEvent', $callback1, 10],
-		        [ 'methodEvent', $callback1, 12],
-		        [ $singleEvent[0], $callback1, 1],
-		        [ 'prioEvent' , $callback1, 10],
-		        [ 'methodEvent', $callback1, 1],
-		        [ $singleEvent[0], $callback1, 12],
-		        [ 'prioEvent', $callback2, 10],
-		        [ 'methodEvent', $callback1, 12],
-		        [ 'single', $callback1, 1 ],
+            ->expects($this->exactly(20))
+            ->method('attach')
+            ->withConsecutive(
+                [ $singleEvent[0], $callback1, 1 ],
+                [ 'prioEvent', $callback1, 10 ],
+                [ 'methodEvent', $callback1, 1],
+                [ $singleEvent[0], $callback1, 12],
+                [ 'prioEvent', $callback1, 10],
+                [ 'methodEvent', $callback1, 12],
+                [ $singleEvent[0], $callback1, 1],
+                [ 'prioEvent' , $callback1, 10],
+                [ 'methodEvent', $callback1, 1],
+                [ $singleEvent[0], $callback1, 12],
+                [ 'prioEvent', $callback2, 10],
+                [ 'methodEvent', $callback1, 12],
+                [ 'single', $callback1, 1 ],
                 [ 'method' , $callback1, 1],
-		        [ 'priority', $callback1, 10],
-		        //[ [ 'method' ], $callback1, 1],
-		        [ 'verbose', $callback1, 20],
-		        [ 'verbose', $callback1, 30],
-		        [ 'verbose', $callback2, 25],
+                [ 'priority', $callback1, 10],
+                //[ [ 'method' ], $callback1, 1],
+                [ 'verbose', $callback1, 20],
+                [ 'verbose', $callback1, 30],
+                [ 'verbose', $callback2, 25],
                 [ 'multi1', [$listenerMock,'multiMethod'], 1],
                 [ 'multi2', [$listenerMock,'multiMethod'], 1]
             )
@@ -363,7 +363,7 @@ 
 }
 
 class AttachListenerTestListenerMock {
-	public function doSomething(){}
-	public function doSomethingElse(){}
-	public function multiMethod(){}
+    public function doSomething(){}
+    public function doSomethingElse(){}
+    public function multiMethod(){}
 }

Spacing +104 added lines, -104 removed lines

@@ -45,7 +45,7 @@ 
     public function setUp()
     {
         $this->target = $this->getMockBuilder('\Core\Factory\EventManager\EventManagerAbstractFactory')
-                             ->setMethods([ 'createEventManager', 'getConfig' ])
+                             ->setMethods(['createEventManager', 'getConfig'])
                              ->getMock();
 
         $events = $this->getMockBuilder('\Zend\EventManager\EventManager')
@@ -60,7 +60,7 @@ 
 
     protected function setTargetListenerConfig($config)
     {
-        $cfg = [ 'listeners' => $config ];
+        $cfg = ['listeners' => $config];
         $this->target->expects($this->once())->method('getConfig')->willReturn($cfg);
     }
 
@@ -71,14 +71,14 @@ 
                          ->getMock();
 
 
-        $hasMap = [ ];
-        $getMap = [ ];
+        $hasMap = [];
+        $getMap = [];
         $defaultListenerMock = new AttachListenerTestListenerMock();
 
         $lazyAggregateMock = $this->getLazyAggregateMock($expectLazyListeners);
         if ($expectLazyListeners) {
             $lazyAggregateMock->expects($this->once())->method('attach');
-            $getMap[] = [ 'Core/Listener/DeferredListenerAggregate', $lazyAggregateMock ];
+            $getMap[] = ['Core/Listener/DeferredListenerAggregate', $lazyAggregateMock];
         }
 
         foreach ($listeners as $serviceName => $listenerMock) {
@@ -88,10 +88,10 @@ 
             }
 
             if (false === $listenerMock) {
-                $hasMap[] = [ $serviceName, false];
+                $hasMap[] = [$serviceName, false];
             } else {
-                $hasMap[] = [ $serviceName, true ];
-                $getMap[] = [ $serviceName, $listenerMock ];
+                $hasMap[] = [$serviceName, true];
+                $getMap[] = [$serviceName, $listenerMock];
             }
         }
 
@@ -135,7 +135,7 @@ 
 
     public function testPullsListenersFromServiceManager()
     {
-        $this->setTargetListenerConfig(['TestListener' => ['test-event','doSomething',1]]);
+        $this->setTargetListenerConfig(['TestListener' => ['test-event', 'doSomething', 1]]);
         $services = $this->getServiceManagerMock(['TestListener']);
         $this->target->createServiceWithName($services, 'irrelevant', 'irrelevant');
     }
@@ -143,7 +143,7 @@ 
     public function testCreatesListenersInstances()
     {
         $this->setTargetListenerConfig(
-        	['\CoreTest\Factory\EventManager\EventManagerAbstractFactory\AttachListenerTestListenerMock' => ['test-event','doSomething',1]]
+        	['\CoreTest\Factory\EventManager\EventManagerAbstractFactory\AttachListenerTestListenerMock' => ['test-event', 'doSomething', 1]]
         );
         $services = $this->getServiceManagerMock([
         	'\CoreTest\Factory\EventManager\EventManagerAbstractFactory\AttachListenerTestListenerMock' => false
@@ -166,7 +166,7 @@ 
 	{
 		$aggregateMock = $this->getMockBuilder('\Zend\EventManager\ListenerAggregateInterface')
 		                      ->getMockForAbstractClass();
-		$aggregateMock->expects($this->exactly(2))->method('attach')->withConsecutive([ $this->events, 1], [$this->events, -100]);
+		$aggregateMock->expects($this->exactly(2))->method('attach')->withConsecutive([$this->events, 1], [$this->events, -100]);
 		
 		$this->setTargetListenerConfig(['TestAggregate', 'TestAggregate2' => -100]);
 		$services = $this->getServiceManagerMock(['TestAggregate' => $aggregateMock, 'TestAggregate2' => $aggregateMock]);
@@ -178,8 +178,8 @@ 
     {
         $listenerMock = new AttachListenerTestListenerMock();
         $this->setTargetListenerConfig([
-        	'TestListener1' => ['test-event1','doSomething',1],
-	        'TestListener2' => ['test-event2','doSomething',2]
+        	'TestListener1' => ['test-event1', 'doSomething', 1],
+	        'TestListener2' => ['test-event2', 'doSomething', 2]
         ]);
         $services = $this->getServiceManagerMock([
         	'TestListener1' => $listenerMock,
@@ -189,8 +189,8 @@ 
 	        ->expects($this->exactly(2))
 	        ->method('attach')
 	        ->withConsecutive(
-	        	['test-event1', [$listenerMock,'doSomething'], 1 ],
-		        ['test-event2', [$listenerMock, 'doSomething'], 2 ]
+	        	['test-event1', [$listenerMock, 'doSomething'], 1],
+		        ['test-event2', [$listenerMock, 'doSomething'], 2]
 	        )
         ;
 
@@ -202,7 +202,7 @@ 
         $listenerMock = new AttachListenerTestListenerMock();
         $singleEvent = 'event';
         $expectSingleEvent = $singleEvent;
-        $multiEvent  = [ 'event1', 'event2' ];
+        $multiEvent  = ['event1', 'event2'];
         $method = 'doSomething';
         $additionalMethod = 'doSomethingElse';
         $priority = 1;
@@ -211,30 +211,30 @@ 
         $notLazy = false;
 
         $listeners = [
-            'Test01' => [ $singleEvent, $method],
-            'Test02' => [ $singleEvent, $method ],
-            'Test03' => [ $multiEvent, $method ],
-            'Test04' => [ $singleEvent, $method ],
-            'Test05' => [ $multiEvent, $method ],
-            'Test06' => [ $singleEvent, $method, $priority ],
-            'Test07' => [ $multiEvent, $method, $priority ],
-            'Test08' => [ $singleEvent, $method, $priority, $lazy ],
-            'Test09' => [ $multiEvent, $method, $priority, $lazy ],
-            'Test10' => [ $singleEvent,$method, $priority ],
-            'Test11' => [ $multiEvent, $method, $priority ],
-            'Test12' => [ $singleEvent,$method, $lazy ],
-            'Test13' => [ $multiEvent,$method, $lazy ],
-            'Test14' => [ $singleEvent, $method, $additionalMethod ],
-            'Test15' => [ $multiEvent, $method, $lazy, $priority, $notLazy, $additionalPriority ],
+            'Test01' => [$singleEvent, $method],
+            'Test02' => [$singleEvent, $method],
+            'Test03' => [$multiEvent, $method],
+            'Test04' => [$singleEvent, $method],
+            'Test05' => [$multiEvent, $method],
+            'Test06' => [$singleEvent, $method, $priority],
+            'Test07' => [$multiEvent, $method, $priority],
+            'Test08' => [$singleEvent, $method, $priority, $lazy],
+            'Test09' => [$multiEvent, $method, $priority, $lazy],
+            'Test10' => [$singleEvent, $method, $priority],
+            'Test11' => [$multiEvent, $method, $priority],
+            'Test12' => [$singleEvent, $method, $lazy],
+            'Test13' => [$multiEvent, $method, $lazy],
+            'Test14' => [$singleEvent, $method, $additionalMethod],
+            'Test15' => [$multiEvent, $method, $lazy, $priority, $notLazy, $additionalPriority],
         ];
 
         $expectedLazyListeners = [
-            [ 'service' => 'Test08', 'event' => $expectSingleEvent, 'method' => $method, 'priority' => $priority ],
-            [ 'service' => 'Test09', 'event' => 'event1', 'method' => $method, 'priority' => $priority ],
-            [ 'service' => 'Test09', 'event' => 'event2', 'method' => $method, 'priority' => $priority ],
-            [ 'service' => 'Test12', 'event' => $expectSingleEvent, 'method' => $method, 'priority' => 1 ],
-            [ 'service' => 'Test13', 'event' => 'event1', 'method' => $method, 'priority' => 1],
-            [ 'service' => 'Test13', 'event' => 'event2', 'method' => $method, 'priority' => 1],
+            ['service' => 'Test08', 'event' => $expectSingleEvent, 'method' => $method, 'priority' => $priority],
+            ['service' => 'Test09', 'event' => 'event1', 'method' => $method, 'priority' => $priority],
+            ['service' => 'Test09', 'event' => 'event2', 'method' => $method, 'priority' => $priority],
+            ['service' => 'Test12', 'event' => $expectSingleEvent, 'method' => $method, 'priority' => 1],
+            ['service' => 'Test13', 'event' => 'event1', 'method' => $method, 'priority' => 1],
+            ['service' => 'Test13', 'event' => 'event2', 'method' => $method, 'priority' => 1],
         ];
 
         $servicesCfg = array_fill_keys([
@@ -251,26 +251,26 @@ 
 
         $this->setTargetListenerConfig($listeners);
         $services = $this->getServiceManagerMock($servicesCfg, true);
-		$expectedCallback = [$listenerMock,'doSomething'];
+		$expectedCallback = [$listenerMock, 'doSomething'];
         $this->events->expects($this->exactly(16))
 			->method('attach')
 			->withConsecutive(
-            [ $expectSingleEvent, $expectedCallback, 1 ],
-            [ $expectSingleEvent, $expectedCallback, 1 ],
-            [ 'event1', $expectedCallback, 1],
-            [ 'event2', $expectedCallback, 1],
-            [ $expectSingleEvent, $expectedCallback, 1],
-            [ 'event1', $expectedCallback, 1],
-            [ 'event2', $expectedCallback, 1],
-            [ $expectSingleEvent, $expectedCallback, $priority],
-            [ 'event1', $expectedCallback, $priority],
-	        [ 'event2', $expectedCallback, $priority],
-            [ $expectSingleEvent, $expectedCallback, $priority ],
-	        [ 'event1', $expectedCallback, $priority ],
-            [ 'event2', $expectedCallback, $priority ],
-            [ $expectSingleEvent, [$listenerMock,$additionalMethod], 1],
-            [ 'event1', $expectedCallback, $additionalPriority ],
-            [ 'event2', $expectedCallback, $additionalPriority ]
+            [$expectSingleEvent, $expectedCallback, 1],
+            [$expectSingleEvent, $expectedCallback, 1],
+            ['event1', $expectedCallback, 1],
+            ['event2', $expectedCallback, 1],
+            [$expectSingleEvent, $expectedCallback, 1],
+            ['event1', $expectedCallback, 1],
+            ['event2', $expectedCallback, 1],
+            [$expectSingleEvent, $expectedCallback, $priority],
+            ['event1', $expectedCallback, $priority],
+	        ['event2', $expectedCallback, $priority],
+            [$expectSingleEvent, $expectedCallback, $priority],
+	        ['event1', $expectedCallback, $priority],
+            ['event2', $expectedCallback, $priority],
+            [$expectSingleEvent, [$listenerMock, $additionalMethod], 1],
+            ['event1', $expectedCallback, $additionalPriority],
+            ['event2', $expectedCallback, $additionalPriority]
         );
 
         $this->target->createServiceWithName($services, '', '');
@@ -279,32 +279,32 @@ 
     public function testNormalizeListenerOptionsWithArrayHashSpecification()
     {
         $listenerMock = new AttachListenerTestListenerMock();
-        $singleEvent = [ 'singleEvent' ];
-        $priorityEvent = [ 'prioEvent' => 10 ];
-        $methodEvent = [ 'methodEvent' => 'doSomething' ];
-        $singleAndPriorityAndMethodEvent = [ 'single', 'priority' => 10, 'method' => 'doSomething'];
-        $verboseEvent = [ 'verbose' => [ 'method' => 'doSomething', 'priority' => 20]];
-        $verboseFullEvent = [ 'verbose' => [ 'method' => ['doSomething', 'doSomethingElse' => 25], 'priority' => 30]];
-        $multiEvent = [ 'multi1', 'multi2' ];
+        $singleEvent = ['singleEvent'];
+        $priorityEvent = ['prioEvent' => 10];
+        $methodEvent = ['methodEvent' => 'doSomething'];
+        $singleAndPriorityAndMethodEvent = ['single', 'priority' => 10, 'method' => 'doSomething'];
+        $verboseEvent = ['verbose' => ['method' => 'doSomething', 'priority' => 20]];
+        $verboseFullEvent = ['verbose' => ['method' => ['doSomething', 'doSomethingElse' => 25], 'priority' => 30]];
+        $multiEvent = ['multi1', 'multi2'];
 
         $listeners = [
-            'Test01' => [ 'events' => $singleEvent, 'method' => 'doSomething'],
-            'Test02' => [ 'events' => $priorityEvent, 'method' => 'doSomething'],
-            'Test03' => [ 'events' => $methodEvent, 'method' => 'doSomething'],
-            'Test04' => [ 'events' => $singleEvent, 'method'=>'doSomething', 'priority' => 12],
-            'Test05' => [ 'events' => $priorityEvent, 'method'=>'doSomething', 'priority' => 12],
-            'Test06' => [ 'events' => $methodEvent,'method'=>'doSomething', 'priority' => 12],
-            'Test07' => [ 'events' => $singleEvent, 'method' => 'doSomething'],
-            'Test08' => [ 'events' => $priorityEvent, 'method' => 'doSomething'],
-            'Test09' => [ 'events' => $methodEvent, 'method' => 'doSomethingElse'],
-            'Test10' => [ 'events' => $singleEvent, 'method' => 'doSomething', 'priority' => 12],
-            'Test11' => [ 'events' => $priorityEvent, 'method' => 'doSomethingElse', 'priority' => 12],
-            'Test12' => [ 'events' => $methodEvent, 'method' => 'doSomethingElse', 'priority' => 12],
-            'Test13' => [ 'events' => $singleAndPriorityAndMethodEvent, 'method'=> 'doSomething'],
-            'Test14' => [ 'events' => $verboseEvent],
-            'Test15' => [ 'events' => $verboseFullEvent],
-            'Test16' => [ 'events' => $singleEvent, 'lazy' => true],
-            'Test17' => [ 'events' => $multiEvent, 'method' => 'multiMethod' ],
+            'Test01' => ['events' => $singleEvent, 'method' => 'doSomething'],
+            'Test02' => ['events' => $priorityEvent, 'method' => 'doSomething'],
+            'Test03' => ['events' => $methodEvent, 'method' => 'doSomething'],
+            'Test04' => ['events' => $singleEvent, 'method'=>'doSomething', 'priority' => 12],
+            'Test05' => ['events' => $priorityEvent, 'method'=>'doSomething', 'priority' => 12],
+            'Test06' => ['events' => $methodEvent, 'method'=>'doSomething', 'priority' => 12],
+            'Test07' => ['events' => $singleEvent, 'method' => 'doSomething'],
+            'Test08' => ['events' => $priorityEvent, 'method' => 'doSomething'],
+            'Test09' => ['events' => $methodEvent, 'method' => 'doSomethingElse'],
+            'Test10' => ['events' => $singleEvent, 'method' => 'doSomething', 'priority' => 12],
+            'Test11' => ['events' => $priorityEvent, 'method' => 'doSomethingElse', 'priority' => 12],
+            'Test12' => ['events' => $methodEvent, 'method' => 'doSomethingElse', 'priority' => 12],
+            'Test13' => ['events' => $singleAndPriorityAndMethodEvent, 'method'=> 'doSomething'],
+            'Test14' => ['events' => $verboseEvent],
+            'Test15' => ['events' => $verboseFullEvent],
+            'Test16' => ['events' => $singleEvent, 'lazy' => true],
+            'Test17' => ['events' => $multiEvent, 'method' => 'multiMethod'],
         ];
 	
 	    $servicesCfg = array_fill_keys([
@@ -313,7 +313,7 @@ 
 		    'Test15', 'Test17',
 	    ], $listenerMock);
         $expectedLazyListeners = [
-            [ 'service' => 'Test16', 'event' => $singleEvent[0], 'method' => null, 'priority' => 1 ],
+            ['service' => 'Test16', 'event' => $singleEvent[0], 'method' => null, 'priority' => 1],
         ];
 
         $lazyAggregateMock = $this->getLazyAggregateMock();
@@ -327,33 +327,33 @@ 
         $this->setTargetListenerConfig($listeners);
         $services = $this->getServiceManagerMock($servicesCfg, true);
 		
-        $callback1 = [$listenerMock,'doSomething'];
-	    $callback2 = [$listenerMock,'doSomethingElse'];
+        $callback1 = [$listenerMock, 'doSomething'];
+	    $callback2 = [$listenerMock, 'doSomethingElse'];
         $this->events
 	        ->expects($this->exactly(20))
 	        ->method('attach')
 	        ->withConsecutive(
-		        [ $singleEvent[0], $callback1, 1 ],
-		        [ 'prioEvent', $callback1, 10 ],
-		        [ 'methodEvent', $callback1, 1],
-		        [ $singleEvent[0], $callback1, 12],
-		        [ 'prioEvent', $callback1, 10],
-		        [ 'methodEvent', $callback1, 12],
-		        [ $singleEvent[0], $callback1, 1],
-		        [ 'prioEvent' , $callback1, 10],
-		        [ 'methodEvent', $callback1, 1],
-		        [ $singleEvent[0], $callback1, 12],
-		        [ 'prioEvent', $callback2, 10],
-		        [ 'methodEvent', $callback1, 12],
-		        [ 'single', $callback1, 1 ],
-                [ 'method' , $callback1, 1],
-		        [ 'priority', $callback1, 10],
+		        [$singleEvent[0], $callback1, 1],
+		        ['prioEvent', $callback1, 10],
+		        ['methodEvent', $callback1, 1],
+		        [$singleEvent[0], $callback1, 12],
+		        ['prioEvent', $callback1, 10],
+		        ['methodEvent', $callback1, 12],
+		        [$singleEvent[0], $callback1, 1],
+		        ['prioEvent', $callback1, 10],
+		        ['methodEvent', $callback1, 1],
+		        [$singleEvent[0], $callback1, 12],
+		        ['prioEvent', $callback2, 10],
+		        ['methodEvent', $callback1, 12],
+		        ['single', $callback1, 1],
+                ['method', $callback1, 1],
+		        ['priority', $callback1, 10],
 		        //[ [ 'method' ], $callback1, 1],
-		        [ 'verbose', $callback1, 20],
-		        [ 'verbose', $callback1, 30],
-		        [ 'verbose', $callback2, 25],
-                [ 'multi1', [$listenerMock,'multiMethod'], 1],
-                [ 'multi2', [$listenerMock,'multiMethod'], 1]
+		        ['verbose', $callback1, 20],
+		        ['verbose', $callback1, 30],
+		        ['verbose', $callback2, 25],
+                ['multi1', [$listenerMock, 'multiMethod'], 1],
+                ['multi2', [$listenerMock, 'multiMethod'], 1]
             )
         ;
 
@@ -363,7 +363,7 @@ 
 }
 
 class AttachListenerTestListenerMock {
-	public function doSomething(){}
-	public function doSomethingElse(){}
-	public function multiMethod(){}
+	public function doSomething() {}
+	public function doSomethingElse() {}
+	public function multiMethod() {}
 }

module/Core/test/CoreTest/Factory/EventManager/EventManagerAbstractFactory/InheritanceAndConfigMergingTest.php

Indentation +8 added lines, -8 removed lines

@@ -44,16 +44,16 @@ 
     {
         $services = new ServiceManager();
         $this->assertTrue(
-             $this->target->canCreate(
+                $this->target->canCreate(
                 $services,'Any.string/Value/Events'
-             ),
-             'Checking correct name failed.'
+                ),
+                'Checking correct name failed.'
         );
         $this->assertFalse(
-             $this->target->canCreate(
+                $this->target->canCreate(
                 $services,'Any.string.not.ending/in/Events.but has it in the middle!'
-             ),
-             'Checking invalid name failed.'
+                ),
+                'Checking invalid name failed.'
         );
     }
 
@@ -94,8 +94,8 @@ 
 
         /* @var EventManagerAbstractFactory|\PHPUnit_Framework_MockObject_MockObject $target */
         $target = $this->getMockBuilder('\Core\Factory\EventManager\EventManagerAbstractFactory')
-                       ->setMethods([ 'createEventManager', 'attachListeners' ])
-                       ->getMock();
+                        ->setMethods([ 'createEventManager', 'attachListeners' ])
+                        ->getMock();
 
         $services = new ServiceManager();
         $services->setService('Config', $config);

Spacing +11 added lines, -11 removed lines

@@ -38,20 +38,20 @@ 
         '@testCanCreateServiceWithName' => ['mock' => ['canCreate' => 1]],
     ];
 
-    protected $inheritance = [ '\Zend\ServiceManager\Factory\AbstractFactoryInterface' ];
+    protected $inheritance = ['\Zend\ServiceManager\Factory\AbstractFactoryInterface'];
 
     public function testDeterminesIfItCanCreateAnEventManagerByName()
     {
         $services = new ServiceManager();
         $this->assertTrue(
              $this->target->canCreate(
-                $services,'Any.string/Value/Events'
+                $services, 'Any.string/Value/Events'
              ),
              'Checking correct name failed.'
         );
         $this->assertFalse(
              $this->target->canCreate(
-                $services,'Any.string.not.ending/in/Events.but has it in the middle!'
+                $services, 'Any.string.not.ending/in/Events.but has it in the middle!'
              ),
              'Checking invalid name failed.'
         );
@@ -62,17 +62,17 @@ 
         $config1 = [];
 
         $config2 = [
-            'event_manager' => [ 'Test2/Events' => [
+            'event_manager' => ['Test2/Events' => [
                 'service' => 'TestService',
                 'configure' => false,
-                'identifiers' => [ 'TestEvents', 'AnotherId' ],
+                'identifiers' => ['TestEvents', 'AnotherId'],
                 'event' => 'SomeEventClass',
-                'listeners' => [ 'listener' => 'event' ]
+                'listeners' => ['listener' => 'event']
             ]]
         ];
         return [
-            [ $config1, 'Test1/Events' ],
-            [ $config2, 'Test2/Events' ],
+            [$config1, 'Test1/Events'],
+            [$config2, 'Test2/Events'],
         ];
     }
 
@@ -87,14 +87,14 @@ 
         $defaults = [
             'service' => 'EventManager',
             'configure' => true,
-            'identifiers' => [ $reqName ],
+            'identifiers' => [$reqName],
             'event' => '\Zend\EventManager\Event',
             'listeners' => [],
         ];
 
         /* @var EventManagerAbstractFactory|\PHPUnit_Framework_MockObject_MockObject $target */
         $target = $this->getMockBuilder('\Core\Factory\EventManager\EventManagerAbstractFactory')
-                       ->setMethods([ 'createEventManager', 'attachListeners' ])
+                       ->setMethods(['createEventManager', 'attachListeners'])
                        ->getMock();
 
         $services = new ServiceManager();
@@ -108,7 +108,7 @@ 
 
         $target->expects($this->once())->method('createEventManager')->with($services, $expected);
 
-        $target($services,$reqName);
+        $target($services, $reqName);
     }
 
     public function testCanCreateServiceWithName()

module/Core/test/CoreTest/Factory/EventManager/EventManagerAbstractFactory/CreateEventManagerTest.php

Indentation +21 added lines, -21 removed lines

@@ -39,8 +39,8 @@ 
     public function setUp()
     {
         $this->target = $this->getMockBuilder('\Core\Factory\EventManager\EventManagerAbstractFactory')
-                             ->setMethods([ 'attachListeners', 'getConfig' ])
-                             ->getMock();
+                                ->setMethods([ 'attachListeners', 'getConfig' ])
+                                ->getMock();
 
     }
 
@@ -59,17 +59,17 @@ 
             $config['event'] = '\Zend\EventManager\Event';
         }
         $this->target
-	        ->expects($this->once())
-	        ->method('getConfig')
-	        ->willReturn($config)
+            ->expects($this->once())
+            ->method('getConfig')
+            ->willReturn($config)
         ;
     }
 
     protected function getServiceManagerMock($events, $args = [])
     {
         $services = $this->getMockBuilder('\Zend\ServiceManager\ServiceManager')
-                         ->disableOriginalConstructor()
-                         ->getMock();
+                            ->disableOriginalConstructor()
+                            ->getMock();
 
 
         if (is_Array($events)) {
@@ -96,11 +96,11 @@ 
                  ->method('has')->will($this->returnValueMap($hasMap));
         */
         $services->expects($this->any())
-	        ->method('has')
-	        ->will($this->returnValueMap($hasMap))
+            ->method('has')
+            ->will($this->returnValueMap($hasMap))
         ;
         $services->expects($this->exactly(count($getMap)))
-                 ->method('get')->will($this->returnValueMap($getMap));
+                    ->method('get')->will($this->returnValueMap($getMap));
 
         return $services;
     }
@@ -130,8 +130,8 @@ 
 
     public function testThrowsExceptionIfNoEventManagerCanBeCreated()
     {
-    	$this->expectException(\UnexpectedValueException::class);
-    	$this->expectExceptionMessage('Cannot create');
+        $this->expectException(\UnexpectedValueException::class);
+        $this->expectExceptionMessage('Cannot create');
 
         $this->setTargetConfig(['service' => 'NonExistantClass' ]);
 
@@ -165,9 +165,9 @@ 
         $events = $this->getMockBuilder('\Core\EventManager\EventManager')->disableOriginalConstructor()
                         ->setMethods(['setIdentifiers', 'setEventPrototype'])->getMock();
         $events
-	        ->expects($this->once())
-	        ->method('setEventPrototype')
-	        ->with($event)
+            ->expects($this->once())
+            ->method('setEventPrototype')
+            ->with($event)
         ;
 
         $services = $this->getServiceManagerMock(['EventManager' => $events], [ 'Event' => $event ]);
@@ -179,14 +179,14 @@ 
     {
         $event = new \Zend\EventManager\Event();
         $events = $this->getMockBuilder('\Zend\EventManager\EventManager')
-                       ->disableOriginalConstructor()
-                       ->setMethods(['setIdentifiers', 'setEventPrototype'])
-                       ->getMock()
+                        ->disableOriginalConstructor()
+                        ->setMethods(['setIdentifiers', 'setEventPrototype'])
+                        ->getMock()
         ;
         $events
-	        ->expects($this->once())
-	        ->method('setEventPrototype')
-	        ->with($this->isInstanceOf(Event::class))
+            ->expects($this->once())
+            ->method('setEventPrototype')
+            ->with($this->isInstanceOf(Event::class))
         ;
 
         $services = $this->getServiceManagerMock(['EventManager' => $events]);

Spacing +12 added lines, -12 removed lines

@@ -39,7 +39,7 @@ 
     public function setUp()
     {
         $this->target = $this->getMockBuilder('\Core\Factory\EventManager\EventManagerAbstractFactory')
-                             ->setMethods([ 'attachListeners', 'getConfig' ])
+                             ->setMethods(['attachListeners', 'getConfig'])
                              ->getMock();
 
     }
@@ -53,7 +53,7 @@ 
             $config['listeners'] = [];
         }
         if (!isset($config['identifiers'])) {
-            $config['identifiers'] = [ 'Test/Events/Manager' ];
+            $config['identifiers'] = ['Test/Events/Manager'];
         }
         if (!isset($config['event'])) {
             $config['event'] = '\Zend\EventManager\Event';
@@ -80,15 +80,15 @@ 
             $eventsService = 'Test/Events/Manager';
         }
 
-        $hasMap = [ [ $eventsService, true ] ];
-        $getMap = [ [ $eventsService, $events ] ];
+        $hasMap = [[$eventsService, true]];
+        $getMap = [[$eventsService, $events]];
 
         foreach ($args as $serviceName => $serviceValue) {
             if (false === $serviceValue) {
-                $hasMap[] = [ $serviceName, true ];
+                $hasMap[] = [$serviceName, true];
             } else {
-                $hasMap[] = [ $serviceName, true];
-                $getMap[] = [ $serviceName, $serviceValue ];
+                $hasMap[] = [$serviceName, true];
+                $getMap[] = [$serviceName, $serviceValue];
             }
         }
 
@@ -112,7 +112,7 @@ 
 
         $services->setService('Test/Events/Manager', $events);
 
-        $this->setTargetConfig([ 'service' => 'Test/Events/Manager', 'configure' => false, 'listeners' => []]);
+        $this->setTargetConfig(['service' => 'Test/Events/Manager', 'configure' => false, 'listeners' => []]);
 
         $this->target->expects($this->once())->method('attachListeners')->with($services, $events, []);
         $this->target->createServiceWithName($services, 'irrelevant', 'Test/Events');
@@ -120,7 +120,7 @@ 
 
     public function testInstatiatesEventManagerFromClassName()
     {
-        $this->setTargetConfig([ 'service' => '\Zend\EventManager\EventManager', 'configure' => false, 'listeners' => []]);
+        $this->setTargetConfig(['service' => '\Zend\EventManager\EventManager', 'configure' => false, 'listeners' => []]);
 
         $services = new ServiceManager();
         $events = $this->target->createServiceWithName($services, 'irrelevant', 'irrelevant');
@@ -133,7 +133,7 @@ 
     	$this->expectException(\UnexpectedValueException::class);
     	$this->expectExceptionMessage('Cannot create');
 
-        $this->setTargetConfig(['service' => 'NonExistantClass' ]);
+        $this->setTargetConfig(['service' => 'NonExistantClass']);
 
         $this->target->createServiceWithName(new ServiceManager(), 'irrelevant', 'irrelevant');
 
@@ -149,7 +149,7 @@ 
 
     public function testSetsIdentifiersOnEventManagerInstance()
     {
-        $ids = [ 'testID', 'TestId2' ];
+        $ids = ['testID', 'TestId2'];
         $events = new EventManager();
         $services = $this->getServiceManagerMock(['EventManager' => $events]);
         $this->setTargetConfig(['configure' => true, 'identifiers' => $ids, 'service' => 'EventManager']);
@@ -170,7 +170,7 @@ 
 	        ->with($event)
         ;
 
-        $services = $this->getServiceManagerMock(['EventManager' => $events], [ 'Event' => $event ]);
+        $services = $this->getServiceManagerMock(['EventManager' => $events], ['Event' => $event]);
         $this->setTargetConfig(['configure' => true, 'service' => 'EventManager', 'event' => 'Event']);
         $this->target->createServiceWithName($services, 'irrelevant', 'Test/Events');
     }

module/Core/test/CoreTest/Controller/AdminControllerEventTest.php

Spacing +11 added lines, -11 removed lines

@@ -28,7 +28,7 @@ 
 
     protected $target = '\Core\Controller\AdminControllerEvent';
 
-    protected $inheritance = [ '\Zend\EventManager\Event' ];
+    protected $inheritance = ['\Zend\EventManager\Event'];
 
     public function testCreatesModelPriorityListUponCreation()
     {
@@ -62,10 +62,10 @@ 
     public function provideAddViewTemplateTestData()
     {
         return [
-            [ [ 'test', 'template' ], ['test', 'template', [], 0] ],
-            [ [ 'test', 'template', [ 'var' => 'iable']], [ 'test', 'template', [ 'var' => 'iable'], 0] ],
-            [ [ 'test', 'template', 10] , ['test', 'template', [], 10] ],
-            [ [ 'test', 'template', [ 'var' => 'iable'], 10 ], [ 'test', 'template', [ 'var' => 'iable'], 10 ]],
+            [['test', 'template'], ['test', 'template', [], 0]],
+            [['test', 'template', ['var' => 'iable']], ['test', 'template', ['var' => 'iable'], 0]],
+            [['test', 'template', 10], ['test', 'template', [], 10]],
+            [['test', 'template', ['var' => 'iable'], 10], ['test', 'template', ['var' => 'iable'], 10]],
         ];
     }
 
@@ -91,12 +91,12 @@ 
     public function provideAddViewVariablesTestData()
     {
         return [
-            [ [ 'test' ] , ['test', ['name' => 'test'], 0] ],
-            [ [ 'test', [ 'var' => 'iable'] ], [ 'test', [ 'name' => 'test', 'var' => 'iable'], 0 ] ],
-            [ [ 'test', [ 'var' => 'iable'], 10], [ 'test', [ 'name' => 'test', 'var' => 'iable'], 10 ]],
-            [ [ [ 'name' => 'other', 'var' => 'test' ], 10], ['other', ['name' => 'other', 'var' => 'test' ], 10] ],
-            [ [ 'test', ['name' => 'other'] ], [ 'test', [ 'name' => 'other' ], 0] ],
-            [ [ 'test', 10 ], ['test', ['name' => 'test'], 10]],
+            [['test'], ['test', ['name' => 'test'], 0]],
+            [['test', ['var' => 'iable']], ['test', ['name' => 'test', 'var' => 'iable'], 0]],
+            [['test', ['var' => 'iable'], 10], ['test', ['name' => 'test', 'var' => 'iable'], 10]],
+            [[['name' => 'other', 'var' => 'test'], 10], ['other', ['name' => 'other', 'var' => 'test'], 10]],
+            [['test', ['name' => 'other']], ['test', ['name' => 'other'], 0]],
+            [['test', 10], ['test', ['name' => 'test'], 10]],
         ];
     }
 

module/Core/test/CoreTest/Controller/FileControllerTest.php

Spacing +14 added lines, -14 removed lines

@@ -80,17 +80,17 @@ 
         $plugins->expects($this->any())
             ->method('get')
             ->willReturnMap([
-                ['acl',null,$this->aclPlugin],
-                ['params',null,$this->paramsPlugin]
+                ['acl', null, $this->aclPlugin],
+                ['params', null, $this->paramsPlugin]
             ])
         ;
 
         $this->paramsPlugin->expects($this->any())
             ->method('__invoke')
             ->willReturnMap([
-                [null,null,$this->paramsPlugin],
-                ['filestore',null,'store.entity'],
-                ['fileId',0,'dir/file.ext']
+                [null, null, $this->paramsPlugin],
+                ['filestore', null, 'store.entity'],
+                ['fileId', 0, 'dir/file.ext']
             ])
         ;
         $this->paramsPlugin->expects($this->any())
@@ -120,7 +120,7 @@ 
         ;
 
         $response = $this->controller->dispatch($request);
-        $this->assertInstanceOf(Response::class,$response);
+        $this->assertInstanceOf(Response::class, $response);
         $this->assertResponseStatusCode(Response::STATUS_CODE_404);
     }
 
@@ -137,7 +137,7 @@ 
         ;
 
         $response = $this->controller->dispatch($request);
-        $this->assertInstanceOf(Response::class,$response);
+        $this->assertInstanceOf(Response::class, $response);
         $this->assertResponseStatusCode(Response::STATUS_CODE_404);
         $this->assertEquals(
             $this->event->getParam('exception'),
@@ -174,7 +174,7 @@ 
         ;
 
 
-        $resource = fopen(__FILE__,'r');
+        $resource = fopen(__FILE__, 'r');
         $file->expects($this->once())
             ->method('getResource')
             ->willReturn($resource)
@@ -186,7 +186,7 @@ 
         ob_end_clean();
 
         $this->assertResponseStatusCode(Response::STATUS_CODE_200);
-        $this->assertStringEqualsFile(__FILE__,$output);
+        $this->assertStringEqualsFile(__FILE__, $output);
         $this->assertEquals(
             'type',
             $this->getResponseHeader('Content-Type')->getFieldValue()
@@ -203,7 +203,7 @@ 
         $request->setMethod(Request::METHOD_GET);
         $headers = $request->getHeaders();
         $headers
-            ->addHeaderLine('X_REQUESTED_WITH','XMLHttpRequest')
+            ->addHeaderLine('X_REQUESTED_WITH', 'XMLHttpRequest')
         ;
 
         $repo = $this->createMock(ObjectRepository::class);
@@ -221,7 +221,7 @@ 
         ;
 
         $output = $this->controller->dispatch($request);
-        $this->assertInstanceOf(JsonModel::class,$output);
+        $this->assertInstanceOf(JsonModel::class, $output);
         $this->assertEquals(
             '{"result":false,"message":"File not found."}',
             $output->serialize()
@@ -233,7 +233,7 @@ 
         $request = new Request();
         $headers = $request->getHeaders();
         $headers
-            ->addHeaderLine('X_REQUESTED_WITH','XMLHttpRequest')
+            ->addHeaderLine('X_REQUESTED_WITH', 'XMLHttpRequest')
         ;
 
         $repo = $this->createMock(ObjectRepository::class);
@@ -273,8 +273,8 @@ 
 
         /* @var \Zend\View\Model\JsonModel $output */
         $output = $this->controller->dispatch($request);
-        $this->assertInstanceOf(JsonModel::class,$output);
-        $this->assertEquals('{"result":true}',$output->serialize());
+        $this->assertInstanceOf(JsonModel::class, $output);
+        $this->assertEquals('{"result":true}', $output->serialize());
     }
 
 }

module/Core/test/CoreTest/Controller/ContentControllerTest.php

Spacing +8 added lines, -8 removed lines

@@ -45,7 +45,7 @@ 
         $request = $this->createMock(Request::class);
 
         $target = $this->getMockBuilder(ContentController::class)
-            ->setMethods(['getRequest','getPluginManager'])
+            ->setMethods(['getRequest', 'getPluginManager'])
             ->getMock()
         ;
 
@@ -65,7 +65,7 @@ 
 
         $request->expects($this->exactly(2))
             ->method('isXmlHttpRequest')
-            ->willReturnOnConsecutiveCalls(false,true)
+            ->willReturnOnConsecutiveCalls(false, true)
         ;
 
         $params->expects($this->exactly(2))
@@ -77,13 +77,13 @@ 
 
         $viewModel = $target->indexAction();
         $this->assertEquals(
-            'content/some_view',$viewModel->getTemplate()
+            'content/some_view', $viewModel->getTemplate()
         );
         $this->assertFalse($viewModel->terminate());
 
         $viewModel = $target->indexAction();
         $this->assertEquals(
-            'content/some_view',$viewModel->getTemplate()
+            'content/some_view', $viewModel->getTemplate()
         );
         $this->assertTrue($viewModel->terminate());
     }
@@ -95,7 +95,7 @@ 
         $request = $this->createMock(Request::class);
 
         $target = $this->getMockBuilder(ContentController::class)
-            ->setMethods(['getRequest','getPluginManager'])
+            ->setMethods(['getRequest', 'getPluginManager'])
             ->getMock()
         ;
 
@@ -115,7 +115,7 @@ 
 
         $request->expects($this->exactly(2))
             ->method('isXmlHttpRequest')
-            ->willReturnOnConsecutiveCalls(false,true)
+            ->willReturnOnConsecutiveCalls(false, true)
         ;
 
         $params->expects($this->exactly(2))
@@ -127,13 +127,13 @@ 
 
         $viewModel = $target->modalAction();
         $this->assertEquals(
-            'some_view',$viewModel->getTemplate()
+            'some_view', $viewModel->getTemplate()
         );
         $this->assertFalse($viewModel->terminate());
 
         $viewModel = $target->modalAction();
         $this->assertEquals(
-            'some_view',$viewModel->getTemplate()
+            'some_view', $viewModel->getTemplate()
         );
         $this->assertTrue($viewModel->terminate());
     }

module/Core/test/CoreTest/Controller/Plugin/MailerTest.php

Spacing +5 added lines, -5 removed lines

@@ -101,7 +101,7 @@ 
         $mail = new Message();
 
         // test return to Mailer when $mail is null
-        $this->assertSame($target,$target());
+        $this->assertSame($target, $target());
 
         // test invokation send directly
         // if $mail instance of Message class
@@ -110,21 +110,21 @@ 
             ->with($mail)
             ->willReturn('returned value')
         ;
-        $this->assertEquals('returned value',$target($mail));
+        $this->assertEquals('returned value', $target($mail));
 
         // convert plugin into message
         $mailService->expects($this->exactly(2))
             ->method('get')
-            ->with('some plugin',array())
+            ->with('some plugin', array())
             ->willReturn($mail)
         ;
         $this->assertEquals(
             $mail,
-            $target('some plugin',array())
+            $target('some plugin', array())
         );
         $this->assertEquals(
             'returned value',
-            $target('some plugin',true,true)
+            $target('some plugin', true, true)
         );
 
     }

module/Core/test/CoreTest/Controller/Plugin/NotificationTest.php

Spacing +17 added lines, -17 removed lines

@@ -75,7 +75,7 @@ 
 
         $mock->expects($this->once())
             ->method('addMessage')
-            ->with('some message',Notification::NAMESPACE_SUCCESS)
+            ->with('some message', Notification::NAMESPACE_SUCCESS)
             ->willReturn($mock)
         ;
 
@@ -87,7 +87,7 @@ 
         );
         $this->assertSame(
             $mock,
-            $mock('some message',Notification::NAMESPACE_SUCCESS)
+            $mock('some message', Notification::NAMESPACE_SUCCESS)
         );
     }
 
@@ -100,12 +100,12 @@ 
         $translator->expects($this->once())
             ->method('translate')
             ->willReturnMap([
-                ['some message','default','translated some message'],
+                ['some message', 'default', 'translated some message'],
             ])
         ;
         $listener->expects($this->exactly(2))
             ->method('trigger')
-            ->with(NotificationEvent::EVENT_NOTIFICATION_ADD,$this->isInstanceOf(NotificationEvent::class))
+            ->with(NotificationEvent::EVENT_NOTIFICATION_ADD, $this->isInstanceOf(NotificationEvent::class))
         ;
 
         $target->setTranslator($translator);
@@ -122,7 +122,7 @@ 
      * @param string $message
      * @dataProvider getTestCreateNamespacedMessages
      */
-    public function testCreateNamespacedMessages($method,$message)
+    public function testCreateNamespacedMessages($method, $message)
     {
         $mock = $this->getMockBuilder(Notification::class)
             ->disableOriginalConstructor()
@@ -136,21 +136,21 @@ 
             ->willReturn($mock)
         ;
 
-        $callback = array($mock,$method);
+        $callback = array($mock, $method);
         $this->assertSame(
             $mock,
-            call_user_func($callback,$message)
+            call_user_func($callback, $message)
         );
     }
 
     public function getTestCreateNamespacedMessages()
     {
         return [
-            ['info','info message'],
-            ['warning','warning message'],
-            ['success','success message'],
-            ['danger','danger message'],
-            ['error','error message']
+            ['info', 'info message'],
+            ['warning', 'warning message'],
+            ['success', 'success message'],
+            ['danger', 'danger message'],
+            ['error', 'error message']
         ];
     }
 
@@ -173,8 +173,8 @@ 
         $events->expects($this->exactly(2))
             ->method('getNotifications')
             ->willReturnOnConsecutiveCalls(
-                [],// setup for empty array test
-                [$entity1,$entity2] // setup for non empty array tests
+                [], // setup for empty array test
+                [$entity1, $entity2] // setup for non empty array tests
             )
         ;
 
@@ -191,8 +191,8 @@ 
         $mock->expects($this->exactly(2))
             ->method('renderMessage')
             ->withConsecutive(
-                ['some notification',Notification::NAMESPACE_INFO],
-                ['some notification',Notification::NAMESPACE_DANGER]
+                ['some notification', Notification::NAMESPACE_INFO],
+                ['some notification', Notification::NAMESPACE_DANGER]
             )
         ;
         $mock->createOutput($events);
@@ -222,6 +222,6 @@ 
             ->willReturn($flash)
         ;
 
-        $target->renderMessage('some message',Notification::NAMESPACE_INFO);
+        $target->renderMessage('some message', Notification::NAMESPACE_INFO);
     }
 }

module/Core/test/CoreTest/Controller/Plugin/CreatePaginatorTest.php

Indentation +7 added lines, -7 removed lines

@@ -92,13 +92,13 @@
             ->disableOriginalConstructor()
             ->getMock()
         ;
-	    $container = $this->getMockBuilder(ContainerInterface::class)
-	                      ->getMock();
-	    $container->expects($this->once())
-		    ->method('get')
-		    ->with('ServiceManager')
-		    ->willReturn($sm)
-		;
+        $container = $this->getMockBuilder(ContainerInterface::class)
+                            ->getMock();
+        $container->expects($this->once())
+            ->method('get')
+            ->with('ServiceManager')
+            ->willReturn($sm)
+        ;
 		    
         $em = $this->getMockBuilder(EventManager::class)
             ->disableOriginalConstructor()

Spacing +6 added lines, -6 removed lines

@@ -49,10 +49,10 @@ 
     public function providePaginatorCreationData()
     {
         return [
-            [ 'Test/Paginator', ['test' => 'value'], ['merged' => 'yes'], false, ['page' => 1, 'count' => 10, 'range' => 5] ],
-            [ 'Test2/YetAnotherPager', ['page' => 2], [], true, ['page' => 2, 'count' => 10, 'range' => 5] ],
-            [ 'Yet/Another', ['page' => 3, 'count' => 90, 'range' => 2], false, false, ['page' => 3, 'count' => 90, 'range' => 2] ],
-            [ 'Even/Another', ['test' => 'value'], [], new \ArrayObject(['test' => 'value']), ['page' => 1, 'count' => 10, 'range' => 5]],
+            ['Test/Paginator', ['test' => 'value'], ['merged' => 'yes'], false, ['page' => 1, 'count' => 10, 'range' => 5]],
+            ['Test2/YetAnotherPager', ['page' => 2], [], true, ['page' => 2, 'count' => 10, 'range' => 5]],
+            ['Yet/Another', ['page' => 3, 'count' => 90, 'range' => 2], false, false, ['page' => 3, 'count' => 90, 'range' => 2]],
+            ['Even/Another', ['test' => 'value'], [], new \ArrayObject(['test' => 'value']), ['page' => 1, 'count' => 10, 'range' => 5]],
         ];
     }
 
@@ -70,7 +70,7 @@ 
     public function testPaginatorCreation($paginatorName, $params, $defaultParams, $usePostParams, $expect)
     {
         if ($defaultParams) { $options = array_merge($params, $defaultParams); }
-        else                { $options = $params; }
+        else { $options = $params; }
         $request = new Request();
         if ($usePostParams) {
             $request->setPost(new Parameters($params));
@@ -102,7 +102,7 @@ 
 		    
         $em = $this->getMockBuilder(EventManager::class)
             ->disableOriginalConstructor()
-            ->setMethods(['getEvent','triggerEvent'])
+            ->setMethods(['getEvent', 'triggerEvent'])
             ->getMock()
         ;
 	    

Braces +1 added lines, -2 removed lines

@@ -69,8 +69,7 @@
      */
     public function testPaginatorCreation($paginatorName, $params, $defaultParams, $usePostParams, $expect)
     {
-        if ($defaultParams) { $options = array_merge($params, $defaultParams); }
-        else                { $options = $params; }
+        if ($defaultParams) { $options = array_merge($params, $defaultParams); } else                { $options = $params; }
         $request = new Request();
         if ($usePostParams) {
             $request->setPost(new Parameters($params));