AliceMajere / wonderland-thread

tests/unit/Mediator/MediatorTest.php

Indentation +16 added lines, -16 removed lines

@@ -15,23 +15,23 @@
  */
 class MediatorTest extends TestCase
 {
-	/** @var Mediator */
-	private $mediator;
+    /** @var Mediator */
+    private $mediator;
 
-	public function setUp()
-	{
-		$this->mediator = new Mediator();
-	}
+    public function setUp()
+    {
+        $this->mediator = new Mediator();
+    }
 
-	public function test_listeners()
-	{
-		$listener = new TestListener();
-		$this->assertSame([], $this->mediator->getListeners());
-		$this->assertSame($this->mediator, $this->mediator->addListener($listener));
-		$this->assertSame([$listener], $this->mediator->getListeners());
-		$this->assertSame($this->mediator, $this->mediator->removeListener(new TestListener()));
-		$this->mediator->notify(new PoolEvent(PoolEvent::POOL_NEW_THREAD));
-		$this->assertSame($this->mediator, $this->mediator->removeListener($listener));
-	}
+    public function test_listeners()
+    {
+        $listener = new TestListener();
+        $this->assertSame([], $this->mediator->getListeners());
+        $this->assertSame($this->mediator, $this->mediator->addListener($listener));
+        $this->assertSame([$listener], $this->mediator->getListeners());
+        $this->assertSame($this->mediator, $this->mediator->removeListener(new TestListener()));
+        $this->mediator->notify(new PoolEvent(PoolEvent::POOL_NEW_THREAD));
+        $this->assertSame($this->mediator, $this->mediator->removeListener($listener));
+    }
 
 }

tests/unit/Event/EventTest.php

Indentation +38 added lines, -38 removed lines

@@ -14,43 +14,43 @@
  */
 class EventTest extends TestCase
 {
-	/** @var PoolEvent */
-	private $event;
-
-	/** @var AbstractThread */
-	private $thread;
-
-	public function setUp()
-	{
-		$this->thread = new SuccessThread('');
-		$this->event = new PoolEvent('unit-test');
-		$this->event->setThread($this->thread);
-	}
-
-	public function test_event()
-	{
-		$this->assertSame('unit-test', $this->event->getEventName());
-		$this->assertSame(0, $this->event->getMaxRunningThreadNb());
-		$this->assertSame(0, $this->event->getRunningThreadNb());
-		$this->assertSame(0, $this->event->getThreadDoneNb());
-		$this->assertSame(0, $this->event->getThreadLeftNb());
-		$this->assertSame(0, $this->event->getThreadNb());
-		$this->assertSame($this->thread, $this->event->getThread());
-
-		$this->assertSame($this->event, $this->event->setThread($this->thread));
-		$this->assertSame($this->event, $this->event->setMaxRunningThreadNb(100));
-		$this->assertSame($this->event, $this->event->setEventName('fake'));
-		$this->assertSame($this->event, $this->event->setRunningThreadNb(10));
-		$this->assertSame($this->event, $this->event->setThreadDoneNb(90));
-		$this->assertSame($this->event, $this->event->setThreadLeftNb(10));
-		$this->assertSame($this->event, $this->event->setThreadNb(10));
-
-		$this->assertSame('fake', $this->event->getEventName());
-		$this->assertSame(100, $this->event->getMaxRunningThreadNb());
-		$this->assertSame(10, $this->event->getRunningThreadNb());
-		$this->assertSame(90, $this->event->getThreadDoneNb());
-		$this->assertSame(10, $this->event->getThreadLeftNb());
-		$this->assertSame(10, $this->event->getThreadNb());
-	}
+    /** @var PoolEvent */
+    private $event;
+
+    /** @var AbstractThread */
+    private $thread;
+
+    public function setUp()
+    {
+        $this->thread = new SuccessThread('');
+        $this->event = new PoolEvent('unit-test');
+        $this->event->setThread($this->thread);
+    }
+
+    public function test_event()
+    {
+        $this->assertSame('unit-test', $this->event->getEventName());
+        $this->assertSame(0, $this->event->getMaxRunningThreadNb());
+        $this->assertSame(0, $this->event->getRunningThreadNb());
+        $this->assertSame(0, $this->event->getThreadDoneNb());
+        $this->assertSame(0, $this->event->getThreadLeftNb());
+        $this->assertSame(0, $this->event->getThreadNb());
+        $this->assertSame($this->thread, $this->event->getThread());
+
+        $this->assertSame($this->event, $this->event->setThread($this->thread));
+        $this->assertSame($this->event, $this->event->setMaxRunningThreadNb(100));
+        $this->assertSame($this->event, $this->event->setEventName('fake'));
+        $this->assertSame($this->event, $this->event->setRunningThreadNb(10));
+        $this->assertSame($this->event, $this->event->setThreadDoneNb(90));
+        $this->assertSame($this->event, $this->event->setThreadLeftNb(10));
+        $this->assertSame($this->event, $this->event->setThreadNb(10));
+
+        $this->assertSame('fake', $this->event->getEventName());
+        $this->assertSame(100, $this->event->getMaxRunningThreadNb());
+        $this->assertSame(10, $this->event->getRunningThreadNb());
+        $this->assertSame(90, $this->event->getThreadDoneNb());
+        $this->assertSame(10, $this->event->getThreadLeftNb());
+        $this->assertSame(10, $this->event->getThreadNb());
+    }
 
 }

