Support PHP 5.4

.docker/config/Dockerfile

@@ -1,4 +1,4 @@
-FROM php:5.6-cli
+FROM php:5.4-cli
 
 #
 # Tools & libraries
@@ -31,12 +31,15 @@ COPY php.ini /usr/local/etc/php/php.ini
 ARG TIMEZONE
 RUN echo "\n""date.timezone = $TIMEZONE""\n" >> /usr/local/etc/php/php.ini
 
+#
+# Disabled, because:
+# PHP versions below 5.5 are not supported
 #
 # Xdebug
 #
-RUN pecl install xdebug \
+#RUN pecl install xdebug \
-    && docker-php-ext-enable xdebug
+#    && docker-php-ext-enable xdebug
-COPY xdebug.ini /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
+#COPY xdebug.ini /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
 
 #
 # Phing

.phing/tests.xml

@@ -146,13 +146,18 @@
     2017-02-22
     -->
     <target name="check:cs" description="Checks coding standard">
-        <echo msg="Checking coding standard..." />
+        <echo msg="Checking coding standard... DISABLED for PHP 5.4" />
+        <!--
+        Disabled, because of error while running PHP 5.4.45:
+        This task requires the PHP_CodeSniffer package installed and available on the include path
+
         <phpcodesniffer standard="PSR2" showWarnings="true">
             <fileset refid="sourcecode" />
             <formatter type="checkstyle" outfile="${dir.reports}/checkstyle.xml" />
             <formatter type="csv" outfile="${dir.reports}/checkstyle.csv" />
             <formatter type="summary" outfile="${dir.reports}/checkstyle_summary.txt" />
         </phpcodesniffer>
+        -->
     </target>
 
     <!-- copy/paste detector -->

composer.json

@@ -11,22 +11,24 @@
         }
     ],
     "require": {
-        "php": ">=5.6",
+        "php": ">=5.4",
         "fguillot/json-rpc": "^1.2",
-        "meritoo/common-library": "~0.0.1"
+        "gedmo/doctrine-extensions": "^2.4",
+        "symfony/http-foundation": "^2.8"
     },
     "require-dev": {
-        "phpunit/phpunit": "^5.7",
+        "phpunit/phpunit": "^4.8",
-        "squizlabs/php_codesniffer": "^2.9",
+        "squizlabs/php_codesniffer": "^3.1",
         "phpmd/phpmd": "^2.6",
-        "sebastian/phpcpd": "^3.0",
+        "sebastian/phpcpd": "^2.0",
         "pdepend/pdepend": "^2.5",
-        "phploc/phploc": "^4.0",
+        "phploc/phploc": "^2.1",
-        "friendsofphp/php-cs-fixer": "^2.6"
+        "friendsofphp/php-cs-fixer": "^2.2"
     },
     "autoload": {
         "psr-4": {
-            "Meritoo\\LimeSurvey\\ApiClient\\": "src/"
+            "Meritoo\\Common\\": "src/Common/",
+            "Meritoo\\LimeSurvey\\ApiClient\\": "src/LimeSurvey/"
         }
     },
     "autoload-dev": {

src/Common/Collection/Collection.php

@@ -0,0 +1,284 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Collection;
+
+use ArrayAccess;
+use ArrayIterator;
+use Countable;
+use IteratorAggregate;
+use Meritoo\Common\Utilities\Arrays;
+
+/**
+ * Collection of elements.
+ * It's a set of some elements, e.g. objects.
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class Collection implements Countable, ArrayAccess, IteratorAggregate
+{
+    /**
+     * The elements of collection
+     *
+     * @var array
+     */
+    private $elements;
+
+    /**
+     * Class constructor
+     *
+     * @param array $elements (optional) The elements of collection
+     */
+    public function __construct(array $elements = [])
+    {
+        $this->elements = $elements;
+    }
+
+    /**
+     * {@inheritdoc}
+     * Required by interface Countable
+     */
+    public function count()
+    {
+        return count($this->elements);
+    }
+
+    /**
+     * {@inheritdoc}
+     * Required by interface ArrayAccess
+     */
+    public function offsetExists($offset)
+    {
+        return $this->exists($offset);
+    }
+
+    /**
+     * {@inheritdoc}
+     * Required by interface ArrayAccess
+     */
+    public function offsetGet($offset)
+    {
+        if ($this->exists($offset)) {
+            return $this->elements[$offset];
+        }
+
+        return null;
+    }
+
+    /**
+     * {@inheritdoc}
+     * Required by interface ArrayAccess
+     */
+    public function offsetSet($offset, $value)
+    {
+        $this->elements[$offset] = $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     * Required by interface ArrayAccess
+     */
+    public function offsetUnset($offset)
+    {
+        if ($this->exists($offset)) {
+            unset($this->elements[$offset]);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     * Required by interface IteratorAggregate
+     */
+    public function getIterator()
+    {
+        return new ArrayIterator($this->elements);
+    }
+
+    /**
+     * Adds given element (at the end of collection)
+     *
+     * @param mixed $element The element to add
+     * @param mixed $index   (optional) Index / key of the element
+     * @return $this
+     */
+    public function add($element, $index = null)
+    {
+        if (null === $index) {
+            $this->elements[] = $element;
+        } else {
+            $this->elements[$index] = $element;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Adds given elements (at the end of collection)
+     *
+     * @param array|Collection $elements   The elements to add
+     * @param bool|false       $useIndexes (optional) If is set to true, indexes of given elements will be used in
+     *                                     this collection. Otherwise - not.
+     * @return $this
+     */
+    public function addMultiple($elements, $useIndexes = false)
+    {
+        if (!empty($elements)) {
+            foreach ($elements as $index => $element) {
+                if (!$useIndexes) {
+                    $index = null;
+                }
+
+                $this->add($element, $index);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Prepends given element (adds given element at the beginning of collection)
+     *
+     * @param mixed $element The element to prepend
+     * @return $this
+     */
+    public function prepend($element)
+    {
+        array_unshift($this->elements, $element);
+
+        return $this;
+    }
+
+    /**
+     * Removes given element
+     *
+     * @param mixed $element The element to remove
+     * @return $this
+     */
+    public function remove($element)
+    {
+        if ($this->count() > 0) {
+            foreach ($this->elements as $index => $existing) {
+                if ($element === $existing) {
+                    unset($this->elements[$index]);
+                    break;
+                }
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Returns information if collection is empty
+     *
+     * @return bool
+     */
+    public function isEmpty()
+    {
+        return empty($this->elements);
+    }
+
+    /**
+     * Returns information if given element is first in the collection
+     *
+     * @param mixed $element The element to verify
+     * @return bool
+     */
+    public function isFirst($element)
+    {
+        return reset($this->elements) === $element;
+    }
+
+    /**
+     * Returns information if given element is last in the collection
+     *
+     * @param mixed $element The element to verify
+     * @return bool
+     */
+    public function isLast($element)
+    {
+        return end($this->elements) === $element;
+    }
+
+    /**
+     * Returns information if the collection has given element, iow. if given element exists in the collection
+     *
+     * @param mixed $element The element to verify
+     * @return bool
+     */
+    public function has($element)
+    {
+        $index = Arrays::getIndexOf($this->elements, $element);
+
+        return null !== $index && false !== $index;
+    }
+
+    /**
+     * Returns previous element for given element
+     *
+     * @param mixed $element The element to verify
+     * @return mixed|null
+     */
+    public function getPrevious($element)
+    {
+        return Arrays::getPreviousElement($this->elements, $element);
+    }
+
+    /**
+     * Returns next element for given element
+     *
+     * @param mixed $element The element to verify
+     * @return mixed|null
+     */
+    public function getNext($element)
+    {
+        return Arrays::getNextElement($this->elements, $element);
+    }
+
+    /**
+     * Returns the first element in the collection
+     *
+     * @return mixed
+     */
+    public function getFirst()
+    {
+        return Arrays::getFirstElement($this->elements);
+    }
+
+    /**
+     * Returns the last element in the collection
+     *
+     * @return mixed
+     */
+    public function getLast()
+    {
+        return Arrays::getLastElement($this->elements);
+    }
+
+    /**
+     * Returns an array representation of the collection
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->elements;
+    }
+
+    /**
+     * Returns information if element with given index/key exists
+     *
+     * @param string|int $index The index/key of element
+     * @return bool
+     */
+    private function exists($index)
+    {
+        return isset($this->elements[$index]) || array_key_exists($index, $this->elements);
+    }
+}

src/Common/Exception/Base/UnknownTypeException.php

@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Base;
+
+use Exception;
+use Meritoo\Common\Type\Base\BaseType;
+use Meritoo\Common\Utilities\Arrays;
+
+/**
+ * An exception used while type of something is unknown
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+abstract class UnknownTypeException extends Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string|int $unknownType  The unknown type of something (value of constant)
+     * @param BaseType   $typeInstance An instance of class that contains type of the something
+     * @param string     $typeName     Name of the something
+     */
+    public function __construct($unknownType, BaseType $typeInstance, $typeName)
+    {
+        $allTypes = $typeInstance->getAll();
+        $types = Arrays::values2string($allTypes, '', ', ');
+
+        $template = 'The \'%s\' type of %s is unknown. Probably doesn\'t exist or there is a typo. You should use one'
+            . ' of these types: %s.';
+
+        $message = sprintf(sprintf($template, $unknownType, $typeName, $types));
+        parent::__construct($message);
+    }
+}

src/Common/Exception/Date/UnknownDatePartTypeException.php

@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Date;
+
+use Meritoo\Common\Exception\Base\UnknownTypeException;
+use Meritoo\Common\Type\DatePartType;
+
+/**
+ * An exception used while type of date part, e.g. "year", is unknown
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class UnknownDatePartTypeException extends UnknownTypeException
+{
+    /**
+     * Class constructor
+     *
+     * @param string $unknownDatePart Type of date part, e.g. "year". One of DatePartType class constants.
+     * @param string $value           Incorrect value
+     */
+    public function __construct($unknownDatePart, $value)
+    {
+        parent::__construct($unknownDatePart, new DatePartType(), sprintf('date part (with value %s)', $value));
+    }
+}

src/Common/Exception/File/EmptyFileException.php

@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\File;
+
+/**
+ * An exception used while file with given path is empty (has no content)
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class EmptyFileException extends \Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string $emptyFilePath Path of the empty file
+     */
+    public function __construct($emptyFilePath)
+    {
+        $template = 'File with path \'%s\' is empty (has no content). Did you provide path of proper file?';
+        $message = sprintf($template, $emptyFilePath);
+
+        parent::__construct($message);
+    }
+}

src/Common/Exception/File/EmptyFilePathException.php

@@ -0,0 +1,26 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\File;
+
+/**
+ * An exception used while path of given file is empty
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class EmptyFilePathException extends \Exception
+{
+    /**
+     * Class constructor
+     */
+    public function __construct()
+    {
+        parent::__construct('Path of the file is empty. Did you provide path of proper file?');
+    }
+}

src/Common/Exception/File/NotExistingFileException.php

@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\File;
+
+/**
+ * An exception used while file with given path does not exist
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class NotExistingFileException extends \Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string $notExistingFilePath Path of not existing (or not readable) file
+     */
+    public function __construct($notExistingFilePath)
+    {
+        $template = 'File with path \'%s\' does not exist (or is not readable). Did you provide path of proper file?';
+        $message = sprintf($template, $notExistingFilePath);
+
+        parent::__construct($message);
+    }
+}

src/Common/Exception/Method/DisabledMethodException.php

@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Method;
+
+use Exception;
+
+/**
+ * An exception used while method cannot be called, because is disabled
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class DisabledMethodException extends Exception
+{
+    const className = '\Meritoo\Common\Exception\Method\DisabledMethodException';
+
+    /**
+     * Class constructor
+     *
+     * @param string $disabledMethod    Name of the disabled method
+     * @param string $alternativeMethod (optional) Name of the alternative method
+     */
+    public function __construct($disabledMethod, $alternativeMethod = '')
+    {
+        $template = 'Method %s() cannot be called, because is disabled.';
+
+        if (!empty($alternativeMethod)) {
+            $template .= ' Use %s() instead.';
+        }
+
+        $message = sprintf($template, $disabledMethod, $alternativeMethod);
+        parent::__construct($message);
+    }
+}

src/Common/Exception/Reflection/CannotResolveClassNameException.php

@@ -0,0 +1,47 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Reflection;
+
+use Exception;
+
+/**
+ * An exception used while name of class or trait cannot be resolved
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class CannotResolveClassNameException extends Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param array|object|string $source   Source of the class's / trait's name. It can be an array of objects,
+     *                                      namespaces, object or namespace.
+     * @param bool                $forClass (optional) If is set to true, message of this exception for class is
+     *                                      prepared. Otherwise - for trait.
+     */
+    public function __construct($source, $forClass = true)
+    {
+        $forWho = 'trait';
+        $value = '';
+
+        if ($forClass) {
+            $forWho = 'class';
+        }
+
+        if (is_scalar($source)) {
+            $value = sprintf(' %s', (string)$source);
+        }
+
+        $template = 'Name of %s from given \'%s\'%s cannot be resolved. Is there everything ok?';
+        $message = sprintf($template, $forWho, gettype($source), $value);
+
+        parent::__construct($message);
+    }
+}

src/Common/Exception/Reflection/MissingChildClassesException.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Reflection;
+
+use Exception;
+use Meritoo\Common\Utilities\Reflection;
+
+/**
+ * An exception used while given class has no child classes
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class MissingChildClassesException extends Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param array|object|string $parentClass Class that hasn't child classes, but it should. An array of objects,
+     *                                         strings, object or string.
+     */
+    public function __construct($parentClass)
+    {
+        $template = 'The \'%s\' class requires one child class at least who will extend her (maybe is an abstract'
+            . ' class), but the child classes are missing. Did you forget to extend this class?';
+
+        $parentClassName = Reflection::getClassName($parentClass);
+        $message = sprintf($template, $parentClassName);
+
+        parent::__construct($message);
+    }
+}

src/Common/Exception/Reflection/TooManyChildClassesException.php

@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Reflection;
+
+use Exception;
+use Meritoo\Common\Utilities\Reflection;
+
+/**
+ * An exception used while given class has more than one child class
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class TooManyChildClassesException extends Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param array|object|string $parentClass  Class that has more than one child class, but it shouldn't. An array
+     *                                          of objects, strings, object or string.
+     * @param array               $childClasses Child classes
+     */
+    public function __construct($parentClass, array $childClasses)
+    {
+        $template = "The '%s' class requires one child class at most who will extend her, but more than one child"
+            . " class was found:\n- %s\n\nWhy did you create more than one classes that extend '%s' class?";
+
+        $parentClassName = Reflection::getClassName($parentClass);
+        $message = sprintf($template, $parentClassName, implode("\n- ", $childClasses), $parentClassName);
+
+        parent::__construct($message);
+    }
+}

src/Common/Exception/Regex/IncorrectColorHexLengthException.php

@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Regex;
+
+/**
+ * An exception used while length of given hexadecimal value of color is incorrect
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class IncorrectColorHexLengthException extends \Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string $color Incorrect hexadecimal value of color
+     */
+    public function __construct($color)
+    {
+        $template = 'Length of hexadecimal value of color \'%s\' is incorrect. It\'s %d, but it should be 3 or 6.'
+            . ' Is there everything ok?';
+
+        $message = sprintf($template, $color, strlen($color));
+        parent::__construct($message);
+    }
+}

src/Common/Exception/Regex/InvalidColorHexValueException.php

@@ -0,0 +1,29 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Regex;
+
+/**
+ * An exception used while given hexadecimal value of color is invalid
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class InvalidColorHexValueException extends \Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string $color Invalid hexadecimal value of color
+     */
+    public function __construct($color)
+    {
+        $message = sprintf('Hexadecimal value of color \'%s\' is invalid. Is there everything ok?', $color);
+        parent::__construct($message);
+    }
+}

src/Common/Exception/Regex/InvalidUrlException.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Meritoo\Common\Exception\Regex;
+
+/**
+ * An exception used while url is invalid
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class InvalidUrlException extends \Exception
+{
+    const className = '\Meritoo\Common\Exception\Regex\InvalidUrlException';
+
+    /**
+     * Class constructor
+     *
+     * @param string $url Invalid url
+     */
+    public function __construct($url)
+    {
+        $message = sprintf('Url \'%s\' is invalid. Is there everything ok?', $url);
+        parent::__construct($message);
+    }
+}

src/Common/Exception/Type/UnknownOopVisibilityTypeException.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Meritoo\Common\Exception\Type;
+
+use Meritoo\Common\Exception\Base\UnknownTypeException;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * An exception used while the visibility of a property, a method or (as of PHP 7.1.0) a constant is unknown
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class UnknownOopVisibilityTypeException extends UnknownTypeException
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function __construct($unknownType)
+    {
+        parent::__construct($unknownType, new OopVisibilityType(), 'OOP-related visibility');
+    }
+}

