PHP EventManager::setSharedManager方法代码示例

 public function setUp()
 {
     // Store original autoloaders
     $this->loaders = spl_autoload_functions();
     if (!is_array($this->loaders)) {
         // spl_autoload_functions does not return empty array when no
         // autoloaders registered...
         $this->loaders = array();
     }
     // Store original include_path
     $this->includePath = get_include_path();
     $autoloader = new ModuleAutoloader(array(dirname(__DIR__) . '/TestAsset'));
     $autoloader->register();
     $this->sharedEvents = new SharedEventManager();
     $this->moduleManager = new ModuleManager(array('ListenerTestModule'));
     $this->moduleManager->getEventManager()->setSharedManager($this->sharedEvents);
     $this->moduleManager->getEventManager()->attach('loadModule.resolve', new ModuleResolverListener(), 1000);
     $this->application = new MockApplication();
     $events = new EventManager(array('Zend\\Mvc\\Application', 'ZendTest\\Module\\TestAsset\\MockApplication', 'application'));
     $events->setSharedManager($this->sharedEvents);
     $this->application->setEventManager($events);
     $this->serviceManager = new ServiceManager();
     $this->serviceManager->setService('ModuleManager', $this->moduleManager);
     $this->application->setServiceManager($this->serviceManager);
 }

 /**
  * Create an instance of EventManagerProxy
  * 
  * @param ServiceLocatorInterface $serviceLocator
  * 
  * @return EventManagerProxy
  */
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     $proxy = new EventManagerProxy();
     $em = new EventManager();
     $em->setSharedManager($serviceLocator->get('SharedEventManager'));
     $proxy->setEventManager($em);
     return $proxy;
 }

 public function testAttach()
 {
     $sharedEvents = new SharedEventManager();
     $events = new EventManager();
     $events->setSharedManager($sharedEvents);
     $listener = new AccessListener();
     $listener->attach($events);
     $this->assertCount(1, $sharedEvents->getListeners('SporkTools', MvcEvent::EVENT_DISPATCH));
 }

 public function setUp()
 {
     $this->module = new Module();
     $this->app = $this->getMockBuilder('Zend\\Mvc\\Application')->disableOriginalConstructor()->getMock();
     $sm = new ServiceManager(new Config(['services' => ['translator' => Translator::factory(['locale' => 'id_ID'])]]));
     $this->app->expects($this->any())->method('getServiceManager')->willReturn($sm);
     $em = new EventManager();
     $em->setSharedManager(new SharedEventManager());
     $this->app->expects($this->any())->method('getEventManager')->willReturn($em);
 }

 public function marshalEventManager()
 {
     $r = new ReflectionClass(EventManager::class);
     if ($r->hasMethod('setSharedManager')) {
         $eventManager = new EventManager();
         $eventManager->setSharedManager(new SharedEventManager());
         return $eventManager;
     }
     return new EventManager(new SharedEventManager());
 }

 public function testCanAttachListeners()
 {
     $mockListener = $this->getMock('EventLogger\\Log\\Listener\\LogListener');
     $serviceManager = new ServiceManager();
     $serviceManager->setService('EventLogger\\Log\\Listener\\AppListener', $mockListener);
     $serviceManager->setService('EventLogger\\Log\\Listener\\DispatchErrorListener', $mockListener);
     $eventManager = new EventManager();
     $eventManager->setSharedManager(new SharedEventManager());
     $listenerAggregate = new ListenerAggregate($serviceManager);
     $listenerAggregate->attach($eventManager);
 }

 public function setUp()
 {
     $this->module = new Module();
     $app = $this->prophesize('Zend\\Mvc\\Application');
     $sm = new ServiceManager(new Config(['services' => ['translator' => Translator::factory(['locale' => 'id_ID'])]]));
     $app->getServiceManager()->willReturn($sm);
     $em = new EventManager();
     $em->setSharedManager(new SharedEventManager());
     $app->getEventManager()->willReturn($em);
     $this->app = $app->reveal();
 }

 /**
  * Create an EventManager instance
  *
  * Creates a new EventManager instance, seeding it with a shared instance
  * of SharedEventManager.
  *
  * @param  ServiceLocatorInterface $serviceLocator
  * @return EventManager
  * @throws ServiceNotFoundException
  */
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     if ($serviceLocator instanceof AbstractPluginManager) {
         $serviceLocator = $serviceLocator->getServiceLocator();
     }
     /** @var SharedEventManagerInterface $sharedEventManager */
     $sharedEventManager = $serviceLocator->get('SharedEventManager');
     $em = new EventManager();
     $em->setSharedManager($sharedEventManager);
     return $em;
 }

 /**
  * Create and return an EventManager composing the shared event manager instance.
  *
  * @return EventManager
  */
 private function createEventManager()
 {
     $r = new \ReflectionClass(EventManager::class);
     if ($r->hasMethod('setSharedManager')) {
         // zend-eventmanager v2 initialization
         $eventManager = new EventManager();
         $eventManager->setSharedManager($this->sharedEventManager);
         return $eventManager;
     }
     // zend-eventmanager v3 initialization
     return new EventManager($this->sharedEventManager);
 }

 /**
  * Create an EventManager instance
  *
  * Creates a new EventManager instance, seeding it with a shared instance
  * of SharedEventManager.
  *
  * @param  ContainerInterface $container
  * @param  string $name
  * @param  null|array $options
  * @return EventManager
  */
 public function __invoke(ContainerInterface $container, $name, array $options = null)
 {
     if ($this->acceptsSharedManagerToConstructor()) {
         // zend-eventmanager v3
         return new EventManager($container->has('SharedEventManager') ? $container->get('SharedEventManager') : null);
     }
     // zend-eventmanager v2
     $events = new EventManager();
     if ($container->has('SharedEventManager')) {
         $events->setSharedManager($container->get('SharedEventManager'));
     }
     return $events;
 }

 /**
  * @param ContainerInterface $container
  *
  * @return EventManager
  */
 protected function createEventManager(ContainerInterface $container)
 {
     if ($this->acceptsSharedManagerToConstructor()) {
         // zend-eventmanager v3
         return new EventManager($container->has('SharedEventManager') ? $container->get('SharedEventManager') : null);
     }
     // zend-eventmanager v2
     $events = new EventManager();
     if ($container->has('SharedEventManager')) {
         $events->setSharedManager($container->get('SharedEventManager'));
     }
     return $events;
 }

 protected function setUp()
 {
     $module = new Module();
     $events = new EventManager();
     $sharedEvents = new SharedEventManager();
     $events->setSharedManager($sharedEvents);
     $plugins = new ControllerPluginManager();
     $this->serviceManager = new ServiceManager();
     $this->serviceManager->setService('Zend\\ServiceManager\\ServiceLocatorInterface', $this->serviceManager);
     $this->serviceManager->setService('EventManager', $events);
     $this->serviceManager->setService('SharedEventManager', $sharedEvents);
     $this->serviceManager->setService('ControllerPluginManager', $plugins);
     $this->controllerManager = new ControllerManager(new Config($module->getControllerConfig()));
     $this->controllerManager->setServiceLocator($this->serviceManager);
     $this->controllerManager->addPeeringServiceManager($this->serviceManager);
 }

 public function testEventListenerIsAttached()
 {
     $module = new Module();
     $mvcEvent = $this->getMock('Zend\\EventManager\\EventInterface');
     $application = $this->getMock('Zend\\Mvc\\Application', [], [], '', false);
     $eventManager = new EventManager();
     $eventManager->setSharedManager(new SharedEventManager());
     $serviceManager = new ServiceManager();
     $mvcEvent->expects($this->once())->method('getParam')->with('application')->will($this->returnValue($application));
     $application->expects($this->once())->method('getEventManager')->will($this->returnValue($eventManager));
     $application->expects($this->once())->method('getServiceManager')->will($this->returnValue($serviceManager));
     $eventManager->addIdentifiers(['ZfcUser\\Service\\User']);
     $event = new Event();
     $event->setName('register.post');
     $userRegistrationService = $this->getMock('HtUserRegistration\\Service\\UserRegistrationServiceInterface');
     $serviceManager->setService('HtUserRegistration\\UserRegistrationService', $userRegistrationService);
     $userRegistrationService->expects($this->once())->method('onUserRegistration')->with($event);
     $module->onBootstrap($mvcEvent);
     $eventManager->trigger($event);
 }

 public function setUp()
 {
     $this->loaders = spl_autoload_functions();
     if (!is_array($this->loaders)) {
         // spl_autoload_functions does not return empty array when no
         // autoloaders registered...
         $this->loaders = array();
     }
     // Store original include_path
     $this->includePath = get_include_path();
     $autoloader = new ModuleAutoloader(array(dirname(__DIR__) . '/TestAsset'));
     $autoloader->register();
     $sharedEvents = new SharedEventManager();
     $this->moduleManager = new ModuleManager(array());
     $this->moduleManager->getEventManager()->setSharedManager($sharedEvents);
     $this->moduleManager->getEventManager()->attach(ModuleEvent::EVENT_LOAD_MODULE_RESOLVE, new ModuleResolverListener(), 1000);
     $this->moduleManager->getEventManager()->attach(ModuleEvent::EVENT_LOAD_MODULE, new OnBootstrapListener(), 1000);
     $this->application = new MockApplication();
     $events = new EventManager(array('Zend\\Mvc\\Application', 'ZendTest\\Module\\TestAsset\\MockApplication', 'application'));
     $events->setSharedManager($sharedEvents);
     $this->application->setEventManager($events);
 }

 /**
  * Create and return an event manager instance.
  *
  * Ensures that the returned event manager has a shared manager
  * composed.
  *
  * @return EventManager
  */
 private function createEventManager()
 {
     $r = new ReflectionClass(EventManager::class);
     if ($r->hasMethod('setSharedManager')) {
         $events = new EventManager();
         $events->setSharedManager(new SharedEventManager());
     } else {
         $events = new EventManager(new SharedEventManager());
     }
     $this->setEventManager($events);
     return $events;
 }