tests/unit/ThreadTest.php

Indentation +43 added lines, -43 removed lines

@@ -17,55 +17,55 @@
  */
 class ThreadTest extends TestCase
 {
-	/** @var AbstractThread */
-	private $thread;
+    /** @var AbstractThread */
+    private $thread;
 
-	public function setUp()
-	{
-		$this->thread = new SuccessThread('unit-test');
-		$this->thread->setMediator(new Mediator());
-		$this->thread->setPid(1);
-	}
+    public function setUp()
+    {
+        $this->thread = new SuccessThread('unit-test');
+        $this->thread->setMediator(new Mediator());
+        $this->thread->setPid(1);
+    }
 
-	public function test_pid()
-	{
-		$this->assertSame(1, $this->thread->getPid());
-		$this->assertSame($this->thread, $this->thread->setPid(100));
-		$this->assertSame(100, $this->thread->getPid());
-	}
+    public function test_pid()
+    {
+        $this->assertSame(1, $this->thread->getPid());
+        $this->assertSame($this->thread, $this->thread->setPid(100));
+        $this->assertSame(100, $this->thread->getPid());
+    }
 
-	public function test_processName()
-	{
-		$this->assertSame('unit-test', $this->thread->getProcessName());
-	}
+    public function test_processName()
+    {
+        $this->assertSame('unit-test', $this->thread->getProcessName());
+    }
 
-	/**
-	 * @throws ThreadException
-	 */
-	public function test_run()
-	{
-		$this->assertSame(0, $this->thread->run());
-	}
+    /**
+     * @throws ThreadException
+     */
+    public function test_run()
+    {
+        $this->assertSame(0, $this->thread->run());
+    }
 
-	/**
-	 * @throws ThreadException
-	 */
-	public function test_run_exception()
-	{
-		$this->expectException(ThreadException::class);
-		$thread = new ExceptionThread('unit-test');
-		$thread->run();
+    /**
+     * @throws ThreadException
+     */
+    public function test_run_exception()
+    {
+        $this->expectException(ThreadException::class);
+        $thread = new ExceptionThread('unit-test');
+        $thread->run();
 
-	}
+    }
 
-	/**
-	 * @throws ThreadException
-	 */
-	public function test_run_exception_status()
-	{
-		$this->expectException(ThreadException::class);
-		$thread = new ErrorThread('unit-test');
-		$thread->run();
-	}
+    /**
+     * @throws ThreadException
+     */
+    public function test_run_exception_status()
+    {
+        $this->expectException(ThreadException::class);
+        $thread = new ErrorThread('unit-test');
+        $thread->run();
+    }
 
 }