src/Common/Iterator/CommonIterator.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace Meritoo\Common\Iterator;
+
+use Iterator;
+
+/**
+ * Iterator of iterable values
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class CommonIterator implements Iterator
+{
+    /**
+     * Index/Position of current value
+     *
+     * @var int
+     */
+    private $currentIndex = 0;
+
+    /**
+     * Maximum index/position of current value
+     *
+     * @var int
+     */
+    private $maxIndex = 0;
+
+    /**
+     * Values to iterate
+     *
+     * @var array
+     */
+    private $values = [];
+
+    /**
+     * Class constructor
+     *
+     * @param array $values Values to iterate
+     */
+    public function __construct(array $values)
+    {
+        $this->values = $values;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function current()
+    {
+        return $this->values[$this->currentIndex];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function key()
+    {
+        return $this->currentIndex;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function next()
+    {
+        if (0 <= $this->currentIndex && $this->maxIndex > $this->currentIndex) {
+            ++$this->currentIndex;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function rewind()
+    {
+        $this->currentIndex = 0;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function valid()
+    {
+        return 0 <= $this->currentIndex && $this->maxIndex >= $this->currentIndex;
+    }
+}

src/Common/Test/Base/BaseTestCase.php

@@ -0,0 +1,310 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Base;
+
+use DateTime;
+use Meritoo\Common\Exception\Type\UnknownOopVisibilityTypeException;
+use Meritoo\Common\Iterator\CommonIterator;
+use Meritoo\Common\Type\OopVisibilityType;
+use Meritoo\Common\Utilities\Miscellaneous;
+use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use ReflectionMethod;
+
+/**
+ * Base test case with common methods and data providers
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+abstract class BaseTestCase extends TestCase
+{
+    /**
+     * Path of directory with data used by test cases
+     *
+     * @var string
+     */
+    private static $testsDataDirPath = '.data/tests';
+
+    /**
+     * Provides an empty value
+     *
+     * @return CommonIterator
+     * //return Generator
+     */
+    public function provideEmptyValue()
+    {
+        return new CommonIterator([
+            '',
+            '   ',
+            null,
+            0,
+            false,
+            [],
+        ]);
+
+        /*
+        yield[''];
+        yield['   '];
+        yield[null];
+        yield[0];
+        yield[false];
+        yield[[]];
+        */
+    }
+
+    /**
+     * Provides boolean value
+     *
+     * @return CommonIterator
+     * //return Generator
+     */
+    public function provideBooleanValue()
+    {
+        return new CommonIterator([
+            true,
+            false,
+        ]);
+
+        /*
+        yield[false];
+        yield[true];
+        */
+    }
+
+    /**
+     * Provides instance of DateTime class
+     *
+     * @return CommonIterator
+     * //return Generator
+     */
+    public function provideDateTimeInstance()
+    {
+        return new CommonIterator([
+            new DateTime(),
+            new DateTime('yesterday'),
+            new DateTime('now'),
+            new DateTime('tomorrow'),
+        ]);
+
+        /*
+        yield[new DateTime()];
+        yield[new DateTime('yesterday')];
+        yield[new DateTime('now')];
+        yield[new DateTime('tomorrow')];
+        */
+    }
+
+    /**
+     * Provides relative / compound format of DateTime
+     *
+     * @return CommonIterator
+     * //return Generator
+     */
+    public function provideDateTimeRelativeFormat()
+    {
+        return new CommonIterator([
+            'now',
+            'yesterday',
+            'tomorrow',
+            'back of 10',
+            'front of 10',
+            'last day of February',
+            'first day of next month',
+            'last day of previous month',
+            'last day of next month',
+            'Y-m-d',
+            'Y-m-d 10:00',
+        ]);
+
+        /*
+        yield['now'];
+        yield['yesterday'];
+        yield['tomorrow'];
+        yield['back of 10'];
+        yield['front of 10'];
+        yield['last day of February'];
+        yield['first day of next month'];
+        yield['last day of previous month'];
+        yield['last day of next month'];
+        yield['Y-m-d'];
+        yield['Y-m-d 10:00'];
+        */
+    }
+
+    /**
+     * Provides path of not existing file, e.g. "lorem/ipsum.jpg"
+     *
+     * @return CommonIterator
+     * //return Generator
+     */
+    public function provideNotExistingFilePath()
+    {
+        return new CommonIterator([
+            'lets-test.doc',
+            'lorem/ipsum.jpg',
+            'surprise/me/one/more/time.txt',
+        ]);
+
+        /*
+        yield['lets-test.doc'];
+        yield['lorem/ipsum.jpg'];
+        yield['surprise/me/one/more/time.txt'];
+        */
+    }
+
+    /**
+     * Returns path of file used by tests.
+     * It should be placed in /.data/tests directory of this project.
+     *
+     * @param string $fileName      Name of file
+     * @param string $directoryPath (optional) Path of directory containing the file
+     * @return string
+     */
+    public function getFilePathToTests($fileName, $directoryPath = '')
+    {
+        $rootPath = Miscellaneous::getProjectRootPath();
+
+        $paths = [
+            $rootPath,
+            self::$testsDataDirPath,
+            $directoryPath,
+            $fileName,
+        ];
+
+        return Miscellaneous::concatenatePaths($paths);
+    }
+
+    /**
+     * Verifies visibility and arguments of method
+     *
+     * @param string                  $classNamespace         Namespace of class that contains method to verify
+     * @param string|ReflectionMethod $method                 Name of method or just the method to verify
+     * @param string                  $visibilityType         Expected visibility of verified method. One of
+     *                                                        OopVisibilityType class constants.
+     * @param int                     $argumentsCount         (optional) Expected count/amount of arguments of the
+     *                                                        verified method
+     * @param int                     $requiredArgumentsCount (optional) Expected count/amount of required arguments
+     *                                                        of the verified method
+     * @throws UnknownOopVisibilityTypeException
+     *
+     * Attention. 2nd argument, the $method, may be:
+     * - string - name of the method
+     * - instance of ReflectionMethod - just the method (provided by ReflectionClass::getMethod() method)
+     */
+    protected static function assertMethodVisibilityAndArguments(
+        $classNamespace,
+        $method,
+        $visibilityType,
+        $argumentsCount = 0,
+        $requiredArgumentsCount = 0
+    ) {
+        /*
+         * Type of visibility is correct?
+         */
+        if (!(new OopVisibilityType())->isCorrectType($visibilityType)) {
+            throw new UnknownOopVisibilityTypeException($visibilityType);
+        }
+
+        $reflection = new ReflectionClass($classNamespace);
+
+        /*
+         * Name of method provided only?
+         * Let's find instance of the method (based on reflection)
+         */
+        if (!$method instanceof ReflectionMethod) {
+            $method = $reflection->getMethod($method);
+        }
+
+        switch ($visibilityType) {
+            case OopVisibilityType::IS_PUBLIC:
+                static::assertTrue($method->isPublic());
+                break;
+
+            case OopVisibilityType::IS_PROTECTED:
+                static::assertTrue($method->isProtected());
+                break;
+
+            case OopVisibilityType::IS_PRIVATE:
+                static::assertTrue($method->isPrivate());
+                break;
+        }
+
+        static::assertEquals($argumentsCount, $method->getNumberOfParameters());
+        static::assertEquals($requiredArgumentsCount, $method->getNumberOfRequiredParameters());
+    }
+
+    /**
+     * Verifies visibility and arguments of class constructor
+     *
+     * @param string $classNamespace         Namespace of class that contains constructor to verify
+     * @param string $visibilityType         Expected visibility of verified method. One of OopVisibilityType class
+     *                                       constants.
+     * @param int    $argumentsCount         (optional) Expected count/amount of arguments of the verified method
+     * @param int    $requiredArgumentsCount (optional) Expected count/amount of required arguments of the verified
+     *                                       method
+     * @throws UnknownOopVisibilityTypeException
+     */
+    protected static function assertConstructorVisibilityAndArguments(
+        $classNamespace,
+        $visibilityType,
+        $argumentsCount = 0,
+        $requiredArgumentsCount = 0
+    ) {
+        /*
+         * Let's grab the constructor
+         */
+        $reflection = new ReflectionClass($classNamespace);
+        $method = $reflection->getConstructor();
+
+        return static::assertMethodVisibilityAndArguments($classNamespace, $method, $visibilityType, $argumentsCount, $requiredArgumentsCount);
+    }
+
+    /**
+     * Asserts that class with given namespace has no constructor
+     *
+     * @param string $classNamespace Namespace of class that contains constructor to verify
+     */
+    protected static function assertHasNoConstructor($classNamespace)
+    {
+        /*
+         * Let's grab the constructor
+         */
+        $reflection = new ReflectionClass($classNamespace);
+        $constructor = $reflection->getConstructor();
+
+        static::assertNull($constructor);
+    }
+
+    /**
+     * Sets path of directory with data used by test cases
+     *
+     * @param string $testsDataDirPath Path of directory with data used by test cases
+     */
+    protected static function setTestsDataDirPath($testsDataDirPath)
+    {
+        static::$testsDataDirPath = $testsDataDirPath;
+    }
+
+    /**
+     * Returns a mock object for the specified class
+     *
+     * @param string $originalClassName Name of the class to mock
+     * @return \PHPUnit_Framework_MockObject_MockObject
+     */
+    protected function createMock($originalClassName)
+    {
+        $methods = [];
+        $arguments = [];
+        $mockClassName = '';
+        $callOriginalConstructor = false;
+
+        return $this->getMock($originalClassName, $methods, $arguments, $mockClassName, $callOriginalConstructor);
+    }
+}

src/Common/Test/Base/BaseTypeTestCase.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace Meritoo\Common\Test\Base;
+
+use Generator;
+use Meritoo\Common\Type\Base\BaseType;
+
+/**
+ * Base test case for the type of something
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+abstract class BaseTypeTestCase extends BaseTestCase
+{
+    /**
+     * Verifies availability of all types
+     */
+    public function testAvailabilityOfAllTypes()
+    {
+        $available = $this->getTestedTypeInstance()->getAll();
+        $all = $this->getAllExpectedTypes();
+
+        if (isset($available['className'])) {
+            unset($available['className']);
+        }
+
+        static::assertEquals($all, $available);
+    }
+
+    /**
+     * Verifies whether given type is correct or not
+     *
+     * @param string $type     Type to verify
+     * @param bool   $expected Information if given type is correct or not
+     *
+     * @dataProvider provideTypeToVerify
+     */
+    public function testIfGivenTypeIsCorrect($type, $expected)
+    {
+        static::assertEquals($expected, $this->getTestedTypeInstance()->isCorrectType($type));
+    }
+
+    /**
+     * Provides type to verify and information if it's correct
+     *
+     * @return Generator
+     */
+    abstract public function provideTypeToVerify();
+
+    /**
+     * Returns instance of the tested type
+     *
+     * @return BaseType
+     */
+    abstract protected function getTestedTypeInstance();
+
+    /**
+     * Returns all expected types of the tested type
+     *
+     * @return array
+     */
+    abstract protected function getAllExpectedTypes();
+}

src/Common/Type/Base/BaseType.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Type\Base;
+
+use Meritoo\Common\Utilities\Reflection;
+
+/**
+ * Base / abstract type of something, e.g. type of button, order, date etc.
+ * Child class should contain constants - each of them represent one type.
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+abstract class BaseType
+{
+    /**
+     * All types
+     *
+     * @var array
+     */
+    private $all;
+
+    /**
+     * Returns all types
+     *
+     * @return array
+     */
+    public function getAll()
+    {
+        if (null === $this->all) {
+            $this->all = Reflection::getConstants($this);
+        }
+
+        return $this->all;
+    }
+
+    /**
+     * Returns information if given type is correct
+     *
+     * @param string $type The type to check
+     * @return bool
+     */
+    public function isCorrectType($type)
+    {
+        return in_array($type, $this->getAll(), true);
+    }
+}

src/Common/Type/DatePartType.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Type;
+
+use Meritoo\Common\Type\Base\BaseType;
+
+/**
+ * Type of date part, e.g. "year"
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class DatePartType extends BaseType
+{
+    /**
+     * The "day" date part
+     *
+     * @var string
+     */
+    const DAY = 'day';
+
+    /**
+     * The "hour" date part
+     *
+     * @var string
+     */
+    const HOUR = 'hour';
+
+    /**
+     * The "minute" date part
+     *
+     * @var string
+     */
+    const MINUTE = 'minute';
+
+    /**
+     * The "month" date part
+     *
+     * @var string
+     */
+    const MONTH = 'month';
+
+    /**
+     * The "second" date part
+     *
+     * @var string
+     */
+    const SECOND = 'second';
+
+    /**
+     * The "year" date part
+     *
+     * @var string
+     */
+    const YEAR = 'year';
+}

src/Common/Type/OopVisibilityType.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Meritoo\Common\Type;
+
+use Meritoo\Common\Type\Base\BaseType;
+
+/**
+ * The visibility of a property, a method or (as of PHP 7.1.0) a constant
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ *
+ * @see       http://php.net/manual/en/language.oop5.visibility.php
+ */
+class OopVisibilityType extends BaseType
+{
+    /**
+     * The "private" visibility of OOP
+     *
+     * @var int
+     */
+    const IS_PRIVATE = 3;
+
+    /**
+     * The "protected" visibility of OOP
+     *
+     * @var int
+     */
+    const IS_PROTECTED = 2;
+
+    /**
+     * The "public" visibility of OOP
+     *
+     * @var int
+     */
+    const IS_PUBLIC = 1;
+}

src/Common/Utilities/Date.php

@@ -0,0 +1,714 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Utilities;
+
+use DateInterval;
+use DateTime;
+use Meritoo\Common\Exception\Date\UnknownDatePartTypeException;
+use Meritoo\Common\Type\DatePartType;
+
+/**
+ * Useful date methods
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class Date
+{
+    /**
+     * The 'days' unit of date difference.
+     * Difference between dates in days.
+     *
+     * @var string
+     */
+    const DATE_DIFFERENCE_UNIT_DAYS = 'days';
+
+    /**
+     * The 'hours' unit of date difference.
+     * Difference between dates in hours.
+     *
+     * @var string
+     */
+    const DATE_DIFFERENCE_UNIT_HOURS = 'hours';
+
+    /**
+     * The 'minutes' unit of date difference.
+     * Difference between dates in minutes.
+     *
+     * @var string
+     */
+    const DATE_DIFFERENCE_UNIT_MINUTES = 'minutes';
+
+    /**
+     * The 'months' unit of date difference.
+     * Difference between dates in months.
+     *
+     * @var string
+     */
+    const DATE_DIFFERENCE_UNIT_MONTHS = 'months';
+
+    /**
+     * The 'years' unit of date difference.
+     * Difference between dates in years.
+     *
+     * @var string
+     */
+    const DATE_DIFFERENCE_UNIT_YEARS = 'years';
+
+    /**
+     * Returns start and end date for given period.
+     * The dates are returned in an array with indexes 'start' and 'end'.
+     *
+     * @param int $period The period, type of period. One of DatePeriod class constants, e.g. DatePeriod::LAST_WEEK.
+     * @return DatePeriod
+     */
+    public static function getDatesForPeriod($period)
+    {
+        $datePeriod = null;
+
+        if (DatePeriod::isCorrectPeriod($period)) {
+            $dateStart = null;
+            $dateEnd = null;
+
+            switch ($period) {
+                case DatePeriod::LAST_WEEK:
+                    $thisWeekStart = new DateTime('this week');
+
+                    $dateStart = clone $thisWeekStart;
+                    $dateEnd = clone $thisWeekStart;
+
+                    $dateStart->sub(new DateInterval('P7D'));
+                    $dateEnd->sub(new DateInterval('P1D'));
+
+                    break;
+                case DatePeriod::THIS_WEEK:
+                    $dateStart = new DateTime('this week');
+
+                    $dateEnd = clone $dateStart;
+                    $dateEnd->add(new DateInterval('P6D'));
+
+                    break;
+                case DatePeriod::NEXT_WEEK:
+                    $dateStart = new DateTime('this week');
+                    $dateStart->add(new DateInterval('P7D'));
+
+                    $dateEnd = clone $dateStart;
+                    $dateEnd->add(new DateInterval('P6D'));
+
+                    break;
+                case DatePeriod::LAST_MONTH:
+                    $dateStart = new DateTime('first day of last month');
+                    $dateEnd = new DateTime('last day of last month');
+
+                    break;
+                case DatePeriod::THIS_MONTH:
+                    $lastMonth = self::getDatesForPeriod(DatePeriod::LAST_MONTH);
+                    $nextMonth = self::getDatesForPeriod(DatePeriod::NEXT_MONTH);
+
+                    $dateStart = $lastMonth->getEndDate();
+                    $dateStart->add(new DateInterval('P1D'));
+
+                    $dateEnd = $nextMonth->getStartDate();
+                    $dateEnd->sub(new DateInterval('P1D'));
+
+                    break;
+                case DatePeriod::NEXT_MONTH:
+                    $dateStart = new DateTime('first day of next month');
+                    $dateEnd = new DateTime('last day of next month');
+
+                    break;
+                case DatePeriod::LAST_YEAR:
+                case DatePeriod::THIS_YEAR:
+                case DatePeriod::NEXT_YEAR:
+                    $dateStart = new DateTime();
+                    $dateEnd = new DateTime();
+
+                    if (DatePeriod::LAST_YEAR == $period || DatePeriod::NEXT_YEAR == $period) {
+                        $yearDifference = 1;
+
+                        if (DatePeriod::LAST_YEAR == $period) {
+                            $yearDifference *= -1;
+                        }
+
+                        $modifyString = sprintf('%s year', $yearDifference);
+                        $dateStart->modify($modifyString);
+                        $dateEnd->modify($modifyString);
+                    }
+
+                    $year = $dateStart->format('Y');
+                    $dateStart->setDate($year, 1, 1);
+                    $dateEnd->setDate($year, 12, 31);
+
+                    break;
+            }
+
+            if (null !== $dateStart && null !== $dateEnd) {
+                $dateStart->setTime(0, 0, 0);
+                $dateEnd->setTime(23, 59, 59);
+
+                $datePeriod = new DatePeriod($dateStart, $dateEnd);
+            }
+        }
+
+        return $datePeriod;
+    }
+
+    /**
+     * Generates and returns random time (the hour, minute and second values)
+     *
+     * @param string $format (optional) Format of returned value. A string acceptable by the DateTime::format()
+     *                       method.
+     * @return string|null
+     */
+    public static function generateRandomTime($format = 'H:i:s')
+    {
+        $dateTime = new DateTime();
+
+        /*
+         * Format si empty or is incorrect?
+         * Nothing to do
+         */
+        if (empty($format) || $dateTime->format($format) === $format) {
+            return null;
+        }
+
+        $hours = [];
+        $minutes = [];
+        $seconds = [];
+
+        for ($i = 1; $i <= 23; ++$i) {
+            $hours[] = $i;
+        }
+
+        for ($i = 1; $i <= 59; ++$i) {
+            $minutes[] = $i;
+        }
+
+        for ($i = 1; $i <= 59; ++$i) {
+            $seconds[] = $i;
+        }
+
+        /*
+         * Prepare random time (hour, minute and second)
+         */
+        $hour = $hours[array_rand($hours)];
+        $minute = $minutes[array_rand($minutes)];
+        $second = $seconds[array_rand($seconds)];
+
+        return $dateTime
+            ->setTime($hour, $minute, $second)
+            ->format($format);
+    }
+
+    /**
+     * Returns current day of week
+     *
+     * @return int
+     */
+    public static function getCurrentDayOfWeek()
+    {
+        $now = new DateTime();
+
+        $year = $now->format('Y');
+        $month = $now->format('m');
+        $day = $now->format('d');
+
+        return self::getDayOfWeek($year, $month, $day);
+    }
+
+    /**
+     * Returns day of week (number 0 to 6, 0 - sunday, 6 - saturday).
+     * Based on the Zeller's algorithm (http://pl.wikipedia.org/wiki/Kalendarz_wieczny).
+     *
+     * @param int $year  The year value
+     * @param int $month The month value
+     * @param int $day   The day value
+     *
+     * @return int
+     * @throws UnknownDatePartTypeException
+     */
+    public static function getDayOfWeek($year, $month, $day)
+    {
+        $year = (int)$year;
+        $month = (int)$month;
+        $day = (int)$day;
+
+        /*
+         * Oops, incorrect year
+         */
+        if ($year <= 0) {
+            throw new UnknownDatePartTypeException(DatePartType::YEAR, $year);
+        }
+
+        /*
+         * Oops, incorrect month
+         */
+        if ($month < 1 || $month > 12) {
+            throw new UnknownDatePartTypeException(DatePartType::MONTH, $month);
+        }
+
+        /*
+         * Oops, incorrect day
+         */
+        if ($day < 1 || $day > 31) {
+            throw new UnknownDatePartTypeException(DatePartType::DAY, $day);
+        }
+
+        if ($month < 3) {
+            $count = 0;
+            $yearValue = $year - 1;
+        } else {
+            $count = 2;
+            $yearValue = $year;
+        }
+
+        $firstPart = floor(23 * $month / 9);
+        $secondPart = floor($yearValue / 4);
+        $thirdPart = floor($yearValue / 100);
+        $fourthPart = floor($yearValue / 400);
+
+        return ($firstPart + $day + 4 + $year + $secondPart - $thirdPart + $fourthPart - $count) % 7;
+    }
+
+    /**
+     * Returns based on locale name of current weekday
+     *
+     * @return string
+     */
+    public static function getCurrentDayOfWeekName()
+    {
+        $now = new DateTime();
+
+        $year = $now->format('Y');
+        $month = $now->format('m');
+        $day = $now->format('d');
+
+        return self::getDayOfWeekName($year, $month, $day);
+    }
+
+    /**
+     * Returns name of weekday based on locale
+     *
+     * @param int $year  The year value
+     * @param int $month The month value
+     * @param int $day   The day value
+     * @return string
+     */
+    public static function getDayOfWeekName($year, $month, $day)
+    {
+        $hour = 0;
+        $minute = 0;
+        $second = 0;
+
+        $time = mktime($hour, $minute, $second, $month, $day, $year);
+        $name = strftime('%A', $time);
+
+        $encoding = mb_detect_encoding($name);
+
+        if (false === $encoding) {
+            $name = mb_convert_encoding($name, 'UTF-8', 'ISO-8859-2');
+        }
+
+        return $name;
+    }
+
+    /**
+     * Returns difference between given dates.
+     *
+     * The difference is calculated in units based on the 3rd argument or all available unit of date difference
+     * (defined as DATE_DIFFERENCE_UNIT_* constants of this class).
+     *
+     * The difference is also whole / complete value for given unit instead of relative value as may be received by
+     * DateTime::diff() method, e.g.:
+     * - 2 days, 50 hours
+     * instead of
+     * - 2 days, 2 hours
+     *
+     * If the unit of date difference is null, all units are returned in array (units are keys of the array).
+     * Otherwise - one, integer value is returned.
+     *
+     * @param string|DateTime $dateStart      The start date
+     * @param string|DateTime $dateEnd        The end date
+     * @param int             $differenceUnit (optional) Unit of date difference. One of this class
+     *                                        DATE_DIFFERENCE_UNIT_* constants. If is set to null all units are
+     *                                        returned in the array.
+     * @return array|int
+     */
+    public static function getDateDifference($dateStart, $dateEnd, $differenceUnit = null)
+    {
+        $validDateStart = self::isValidDate($dateStart, true);
+        $validDateEnd = self::isValidDate($dateEnd, true);
+
+        /*
+         * The start or end date is unknown?
+         * or
+         * The start or end date is not valid date?
+         *
+         * Nothing to do
+         */
+        if (empty($dateStart) || empty($dateEnd) || !$validDateStart || !$validDateEnd) {
+            return null;
+        }
+
+        $dateStart = self::getDateTime($dateStart, true);
+        $dateEnd = self::getDateTime($dateEnd, true);
+
+        $difference = [];
+        $dateDiff = $dateEnd->getTimestamp() - $dateStart->getTimestamp();
+
+        $daysInSeconds = 0;
+        $hoursInSeconds = 0;
+
+        $hourSeconds = 60 * 60;
+        $daySeconds = $hourSeconds * 24;
+
+        /*
+         * These units are related, because while calculating difference in the lowest unit, difference in the
+         * highest unit is required, e.g. while calculating hours I have to know difference in days
+         */
+        $relatedUnits = [
+            self::DATE_DIFFERENCE_UNIT_DAYS,
+            self::DATE_DIFFERENCE_UNIT_HOURS,
+            self::DATE_DIFFERENCE_UNIT_MINUTES,
+        ];
+
+        if (null === $differenceUnit || self::DATE_DIFFERENCE_UNIT_YEARS == $differenceUnit) {
+            $diff = $dateEnd->diff($dateStart);
+
+            /*
+             * Difference between dates in years should be returned only?
+             */
+            if (self::DATE_DIFFERENCE_UNIT_YEARS == $differenceUnit) {
+                return $diff->y;
+            }
+
+            $difference[self::DATE_DIFFERENCE_UNIT_YEARS] = $diff->y;
+        }
+
+        if (null === $differenceUnit || self::DATE_DIFFERENCE_UNIT_MONTHS == $differenceUnit) {
+            $diff = $dateEnd->diff($dateStart);
+
+            /*
+             * Difference between dates in months should be returned only?
+             */
+            if (self::DATE_DIFFERENCE_UNIT_MONTHS == $differenceUnit) {
+                return $diff->m;
+            }
+
+            $difference[self::DATE_DIFFERENCE_UNIT_MONTHS] = $diff->m;
+        }
+
+        if (null === $differenceUnit || in_array($differenceUnit, $relatedUnits)) {
+            $days = (int)floor($dateDiff / $daySeconds);
+
+            /*
+             * Difference between dates in days should be returned only?
+             */
+            if (self::DATE_DIFFERENCE_UNIT_DAYS == $differenceUnit) {
+                return $days;
+            }
+
+            /*
+             * All units should be returned?
+             */
+            if (null === $differenceUnit) {
+                $difference[self::DATE_DIFFERENCE_UNIT_DAYS] = $days;
+            }
+
+            /*
+             * Calculation for later usage
+             */
+            $daysInSeconds = $days * $daySeconds;
+        }
+
+        if (null === $differenceUnit || in_array($differenceUnit, $relatedUnits)) {
+            $hours = (int)floor(($dateDiff - $daysInSeconds) / $hourSeconds);
+
+            /*
+             * Difference between dates in hours should be returned only?
+             */
+            if (self::DATE_DIFFERENCE_UNIT_HOURS == $differenceUnit) {
+                return $hours;
+            }
+
+            /*
+             * All units should be returned?
+             */
+            if (null === $differenceUnit) {
+                $difference[self::DATE_DIFFERENCE_UNIT_HOURS] = $hours;
+            }
+
+            /*
+             * Calculation for later usage
+             */
+            $hoursInSeconds = $hours * $hourSeconds;
+        }
+
+        if (null === $differenceUnit || self::DATE_DIFFERENCE_UNIT_MINUTES == $differenceUnit) {
+            $minutes = (int)floor(($dateDiff - $daysInSeconds - $hoursInSeconds) / 60);
+
+            /*
+             * Difference between dates in minutes should be returned only?
+             */
+            if (self::DATE_DIFFERENCE_UNIT_MINUTES == $differenceUnit) {
+                return $minutes;
+            }
+
+            $difference[self::DATE_DIFFERENCE_UNIT_MINUTES] = $minutes;
+        }
+
+        return $difference;
+    }
+
+    /**
+     * Returns collection / set of dates for given start date and count of dates.
+     * Start from given date, add next, iterated value to given date interval and returns requested count of dates.
+     *
+     * @param DateTime $startDate        The start date. Start of the collection / set.
+     * @param int      $datesCount       Count of dates in resulting collection / set
+     * @param string   $intervalTemplate (optional) Template used to build date interval. It should contain "%d" as the
+     *                                   placeholder which is replaced with a number that represents each iteration.
+     *                                   Default: interval for days.
+     * @return array
+     */
+    public static function getDatesCollection(DateTime $startDate, $datesCount, $intervalTemplate = 'P%dD')
+    {
+        $dates = [];
+
+        /*
+         * The template used to build date interval have to be string.
+         * Otherwise cannot run preg_match() function and an error occurs.
+         */
+        if (is_string($intervalTemplate)) {
+            /*
+             * Let's verify the interval template. It should contains the "%d" placeholder and something before and
+             * after it.
+             *
+             * Examples:
+             * - P%dD
+             * - P%dM
+             * - P1Y%dMT1H
+             */
+            $intervalPattern = '/^(\w*)\%d(\w*)$/';
+            $matches = [];
+            $matchCount = preg_match($intervalPattern, $intervalTemplate, $matches);
+
+            if ($matchCount > 0 && (!empty($matches[1]) || !empty($matches[2]))) {
+                $datesCount = (int)$datesCount;
+
+                for ($index = 1; $index <= $datesCount; ++$index) {
+                    $date = clone $startDate;
+                    $dates[$index] = $date->add(new DateInterval(sprintf($intervalTemplate, $index)));
+                }
+            }
+        }
+
+        return $dates;
+    }
+
+    /**
+     * Returns random date based on given start date
+     *
+     * @param DateTime $startDate        The start date. Start of the random date.
+     * @param int      $start            (optional) Start of random partition
+     * @param int      $end              (optional) End of random partition
+     * @param string   $intervalTemplate (optional) Template used to build date interval. The placeholder is replaced
+     *                                   with next, iterated value.
+     * @return DateTime
+     */
+    public static function getRandomDate(DateTime $startDate = null, $start = 1, $end = 100, $intervalTemplate = 'P%sD')
+    {
+        if (null === $startDate) {
+            $startDate = new DateTime();
+        }
+
+        $start = (int)$start;
+        $end = (int)$end;
+
+        /*
+         * Incorrect end of random partition?
+         * Use start as the end of random partition
+         */
+        if ($end < $start) {
+            $end = $start;
+        }
+
+        $randomDate = clone $startDate;
+        $randomInterval = new DateInterval(sprintf($intervalTemplate, rand($start, $end)));
+
+        return $randomDate->add($randomInterval);
+    }
+
+    /**
+     * Returns the DateTime object for given value.
+     * If the DateTime object cannot be created, false is returned.
+     *
+     * @param mixed  $value                The value which maybe is a date
+     * @param bool   $allowCompoundFormats (optional) If is set to true, the compound formats used to create an
+     *                                     instance of DateTime class are allowed (e.g. "now", "last day of next
+     *                                     month", "yyyy"). Otherwise - not and every incorrect value is refused.
+     * @param string $dateFormat           (optional) Format of date used to verify if given value is actually a date.
+     *                                     It should be format matched to the given value, e.g. "Y-m-d H:i" for
+     *                                     "2015-01-01 10:00" value.
+     * @return DateTime|bool
+     */
+    public static function getDateTime($value, $allowCompoundFormats = false, $dateFormat = 'Y-m-d')
+    {
+        /*
+         * Empty value?
+         * Nothing to do :)
+         */
+        if (empty($value)) {
+            return false;
+        }
+
+        /*
+         * Instance of DateTime class?
+         * Nothing to do :)
+         */
+        if ($value instanceof DateTime) {
+            return $value;
+        }
+
+        try {
+            try {
+                /*
+                 * Pass the value to the constructor. Maybe it's one of the allowed relative formats.
+                 * Examples: "now", "last day of next month"
+                 */
+                $date = new DateTime($value);
+
+                /*
+                 * Instance of the DateTime class was created.
+                 * Let's verify if given value is really proper date.
+                 */
+                $dateFromFormat = DateTime::createFromFormat($dateFormat, $value);
+
+                if (false === $dateFromFormat) {
+                    /*
+                     * Nothing to do more, because:
+                     * a) instance of the DateTime was created
+                     * and
+                     * b) if createFromFormat() method failed, given value is one of the allowed relative formats
+                     * ("now", "last day of next month")
+                     * and...
+                     */
+                    if ($allowCompoundFormats) {
+                        /*
+                         * ...and
+                         * c) it's not an integer, e.g. not 10 or 100 or 1000
+                         */
+                        if (!is_numeric($value)) {
+                            return $date;
+                        }
+                    } else {
+                        $specialFormats = [
+                            'now',
+                        ];
+
+                        /*
+                         * ...and
+                         * c) it's special compound format that contains characters that each may be used by
+                         * DateTime::format() method and it raises problem while trying to verify the value at the end
+                         * of this method:
+                         *
+                         * (new DateTime())->format($value);
+                         *
+                         * So, I have to refuse those special compound formats if they are not explicitly declared as
+                         * compound (2nd argument of this method, set to false by default)
+                         */
+                        if (in_array($value, $specialFormats)) {
+                            return false;
+                        }
+                    }
+                } /*
+                 * Verify instance of the DateTime created by constructor and by createFromFormat() method.
+                 * After formatting, these dates should be the same.
+                 */
+                else {
+                    if ($dateFromFormat->format($dateFormat) === $value) {
+                        return $date;
+                    }
+                }
+            } catch (\Exception $exception) {
+                if (!$allowCompoundFormats) {
+                    return false;
+                }
+            }
+
+            /*
+             * Does the value is a string that may be used to format date?
+             * Example: "Y-m-d"
+             */
+            $dateString = (new DateTime())->format($value);
+
+            if ($dateString != $value) {
+                return new DateTime($dateString);
+            }
+        } catch (\Exception $exception) {
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns information if given value is valid date
+     *
+     * @param mixed $value                The value which maybe is a date
+     * @param bool  $allowCompoundFormats (optional) If is set to true, the compound formats used to create an
+     *                                    instance of DateTime class are allowed (e.g. "now", "last day of next
+     *                                    month", "yyyy"). Otherwise - not and every incorrect value is refused.
+     * @return bool
+     */
+    public static function isValidDate($value, $allowCompoundFormats = false)
+    {
+        return self::getDateTime($value, $allowCompoundFormats) instanceof DateTime;
+    }
+
+    /**
+     * Returns information if given format of date is valid
+     *
+     * @param string $format The validated format of date
+     * @return bool
+     */
+    public static function isValidDateFormat($format)
+    {
+        if (empty($format) || !is_string($format)) {
+            return false;
+        }
+
+        /*
+         * Datetime to string
+         */
+        $formatted = (new DateTime())->format($format);
+
+        /*
+         * Formatted date it's the format who is validated?
+         * The format is invalid
+         */
+        if ($formatted == $format) {
+            return false;
+        }
+
+        /*
+         * Validate the format used to create the datetime
+         */
+        $fromFormat = DateTime::createFromFormat($format, $formatted);
+
+        /*
+         * It's instance of DateTime?
+         * The format is valid
+         */
+        if ($fromFormat instanceof DateTime) {
+            return true;
+        }
+
+        return $fromFormat instanceof DateTime;
+    }
+}

src/Common/Utilities/DatePeriod.php

@@ -0,0 +1,195 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Utilities;
+
+use DateTime;
+
+/**
+ * A date's period.
+ * Contains start and end date of the period.
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class DatePeriod
+{
+    /**
+     * The period constant: last month
+     *
+     * @var int
+     */
+    const LAST_MONTH = 4;
+
+    /**
+     * The period constant: last week
+     *
+     * @var int
+     */
+    const LAST_WEEK = 1;
+
+    /**
+     * The period constant: last year
+     *
+     * @var int
+     */
+    const LAST_YEAR = 7;
+
+    /**
+     * The period constant: next month
+     *
+     * @var int
+     */
+    const NEXT_MONTH = 6;
+
+    /**
+     * The period constant: next week
+     *
+     * @var int
+     */
+    const NEXT_WEEK = 3;
+
+    /**
+     * The period constant: next year
+     *
+     * @var int
+     */
+    const NEXT_YEAR = 9;
+
+    /**
+     * The period constant: this month
+     *
+     * @var int
+     */
+    const THIS_MONTH = 5;
+
+    /**
+     * The period constant: this week
+     *
+     * @var int
+     */
+    const THIS_WEEK = 2;
+
+    /**
+     * The period constant: this year
+     *
+     * @var int
+     */
+    const THIS_YEAR = 8;
+
+    /**
+     * The start date of period
+     *
+     * @var DateTime
+     */
+    private $startDate;
+
+    /**
+     * The end date of period
+     *
+     * @var DateTime
+     */
+    private $endDate;
+
+    /**
+     * Class constructor
+     *
+     * @param DateTime $startDate (optional) The start date of period
+     * @param DateTime $endDate   (optional) The end date of period
+     */
+    public function __construct(DateTime $startDate = null, DateTime $endDate = null)
+    {
+        $this->startDate = $startDate;
+        $this->endDate = $endDate;
+    }
+
+    /**
+     * Returns information if given period is correct
+     *
+     * @param int $period The period to verify
+     * @return bool
+     */
+    public static function isCorrectPeriod($period)
+    {
+        return in_array($period, Reflection::getConstants(__CLASS__));
+    }
+
+    /**
+     * Returns formatted one of the period's date: start date or end date
+     *
+     * @param string $format    Format used to format the date
+     * @param bool   $startDate (optional) If is set to true, start date is formatted. Otherwise - end date.
+     * @return string
+     */
+    public function getFormattedDate($format, $startDate = true)
+    {
+        $date = $this->getEndDate();
+
+        /*
+         * Start date should be formatted?
+         */
+        if ($startDate) {
+            $date = $this->getStartDate();
+        }
+
+        /*
+         * Unknown date or format is invalid?
+         */
+        if (null === $date || !Date::isValidDateFormat($format)) {
+            return '';
+        }
+
+        return $date->format($format);
+    }
+
+    /**
+     * Returns the end date of period
+     *
+     * @return DateTime
+     */
+    public function getEndDate()
+    {
+        return $this->endDate;
+    }
+
+    /**
+     * Sets the end date of period
+     *
+     * @param DateTime $endDate (optional) The end date of period
+     * @return $this
+     */
+    public function setEndDate(DateTime $endDate = null)
+    {
+        $this->endDate = $endDate;
+
+        return $this;
+    }
+
+    /**
+     * Returns the start date of period
+     *
+     * @return DateTime
+     */
+    public function getStartDate()
+    {
+        return $this->startDate;
+    }
+
+    /**
+     * Sets the start date of period
+     *
+     * @param DateTime $startDate (optional) The start date of period
+     * @return $this
+     */
+    public function setStartDate(DateTime $startDate = null)
+    {
+        $this->startDate = $startDate;
+
+        return $this;
+    }
+}

src/Common/Utilities/Reflection.php

@@ -0,0 +1,668 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Utilities;
+
+use Doctrine\Common\Util\ClassUtils;
+use Doctrine\Common\Util\Inflector;
+use Meritoo\Common\Collection\Collection;
+use Meritoo\Common\Exception\Reflection\CannotResolveClassNameException;
+use Meritoo\Common\Exception\Reflection\MissingChildClassesException;
+use Meritoo\Common\Exception\Reflection\TooManyChildClassesException;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionMethod;
+use ReflectionObject;
+use ReflectionProperty;
+
+/**
+ * Useful reflection methods
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class Reflection
+{
+    /**
+     * Returns names of methods for given class / object
+     *
+     * @param object|string $class              The object or name of object's class
+     * @param bool          $withoutInheritance (optional) If is set to true, only methods for given class are returned.
+     *                                          Otherwise - all methods, with inherited methods too.
+     * @return array
+     */
+    public static function getMethods($class, $withoutInheritance = false)
+    {
+        $effect = [];
+
+        $reflection = new ReflectionClass($class);
+        $methods = $reflection->getMethods();
+
+        if (!empty($methods)) {
+            $className = self::getClassName($class);
+
+            foreach ($methods as $method) {
+                if ($method instanceof ReflectionMethod) {
+                    if ($withoutInheritance && $className !== $method->class) {
+                        continue;
+                    }
+
+                    $effect[] = $method->name;
+                }
+            }
+        }
+
+        return $effect;
+    }
+
+    /**
+     * Returns constants of given class / object
+     *
+     * @param object|string $class The object or name of object's class
+     * @return array
+     */
+    public static function getConstants($class)
+    {
+        $reflection = new ReflectionClass($class);
+
+        return $reflection->getConstants();
+    }
+
+    /**
+     * Returns maximum constant from all constants of given class / object.
+     * Values of constants should be integers.
+     *
+     * @param object|string $class The object or name of object's class
+     * @return int|null
+     */
+    public static function getMaxNumberConstant($class)
+    {
+        $constants = self::getConstants($class);
+
+        if (empty($constants)) {
+            return null;
+        }
+
+        $maxNumber = 0;
+
+        foreach ($constants as $constant) {
+            if (is_numeric($constant) && $constant > $maxNumber) {
+                $maxNumber = $constant;
+            }
+        }
+
+        return $maxNumber;
+    }
+
+    /**
+     * Returns information if given class / object has given method
+     *
+     * @param object|string $class  The object or name of object's class
+     * @param string        $method Name of the method to find
+     * @return bool
+     */
+    public static function hasMethod($class, $method)
+    {
+        $reflection = new ReflectionClass($class);
+
+        return $reflection->hasMethod($method);
+    }
+
+    /**
+     * Returns information if given class / object has given property
+     *
+     * @param object|string $class    The object or name of object's class
+     * @param string        $property Name of the property to find
+     * @return bool
+     */
+    public static function hasProperty($class, $property)
+    {
+        $reflection = new ReflectionClass($class);
+
+        return $reflection->hasProperty($property);
+    }
+
+    /**
+     * Returns information if given class / object has given constant
+     *
+     * @param object|string $class    The object or name of object's class
+     * @param string        $constant Name of the constant to find
+     * @return bool
+     */
+    public static function hasConstant($class, $constant)
+    {
+        $reflection = new ReflectionClass($class);
+
+        return $reflection->hasConstant($constant);
+    }
+
+    /**
+     * Returns value of given constant
+     *
+     * @param object|string $class    The object or name of object's class
+     * @param string        $constant Name of the constant that contains a value
+     * @return mixed
+     */
+    public static function getConstantValue($class, $constant)
+    {
+        $reflection = new ReflectionClass($class);
+
+        if (self::hasConstant($class, $constant)) {
+            return $reflection->getConstant($constant);
+        }
+
+        return null;
+    }
+
+    /**
+     * Returns value of given property.
+     * Looks for proper getter for the property.
+     *
+     * @param mixed  $object   Object that should contains given property
+     * @param string $property Name of the property that contains a value. It may be also multiple properties
+     *                         dot-separated, e.g. "invoice.user.email".
+     * @param bool   $force    (optional) If is set to true, try to retrieve value even if the object doesn't have
+     *                         property. Otherwise - not.
+     * @return mixed
+     */
+    public static function getPropertyValue($object, $property, $force = false)
+    {
+        $value = null;
+
+        /*
+         * Property is a dot-separated string?
+         * Let's find all values of the chain, of the dot-separated properties
+         */
+        if (Regex::contains($property, '.')) {
+            $exploded = explode('.', $property);
+
+            $property = $exploded[0];
+            $object = self::getPropertyValue($object, $property, $force);
+
+            /*
+             * Value of processed property from the chain is not null?
+             * Let's dig more and get proper value
+             *
+             * Required to avoid bug:
+             * ReflectionObject::__construct() expects parameter 1 to be object, null given
+             * (...)
+             * 4. at ReflectionObject->__construct (null)
+             * 5. at Reflection ::getPropertyValue (null, 'name', true)
+             * 6. at ListService->getItemValue (object(Deal), 'project.name', '0')
+             *
+             * while using "project.name" as property - $project has $name property ($project exists in the Deal class)
+             * and the $project equals null
+             *
+             * Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+             * 2016-11-07
+             */
+            if (null !== $object) {
+                unset($exploded[0]);
+
+                $property = implode('.', $exploded);
+                $value = self::getPropertyValue($object, $property, $force);
+            }
+        } else {
+            $className = self::getClassName($object);
+            $reflectionProperty = null;
+
+            /*
+             * 1st try:
+             * Use \ReflectionObject class
+             */
+            try {
+                $reflectionProperty = new ReflectionProperty($className, $property);
+                $value = $reflectionProperty->getValue($object);
+            } catch (ReflectionException $exception) {
+                /*
+                 * 2nd try:
+                 * Look for the get / has / is methods
+                 */
+                $class = new ReflectionObject($object);
+                $valueFound = false;
+
+                if ($class->hasProperty($property) || $force) {
+                    $property = Inflector::classify($property);
+
+                    $getterPrefixes = [
+                        'get',
+                        'has',
+                        'is',
+                    ];
+
+                    foreach ($getterPrefixes as $prefix) {
+                        $getterName = sprintf('%s%s', $prefix, $property);
+
+                        if ($class->hasMethod($getterName)) {
+                            $method = new ReflectionMethod($object, $getterName);
+
+                            /*
+                             * Getter is not accessible publicly?
+                             * I have to skip it, to avoid an error like this:
+                             *
+                             * Call to protected method My\ExtraClass::getExtraProperty() from context 'My\ExtraClass'
+                             */
+                            if ($method->isProtected() || $method->isPrivate()) {
+                                continue;
+                            }
+
+                            $value = $object->{$getterName}();
+                            $valueFound = true;
+                            break;
+                        }
+                    }
+                }
+
+                if (!$valueFound && null !== $reflectionProperty) {
+                    /*
+                     * Oops, value of the property is still unknown
+                     *
+                     * 3rd try:
+                     * Let's modify accessibility of the property and try again to get value
+                     */
+                    $reflectionProperty->setAccessible(true);
+                    $value = $reflectionProperty->getValue($object);
+                    $reflectionProperty->setAccessible(false);
+                }
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * Returns values of given property for given objects.
+     * Looks for proper getter for the property.
+     *
+     * @param Collection|object|array $objects  The objects that should contain given property. It may be also one
+     *                                          object.
+     * @param string                  $property Name of the property that contains a value
+     * @param bool                    $force    (optional) If is set to true, try to retrieve value even if the
+     *                                          object does not have property. Otherwise - not.
+     * @return array
+     */
+    public static function getPropertyValues($objects, $property, $force = false)
+    {
+        /*
+         * No objects?
+         * Nothing to do
+         */
+        if (empty($objects)) {
+            return [];
+        }
+
+        if ($objects instanceof Collection) {
+            $objects = $objects->toArray();
+        }
+
+        $values = [];
+        $objects = Arrays::makeArray($objects);
+
+        foreach ($objects as $entity) {
+            $value = self::getPropertyValue($entity, $property, $force);
+
+            if (null !== $value) {
+                $values[] = $value;
+            }
+        }
+
+        return $values;
+    }
+
+    /**
+     * Returns a class name for given source
+     *
+     * @param array|object|string $source           An array of objects, namespaces, object or namespace
+     * @param bool                $withoutNamespace (optional) If is set to true, namespace is omitted. Otherwise -
+     *                                              not, full name of class is returned, with namespace.
+     * @return string|null
+     */
+    public static function getClassName($source, $withoutNamespace = false)
+    {
+        /*
+         * First argument is not proper source of class?
+         * Nothing to do
+         */
+        if (empty($source) || (!is_array($source) && !is_object($source) && !is_string($source))) {
+            return null;
+        }
+
+        $name = '';
+
+        /*
+         * An array of objects was provided?
+         * Let's use first of them
+         */
+        if (is_array($source)) {
+            $source = Arrays::getFirstElement($source);
+        }
+
+        /*
+         * Let's prepare name of class
+         */
+        if (is_object($source)) {
+            $name = get_class($source);
+        } elseif (is_string($source) && (class_exists($source) || trait_exists($source))) {
+            $name = $source;
+        }
+
+        /*
+         * Name of class is still unknown?
+         * Nothing to do
+         */
+        if (empty($name)) {
+            return null;
+        }
+
+        /*
+         * Namespace is not required?
+         * Let's return name of class only
+         */
+        if ($withoutNamespace) {
+            $classOnly = Miscellaneous::getLastElementOfString($name, '\\');
+
+            if (null !== $classOnly) {
+                $name = $classOnly;
+            }
+
+            return $name;
+        }
+
+        return ClassUtils::getRealClass($name);
+    }
+
+    /**
+     * Returns namespace of class for given source
+     *
+     * @param array|object|string $source An array of objects, namespaces, object or namespace
+     * @return string
+     */
+    public static function getClassNamespace($source)
+    {
+        $fullClassName = self::getClassName($source);
+
+        if (empty($fullClassName)) {
+            return '';
+        }
+
+        $className = self::getClassName($source, true);
+
+        if ($className == $fullClassName) {
+            return $className;
+        }
+
+        return Miscellaneous::getStringWithoutLastElement($fullClassName, '\\');
+    }
+
+    /**
+     * Returns information if given interface is implemented by given class / object
+     *
+     * @param array|object|string $source    An array of objects, namespaces, object or namespace
+     * @param string              $interface The interface that should be implemented
+     * @return bool
+     */
+    public static function isInterfaceImplemented($source, $interface)
+    {
+        $className = self::getClassName($source);
+        $interfaces = class_implements($className);
+
+        return in_array($interface, $interfaces);
+    }
+
+    /**
+     * Returns information if given child class is a subclass of given parent class
+     *
+     * @param array|object|string $childClass  The child class. An array of objects, namespaces, object or namespace.
+     * @param array|object|string $parentClass The parent class. An array of objects, namespaces, object or namespace.
+     * @return bool
+     */
+    public static function isChildOfClass($childClass, $parentClass)
+    {
+        $childClassName = self::getClassName($childClass);
+        $parentClassName = self::getClassName($parentClass);
+
+        $parents = class_parents($childClassName);
+
+        if (is_array($parents)) {
+            return in_array($parentClassName, $parents);
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns given object properties
+     *
+     * @param array|object|string $source         An array of objects, namespaces, object or namespace
+     * @param int                 $filter         (optional) Filter of properties. Uses ReflectionProperty class
+     *                                            constants. By default all properties are returned.
+     * @param bool                $includeParents (optional) If is set to true, properties of parent classes are
+     *                                            included (recursively). Otherwise - not.
+     * @return array|ReflectionProperty
+     */
+    public static function getProperties($source, $filter = null, $includeParents = false)
+    {
+        $className = self::getClassName($source);
+        $reflection = new ReflectionClass($className);
+
+        if (null === $filter) {
+            $filter = ReflectionProperty::IS_PRIVATE
+                + ReflectionProperty::IS_PROTECTED
+                + ReflectionProperty::IS_PUBLIC
+                + ReflectionProperty::IS_STATIC;
+        }
+
+        $properties = $reflection->getProperties($filter);
+        $parentProperties = [];
+
+        if ($includeParents) {
+            $parent = self::getParentClass($source);
+
+            if (false !== $parent) {
+                $parentClass = $parent->getName();
+                $parentProperties = self::getProperties($parentClass, $filter, $includeParents);
+            }
+        }
+
+        return array_merge($properties, $parentProperties);
+    }
+
+    /**
+     * Returns a parent class or false if there is no parent class
+     *
+     * @param array|object|string $source An array of objects, namespaces, object or namespace
+     * @return ReflectionClass|bool
+     */
+    public static function getParentClass($source)
+    {
+        $className = self::getClassName($source);
+        $reflection = new ReflectionClass($className);
+
+        return $reflection->getParentClass();
+    }
+
+    /**
+     * Returns child classes of given class.
+     * It's an array of namespaces of the child classes or null (if given class has not child classes).
+     *
+     * @param array|object|string $class Class who child classes should be returned. An array of objects, strings,
+     *                                   object or string.
+     * @return array|null
+     * @throws CannotResolveClassNameException
+     */
+    public static function getChildClasses($class)
+    {
+        $allClasses = get_declared_classes();
+
+        /*
+         * No classes?
+         * Nothing to do
+         */
+        if (empty($allClasses)) {
+            return null;
+        }
+
+        $className = self::getClassName($class);
+
+        /*
+         * Oops, cannot resolve class
+         */
+        if (null === $className) {
+            throw new CannotResolveClassNameException($class);
+        }
+
+        $childClasses = [];
+
+        foreach ($allClasses as $oneClass) {
+            if (self::isChildOfClass($oneClass, $className)) {
+                /*
+                 * Attention. I have to use ClassUtils::getRealClass() method to avoid problem with the proxy / cache
+                 * classes. Example:
+                 * - My\ExtraBundle\Entity\MyEntity
+                 * - Proxies\__CG__\My\ExtraBundle\Entity\MyEntity
+                 *
+                 * It's actually the same class, so I have to skip it.
+                 */
+                $realClass = ClassUtils::getRealClass($oneClass);
+
+                if (in_array($realClass, $childClasses)) {
+                    continue;
+                }
+
+                $childClasses[] = $realClass;
+            }
+        }
+
+        return $childClasses;
+    }
+
+    /**
+     * Returns namespace of one child class which extends given class.
+     * Extended class should has only one child class.
+     *
+     * @param array|object|string $parentClass Class who child class should be returned. An array of objects,
+     *                                         namespaces, object or namespace.
+     * @return mixed
+     *
+     * @throws MissingChildClassesException
+     * @throws TooManyChildClassesException
+     */
+    public static function getOneChildClass($parentClass)
+    {
+        $childClasses = self::getChildClasses($parentClass);
+
+        /*
+         * No child classes?
+         * Oops, the base / parent class hasn't child class
+         */
+        if (empty($childClasses)) {
+            throw new MissingChildClassesException($parentClass);
+        }
+
+        /*
+         * More than 1 child class?
+         * Oops, the base / parent class has too many child classes
+         */
+        if (count($childClasses) > 1) {
+            throw new TooManyChildClassesException($parentClass, $childClasses);
+        }
+
+        return trim($childClasses[0]);
+    }
+
+    /**
+     * Returns property, the ReflectionProperty instance, of given object
+     *
+     * @param array|object|string $class    An array of objects, namespaces, object or namespace
+     * @param string              $property Name of the property
+     * @param int                 $filter   (optional) Filter of properties. Uses ReflectionProperty class constants.
+     *                                      By default all properties are allowed / processed.
+     * @return null|ReflectionProperty
+     */
+    public static function getProperty($class, $property, $filter = null)
+    {
+        $className = self::getClassName($class);
+        $properties = self::getProperties($className, $filter);
+
+        if (!empty($properties)) {
+            /* @var $reflectionProperty ReflectionProperty */
+            foreach ($properties as $reflectionProperty) {
+                if ($reflectionProperty->getName() == $property) {
+                    return $reflectionProperty;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Returns information if given class / object uses / implements given trait
+     *
+     * @param array|object|string $class         An array of objects, namespaces, object or namespace
+     * @param array|string        $trait         An array of strings or string
+     * @param bool                $verifyParents If is set to true, parent classes are verified if they use given
+     *                                           trait. Otherwise - not.
+     * @return bool|null
+     * @throws CannotResolveClassNameException
+     */
+    public static function usesTrait($class, $trait, $verifyParents = false)
+    {
+        $className = self::getClassName($class);
+        $traitName = self::getClassName($trait);
+
+        /*
+         * Oops, cannot resolve class
+         */
+        if (empty($className)) {
+            throw new CannotResolveClassNameException($class);
+        }
+
+        /*
+         * Oops, cannot resolve trait
+         */
+        if (empty($traitName)) {
+            throw new CannotResolveClassNameException($class, false);
+        }
+
+        $reflection = new ReflectionClass($className);
+        $traitsNames = $reflection->getTraitNames();
+
+        $uses = in_array($traitName, $traitsNames);
+
+        if (!$uses && $verifyParents) {
+            $parentClassName = self::getParentClassName($className);
+
+            if (null !== $parentClassName) {
+                return self::usesTrait($parentClassName, $trait, true);
+            }
+        }
+
+        return $uses;
+    }
+
+    /**
+     * Returns name of the parent class.
+     * If given class does not extend another, returns null.
+     *
+     * @param array|object|string $class An array of objects, namespaces, object or namespace
+     * @return string|null
+     */
+    public static function getParentClassName($class)
+    {
+        $className = self::getClassName($class);
+        $reflection = new ReflectionClass($className);
+        $parentClass = $reflection->getParentClass();
+
+        if (null === $parentClass || false === $parentClass) {
+            return null;
+        }
+
+        return $parentClass->getName();
+    }
+}

src/Common/Utilities/Regex.php

@@ -0,0 +1,726 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Utilities;
+
+use Meritoo\Common\Exception\Regex\IncorrectColorHexLengthException;
+use Meritoo\Common\Exception\Regex\InvalidColorHexValueException;
+
+/**
+ * Useful regular expressions methods
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class Regex
+{
+    /**
+     * Patterns used to validate / verify values
+     *
+     * @var array
+     */
+    private static $patterns = [
+        'email'            => '/[\w-]{2,}@[\w-]+\.[\w]{2,}+/',
+        'phone'            => '/^\+?[0-9 ]+$/',
+        'camelCasePart'    => '/([a-z]|[A-Z]){1}[a-z]*/',
+        'urlProtocol'      => '/^([a-z]+:\/\/)',
+        'urlDomain'        => '([\da-z\.-]+)\.([a-z\.]{2,6})(\/)?([\w\.\-]*)?(\?)?([\w \.\-\/=&]*)\/?$/i',
+        'letterOrDigit'    => '/[a-zA-Z0-9]+/',
+        'htmlEntity'       => '/&[a-z0-9]+;/',
+        'fileName'         => '/.+\.\w+$/',
+        'isQuoted'         => '/^[\'"]{1}.+[\'"]{1}$/',
+        'windowsBasedPath' => '/^[A-Z]{1}:\\\.*$/',
+        'money'            => '/^[-+]?\d+([\.,]{1}\d*)?$/',
+        'color'            => '/^[a-f0-9]{6}$/i',
+    ];
+
+    /**
+     * Returns information if given e-mail address is valid
+     *
+     * @param string $email E-mail address to validate / verify
+     * @return bool
+     *
+     * Examples:
+     * a) valid e-mails:
+     * - ni@g-m.pl
+     * - ni@gm.pl
+     * - ni@g_m.pl
+     * b) invalid e-mails:
+     * - ni@g-m.p
+     * - n@g-m.pl
+     */
+    public static function isValidEmail($email)
+    {
+        $pattern = self::getEmailPattern();
+
+        return (bool)preg_match($pattern, $email);
+    }
+
+    /**
+     * Returns information if given tax ID (in polish: NIP) is valid
+     *
+     * @param string $taxidString Tax ID (NIP) string
+     * @return bool
+     */
+    public static function isValidTaxid($taxidString)
+    {
+        if (!empty($taxidString)) {
+            $weights = [
+                6,
+                5,
+                7,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+            ];
+            $taxid = preg_replace('/[\s-]/', '', $taxidString);
+            $sum = 0;
+
+            if (10 == strlen($taxid) && is_numeric($taxid)) {
+                for ($x = 0; $x <= 8; ++$x) {
+                    $sum += $taxid[$x] * $weights[$x];
+                }
+
+                if ((($sum % 11) % 10) == $taxid[9]) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns information if given url address is valid
+     *
+     * @param string $url             The url to validate / verify
+     * @param bool   $requireProtocol (optional) If is set to true, the protocol is required to be passed in the url.
+     *                                Otherwise - not.
+     * @return bool
+     */
+    public static function isValidUrl($url, $requireProtocol = false)
+    {
+        $pattern = self::getUrlPattern($requireProtocol);
+
+        return (bool)preg_match($pattern, $url);
+    }
+
+    /**
+     * Returns information if given phone number is valid
+     *
+     * @param string $phoneNumber The phone number to validate / verify
+     * @return bool
+     */
+    public static function isValidPhoneNumber($phoneNumber)
+    {
+        $pattern = self::getPhoneNumberPattern();
+
+        return (bool)preg_match($pattern, $phoneNumber);
+    }
+
+    /**
+     * Returns array values that matches given pattern (or values that keys matches)
+     *
+     * @param string $pattern       Pattern to match
+     * @param array  $dataArray     The array
+     * @param bool   $itsKeyPattern (optional) If is set to true, keys are checks if they match pattern. Otherwise -
+     *                              values are checks.
+     * @return array
+     */
+    public static function getArrayValuesByPattern($pattern, $dataArray, $itsKeyPattern = false)
+    {
+        if ($itsKeyPattern) {
+            $effect = [];
+
+            if (!empty($dataArray)) {
+                $matches = [];
+
+                foreach ($dataArray as $key => $value) {
+                    if (preg_match($pattern, $key, $matches)) {
+                        $effect[$key] = $value;
+                    }
+                }
+            }
+
+            return $effect;
+        }
+
+        return preg_grep($pattern, $dataArray);
+    }
+
+    /**
+     * Filters array by given expression and column
+     *
+     * Expression can be simple compare expression, like ' == 2', or regular expression.
+     * Returns filtered array.
+     *
+     * @param array  $array                The array that should be filtered
+     * @param string $arrayColumnKey       Column name
+     * @param string $filterExpression     Filter expression, e.g. '== 2' or '!= \'home\''
+     * @param bool   $itsRegularExpression (optional) If is set to true, means that filter expression is a
+     *                                     regular expression
+     * @return array
+     */
+    public static function arrayFilter($array, $arrayColumnKey, $filterExpression, $itsRegularExpression = false)
+    {
+        $effect = [];
+
+        if (!empty($array)) {
+            $effect = $array;
+
+            foreach ($effect as $key => &$item) {
+                if (isset($item[$arrayColumnKey])) {
+                    $value = $item[$arrayColumnKey];
+
+                    if ($itsRegularExpression) {
+                        $matches = [];
+                        $pattern = '|' . $filterExpression . '|';
+                        $matchesCount = preg_match($pattern, $value, $matches);
+
+                        $remove = 0 == $matchesCount;
+                    } else {
+                        if ('' == $value) {
+                            $value = '\'\'';
+                        } elseif (is_string($value)) {
+                            $value = '\'' . $value . '\'';
+                        }
+
+                        eval('$isTrue = ' . $value . $filterExpression . ';');
+
+                        /* @var bool $isTrue */
+                        $remove = !$isTrue;
+                    }
+
+                    if ($remove) {
+                        unset($effect[$key]);
+                    }
+                }
+            }
+        }
+
+        return $effect;
+    }
+
+    /**
+     * Perform regular expression match with many given patterns.
+     * Returns information if given $subject matches one or all given $patterns.
+     *
+     * @param array|string $patterns     The patterns to match
+     * @param string       $subject      The string to check
+     * @param bool         $mustAllMatch (optional) If is set to true, $subject must match all $patterns. Otherwise -
+     *                                   not.
+     * @return bool
+     */
+    public static function pregMultiMatch($patterns, $subject, $mustAllMatch = false)
+    {
+        $effect = false;
+        $patterns = Arrays::makeArray($patterns);
+
+        if (!empty($patterns)) {
+            if ($mustAllMatch) {
+                $effect = true;
+            }
+
+            foreach ($patterns as $pattern) {
+                $matches = [];
+                $matched = (bool)preg_match_all($pattern, $subject, $matches);
+
+                if ($mustAllMatch) {
+                    $effect = $effect && $matched;
+                } else {
+                    if ($matched) {
+                        $effect = $matched;
+                        break;
+                    }
+                }
+            }
+        }
+
+        return $effect;
+    }
+
+    /**
+     * Returns string in human readable style generated from given camel case string / text
+     *
+     * @param string $string              The string / text to convert
+     * @param bool   $applyUpperCaseFirst (optional) If is set to true, first word / element from the converted
+     *                                    string is uppercased. Otherwise - not.
+     * @return string
+     */
+    public static function camelCase2humanReadable($string, $applyUpperCaseFirst = false)
+    {
+        $parts = self::getCamelCaseParts($string);
+
+        if (!empty($parts)) {
+            $elements = [];
+
+            foreach ($parts as $part) {
+                $elements[] = strtolower($part);
+            }
+
+            $string = implode(' ', $elements);
+
+            if ($applyUpperCaseFirst) {
+                $string = ucfirst($string);
+            }
+        }
+
+        return $string;
+    }
+
+    /**
+     * Returns parts of given camel case string / text
+     *
+     * @param string $string The string / text to retrieve parts
+     * @return array
+     */
+    public static function getCamelCaseParts($string)
+    {
+        $pattern = self::getCamelCasePartPattern();
+        $matches = [];
+        preg_match_all($pattern, $string, $matches);
+
+        return $matches[0];
+    }
+
+    /**
+     * Returns simple, lowercase string generated from given camel case string / text
+     *
+     * @param string $string         The string / text to convert
+     * @param string $separator      (optional) Separator used to concatenate parts of the string, e.g. '-' or '_'
+     * @param bool   $applyLowercase (optional) If is set to true, returned string will be lowercased. Otherwise - not.
+     * @return string
+     */
+    public static function camelCase2simpleLowercase($string, $separator = '', $applyLowercase = true)
+    {
+        $parts = self::getCamelCaseParts($string);
+
+        if (!empty($parts)) {
+            $string = implode($separator, $parts);
+
+            if ($applyLowercase) {
+                $string = strtolower($string);
+            }
+        }
+
+        return $string;
+    }
+
+    /**
+     * Returns pattern used to validate / verify or get e-mail address
+     *
+     * @return string
+     */
+    public static function getEmailPattern()
+    {
+        return self::$patterns['email'];
+    }
+
+    /**
+     * Returns pattern used to validate / verify or get phone number
+     *
+     * @return string
+     */
+    public static function getPhoneNumberPattern()
+    {
+        return self::$patterns['phone'];
+    }
+
+    /**
+     * Returns pattern used to validate / verify or get camel case parts of string
+     *
+     * @return string
+     */
+    public static function getCamelCasePartPattern()
+    {
+        return self::$patterns['camelCasePart'];
+    }
+
+    /**
+     * Returns pattern used to validate / verify or get url address
+     *
+     * @param bool $requireProtocol (optional) If is set to true, the protocol is required to be passed in the url.
+     *                              Otherwise - not.
+     * @return string
+     */
+    public static function getUrlPattern($requireProtocol = false)
+    {
+        $urlProtocol = self::$patterns['urlProtocol'];
+        $urlDomain = self::$patterns['urlDomain'];
+        $protocolPatternPart = '?';
+
+        if ($requireProtocol) {
+            $protocolPatternPart = '';
+        }
+
+        return sprintf('%s%s%s', $urlProtocol, $protocolPatternPart, $urlDomain);
+    }
+
+    /**
+     * Returns information if given path is sub-path of another path, e.g. path file is owned by path of directory
+     *
+     * @param string $subPath Path to verify, probably sub-path
+     * @param string $path    Main / parent path
+     * @return bool
+     */
+    public static function isSubPathOf($subPath, $path)
+    {
+        /*
+         * Empty path?
+         * Nothing to do
+         */
+        if (empty($path) || empty($subPath)) {
+            return false;
+        }
+
+        /*
+         * I have to escape all slashes (directory separators): "/" -> "\/"
+         */
+        $prepared = preg_quote($path, '/');
+
+        /*
+         * Slash at the ending is optional
+         */
+        if (self::endsWith($path, '/')) {
+            $prepared .= '?';
+        }
+
+        $pattern = sprintf('/^%s.*/', $prepared);
+
+        return (bool)preg_match($pattern, $subPath);
+    }
+
+    /**
+     * Returns pattern used to validate / verify letter or digit
+     *
+     * @return string
+     */
+    public static function getLetterOrDigitPattern()
+    {
+        return self::$patterns['letterOrDigit'];
+    }
+
+    /**
+     * Returns information if given character is a letter or digit
+     *
+     * @param string $char Character to check
+     * @return bool
+     */
+    public static function isLetterOrDigit($char)
+    {
+        $pattern = self::getLetterOrDigitPattern();
+
+        return is_scalar($char) && (bool)preg_match($pattern, $char);
+    }
+
+    /**
+     * Returns information if the string starts with given beginning / characters
+     *
+     * @param string $string    String to check
+     * @param string $beginning The beginning of string, one or more characters
+     * @return bool
+     */
+    public static function startsWith($string, $beginning)
+    {
+        if (!empty($string) && !empty($beginning)) {
+            if (1 == strlen($beginning) && !self::isLetterOrDigit($beginning)) {
+                $beginning = '\\' . $beginning;
+            }
+
+            $pattern = sprintf('|^%s|', $beginning);
+
+            return (bool)preg_match($pattern, $string);
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns information if the string ends with given ending / characters
+     *
+     * @param string $string String to check
+     * @param string $ending The ending of string, one or more characters
+     * @return bool
+     */
+    public static function endsWith($string, $ending)
+    {
+        if (1 == strlen($ending) && !self::isLetterOrDigit($ending)) {
+            $ending = '\\' . $ending;
+        }
+
+        return (bool)preg_match('|' . $ending . '$|', $string);
+    }
+
+    /**
+     * Returns information if the string starts with directory's separator
+     *
+     * @param string $string    String that may contain a directory's separator at the start / beginning
+     * @param string $separator (optional) The directory's separator, e.g. "/". If is empty (not provided), system's
+     *                          separator is used.
+     * @return bool
+     */
+    public static function startsWithDirectorySeparator($string, $separator = '')
+    {
+        if (empty($separator)) {
+            $separator = DIRECTORY_SEPARATOR;
+        }
+
+        return self::startsWith($string, $separator);
+    }
+
+    /**
+     * Returns information if the string ends with directory's separator
+     *
+     * @param string $text      String that may contain a directory's separator at the end
+     * @param string $separator (optional) The directory's separator, e.g. "/". If is empty (not provided), system's
+     *                          separator is used.
+     * @return string
+     */
+    public static function endsWithDirectorySeparator($text, $separator = '')
+    {
+        if (empty($separator)) {
+            $separator = DIRECTORY_SEPARATOR;
+        }
+
+        return self::endsWith($text, $separator);
+    }
+
+    /**
+     * Returns information if uri contains parameter
+     *
+     * @param string $uri           Uri string (e.g. $_SERVER['REQUEST_URI'])
+     * @param string $parameterName Uri parameter name
+     * @return bool
+     */
+    public static function isSetUriParameter($uri, $parameterName)
+    {
+        return (bool)preg_match('|[?&]{1}' . $parameterName . '=|', $uri); // e.g. ?name=phil&type=4 -> '$type='
+    }
+
+    /**
+     * Returns pattern used to validate / verify html entity
+     *
+     * @return string
+     */
+    public static function getHtmlEntityPattern()
+    {
+        return self::$patterns['htmlEntity'];
+    }
+
+    /**
+     * Returns information if the string contains html entities
+     *
+     * @param string $string String to check
+     * @return bool
+     */
+    public static function containsEntities($string)
+    {
+        $pattern = self::getHtmlEntityPattern();
+
+        return (bool)preg_match_all($pattern, $string);
+    }
+
+    /**
+     * Returns information if one string contains another string
+     *
+     * @param string $haystack The string to search in
+     * @param string $needle   The string to be search for
+     * @return bool
+     */
+    public static function contains($haystack, $needle)
+    {
+        if (1 == strlen($needle) && !self::isLetterOrDigit($needle)) {
+            $needle = '\\' . $needle;
+        }
+
+        return (bool)preg_match('|.*' . $needle . '.*|', $haystack);
+    }
+
+    /**
+     * Returns pattern used to validate / verify name of file
+     *
+     * @return string
+     */
+    public static function getFileNamePattern()
+    {
+        return self::$patterns['fileName'];
+    }
+
+    /**
+     * Returns information if given name of file is a really name of file.
+     * Verifies if given name contains a dot and an extension, e.g. "My File 001.jpg".
+     *
+     * @param string $fileName Name of file to check. It may be path of file also.
+     * @return bool
+     */
+    public static function isFileName($fileName)
+    {
+        $pattern = self::getFileNamePattern();
+
+        return (bool)preg_match($pattern, $fileName);
+    }
+
+    /**
+     * Returns pattern used to validate / verify if value is quoted (by apostrophes or quotation marks)
+     *
+     * @return string
+     */
+    public static function getIsQuotedPattern()
+    {
+        return self::$patterns['isQuoted'];
+    }
+
+    /**
+     * Returns information if given value is quoted (by apostrophes or quotation marks)
+     *
+     * @param mixed $value The value to check
+     * @return bool
+     */
+    public static function isQuoted($value)
+    {
+        $pattern = self::getIsQuotedPattern();
+
+        return is_scalar($value) && (bool)preg_match($pattern, $value);
+    }
+
+    /**
+     * Returns pattern used to validate / verify if given path is a Windows-based path, e.g. "C:\path\to\file.jpg"
+     *
+     * @return string
+     */
+    public static function getWindowsBasedPathPattern()
+    {
+        return self::$patterns['windowsBasedPath'];
+    }
+
+    /**
+     * Returns information if given path is a Windows-based path, e.g. "C:\path\to\file.jpg"
+     *
+     * @param string $path The path to verify
+     * @return bool
+     */
+    public static function isWindowsBasedPath($path)
+    {
+        $pattern = self::getWindowsBasedPathPattern();
+
+        return (bool)preg_match($pattern, $path);
+    }
+
+    /**
+     * Returns information if given NIP number is valid
+     *
+     * @param string $nip A given NIP number
+     * @return bool
+     *
+     * @see https://pl.wikipedia.org/wiki/NIP#Znaczenie_numeru
+     */
+    public static function isValidNip($nip)
+    {
+        $nip = preg_replace('/[^0-9]/', '', $nip);
+
+        $invalidNips = [
+            '1234567890',
+            '0000000000',
+        ];
+
+        if (!preg_match('/^[0-9]{10}$/', $nip) || in_array($nip, $invalidNips)) {
+            return false;
+        }
+
+        $sum = 0;
+        $weights = [
+            6,
+            5,
+            7,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+        ];
+
+        for ($i = 0; $i < 9; ++$i) {
+            $sum += $weights[$i] * $nip[$i];
+        }
+
+        $modulo = $sum % 11;
+        $numberControl = (10 == $modulo) ? 0 : $modulo;
+
+        return $numberControl == $nip[9];
+    }
+
+    /**
+     * Returns pattern used to validate / verify if given value is money-related value
+     *
+     * @return string
+     */
+    public static function getMoneyPattern()
+    {
+        return self::$patterns['money'];
+    }
+
+    /**
+     * Returns information if given value is valid money-related value
+     *
+     * @param mixed $value Value to verify
+     * @return bool
+     */
+    public static function isValidMoneyValue($value)
+    {
+        $pattern = self::getMoneyPattern();
+
+        return (bool)preg_match($pattern, $value);
+    }
+
+    /**
+     * Returns valid given hexadecimal value of color.
+     * If the value is invalid, throws an exception or returns false.
+     *
+     * @param string $color          Color to verify
+     * @param bool   $throwException (optional) If is set to true, throws an exception if given color is invalid
+     *                               (default behaviour). Otherwise - not.
+     * @return string|bool
+     *
+     * @throws IncorrectColorHexLengthException
+     * @throws InvalidColorHexValueException
+     */
+    public static function getValidColorHexValue($color, $throwException = true)
+    {
+        $color = Miscellaneous::replace($color, '/#/', '');
+        $length = strlen($color);
+
+        if (3 === $length) {
+            $color = Miscellaneous::replace($color, '/(.)(.)(.)/', '$1$1$2$2$3$3');
+        } else {
+            if (6 !== $length) {
+                if ($throwException) {
+                    throw new IncorrectColorHexLengthException($color);
+                }
+
+                return false;
+            }
+        }
+
+        $pattern = self::$patterns['color'];
+        $match = (bool)preg_match($pattern, $color);
+
+        if (!$match) {
+            if ($throwException) {
+                throw new InvalidColorHexValueException($color);
+            }
+
+            return false;
+        }
+
+        return strtolower($color);
+    }
+}

src/LimeSurvey/Base/Result/BaseItem.php

@@ -16,6 +16,8 @@ namespace Meritoo\LimeSurvey\ApiClient\Base\Result;
  */
 abstract class BaseItem
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Base\Result\BaseItem';
+
     /**
      * Class constructor
      *

src/LimeSurvey/Client/Client.php

@@ -24,6 +24,8 @@ use Meritoo\LimeSurvey\ApiClient\Type\MethodType;
  */
 class Client
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Client\Client';
+
     /**
      * Configuration used while connecting to LimeSurvey's API
      *

src/LimeSurvey/Configuration/ConnectionConfiguration.php

@@ -19,6 +19,8 @@ use Meritoo\Common\Utilities\Regex;
  */
 class ConnectionConfiguration
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Configuration\ConnectionConfiguration';
+
     /**
      * Base url.
      * Protocol & domain.

src/LimeSurvey/Exception/CannotProcessDataException.php

@@ -16,6 +16,8 @@ namespace Meritoo\LimeSurvey\ApiClient\Exception;
  */
 class CannotProcessDataException extends \Exception
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Exception\CannotProcessDataException';
+
     /**
      * Reason why data cannot be processed, e.g. "Invalid user name or password"
      *

src/LimeSurvey/Exception/CreateSessionKeyFailedException.php

@@ -18,6 +18,8 @@ use Exception;
  */
 class CreateSessionKeyFailedException extends Exception
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Exception\CreateSessionKeyFailedException';
+
     /**
      * Class constructor
      *

src/LimeSurvey/Exception/IncorrectClassOfResultItemException.php

@@ -19,6 +19,8 @@ use Meritoo\LimeSurvey\ApiClient\Base\Result\BaseItem;
  */
 class IncorrectClassOfResultItemException extends \Exception
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Exception\IncorrectClassOfResultItemException';
+
     /**
      * Class constructor
      *
@@ -29,7 +31,7 @@ class IncorrectClassOfResultItemException extends \Exception
         $template = 'Class %s used to create instance of one item of the result should extend %s, but it does not. Did'
             . ' you forget to use proper base class?';
 
-        $message = sprintf($template, $className, BaseItem::class);
+        $message = sprintf($template, $className, BaseItem::className);
         parent::__construct($message);
     }
 }

src/LimeSurvey/Exception/InvalidResultOfMethodRunException.php

@@ -19,6 +19,8 @@ use Meritoo\Common\Utilities\Arrays;
  */
 class InvalidResultOfMethodRunException extends Exception
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Exception\InvalidResultOfMethodRunException';
+
     /**
      * Class constructor
      *

src/LimeSurvey/Exception/MissingParticipantOfSurveyException.php

@@ -16,6 +16,8 @@ namespace Meritoo\LimeSurvey\ApiClient\Exception;
  */
 class MissingParticipantOfSurveyException extends \Exception
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Exception\MissingParticipantOfSurveyException';
+
     /**
      * Class constructor
      *

src/LimeSurvey/Exception/UnknownInstanceOfResultItem.php

@@ -20,6 +20,8 @@ use Meritoo\LimeSurvey\ApiClient\Result\Processor\ResultProcessor;
  */
 class UnknownInstanceOfResultItem extends Exception
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Exception\UnknownInstanceOfResultItem';
+
     /**
      * Class constructor
      *
@@ -31,7 +33,7 @@ class UnknownInstanceOfResultItem extends Exception
         $template = 'Class name used to create instance of one item used by result the of \'%s\' LimeSurvey API\'s'
             . ' method is unknown. Proper class is not mapped in %s::%s() method. Did you forget about this?';
 
-        $message = sprintf($template, $method, ResultProcessor::class, 'getItemClassName');
+        $message = sprintf($template, $method, ResultProcessor::className, 'getItemClassName');
         parent::__construct($message);
     }
 }

src/LimeSurvey/Exception/UnknownMethodException.php

@@ -19,6 +19,8 @@ use Meritoo\LimeSurvey\ApiClient\Type\MethodType;
  */
 class UnknownMethodException extends UnknownTypeException
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Exception\UnknownMethodException';
+
     /**
      * {@inheritdoc}
      */

src/LimeSurvey/Manager/JsonRpcClientManager.php

@@ -17,6 +17,8 @@ use Meritoo\LimeSurvey\ApiClient\Type\MethodType;
  */
 class JsonRpcClientManager
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Manager\JsonRpcClientManager';
+
     /**
      * Configuration used while connecting to LimeSurvey's API
      *

src/LimeSurvey/Manager/SessionManager.php

@@ -13,6 +13,8 @@ use Meritoo\LimeSurvey\ApiClient\Type\SystemMethodType;
  */
 class SessionManager
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Manager\SessionManager';
+
     /**
      * The session key.
      * Used to authenticate user while connecting to LimeSurvey's API.

src/LimeSurvey/Result/Collection/Participants.php

@@ -24,6 +24,8 @@ use Meritoo\LimeSurvey\ApiClient\Result\Item\ParticipantShort;
  */
 class Participants extends Collection
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Result\Collection\Participants';
+
     /**
      * {@inheritdoc}
      */

src/LimeSurvey/Result/Collection/Surveys.php

@@ -19,6 +19,8 @@ use Meritoo\LimeSurvey\ApiClient\Result\Item\Survey;
  */
 class Surveys extends Collection
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Result\Collection\Surveys';
+
     /**
      * {@inheritdoc}
      */

src/LimeSurvey/Result/Item/Participant.php

@@ -20,6 +20,8 @@ use Meritoo\LimeSurvey\ApiClient\Base\Result\BaseItem;
  */
 class Participant extends BaseItem
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Result\Item\Participant';
+
     /**
      * ID of the participant
      *

src/LimeSurvey/Result/Item/ParticipantShort.php

@@ -18,6 +18,8 @@ use Meritoo\LimeSurvey\ApiClient\Base\Result\BaseItem;
  */
 class ParticipantShort extends BaseItem
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Result\Item\ParticipantShort';
+
     /**
      * ID of the participant
      *

src/LimeSurvey/Result/Item/Question.php

@@ -16,6 +16,8 @@ namespace Meritoo\LimeSurvey\ApiClient\Result\Item;
  */
 class Question extends QuestionShort
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Result\Item\Question';
+
     /**
      * Available answers
      *

src/LimeSurvey/Result/Item/QuestionShort.php

@@ -18,6 +18,8 @@ use Meritoo\LimeSurvey\ApiClient\Base\Result\BaseItem;
  */
 class QuestionShort extends BaseItem
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Result\Item\QuestionShort';
+
     /**
      * ID of the question
      *

src/LimeSurvey/Result/Item/Survey.php

@@ -20,6 +20,8 @@ use Meritoo\LimeSurvey\ApiClient\Base\Result\BaseItem;
  */
 class Survey extends BaseItem
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Result\Item\Survey';
+
     /**
      * ID of the survey
      *

src/LimeSurvey/Result/Processor/ResultProcessor.php

@@ -27,6 +27,8 @@ use Meritoo\LimeSurvey\ApiClient\Type\MethodType;
  */
 class ResultProcessor
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Result\Processor\ResultProcessor';
+
     /**
      * Returns processed data based on the raw data returned by the LimeSurvey's API
      *
@@ -88,23 +90,23 @@ class ResultProcessor
         switch ($method) {
             case MethodType::ADD_PARTICIPANTS:
             case MethodType::GET_PARTICIPANT_PROPERTIES:
-                $className = Participant::class;
+                $className = Participant::className;
                 break;
 
             case MethodType::GET_QUESTION_PROPERTIES:
-                $className = Question::class;
+                $className = Question::className;
                 break;
 
             case MethodType::LIST_PARTICIPANTS:
-                $className = ParticipantShort::class;
+                $className = ParticipantShort::className;
                 break;
 
             case MethodType::LIST_QUESTIONS:
-                $className = QuestionShort::class;
+                $className = QuestionShort::className;
                 break;
 
             case MethodType::LIST_SURVEYS:
-                $className = Survey::class;
+                $className = Survey::className;
                 break;
 
             /*
@@ -119,7 +121,7 @@ class ResultProcessor
             throw new UnknownInstanceOfResultItem($method);
         }
 
-        if (Reflection::isChildOfClass($className, BaseItem::class)) {
+        if (Reflection::isChildOfClass($className, BaseItem::className)) {
             return $className;
         }
 

src/LimeSurvey/Result/Result.php

@@ -22,6 +22,8 @@ use Meritoo\LimeSurvey\ApiClient\Type\MethodType;
  */
 class Result
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Result\Result';
+
     /**
      * Name of called method while talking to the LimeSurvey's API. One of the MethodType class constants.
      *

src/LimeSurvey/Service/ParticipantService.php

@@ -26,6 +26,8 @@ use Meritoo\LimeSurvey\ApiClient\Type\ReasonType;
  */
 class ParticipantService
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Service\ParticipantService';
+
     /**
      * Client of the LimeSurvey's API
      *

src/LimeSurvey/Service/SurveyService.php

@@ -25,6 +25,8 @@ use Meritoo\LimeSurvey\ApiClient\Type\ReasonType;
  */
 class SurveyService
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Service\SurveyService';
+
     /**
      * Client of the LimeSurvey's API
      *

src/LimeSurvey/Type/MethodType.php

@@ -19,6 +19,8 @@ use Meritoo\LimeSurvey\ApiClient\Exception\UnknownMethodException;
  */
 class MethodType extends BaseType
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Type\MethodType';
+
     /**
      * Add participants to the tokens collection of the survey
      *

src/LimeSurvey/Type/ReasonType.php

@@ -12,6 +12,8 @@ use Meritoo\Common\Type\Base\BaseType;
  */
 class ReasonType extends BaseType
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Type\ReasonType';
+
     /**
      * Reason of exception when there is no survey with given ID
      *

src/LimeSurvey/Type/SystemMethodType.php

@@ -18,6 +18,8 @@ use Meritoo\Common\Type\Base\BaseType;
  */
 class SystemMethodType extends BaseType
 {
+    const className = 'Meritoo\LimeSurvey\ApiClient\Type\SystemMethodType';
+
     /**
      * Create and return a session key
      *

tests/Base/Result/BaseItemTest.php

@@ -22,11 +22,11 @@ class BaseItemTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(BaseItem::class, OopVisibilityType::IS_PUBLIC, 1, 0);
+        static::assertConstructorVisibilityAndArguments(BaseItem::className, OopVisibilityType::IS_PUBLIC, 1, 0);
     }
 
     public function testSetValuesVisibilityAndArguments()
     {
-        static::assertMethodVisibilityAndArguments(BaseItem::class, 'setValues', OopVisibilityType::IS_PRIVATE, 1, 1);
+        static::assertMethodVisibilityAndArguments(BaseItem::className, 'setValues', OopVisibilityType::IS_PRIVATE, 1, 1);
     }
 }

tests/Client/ClientTest.php

@@ -8,15 +8,12 @@
 
 namespace Meritoo\LimeSurvey\Test\ApiClient\Client;
 
-use Generator;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
 use Meritoo\LimeSurvey\ApiClient\Client\Client;
 use Meritoo\LimeSurvey\ApiClient\Configuration\ConnectionConfiguration;
-use Meritoo\LimeSurvey\ApiClient\Exception\UnknownMethodException;
 use Meritoo\LimeSurvey\ApiClient\Manager\JsonRpcClientManager;
 use Meritoo\LimeSurvey\ApiClient\Manager\SessionManager;
-use Meritoo\LimeSurvey\ApiClient\Result\Result;
 use Meritoo\LimeSurvey\ApiClient\Type\MethodType;
 
 /**
@@ -36,7 +33,7 @@ class ClientTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(Client::class, OopVisibilityType::IS_PUBLIC, 3, 1);
+        static::assertConstructorVisibilityAndArguments(Client::className, OopVisibilityType::IS_PUBLIC, 3, 1);
     }
 
     /**
@@ -45,7 +42,7 @@ class ClientTest extends BaseTestCase
      */
     public function testRunWithIncorrectMethod($incorrectMethod)
     {
-        $this->expectException(UnknownMethodException::class);
+        $this->setExpectedException('Meritoo\LimeSurvey\ApiClient\Exception\UnknownMethodException');
 
         $client = new Client($this->configuration);
         $client->run($incorrectMethod);
@@ -61,8 +58,8 @@ class ClientTest extends BaseTestCase
      */
     public function testRun($method, $arguments, $debugMode, $expectedRawData)
     {
-        $sessionManager = $this->createMock(SessionManager::class);
+        $sessionManager = $this->createMock(SessionManager::className);
-        $rpcClientManager = $this->createMock(JsonRpcClientManager::class);
+        $rpcClientManager = $this->createMock(JsonRpcClientManager::className);
 
         $rpcClientManager
             ->expects(static::any())
@@ -78,7 +75,7 @@ class ClientTest extends BaseTestCase
         );
 
         $client = new Client($configuration, $rpcClientManager, $sessionManager);
-        static::assertInstanceOf(Result::class, $client->run($method, $arguments));
+        static::assertInstanceOf('Meritoo\LimeSurvey\ApiClient\Result\Result', $client->run($method, $arguments));
     }
 
     public function testGetConfiguration()
@@ -89,21 +86,29 @@ class ClientTest extends BaseTestCase
 
     public function testGetRpcClientManagerVisibilityAndArguments()
     {
-        static::assertMethodVisibilityAndArguments(Client::class, 'getRpcClientManager', OopVisibilityType::IS_PRIVATE);
+        static::assertMethodVisibilityAndArguments(Client::className, 'getRpcClientManager', OopVisibilityType::IS_PRIVATE);
     }
 
     public function testGetSessionManagerVisibilityAndArguments()
     {
-        static::assertMethodVisibilityAndArguments(Client::class, 'getRpcClientManager', OopVisibilityType::IS_PRIVATE);
+        static::assertMethodVisibilityAndArguments(Client::className, 'getRpcClientManager', OopVisibilityType::IS_PRIVATE);
     }
 
     /**
      * Provides incorrect name of method
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideIncorrectMethod()
     {
+        return [
+            ['lorem'],
+            ['ipsum'],
+            [''],
+        ];
+
+        /*
         yield[
             'lorem',
         ];
@@ -115,15 +120,39 @@ class ClientTest extends BaseTestCase
         yield[
             '',
         ];
+        */
     }
 
     /**
      * Provides correct name of method
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideMethod()
     {
+        return [
+            [
+                MethodType::GET_PARTICIPANT_PROPERTIES,
+                [],
+                true,
+                [],
+            ],
+            [
+                MethodType::LIST_SURVEYS,
+                [],
+                false,
+                [],
+            ],
+            [
+                MethodType::LIST_PARTICIPANTS,
+                [],
+                false,
+                null,
+            ],
+        ];
+
+        /*
         yield[
             MethodType::GET_PARTICIPANT_PROPERTIES,
             [],
@@ -144,6 +173,7 @@ class ClientTest extends BaseTestCase
             false,
             null,
         ];
+        */
 
         /*
          * todo: Use/Verify other types of methods

tests/Configuration/ConnectionConfigurationTest.php

@@ -8,7 +8,6 @@
 
 namespace Meritoo\LimeSurvey\Test\ApiClient\Configuration;
 
-use Generator;
 use Meritoo\Common\Exception\Regex\InvalidUrlException;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
@@ -38,7 +37,7 @@ class ConnectionConfigurationTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(ConnectionConfiguration::class, OopVisibilityType::IS_PUBLIC, 5, 3);
+        static::assertConstructorVisibilityAndArguments(ConnectionConfiguration::className, OopVisibilityType::IS_PUBLIC, 5, 3);
     }
 
     /**
@@ -47,7 +46,7 @@ class ConnectionConfigurationTest extends BaseTestCase
      */
     public function testConstructorWithEmptyBaseUrl($emptyBaseUrl)
     {
-        $this->expectException(InvalidUrlException::class);
+        $this->setExpectedException(InvalidUrlException::className);
         new ConnectionConfiguration($emptyBaseUrl, '', '');
     }
 
@@ -57,7 +56,7 @@ class ConnectionConfigurationTest extends BaseTestCase
      */
     public function testConstructorWithInvalidBaseUrl($invalidBaseUrl)
     {
-        $this->expectException(InvalidUrlException::class);
+        $this->setExpectedException(InvalidUrlException::className);
         new ConnectionConfiguration($invalidBaseUrl, '', '');
     }
 
@@ -94,10 +93,17 @@ class ConnectionConfigurationTest extends BaseTestCase
     /**
      * Provides empty base url
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideEmptyBaseUrl()
     {
+        return [
+            [''],
+            [null],
+        ];
+
+        /*
         yield[
             '',
         ];
@@ -105,15 +111,24 @@ class ConnectionConfigurationTest extends BaseTestCase
         yield[
             null,
         ];
+        */
     }
 
     /**
      * Provides invalid base url
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideInvalidBaseUrl()
     {
+        return [
+            ['lorem'],
+            ['ipsum'],
+            ['htp:/dolor.com'],
+        ];
+
+        /*
         yield[
             'lorem',
         ];
@@ -125,6 +140,7 @@ class ConnectionConfigurationTest extends BaseTestCase
         yield[
             'htp:/dolor.com',
         ];
+        */
     }
 
     /**

tests/Exception/CannotProcessDataExceptionTest.php

@@ -8,7 +8,6 @@
 
 namespace Meritoo\LimeSurvey\Test\ApiClient\Exception;
 
-use Generator;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
 use Meritoo\LimeSurvey\ApiClient\Exception\CannotProcessDataException;
@@ -23,7 +22,7 @@ class CannotProcessDataExceptionTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(CannotProcessDataException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+        static::assertConstructorVisibilityAndArguments(CannotProcessDataException::className, OopVisibilityType::IS_PUBLIC, 1, 1);
     }
 
     /**
@@ -41,12 +40,25 @@ class CannotProcessDataExceptionTest extends BaseTestCase
     /**
      * Provides reason why data cannot be processed
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideReason()
     {
         $template = 'Raw data returned by the LimeSurvey\'s API cannot be processed. Reason: \'%s\'.';
 
+        return [
+            [
+                'unknown',
+                sprintf($template, 'unknown'),
+            ],
+            [
+                'Invalid user name or password',
+                sprintf($template, 'Invalid user name or password'),
+            ],
+        ];
+
+        /*
         yield[
             'unknown',
             sprintf($template, 'unknown'),
@@ -56,5 +68,6 @@ class CannotProcessDataExceptionTest extends BaseTestCase
             'Invalid user name or password',
             sprintf($template, 'Invalid user name or password'),
         ];
+        */
     }
 }

tests/Exception/CreateSessionKeyFailedExceptionTest.php

@@ -8,7 +8,6 @@
 
 namespace Meritoo\LimeSurvey\Test\ApiClient\Exception;
 
-use Generator;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
 use Meritoo\LimeSurvey\ApiClient\Exception\CreateSessionKeyFailedException;
@@ -23,7 +22,7 @@ class CreateSessionKeyFailedExceptionTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(CreateSessionKeyFailedException::class, OopVisibilityType::IS_PUBLIC, 1, 0);
+        static::assertConstructorVisibilityAndArguments(CreateSessionKeyFailedException::className, OopVisibilityType::IS_PUBLIC, 1, 0);
     }
 
     /**
@@ -41,13 +40,26 @@ class CreateSessionKeyFailedExceptionTest extends BaseTestCase
     /**
      * Provides reason of failure
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideReason()
     {
         $shortMessage = 'Create of the session key has failed';
         $longMessageTemplate = sprintf('%s. Reason: \'%s\'.', $shortMessage, '%s');
 
+        return [
+            [
+                '',
+                $shortMessage,
+            ],
+            [
+                'Invalid user name or password',
+                sprintf($longMessageTemplate, 'Invalid user name or password'),
+            ],
+        ];
+
+        /*
         yield[
             '',
             $shortMessage,
@@ -57,5 +69,6 @@ class CreateSessionKeyFailedExceptionTest extends BaseTestCase
             'Invalid user name or password',
             sprintf($longMessageTemplate, 'Invalid user name or password'),
         ];
+        */
     }
 }

tests/Exception/IncorrectClassOfResultItemExceptionTest.php

@@ -8,12 +8,9 @@
 
 namespace Meritoo\LimeSurvey\Test\ApiClient\Exception;
 
-use Generator;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
-use Meritoo\LimeSurvey\ApiClient\Base\Result\BaseItem;
 use Meritoo\LimeSurvey\ApiClient\Exception\IncorrectClassOfResultItemException;
-use stdClass;
 
 /**
  * Test case of an exception used while class used to create instance of one item of the result is incorrect
@@ -25,7 +22,7 @@ class IncorrectClassOfResultItemExceptionTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(IncorrectClassOfResultItemException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+        static::assertConstructorVisibilityAndArguments(IncorrectClassOfResultItemException::className, OopVisibilityType::IS_PUBLIC, 1, 1);
     }
 
     /**
@@ -43,16 +40,26 @@ class IncorrectClassOfResultItemExceptionTest extends BaseTestCase
     /**
      * Provides incorrect class name used to create instance of one item
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideIncorrectClassName()
     {
         $template = 'Class %s used to create instance of one item of the result should extend %s, but it does not. Did'
             . ' you forget to use proper base class?';
 
+        return [
+            [
+                '\stdClass',
+                sprintf($template, '\stdClass', 'Meritoo\LimeSurvey\ApiClient\Base\Result\BaseItem'),
+            ],
+        ];
+
+        /*
         yield[
             stdClass::class,
             sprintf($template, stdClass::class, BaseItem::class),
         ];
+        */
     }
 }

tests/Exception/InvalidResultOfMethodRunExceptionTest.php

@@ -9,7 +9,6 @@
 namespace Meritoo\LimeSurvey\Test\ApiClient\Exception;
 
 use Exception;
-use Generator;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
 use Meritoo\LimeSurvey\ApiClient\Exception\InvalidResultOfMethodRunException;
@@ -25,7 +24,7 @@ class InvalidResultOfMethodRunExceptionTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(InvalidResultOfMethodRunException::class, OopVisibilityType::IS_PUBLIC, 3, 2);
+        static::assertConstructorVisibilityAndArguments(InvalidResultOfMethodRunException::className, OopVisibilityType::IS_PUBLIC, 3, 2);
     }
 
     /**
@@ -45,7 +44,8 @@ class InvalidResultOfMethodRunExceptionTest extends BaseTestCase
     /**
      * Provides previous exception, name and arguments of called method
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function providePreviousExceptionAndMethod()
     {
@@ -54,6 +54,26 @@ class InvalidResultOfMethodRunExceptionTest extends BaseTestCase
             . "- method: %s,\n"
             . '- arguments: %s.';
 
+        return [
+            [
+                new Exception('Lorem ipsum'),
+                MethodType::ADD_RESPONSE,
+                [],
+                sprintf($template, 'Lorem ipsum', MethodType::ADD_RESPONSE, '(no arguments)'),
+            ],
+            [
+                new Exception('Dolor sit amet'),
+                MethodType::LIST_SURVEYS,
+                [
+                    'fist_name' => 'John',
+                    'last_name' => 'Scott',
+                    'email'     => 'john@scott.com',
+                ],
+                sprintf($template, 'Dolor sit amet', MethodType::LIST_SURVEYS, 'fist_name="John", last_name="Scott", email="john@scott.com"'),
+            ],
+        ];
+
+        /*
         yield[
             new Exception('Lorem ipsum'),
             MethodType::ADD_RESPONSE,
@@ -71,5 +91,6 @@ class InvalidResultOfMethodRunExceptionTest extends BaseTestCase
             ],
             sprintf($template, 'Dolor sit amet', MethodType::LIST_SURVEYS, 'fist_name="John", last_name="Scott", email="john@scott.com"'),
         ];
+        */
     }
 }

tests/Exception/MissingParticipantOfSurveyExceptionTest.php

@@ -22,7 +22,7 @@ class MissingParticipantOfSurveyExceptionTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(MissingParticipantOfSurveyException::class, OopVisibilityType::IS_PUBLIC, 2, 2);
+        static::assertConstructorVisibilityAndArguments(MissingParticipantOfSurveyException::className, OopVisibilityType::IS_PUBLIC, 2, 2);
     }
 
     /**
@@ -41,12 +41,27 @@ class MissingParticipantOfSurveyExceptionTest extends BaseTestCase
     /**
      * Provides ID of survey and e-mail address of the participant
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideSurveyIdAndEmail()
     {
         $template = 'Participant with e-mail %s of survey with ID %s is missing. Maybe was not added to the survey?';
 
+        return [
+            [
+                1,
+                'lorem@ipsum.com',
+                sprintf($template, 'lorem@ipsum.com', 1),
+            ],
+            [
+                1234,
+                'another@email.comm',
+                sprintf($template, 'another@email.comm', 1234),
+            ],
+        ];
+
+        /*
         yield[
             1,
             'lorem@ipsum.com',
@@ -58,5 +73,6 @@ class MissingParticipantOfSurveyExceptionTest extends BaseTestCase
             'another@email.comm',
             sprintf($template, 'another@email.comm', 1234),
         ];
+        */
     }
 }