tests/unit/ThreadPoolTest.php

Indentation +84 added lines, -84 removed lines

@@ -19,89 +19,89 @@
  */
 class ThreadPoolTest extends TestCase
 {
-	/** @var ThreadPool */
-	private $threadPool;
-
-	protected function setUp()
-	{
-		$this->threadPool = new ThreadPool();
-	}
-
-	public function test_constructor_destructor()
-	{
-		$this->assertAttributeEquals([], 'threads', $this->threadPool);
-		$this->assertAttributeEquals([], 'runningThreads', $this->threadPool);
-		$this->assertAttributeEquals([], 'toRunThreads', $this->threadPool);
-		$this->assertAttributeEquals(false, 'isRunning', $this->threadPool);
-		$this->assertAttributeEquals(0, 'maxRunningThreadNb', $this->threadPool);
-
-		unset($this->threadPool);
-	}
-
-	public function test_getThreads()
-	{
-		$threads = [new SuccessThread('')];
-		$this->assertSame($this->threadPool, $this->threadPool->setThreads($threads));
-		$this->assertSame($threads, $this->threadPool->getThreads());
-	}
-
-	public function test_addThread()
-	{
-		$thread = new SuccessThread('');
-		$this->assertSame($this->threadPool, $this->threadPool->addThread($thread));
-		$this->assertContains($thread, $this->threadPool->getThreads());
-	}
-
-	public function test_getMaxRunningThreadNb()
-	{
-		$this->assertSame(0, $this->threadPool->getMaxRunningThreadNb());
-	}
-
-	public function test_setMaxRunningThreadNb()
-	{
-		$this->assertSame($this->threadPool, $this->threadPool->setMaxRunningThreadNb(10));
-		$this->assertSame(10, $this->threadPool->getMaxRunningThreadNb());
-	}
-
-	public function test_getToRunThreads()
-	{
-		$this->assertSame([], $this->threadPool->getToRunThreads());
-	}
-
-	public function test_getRunningThreads()
-	{
-		$this->assertSame([], $this->threadPool->getRunningThreads());
-	}
-
-	/**
-	 * @throws \Wonderland\Thread\Exception\ThreadException
-	 */
-	public function test_run()
-	{
-		$thread = new SuccessThread('');
-		$threads = [];
-		$listener = new TestListener();
-
-		$this->threadPool->setMaxRunningThreadNb(10);
-		$this->assertSame($this->threadPool, $this->threadPool->addListener($listener));
-		for ($i = 0; $i < 20; $i++) {
-			$threads[] = clone $thread;
-		}
-		$this->assertSame($this->threadPool, $this->threadPool->addThread($thread));
-		$this->assertSame($this->threadPool, $this->threadPool->setThreads($threads));
-
-		$this->threadPool->run();
-
-		$this->assertSame($this->threadPool, $this->threadPool->removeListener($listener));
-	}
-
-	/**
-	 * @throws ThreadException
-	 */
-	public function test_run_exception()
-	{
-		$this->expectException(ThreadException::class);
-		$this->threadPool->run();
-	}
+    /** @var ThreadPool */
+    private $threadPool;
+
+    protected function setUp()
+    {
+        $this->threadPool = new ThreadPool();
+    }
+
+    public function test_constructor_destructor()
+    {
+        $this->assertAttributeEquals([], 'threads', $this->threadPool);
+        $this->assertAttributeEquals([], 'runningThreads', $this->threadPool);
+        $this->assertAttributeEquals([], 'toRunThreads', $this->threadPool);
+        $this->assertAttributeEquals(false, 'isRunning', $this->threadPool);
+        $this->assertAttributeEquals(0, 'maxRunningThreadNb', $this->threadPool);
+
+        unset($this->threadPool);
+    }
+
+    public function test_getThreads()
+    {
+        $threads = [new SuccessThread('')];
+        $this->assertSame($this->threadPool, $this->threadPool->setThreads($threads));
+        $this->assertSame($threads, $this->threadPool->getThreads());
+    }
+
+    public function test_addThread()
+    {
+        $thread = new SuccessThread('');
+        $this->assertSame($this->threadPool, $this->threadPool->addThread($thread));
+        $this->assertContains($thread, $this->threadPool->getThreads());
+    }
+
+    public function test_getMaxRunningThreadNb()
+    {
+        $this->assertSame(0, $this->threadPool->getMaxRunningThreadNb());
+    }
+
+    public function test_setMaxRunningThreadNb()
+    {
+        $this->assertSame($this->threadPool, $this->threadPool->setMaxRunningThreadNb(10));
+        $this->assertSame(10, $this->threadPool->getMaxRunningThreadNb());
+    }
+
+    public function test_getToRunThreads()
+    {
+        $this->assertSame([], $this->threadPool->getToRunThreads());
+    }
+
+    public function test_getRunningThreads()
+    {
+        $this->assertSame([], $this->threadPool->getRunningThreads());
+    }
+
+    /**
+     * @throws \Wonderland\Thread\Exception\ThreadException
+     */
+    public function test_run()
+    {
+        $thread = new SuccessThread('');
+        $threads = [];
+        $listener = new TestListener();
+
+        $this->threadPool->setMaxRunningThreadNb(10);
+        $this->assertSame($this->threadPool, $this->threadPool->addListener($listener));
+        for ($i = 0; $i < 20; $i++) {
+            $threads[] = clone $thread;
+        }
+        $this->assertSame($this->threadPool, $this->threadPool->addThread($thread));
+        $this->assertSame($this->threadPool, $this->threadPool->setThreads($threads));
+
+        $this->threadPool->run();
+
+        $this->assertSame($this->threadPool, $this->threadPool->removeListener($listener));
+    }
+
+    /**
+     * @throws ThreadException
+     */
+    public function test_run_exception()
+    {
+        $this->expectException(ThreadException::class);
+        $this->threadPool->run();
+    }
 
 }

src/Factory/EventPoolFactory.php

Indentation +21 added lines, -21 removed lines

@@ -10,27 +10,27 @@
 class EventPoolFactory
 {
 
-	/**
-	 * @param string                                $eventName
-	 * @param ThreadPool|AbstractThreadPoolMediator $pool
-	 * @param AbstractThread|null                   $thread
-	 * @return PoolEvent
-	 */
-	public static function create(
-		string $eventName,
-		AbstractThreadPoolMediator $pool,
-		?AbstractThread $thread = null
-	): PoolEvent
-	{
-		$event = new PoolEvent($eventName);
-		$event->setThreadNb(count($pool->getThreads()));
-		$event->setThreadDoneNb(count($pool->getThreads()) - count($pool->getToRunThreads()));
-		$event->setMaxRunningThreadNb($pool->getMaxRunningThreadNb());
-		$event->setThreadLeftNb(count($pool->getToRunThreads()));
-		$event->setRunningThreadNb(count($pool->getRunningThreads()));
-		$event->setThread($thread);
+    /**
+     * @param string                                $eventName
+     * @param ThreadPool|AbstractThreadPoolMediator $pool
+     * @param AbstractThread|null                   $thread
+     * @return PoolEvent
+     */
+    public static function create(
+        string $eventName,
+        AbstractThreadPoolMediator $pool,
+        ?AbstractThread $thread = null
+    ): PoolEvent
+    {
+        $event = new PoolEvent($eventName);
+        $event->setThreadNb(count($pool->getThreads()));
+        $event->setThreadDoneNb(count($pool->getThreads()) - count($pool->getToRunThreads()));
+        $event->setMaxRunningThreadNb($pool->getMaxRunningThreadNb());
+        $event->setThreadLeftNb(count($pool->getToRunThreads()));
+        $event->setRunningThreadNb(count($pool->getRunningThreads()));
+        $event->setThread($thread);
 
-		return $event;
-	}
+        return $event;
+    }
 
 }

src/Mediator/Mediator.php

Indentation +45 added lines, -45 removed lines