tests/Exception/UnknownInstanceOfResultItemTest.php

@@ -8,11 +8,9 @@
 
 namespace Meritoo\LimeSurvey\Test\ApiClient\Exception;
 
-use Generator;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
 use Meritoo\LimeSurvey\ApiClient\Exception\UnknownInstanceOfResultItem;
-use Meritoo\LimeSurvey\ApiClient\Result\Processor\ResultProcessor;
 use Meritoo\LimeSurvey\ApiClient\Type\MethodType;
 
 /**
@@ -26,7 +24,7 @@ class UnknownInstanceOfResultItemTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(UnknownInstanceOfResultItem::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+        static::assertConstructorVisibilityAndArguments(UnknownInstanceOfResultItem::className, OopVisibilityType::IS_PUBLIC, 1, 1);
     }
 
     /**
@@ -45,13 +43,26 @@ class UnknownInstanceOfResultItemTest extends BaseTestCase
     /**
      * Provides name of called method
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideMethodName()
     {
         $template = 'Class name used to create instance of one item used by result the of \'%s\' LimeSurvey API\'s'
             . ' method is unknown. Proper class is not mapped in %s::%s() method. Did you forget about this?';
 
+        return [
+            [
+                MethodType::LIST_SURVEYS,
+                sprintf($template, MethodType::LIST_SURVEYS, 'Meritoo\LimeSurvey\ApiClient\Result\Processor\ResultProcessor', 'getItemClassName'),
+            ],
+            [
+                MethodType::ADD_PARTICIPANTS,
+                sprintf($template, MethodType::ADD_PARTICIPANTS, 'Meritoo\LimeSurvey\ApiClient\Result\Processor\ResultProcessor', 'getItemClassName'),
+            ],
+        ];
+
+        /*
         yield[
             MethodType::LIST_SURVEYS,
             sprintf($template, MethodType::LIST_SURVEYS, ResultProcessor::class, 'getItemClassName'),
@@ -61,5 +72,6 @@ class UnknownInstanceOfResultItemTest extends BaseTestCase
             MethodType::ADD_PARTICIPANTS,
             sprintf($template, MethodType::ADD_PARTICIPANTS, ResultProcessor::class, 'getItemClassName'),
         ];
+        */
     }
 }