@@ -7,50 +7,50 @@
 
 class Mediator
 {
-	/** @var ListenerInterface[] */
-	private $listeners = [];
-
-	/**
-	 * @return ListenerInterface[]
-	 */
-	public function getListeners(): array
-	{
-		return $this->listeners;
-	}
-
-	/**
-	 * @param ListenerInterface $listener
-	 * @return Mediator
-	 */
-	public function addListener(ListenerInterface $listener): self
-	{
-		$this->listeners[] = $listener;
-
-		return $this;
-	}
-
-	/**
-	 * @param ListenerInterface $listener
-	 * @return Mediator
-	 */
-	public function removeListener(ListenerInterface $listener): self
-	{
-		$key = array_search($listener, $this->listeners, true);
-		if (false !== $key) {
-			unset($this->listeners[$key]);
-		}
-
-		return $this;
-	}
-
-	/**
-	 * @param EventInterface $event
-	 */
-	public function notify(EventInterface $event)
-	{
-		foreach ($this->listeners as $listener) {
-			$listener->notify($event);
-		}
-	}
+    /** @var ListenerInterface[] */
+    private $listeners = [];
+
+    /**
+     * @return ListenerInterface[]
+     */
+    public function getListeners(): array
+    {
+        return $this->listeners;
+    }
+
+    /**
+     * @param ListenerInterface $listener
+     * @return Mediator
+     */
+    public function addListener(ListenerInterface $listener): self
+    {
+        $this->listeners[] = $listener;
+
+        return $this;
+    }
+
+    /**
+     * @param ListenerInterface $listener
+     * @return Mediator
+     */
+    public function removeListener(ListenerInterface $listener): self
+    {
+        $key = array_search($listener, $this->listeners, true);
+        if (false !== $key) {
+            unset($this->listeners[$key]);
+        }
+
+        return $this;
+    }
+
+    /**
+     * @param EventInterface $event
+     */
+    public function notify(EventInterface $event)
+    {
+        foreach ($this->listeners as $listener) {
+            $listener->notify($event);
+        }
+    }
 
 }

src/Mediator/Listener/AbstractListener.php

Indentation +14 added lines, -14 removed lines

@@ -7,20 +7,20 @@
 abstract class AbstractListener implements ListenerInterface
 {
 
-	/**
-	 * @param EventInterface $event
-	 */
-	public function notify(EventInterface $event)
-	{
-		$mapping = $this->getEventMapping();
-		if (false === isset($mapping[$event->getEventName()])) {
-			return;
-		}
+    /**
+     * @param EventInterface $event
+     */
+    public function notify(EventInterface $event)
+    {
+        $mapping = $this->getEventMapping();
+        if (false === isset($mapping[$event->getEventName()])) {
+            return;
+        }
 
-		call_user_func(
-			[$this, $mapping[$event->getEventName()]],
-			$event
-		);
-	}
+        call_user_func(
+            [$this, $mapping[$event->getEventName()]],
+            $event
+        );
+    }
 
 }

src/AbstractThread.php

Indentation +83 added lines, -83 removed lines

@@ -6,88 +6,88 @@
 
 abstract class AbstractThread extends AbstractThreadMediator
 {
-	const EXIT_STATUS_SUCCESS = 0;
-	const EXIT_STATUS_ERROR = 1;
-
-	/** @var int $pid */
-	private $pid;
-
-	/** @var string $processName */
-	private $processName;
-
-	/**
-	 * AbstractThread constructor.
-	 *
-	 * @param string $processName
-	 */
-	public function __construct(string $processName)
-	{
-		$this->processName = $processName;
-	}
-
-	/**
-	 * Return the name of the method to process during the thread
-	 *
-	 * @return string
-	 */
-	abstract protected function getMethodName(): string;
-
-	/**
-	 * Return the list of dependencies that will be passed as parameters of the method referenced by getMethodName
-	 *
-	 * @return array
-	 */
-	abstract protected function getDependencies(): array;
-
-	/**
-	 * @return int|null
-	 */
-	public function getPid(): ?int
-	{
-		return $this->pid;
-	}
-
-	/**
-	 * @param int $pid
-	 * @return AbstractThread
-	 */
-	public function setPid(int $pid): self
-	{
-		$this->pid = $pid;
-
-		return $this;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getProcessName(): ?string
-	{
-		return $this->processName;
-	}
-
-	/**
-	 * @return int
-	 * @throws ThreadException
-	 */
-	public function run(): int
-	{
-		if (false === method_exists($this, $this->getMethodName())) {
-			throw new ThreadException('No proper method defined for the thread');
-		}
-
-		$status = call_user_func_array(
-			[$this, $this->getMethodName()],
-			array_merge([$this->getProcessName()], $this->getDependencies())
-		);
-
-		if (null === $status) {
-			throw new ThreadException(
-				'Error. You must return a process status in '.get_class($this).':'.$this->getMethodName()
-			);
-		}
-
-		return $status;
-	}
+    const EXIT_STATUS_SUCCESS = 0;
+    const EXIT_STATUS_ERROR = 1;
+
+    /** @var int $pid */
+    private $pid;
+
+    /** @var string $processName */
+    private $processName;
+
+    /**
+     * AbstractThread constructor.
+     *
+     * @param string $processName
+     */
+    public function __construct(string $processName)
+    {
+        $this->processName = $processName;
+    }
+
+    /**
+     * Return the name of the method to process during the thread
+     *
+     * @return string
+     */
+    abstract protected function getMethodName(): string;
+
+    /**
+     * Return the list of dependencies that will be passed as parameters of the method referenced by getMethodName
+     *
+     * @return array
+     */
+    abstract protected function getDependencies(): array;
+
+    /**
+     * @return int|null
+     */
+    public function getPid(): ?int
+    {
+        return $this->pid;
+    }
+
+    /**
+     * @param int $pid
+     * @return AbstractThread
+     */
+    public function setPid(int $pid): self
+    {
+        $this->pid = $pid;
+
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getProcessName(): ?string
+    {
+        return $this->processName;
+    }
+
+    /**
+     * @return int
+     * @throws ThreadException
+     */
+    public function run(): int
+    {
+        if (false === method_exists($this, $this->getMethodName())) {
+            throw new ThreadException('No proper method defined for the thread');
+        }
+
+        $status = call_user_func_array(
+            [$this, $this->getMethodName()],
+            array_merge([$this->getProcessName()], $this->getDependencies())
+        );
+
+        if (null === $status) {
+            throw new ThreadException(
+                'Error. You must return a process status in '.get_class($this).':'.$this->getMethodName()
+            );
+        }
+
+        return $status;
+    }
 
 }

Spacing +1 added lines, -1 removed lines

@@ -83,7 +83,7 @@
 
 		if (null === $status) {
 			throw new ThreadException(
-				'Error. You must return a process status in '.get_class($this).':'.$this->getMethodName()
+				'Error. You must return a process status in ' . get_class($this) . ':' . $this->getMethodName()
 			);
 		}
 

src/AbstractThreadMediator.php

Indentation +20 added lines, -20 removed lines

@@ -7,28 +7,28 @@
 
 class AbstractThreadMediator
 {
-	/** @var Mediator */
-	private $mediator;
+    /** @var Mediator */
+    private $mediator;
 
-	/**
-	 * @return Mediator
-	 */
-	protected function getMediator()
-	{
-		return $this->mediator;
-	}
+    /**
+     * @return Mediator
+     */
+    protected function getMediator()
+    {
+        return $this->mediator;
+    }
 
-	public function setMediator(Mediator $mediator)
-	{
-		$this->mediator = $mediator;
-	}
+    public function setMediator(Mediator $mediator)
+    {
+        $this->mediator = $mediator;
+    }
 
-	/**
-	 * @param EventInterface $event
-	 */
-	protected function notify(EventInterface $event)
-	{
-		$this->getMediator()->notify($event);
-	}
+    /**
+     * @param EventInterface $event
+     */
+    protected function notify(EventInterface $event)
+    {
+        $this->getMediator()->notify($event);
+    }
 
 }