tests/Exception/UnknownMethodExceptionTest.php

@@ -8,7 +8,6 @@
 
 namespace Meritoo\LimeSurvey\Test\ApiClient\Exception;
 
-use Generator;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
 use Meritoo\LimeSurvey\ApiClient\Exception\UnknownMethodException;
@@ -24,7 +23,7 @@ class UnknownMethodExceptionTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(UnknownMethodException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+        static::assertConstructorVisibilityAndArguments(UnknownMethodException::className, OopVisibilityType::IS_PUBLIC, 1, 1);
     }
 
     /**
@@ -42,7 +41,8 @@ class UnknownMethodExceptionTest extends BaseTestCase
     /**
      * Provides name of called method
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideUnknownType()
     {
@@ -51,6 +51,18 @@ class UnknownMethodExceptionTest extends BaseTestCase
         $template = 'The \'%s\' type of name of method used while talking to the LimeSurvey\'s API is unknown. Probably'
             . ' doesn\'t exist or there is a typo. You should use one of these types: %s.';
 
+        return [
+            [
+                MethodType::ADD_PARTICIPANTS,
+                sprintf($template, MethodType::ADD_PARTICIPANTS, $allMethods),
+            ],
+            [
+                MethodType::ADD_PARTICIPANTS,
+                sprintf($template, MethodType::ADD_PARTICIPANTS, $allMethods),
+            ],
+        ];
+
+        /*
         yield[
             MethodType::ADD_PARTICIPANTS,
             sprintf($template, MethodType::ADD_PARTICIPANTS, $allMethods),
@@ -60,5 +72,6 @@ class UnknownMethodExceptionTest extends BaseTestCase
             MethodType::ADD_PARTICIPANTS,
             sprintf($template, MethodType::ADD_PARTICIPANTS, $allMethods),
         ];
+        */
     }
 }

tests/Manager/JsonRpcClientManagerTest.php

@@ -8,7 +8,6 @@
 
 namespace Meritoo\LimeSurvey\Test\ApiClient\Manager;
 
-use JsonRPC\Client as RpcClient;
 use JsonRPC\Exception\InvalidJsonFormatException;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
@@ -35,15 +34,15 @@ class JsonRpcClientManagerTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(JsonRpcClientManager::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+        static::assertConstructorVisibilityAndArguments(JsonRpcClientManager::className, OopVisibilityType::IS_PUBLIC, 1, 1);
     }
 
     public function testRunMethodWithEmptyArrayReturned()
     {
-        $rpcClient = $this->createMock(RpcClient::class);
+        $rpcClient = $this->createMock('\JsonRPC\Client');
 
         $manager = $this
-            ->getMockBuilder(JsonRpcClientManager::class)
+            ->getMockBuilder(JsonRpcClientManager::className)
             ->setConstructorArgs([
                 $this->configuration,
             ])
@@ -68,8 +67,8 @@ class JsonRpcClientManagerTest extends BaseTestCase
 
     public function testRunMethodWithRawDataReturned()
     {
-        $rpcClient = $this->createMock(RpcClient::class);
+        $rpcClient = $this->createMock('\JsonRPC\Client');
-        $manager = $this->createPartialMock(JsonRpcClientManager::class, ['getRpcClient']);
+        $manager = $this->getMock(JsonRpcClientManager::className, ['getRpcClient'], [], '', false);
 
         $rpcClient
             ->expects(static::once())
@@ -87,10 +86,10 @@ class JsonRpcClientManagerTest extends BaseTestCase
 
     public function testRunMethodWithException()
     {
-        $this->expectException(InvalidResultOfMethodRunException::class);
+        $this->setExpectedException(InvalidResultOfMethodRunException::className);
 
-        $manager = $this->createPartialMock(JsonRpcClientManager::class, ['getRpcClient']);
+        $manager = $this->getMock(JsonRpcClientManager::className, ['getRpcClient'], [], '', false);
-        $rpcClient = $this->createMock(RpcClient::class);
+        $rpcClient = $this->createMock('\JsonRPC\Client');
 
         $rpcClient
             ->expects(self::once())
@@ -108,7 +107,7 @@ class JsonRpcClientManagerTest extends BaseTestCase
 
     public function testGetRpcClientVisibilityAndArguments()
     {
-        static::assertMethodVisibilityAndArguments(JsonRpcClientManager::class, 'getRpcClient', OopVisibilityType::IS_PROTECTED);
+        static::assertMethodVisibilityAndArguments(JsonRpcClientManager::className, 'getRpcClient', OopVisibilityType::IS_PROTECTED);
     }
 
     /**

tests/Manager/SessionManagerTest.php

@@ -24,15 +24,15 @@ class SessionManagerTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(SessionManager::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+        static::assertConstructorVisibilityAndArguments(SessionManager::className, OopVisibilityType::IS_PUBLIC, 1, 1);
     }
 
     public function testGetSessionKeyWhenFailedWithoutReason()
     {
-        $this->expectException(CreateSessionKeyFailedException::class);
+        $this->setExpectedException(CreateSessionKeyFailedException::className, 'Create of the session key has failed');
-        $this->expectExceptionMessage('Create of the session key has failed');
+        //$this->expectExceptionMessage('Create of the session key has failed');
 
-        $clientManager = $this->createMock(JsonRpcClientManager::class);
+        $clientManager = $this->createMock(JsonRpcClientManager::className);
 
         $clientManager
             ->expects(static::any())
@@ -46,10 +46,10 @@ class SessionManagerTest extends BaseTestCase
     {
         $reason = 'Invalid credentials';
 
-        $this->expectException(CreateSessionKeyFailedException::class);
+        $this->setExpectedException(CreateSessionKeyFailedException::className, sprintf('Create of the session key has failed. Reason: \'%s\'.', $reason));
-        $this->expectExceptionMessage(sprintf('Create of the session key has failed. Reason: \'%s\'.', $reason));
+        //$this->expectExceptionMessage(sprintf('Create of the session key has failed. Reason: \'%s\'.', $reason));
 
-        $clientManager = $this->createMock(JsonRpcClientManager::class);
+        $clientManager = $this->createMock(JsonRpcClientManager::className);
 
         $clientManager
             ->expects(static::any())
@@ -63,7 +63,7 @@ class SessionManagerTest extends BaseTestCase
 
     public function testGetSessionKey()
     {
-        $clientManager = $this->createMock(JsonRpcClientManager::class);
+        $clientManager = $this->createMock(JsonRpcClientManager::className);
 
         $clientManager
             ->expects(static::any())
@@ -76,7 +76,7 @@ class SessionManagerTest extends BaseTestCase
 
     public function testReleaseSessionKey()
     {
-        $clientManager = $this->createMock(JsonRpcClientManager::class);
+        $clientManager = $this->createMock(JsonRpcClientManager::className);
 
         $clientManager
             ->expects(static::any())
@@ -84,6 +84,6 @@ class SessionManagerTest extends BaseTestCase
             ->willReturn([]);
 
         $sessionManager = new SessionManager($clientManager);
-        static::assertInstanceOf(SessionManager::class, $sessionManager->releaseSessionKey());
+        static::assertInstanceOf(SessionManager::className, $sessionManager->releaseSessionKey());
     }
 }

tests/Result/Collection/ParticipantsTest.php

@@ -47,24 +47,24 @@ class ParticipantsTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(Participants::class, OopVisibilityType::IS_PUBLIC, 1, 0);
+        static::assertConstructorVisibilityAndArguments(Participants::className, OopVisibilityType::IS_PUBLIC, 1, 0);
     }
 
     public function testAdd()
     {
-        $this->expectException(DisabledMethodException::class);
+        $this->setExpectedException(DisabledMethodException::className);
         (new Participants())->add('');
     }
 
     public function testAddMultiple()
     {
-        $this->expectException(DisabledMethodException::class);
+        $this->setExpectedException(DisabledMethodException::className);
         (new Participants())->addMultiple([]);
     }
 
     public function testHas()
     {
-        $this->expectException(DisabledMethodException::class);
+        $this->setExpectedException(DisabledMethodException::className);
         (new Participants())->has(new Participant());
     }
 

tests/Result/Collection/SurveysTest.php

@@ -37,7 +37,7 @@ class SurveysTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(Surveys::class, OopVisibilityType::IS_PUBLIC, 1, 0);
+        static::assertConstructorVisibilityAndArguments(Surveys::className, OopVisibilityType::IS_PUBLIC, 1, 0);
     }
 
     public function testAddWithoutIndex()

tests/Result/Item/ParticipantShortTest.php

@@ -46,7 +46,7 @@ class ParticipantShortTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(ParticipantShort::class, OopVisibilityType::IS_PUBLIC, 1, 0);
+        static::assertConstructorVisibilityAndArguments(ParticipantShort::className, OopVisibilityType::IS_PUBLIC, 1, 0);
     }
 
     public function testCreateOfTheParticipant()

tests/Result/Item/ParticipantTest.php

@@ -46,7 +46,7 @@ class ParticipantTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(Participant::class, OopVisibilityType::IS_PUBLIC, 1, 0);
+        static::assertConstructorVisibilityAndArguments(Participant::className, OopVisibilityType::IS_PUBLIC, 1, 0);
     }
 
     public function testCreateOfTheParticipant()
@@ -54,7 +54,7 @@ class ParticipantTest extends BaseTestCase
         $processor = new ResultProcessor();
         $processed = $processor->process(MethodType::GET_PARTICIPANT_PROPERTIES, $this->rawData[0]);
 
-        static::assertInstanceOf(Participant::class, $processed);
+        static::assertInstanceOf(Participant::className, $processed);
     }
 
     public function testGetId()

tests/Result/Item/QuestionShortTest.php

@@ -45,7 +45,7 @@ class QuestionShortTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(QuestionShort::class, OopVisibilityType::IS_PUBLIC, 1, 0);
+        static::assertConstructorVisibilityAndArguments(QuestionShort::className, OopVisibilityType::IS_PUBLIC, 1, 0);
     }
 
     public function testCreateOfTheQuestionShort()

tests/Result/Item/QuestionTest.php

@@ -45,7 +45,7 @@ class QuestionTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(Question::class, OopVisibilityType::IS_PUBLIC, 1, 0);
+        static::assertConstructorVisibilityAndArguments(Question::className, OopVisibilityType::IS_PUBLIC, 1, 0);
     }
 
     public function testCreateOfTheQuestionShort()
@@ -53,7 +53,7 @@ class QuestionTest extends BaseTestCase
         $processor = new ResultProcessor();
         $processed = $processor->process(MethodType::GET_QUESTION_PROPERTIES, $this->rawData);
 
-        static::assertInstanceOf(Question::class, $processed);
+        static::assertInstanceOf(Question::className, $processed);
     }
 
     public function testGetId()

tests/Result/Item/SurveyTest.php

@@ -46,7 +46,7 @@ class SurveyTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(Survey::class, OopVisibilityType::IS_PUBLIC, 1, 0);
+        static::assertConstructorVisibilityAndArguments(Survey::className, OopVisibilityType::IS_PUBLIC, 1, 0);
     }
 
     public function testCreateOfTheSurvey()

tests/Result/Processor/ResultProcessorTest.php

@@ -27,7 +27,7 @@ class ResultProcessorTest extends BaseTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertHasNoConstructor(ResultProcessor::class);
+        static::assertHasNoConstructor(ResultProcessor::className);
     }
 
     public function testProcessWithEmptyRawData()
@@ -72,17 +72,17 @@ class ResultProcessorTest extends BaseTestCase
 
         static::assertNotEmpty($processed);
         static::assertFalse(is_array($processed));
-        static::assertInstanceOf(BaseItem::class, $processed);
+        static::assertInstanceOf(BaseItem::className, $processed);
     }
 
     public function testGetItemClassNameVisibilityAndArguments()
     {
-        static::assertMethodVisibilityAndArguments(ResultProcessor::class, 'getItemClassName', OopVisibilityType::IS_PRIVATE, 1, 1);
+        static::assertMethodVisibilityAndArguments(ResultProcessor::className, 'getItemClassName', OopVisibilityType::IS_PRIVATE, 1, 1);
     }
 
     public function testRunWithUnknownResultClass()
     {
-        $this->expectException(UnknownInstanceOfResultItem::class);
+        $this->setExpectedException(UnknownInstanceOfResultItem::className);
 
         $rawData = [
             'lorem' => 'ipsum',

tests/Result/ResultTest.php

@@ -87,7 +87,7 @@ class ResultTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(Result::class, OopVisibilityType::IS_PUBLIC, 2, 2);
+        static::assertConstructorVisibilityAndArguments(Result::className, OopVisibilityType::IS_PUBLIC, 2, 2);
     }
 
     public function testIsEmpty()
@@ -108,7 +108,7 @@ class ResultTest extends BaseTestCase
 
         static::assertCount(count($this->emptyData), $emptyData);
         static::assertCount(count($this->iterableData), $iterableData);
-        static::assertInstanceOf(BaseItem::class, $notIterableData);
+        static::assertInstanceOf(BaseItem::className, $notIterableData);
     }
 
     public function testGetDataUsingRawData()
@@ -128,18 +128,18 @@ class ResultTest extends BaseTestCase
 
     public function testGetDataUsingProcessedDataWhoCannotBeProcessed()
     {
-        $this->expectException(CannotProcessDataException::class);
+        $this->setExpectedException(CannotProcessDataException::className);
         $this->statusInsteadDataResult->getData();
     }
 
     public function testGetProcessedDataVisibilityAndArguments()
     {
-        static::assertMethodVisibilityAndArguments(Result::class, 'getProcessedData', OopVisibilityType::IS_PRIVATE, 1, 1);
+        static::assertMethodVisibilityAndArguments(Result::className, 'getProcessedData', OopVisibilityType::IS_PRIVATE, 1, 1);
     }
 
     public function testGetResultProcessorVisibilityAndArguments()
     {
-        static::assertMethodVisibilityAndArguments(Result::class, 'getResultProcessor', OopVisibilityType::IS_PRIVATE);
+        static::assertMethodVisibilityAndArguments(Result::className, 'getResultProcessor', OopVisibilityType::IS_PRIVATE);
     }
 
     public function testGetStatusWhenIsNotProvided()
@@ -218,6 +218,6 @@ class ResultTest extends BaseTestCase
      */
     private function getResultMock($constructorArguments)
     {
-        return $this->getMockForAbstractClass(Result::class, $constructorArguments);
+        return $this->getMockForAbstractClass(Result::className, $constructorArguments);
     }
 }

tests/Service/ParticipantServiceTest.php

@@ -51,7 +51,7 @@ class ParticipantServiceTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(ParticipantService::class, OopVisibilityType::IS_PUBLIC, 2, 1);
+        static::assertConstructorVisibilityAndArguments(ParticipantService::className, OopVisibilityType::IS_PUBLIC, 2, 1);
     }
 
     public function testGetClient()
@@ -62,8 +62,8 @@ class ParticipantServiceTest extends BaseTestCase
         $this->createServiceWithoutParticipants($rpcClientManager, $sessionManager);
         $this->createServiceWithParticipants($rpcClientManager, $sessionManager);
 
-        static::assertInstanceOf(Client::class, $this->serviceWithoutParticipants->getClient());
+        static::assertInstanceOf(Client::className, $this->serviceWithoutParticipants->getClient());
-        static::assertInstanceOf(Client::class, $this->serviceWithParticipants->getClient());
+        static::assertInstanceOf(Client::className, $this->serviceWithParticipants->getClient());
 
         $connectionConfiguration = $this->getConnectionConfiguration();
         $client = new Client($connectionConfiguration);
@@ -90,7 +90,7 @@ class ParticipantServiceTest extends BaseTestCase
 
     public function testGetSurveyParticipantsWithImportantException()
     {
-        $this->expectException(CannotProcessDataException::class);
+        $this->setExpectedException(CannotProcessDataException::className);
         $exception = new CannotProcessDataException(ReasonType::NO_TOKEN_TABLE);
 
         $rpcClientManager = $this->getJsonRpcClientManagerWithException(1, $exception);
@@ -129,7 +129,7 @@ class ParticipantServiceTest extends BaseTestCase
 
     public function testAddParticipantForNotExistingSurvey()
     {
-        $this->expectException(CannotProcessDataException::class);
+        $this->setExpectedException(CannotProcessDataException::className);
         $exception = new CannotProcessDataException(ReasonType::NOT_EXISTING_SURVEY_ID);
 
         $rpcClientManager = $this->getJsonRpcClientManagerWithException(1, $exception);
@@ -169,7 +169,7 @@ class ParticipantServiceTest extends BaseTestCase
         $this->createServiceWithoutParticipants($rpcClientManager, $sessionManager);
         $result = $this->serviceWithoutParticipants->addParticipant($surveyId, $firstName, $lastName, $email);
 
-        static::assertInstanceOf(Participant::class, $result);
+        static::assertInstanceOf(Participant::className, $result);
         static::assertEquals($firstName, $result->getFirstName());
         static::assertEquals($lastName, $result->getLastName());
         static::assertEquals($email, $result->getEmail());
@@ -186,7 +186,7 @@ class ParticipantServiceTest extends BaseTestCase
         static::assertNull($this->serviceWithoutParticipants->getParticipant(1, 'john@scott.com'));
         $participant = $this->serviceWithParticipants->getParticipant(1, 'john@scott.com');
 
-        static::assertInstanceOf(ParticipantShort::class, $participant);
+        static::assertInstanceOf(ParticipantShort::className, $participant);
         static::assertEquals('John', $participant->getFirstName());
         static::assertEquals('Scott', $participant->getLastName());
         static::assertEquals('john@scott.com', $participant->getEmail());
@@ -215,7 +215,7 @@ class ParticipantServiceTest extends BaseTestCase
         static::assertNull($this->serviceWithoutParticipants->getParticipantDetails(1, 'john@scott.com'));
         $participant = $this->serviceWithParticipants->getParticipantDetails(1, 'john@scott.com');
 
-        static::assertInstanceOf(Participant::class, $participant);
+        static::assertInstanceOf(Participant::className, $participant);
         static::assertEquals($runMethodCallResults['tid'], $participant->getId());
         static::assertEquals($runMethodCallResults['firstname'], $participant->getFirstName());
         static::assertEquals($runMethodCallResults['lastname'], $participant->getLastName());
@@ -229,7 +229,7 @@ class ParticipantServiceTest extends BaseTestCase
 
     public function testHasParticipantFilledSurveyWithException()
     {
-        $this->expectException(MissingParticipantOfSurveyException::class);
+        $this->setExpectedException(MissingParticipantOfSurveyException::className);
 
         $rpcClientManager = $this->getJsonRpcClientManager(1);
         $sessionManager = $this->getSessionManager();
@@ -256,7 +256,7 @@ class ParticipantServiceTest extends BaseTestCase
 
     public function testHasParticipantFilledSurveyUsingNotExistingParticipant()
     {
-        $this->expectException(MissingParticipantOfSurveyException::class);
+        $this->setExpectedException(MissingParticipantOfSurveyException::className);
 
         $rpcClientManager = $this->getJsonRpcClientManager(1);
         $sessionManager = $this->getSessionManager();
@@ -282,7 +282,7 @@ class ParticipantServiceTest extends BaseTestCase
      */
     private function getSessionManager()
     {
-        return $this->createMock(SessionManager::class);
+        return $this->createMock(SessionManager::className);
     }
 
     /**
@@ -294,7 +294,7 @@ class ParticipantServiceTest extends BaseTestCase
      */
     private function getJsonRpcClientManager($runMethodCallCount, array $runMethodCallResults = [])
     {
-        $rpcClientManager = $this->createMock(JsonRpcClientManager::class);
+        $rpcClientManager = $this->createMock(JsonRpcClientManager::className);
 
         $rpcClientManager
             ->expects(static::exactly($runMethodCallCount))
@@ -314,7 +314,7 @@ class ParticipantServiceTest extends BaseTestCase
      */
     private function getJsonRpcClientManagerWithException($runMethodCallCount, Exception $exception)
     {
-        $rpcClientManager = $this->createMock(JsonRpcClientManager::class);
+        $rpcClientManager = $this->createMock(JsonRpcClientManager::className);
 
         $rpcClientManager
             ->expects(static::exactly($runMethodCallCount))

tests/Service/SurveyServiceTest.php

@@ -57,7 +57,7 @@ class SurveyServiceTest extends BaseTestCase
 
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertConstructorVisibilityAndArguments(SurveyService::class, OopVisibilityType::IS_PUBLIC, 2, 1);
+        static::assertConstructorVisibilityAndArguments(SurveyService::className, OopVisibilityType::IS_PUBLIC, 2, 1);
     }
 
     public function testGetClient()
@@ -68,8 +68,8 @@ class SurveyServiceTest extends BaseTestCase
         $this->createServiceWithoutSurveys($rpcClientManager, $sessionManager);
         $this->createServiceWithSurveys($rpcClientManager, $sessionManager);
 
-        static::assertInstanceOf(Client::class, $this->serviceWithoutSurveys->getClient());
+        static::assertInstanceOf(Client::className, $this->serviceWithoutSurveys->getClient());
-        static::assertInstanceOf(Client::class, $this->serviceWithSurveys->getClient());
+        static::assertInstanceOf(Client::className, $this->serviceWithSurveys->getClient());
 
         $connectionConfiguration = $this->getConnectionConfiguration();
         $client = new Client($connectionConfiguration);
@@ -80,7 +80,7 @@ class SurveyServiceTest extends BaseTestCase
 
     public function testGetAllSurveysWithImportantException()
     {
-        $this->expectException(CannotProcessDataException::class);
+        $this->setExpectedException(CannotProcessDataException::className);
         $exception = new CannotProcessDataException(ReasonType::NO_TOKEN_TABLE);
 
         $rpcClientManager = $this->getJsonRpcClientManagerWithException(1, $exception);
@@ -202,7 +202,7 @@ class SurveyServiceTest extends BaseTestCase
      */
     private function getSessionManager()
     {
-        return $this->createMock(SessionManager::class);
+        return $this->createMock(SessionManager::className);
     }
 
     /**
@@ -214,7 +214,7 @@ class SurveyServiceTest extends BaseTestCase
      */
     private function getJsonRpcClientManager($runMethodCallCount, array $runMethodCallResults = [])
     {
-        $rpcClientManager = $this->createMock(JsonRpcClientManager::class);
+        $rpcClientManager = $this->createMock(JsonRpcClientManager::className);
 
         $rpcClientManager
             ->expects(static::exactly($runMethodCallCount))
@@ -234,7 +234,7 @@ class SurveyServiceTest extends BaseTestCase
      */
     private function getJsonRpcClientManagerWithException($runMethodCallCount, Exception $exception)
     {
-        $rpcClientManager = $this->createMock(JsonRpcClientManager::class);
+        $rpcClientManager = $this->createMock(JsonRpcClientManager::className);
 
         $rpcClientManager
             ->expects(static::exactly($runMethodCallCount))

tests/Type/MethodTypeTest.php

@@ -8,7 +8,6 @@
 
 namespace Meritoo\LimeSurvey\Test\ApiClient\Type;
 
-use Generator;
 use Meritoo\Common\Test\Base\BaseTypeTestCase;
 use Meritoo\LimeSurvey\ApiClient\Exception\UnknownMethodException;
 use Meritoo\LimeSurvey\ApiClient\Type\MethodType;
@@ -24,7 +23,7 @@ class MethodTypeTest extends BaseTypeTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertHasNoConstructor(MethodType::class);
+        static::assertHasNoConstructor(MethodType::className);
     }
 
     /**
@@ -33,7 +32,7 @@ class MethodTypeTest extends BaseTypeTestCase
      */
     public function testGetValidatedMethodWithIncorrectMethod($incorrectMethod)
     {
-        $this->expectException(UnknownMethodException::class);
+        $this->setExpectedException(UnknownMethodException::className);
         MethodType::getValidatedMethod($incorrectMethod);
     }
 
@@ -52,7 +51,7 @@ class MethodTypeTest extends BaseTypeTestCase
      */
     public function testIsResultIterableWithIncorrectMethod($incorrectMethod)
     {
-        $this->expectException(UnknownMethodException::class);
+        $this->setExpectedException(UnknownMethodException::className);
         MethodType::isResultIterable($incorrectMethod);
     }
 
@@ -70,10 +69,33 @@ class MethodTypeTest extends BaseTypeTestCase
     /**
      * Provides correct type of method
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideMethod()
     {
+        return [
+            [
+                MethodType::ADD_RESPONSE,
+            ],
+            [
+                MethodType::EXPORT_STATISTICS,
+            ],
+            [
+                MethodType::GET_PARTICIPANT_PROPERTIES,
+            ],
+            [
+                MethodType::LIST_SURVEYS,
+            ],
+            [
+                SystemMethodType::GET_SESSION_KEY,
+            ],
+            [
+                SystemMethodType::RELEASE_SESSION_KEY,
+            ],
+        ];
+
+        /*
         yield[
             MethodType::ADD_RESPONSE,
         ];
@@ -97,15 +119,36 @@ class MethodTypeTest extends BaseTypeTestCase
         yield[
             SystemMethodType::RELEASE_SESSION_KEY,
         ];
+        */
     }
 
     /**
      * Provides incorrect type of method
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideIncorrectMethod()
     {
+        return [
+            [
+                '',
+            ],
+            [
+                null,
+            ],
+            [
+                true,
+            ],
+            [
+                false,
+            ],
+            [
+                'lorem',
+            ],
+        ];
+
+        /*
         yield[
             '',
         ];
@@ -125,15 +168,45 @@ class MethodTypeTest extends BaseTypeTestCase
         yield[
             'lorem',
         ];
+        */
     }
 
     /**
      * Provides type of method who result provided by the API is iterable and information if it's iterable
      *
-     * @return Generator
+     * @return array
+     * //return Generator
      */
     public function provideIterableType()
     {
+        return [
+            [
+                MethodType::ADD_RESPONSE,
+                false,
+            ],
+            [
+                MethodType::GET_PARTICIPANT_PROPERTIES,
+                false,
+            ],
+            [
+                MethodType::LIST_PARTICIPANTS,
+                true,
+            ],
+            [
+                MethodType::LIST_QUESTIONS,
+                true,
+            ],
+            [
+                MethodType::LIST_SURVEYS,
+                true,
+            ],
+            [
+                MethodType::LIST_USERS,
+                true,
+            ],
+        ];
+
+        /*
         yield[
             MethodType::ADD_RESPONSE,
             false,
@@ -163,6 +236,7 @@ class MethodTypeTest extends BaseTypeTestCase
             MethodType::LIST_USERS,
             true,
         ];
+        */
     }
 
     /**
@@ -196,6 +270,26 @@ class MethodTypeTest extends BaseTypeTestCase
      */
     public function provideTypeToVerify()
     {
+        return [
+            [
+                '',
+                false,
+            ],
+            [
+                'lorem',
+                false,
+            ],
+            [
+                MethodType::ADD_RESPONSE,
+                true,
+            ],
+            [
+                MethodType::GET_PARTICIPANT_PROPERTIES,
+                true,
+            ],
+        ];
+
+        /*
         yield[
             '',
             false,
@@ -215,5 +309,6 @@ class MethodTypeTest extends BaseTypeTestCase
             MethodType::GET_PARTICIPANT_PROPERTIES,
             true,
         ];
+        */
     }
 }

tests/Type/ReasonTypeTest.php

@@ -21,7 +21,7 @@ class ReasonTypeTest extends BaseTypeTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertHasNoConstructor(ReasonType::class);
+        static::assertHasNoConstructor(ReasonType::className);
     }
 
     /**
@@ -50,6 +50,34 @@ class ReasonTypeTest extends BaseTypeTestCase
      */
     public function provideTypeToVerify()
     {
+        return [
+            [
+                '',
+                false,
+            ],
+            [
+                'lorem',
+                false,
+            ],
+            [
+                ReasonType::NOT_EXISTING_SURVEY_ID,
+                true,
+            ],
+            [
+                ReasonType::NO_PARTICIPANTS_FOUND,
+                true,
+            ],
+            [
+                ReasonType::NO_SURVEYS_FOUND,
+                true,
+            ],
+            [
+                ReasonType::NO_TOKEN_TABLE,
+                true,
+            ],
+        ];
+
+        /*
         yield[
             '',
             false,
@@ -79,5 +107,6 @@ class ReasonTypeTest extends BaseTypeTestCase
             ReasonType::NO_TOKEN_TABLE,
             true,
         ];
+        */
     }
 }

tests/Type/SystemMethodTypeTest.php

@@ -21,7 +21,7 @@ class SystemMethodTypeTest extends BaseTypeTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        static::assertHasNoConstructor(SystemMethodType::class);
+        static::assertHasNoConstructor(SystemMethodType::className);
     }
 
     /**
@@ -48,6 +48,26 @@ class SystemMethodTypeTest extends BaseTypeTestCase
      */
     public function provideTypeToVerify()
     {
+        return [
+            [
+                '',
+                false,
+            ],
+            [
+                'lorem',
+                false,
+            ],
+            [
+                SystemMethodType::GET_SESSION_KEY,
+                true,
+            ],
+            [
+                SystemMethodType::RELEASE_SESSION_KEY,
+                true,
+            ],
+        ];
+
+        /*
         yield[
             '',
             false,
@@ -67,5 +87,6 @@ class SystemMethodTypeTest extends BaseTypeTestCase
             SystemMethodType::RELEASE_SESSION_KEY,
             true,
         ];
+        */
     }
 }