composer.json - update name of this package (name of vendor, actually)

Details: https://github.com/phingofficial/phing/issues/716

.docker/config/Dockerfile

@@ -1,10 +1,11 @@
-FROM php:5.6-cli
+FROM php:5.5-cli
 
 #
 # Tools & libraries
 #
 RUN apt-get update \
     && apt-get install -y --no-install-recommends \
+        vim \
         git \
         zip \
         unzip \
@@ -14,7 +15,7 @@ RUN apt-get update \
     && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
 
 #
-# PHP Extensions
+# PHP extensions
 #
 RUN docker-php-ext-install \
     zip \
@@ -23,10 +24,12 @@ RUN docker-php-ext-install \
 
 #
 # PHP configuration:
+# - default configuration
 # - timezone
 #
+COPY php.ini /usr/local/etc/php/php.ini
 ARG TIMEZONE
-RUN echo "date.timezone = $TIMEZONE" >> /usr/local/etc/php/php.ini
+RUN echo "\n""date.timezone = $TIMEZONE""\n" >> /usr/local/etc/php/php.ini
 
 #
 # Xdebug
@@ -52,3 +55,10 @@ RUN php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');" \
     && php -r "unlink('composer-setup.php');" \
     && composer global require --no-plugins --no-scripts hirak/prestissimo \
     && rm -rf /root/.composer/cache/*
+
+#
+# Bash
+#
+RUN sed -i 's/^# export/export/g' /root/.bashrc \
+    && sed -i 's/^# alias/alias/g' /root/.bashrc \
+    && echo "\n"'export PATH=/project/vendor/bin:$PATH'"\n" >> /root/.bashrc

.docker/config/php.ini

@@ -0,0 +1,3 @@
+display_errors = On
+display_startup_errors = On
+error_reporting = E_ALL

.docker/config/xdebug.ini

@@ -1,7 +1,6 @@
 [xdebug]
-zend_extension='xdebug.so'
+zend_extension=xdebug.so
 
 xdebug.remote_enable=1
-xdebug.remote_connect_back=1
-xdebug.idekey='PHPSTORM'
 xdebug.remote_port=9001
+xdebug.remote_host=10.254.254.254

.phing/properties.dist

@@ -28,7 +28,13 @@ assets.installWithSymlink = true
 
 # Clear cache with the "warmup" option
 #
-cache.clearWithWarmup = true
+# The cache:clear command should always be called with the --no-warmup option. Warmup should be done via the cache:warmup command.
+# https://github.com/symfony/symfony/blob/master/UPGRADE-3.3.md#frameworkbundle
+#
+# Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+# 2017-06-06
+#
+cache.clearWithWarmup = false
 
 # --------------------------------------------------------------------------------
 # Composer

README.md

@@ -5,10 +5,22 @@ Common and useful classes, methods, exceptions etc.
 
 ## Installation
 
+In your `composer.json` add address of repository into `repositories` section:
+
+```json
+"repositories": [
+    (...)
+    {
+        "type": "vcs",
+        "url": "https://github.com/wiosna-dev/common-library"
+    }
+]
+```
+
 Run [Composer](https://getcomposer.org) to install this package in your project:
 
 ```bash
-$ composer require meritoo/common-library
+$ composer require wiosna-dev/common-library
 ```
 
 > How to install Composer: https://getcomposer.org/download

composer.json

@@ -1,8 +1,8 @@
 {
-    "name": "meritoo/common-library",
+    "name": "wiosna-dev/common-library",
     "description": "Useful classes, methods, extensions etc.",
     "license": "MIT",
-    "version": "0.0.15",
+    "version": "0.0.17",
     "authors": [
         {
             "name": "Meritoo.pl",
@@ -11,18 +11,18 @@
         }
     ],
     "require": {
-        "php": ">=5.6.0",
+        "php": ">=5.5.9",
         "doctrine/orm": "^2.5",
         "gedmo/doctrine-extensions": "^2.4",
         "symfony/http-foundation": "^3.3"
     },
     "require-dev": {
-        "friendsofphp/php-cs-fixer": "^2.6",
+        "friendsofphp/php-cs-fixer": "^2.2",
         "pdepend/pdepend": "^2.5",
-        "phploc/phploc": "^4.0",
+        "phploc/phploc": "^2.1",
         "phpmd/phpmd": "^2.6",
-        "phpunit/phpunit": "^5.7",
+        "phpunit/phpunit": "^4.8",
-        "sebastian/phpcpd": "^3.0",
+        "sebastian/phpcpd": "^2.0",
         "squizlabs/php_codesniffer": "^2.9"
     },
     "autoload": {
@@ -34,5 +34,8 @@
         "psr-4": {
             "Meritoo\\Common\\Test\\": "tests/"
         }
+    },
+    "config": {
+        "sort-packages": true
     }
 }

src/Test/Base/BaseTestCase.php

@@ -8,14 +8,8 @@
 
 namespace Meritoo\Common\Test\Base;
 
-use DateTime;
+use Meritoo\Common\Traits\Test\Base\BaseTestCaseTrait;
-use Generator;
-use Meritoo\Common\Exception\Type\UnknownOopVisibilityTypeException;
-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
@@ -25,214 +19,5 @@ use ReflectionMethod;
  */
 abstract class BaseTestCase extends TestCase
 {
-    /**
+    use BaseTestCaseTrait;
-     * Path of directory with data used by test cases
-     *
-     * @var string
-     */
-    private static $testsDataDirPath = '.data/tests';
-
-    /**
-     * Provides an empty value
-     *
-     * @return Generator
-     */
-    public function provideEmptyValue()
-    {
-        yield[''];
-        yield['   '];
-        yield[null];
-        yield[0];
-        yield[false];
-        yield[[]];
-    }
-
-    /**
-     * Provides boolean value
-     *
-     * @return Generator
-     */
-    public function provideBooleanValue()
-    {
-        yield[false];
-        yield[true];
-    }
-
-    /**
-     * Provides instance of DateTime class
-     *
-     * @return Generator
-     */
-    public function provideDateTimeInstance()
-    {
-        yield[new DateTime()];
-        yield[new DateTime('yesterday')];
-        yield[new DateTime('now')];
-        yield[new DateTime('tomorrow')];
-    }
-
-    /**
-     * Provides relative / compound format of DateTime
-     *
-     * @return Generator
-     */
-    public function provideDateTimeRelativeFormat()
-    {
-        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 Generator
-     */
-    public function provideNotExistingFilePath()
-    {
-        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;
-    }
 }

src/Test/Base/BaseTypeTestCase.php

@@ -1,9 +1,14 @@
 <?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 Generator;
+use Meritoo\Common\Traits\Test\Base\BaseTypeTestCaseTrait;
-use Meritoo\Common\Type\Base\BaseType;
 
 /**
  * Base test case for the type of something
@@ -13,48 +18,5 @@ use Meritoo\Common\Type\Base\BaseType;
  */
 abstract class BaseTypeTestCase extends BaseTestCase
 {
-    /**
+    use BaseTypeTestCaseTrait;
-     * Verifies availability of all types
-     */
-    public function testAvailabilityOfAllTypes()
-    {
-        $available = $this->getTestedTypeInstance()->getAll();
-        $all = $this->getAllExpectedTypes();
-
-        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/Traits/Test/Base/BaseTestCaseTrait.php

@@ -0,0 +1,238 @@
+<?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\Traits\Test\Base;
+
+use DateTime;
+use Generator;
+use Meritoo\Common\Exception\Type\UnknownOopVisibilityTypeException;
+use Meritoo\Common\Type\OopVisibilityType;
+use Meritoo\Common\Utilities\Miscellaneous;
+use ReflectionClass;
+use ReflectionMethod;
+
+/**
+ * BaseTestCaseTrait
+ * Created on 2017-11-02
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+trait BaseTestCaseTrait
+{
+    /**
+     * Path of directory with data used by test cases
+     *
+     * @var string
+     */
+    private static $testsDataDirPath = '.data/tests';
+
+    /**
+     * Provides an empty value
+     *
+     * @return Generator
+     */
+    public function provideEmptyValue()
+    {
+        yield[''];
+        yield['   '];
+        yield[null];
+        yield[0];
+        yield[false];
+        yield[[]];
+    }
+
+    /**
+     * Provides boolean value
+     *
+     * @return Generator
+     */
+    public function provideBooleanValue()
+    {
+        yield[false];
+        yield[true];
+    }
+
+    /**
+     * Provides instance of DateTime class
+     *
+     * @return Generator
+     */
+    public function provideDateTimeInstance()
+    {
+        yield[new DateTime()];
+        yield[new DateTime('yesterday')];
+        yield[new DateTime('now')];
+        yield[new DateTime('tomorrow')];
+    }
+
+    /**
+     * Provides relative / compound format of DateTime
+     *
+     * @return Generator
+     */
+    public function provideDateTimeRelativeFormat()
+    {
+        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 Generator
+     */
+    public function provideNotExistingFilePath()
+    {
+        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 getFilePathForTesting($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();
+
+        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;
+    }
+}

src/Traits/Test/Base/BaseTypeTestCaseTrait.php

@@ -0,0 +1,66 @@
+<?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\Traits\Test\Base;
+
+use Generator;
+use Meritoo\Common\Type\Base\BaseType;
+
+/**
+ * Trait for the base test case for the type of something
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+trait BaseTypeTestCaseTrait
+{
+    /**
+     * Verifies availability of all types
+     */
+    public function testAvailabilityOfAllTypes()
+    {
+        $available = $this->getTestedTypeInstance()->getAll();
+        $all = $this->getAllExpectedTypes();
+
+        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();
+}

tests/Exception/Base/UnknownTypeExceptionTest.php

@@ -33,7 +33,7 @@ class UnknownTypeExceptionTest extends BaseTestCase
 
     public function testTheException()
     {
-        $this->expectException(UnknownTestTypeException::class);
+        $this->setExpectedException(UnknownTestTypeException::class);
         self::assertEmpty((new TestService())->getTranslatedType('test_3'));
     }
 }

tests/Test/Base/BaseTestCaseTest.php

@@ -0,0 +1,176 @@
+<?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\Test\Base;
+
+use DateTime;
+use Generator;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+use Meritoo\Common\Utilities\GeneratorUtility;
+
+/**
+ * Test case of the base test case with common methods and data providers
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class BaseTestCaseTest extends BaseTestCase
+{
+    public function testConstructor()
+    {
+        static::assertConstructorVisibilityAndArguments(BaseTestCase::class, OopVisibilityType::IS_PUBLIC, 3);
+    }
+
+    public function testProvideEmptyValue()
+    {
+        $elements = [
+            [''],
+            ['   '],
+            [null],
+            [0],
+            [false],
+            [[]],
+        ];
+
+        $generator = (new SimpleTestCase())->provideEmptyValue();
+        self::assertEquals($elements, GeneratorUtility::getGeneratorElements($generator));
+    }
+
+    public function testProvideBooleanValue()
+    {
+        $elements = [
+            [false],
+            [true],
+        ];
+
+        $generator = (new SimpleTestCase())->provideBooleanValue();
+        self::assertEquals($elements, GeneratorUtility::getGeneratorElements($generator));
+    }
+
+    public function testProvideDateTimeInstance()
+    {
+        $dateFormat = 'Y-m-d H:i';
+
+        $expectedElements = [
+            [new DateTime()],
+            [new DateTime('yesterday')],
+            [new DateTime('now')],
+            [new DateTime('tomorrow')],
+        ];
+
+        $generator = (new SimpleTestCase())->provideDateTimeInstance();
+        $generatedElements = GeneratorUtility::getGeneratorElements($generator);
+
+        /* @var DateTime $instance1 */
+        $instance1 = $generatedElements[0][0];
+
+        /* @var DateTime $instance2 */
+        $instance2 = $generatedElements[1][0];
+
+        /* @var DateTime $instance3 */
+        $instance3 = $generatedElements[2][0];
+
+        /* @var DateTime $instance4 */
+        $instance4 = $generatedElements[3][0];
+
+        self::assertCount(count($expectedElements), $generatedElements);
+        self::assertEquals($instance1->format($dateFormat), (new DateTime())->format($dateFormat));
+        self::assertEquals($instance2->format($dateFormat), (new DateTime('yesterday'))->format($dateFormat));
+        self::assertEquals($instance3->format($dateFormat), (new DateTime('now'))->format($dateFormat));
+        self::assertEquals($instance4->format($dateFormat), (new DateTime('tomorrow'))->format($dateFormat));
+    }
+
+    public function testProvideDateTimeRelativeFormat()
+    {
+        $elements = [
+            ['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'],
+        ];
+
+        $generator = (new SimpleTestCase())->provideDateTimeRelativeFormat();
+        self::assertEquals($elements, GeneratorUtility::getGeneratorElements($generator));
+    }
+
+    public function testProvideNotExistingFilePath()
+    {
+        $elements = [
+            ['lets-test.doc'],
+            ['lorem/ipsum.jpg'],
+            ['surprise/me/one/more/time.txt'],
+        ];
+
+        $generator = (new SimpleTestCase())->provideNotExistingFilePath();
+        self::assertEquals($elements, GeneratorUtility::getGeneratorElements($generator));
+    }
+
+    /**
+     * @param string $fileName      Name of file
+     * @param string $directoryPath Path of directory containing the file
+     *
+     * @dataProvider provideFileNameAndDirectoryPath
+     */
+    public function testGetFilePathForTesting($fileName, $directoryPath)
+    {
+        $path = (new SimpleTestCase())->getFilePathForTesting($fileName, $directoryPath);
+
+        if (!empty($directoryPath)) {
+            $directoryPath .= '/';
+        }
+
+        $expectedContains = sprintf('/.data/tests/%s%s', $directoryPath, $fileName);
+        static::assertContains($expectedContains, $path);
+    }
+
+    /**
+     * Provides name of file and path of directory containing the file
+     *
+     * @return Generator
+     */
+    public function provideFileNameAndDirectoryPath()
+    {
+        yield[
+            'abc.jpg',
+            '',
+        ];
+
+        yield[
+            'abc.def.jpg',
+            '',
+        ];
+
+        yield[
+            'abc.jpg',
+            'def',
+        ];
+
+        yield[
+            'abc.def.jpg',
+            'def',
+        ];
+    }
+}
+
+/**
+ * Simple test case
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class SimpleTestCase extends BaseTestCase
+{
+}

tests/Type/Base/BaseTypeTest.php

@@ -9,8 +9,8 @@
 namespace Meritoo\Common\Test\Type\Base;
 
 use Generator;
+use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\Base\BaseType;
-use PHPUnit\Framework\TestCase;
 
 /**
  * Test case of the base / abstract type of something
@@ -18,8 +18,13 @@ use PHPUnit\Framework\TestCase;
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-class BaseTypeTest extends TestCase
+class BaseTypeTest extends BaseTestCase
 {
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(BaseType::class);
+    }
+
     /**
      * @param BaseType $type          Type of something
      * @param array    $expectedTypes Expected concrete types of given instance of type

tests/Utilities/ComposerTest.php

@@ -88,6 +88,6 @@ class ComposerTest extends BaseTestCase
     {
         parent::setUp();
 
-        $this->composerJsonPath = $this->getFilePathToTests(Composer::FILE_NAME_MAIN);
+        $this->composerJsonPath = $this->getFilePathForTesting(Composer::FILE_NAME_MAIN);
     }
 }

tests/Utilities/DateTest.php

@@ -223,7 +223,7 @@ class DateTest extends BaseTestCase
      */
     public function testGetDayOfWeekIncorrectValues($year, $month, $day)
     {
-        $this->expectException(UnknownDatePartTypeException::class);
+        $this->setExpectedException(UnknownDatePartTypeException::class);
         self::assertEmpty(Date::getDayOfWeek($year, $month, $day));
     }
 

tests/Utilities/MimeTypesTest.php

@@ -447,12 +447,12 @@ class MimeTypesTest extends BaseTestCase
     public function provideFilePathToGetMimeTypeOfRealFile()
     {
         yield[
-            $this->getFilePathToTests('minion.jpg'),
+            $this->getFilePathForTesting('minion.jpg'),
             'image/jpeg',
         ];
 
         yield[
-            $this->getFilePathToTests('lorem-ipsum.txt'),
+            $this->getFilePathForTesting('lorem-ipsum.txt'),
             'text/plain',
         ];
     }
@@ -465,12 +465,12 @@ class MimeTypesTest extends BaseTestCase
     public function provideExistingFilePathToCheckIsImagePath()
     {
         yield[
-            $this->getFilePathToTests('minion.jpg'),
+            $this->getFilePathForTesting('minion.jpg'),
             true,
         ];
 
         yield[
-            $this->getFilePathToTests('lorem-ipsum.txt'),
+            $this->getFilePathForTesting('lorem-ipsum.txt'),
             false,
         ];
     }

tests/Utilities/MiscellaneousTest.php

@@ -663,7 +663,8 @@ class MiscellaneousTest extends BaseTestCase
 
     public function testGetInvertedColorWithIncorrectLength()
     {
-        $this->expectException(IncorrectColorHexLengthException::class);
+        $this->setExpectedException(IncorrectColorHexLengthException::class);
+
         Miscellaneous::getInvertedColor(null);
         Miscellaneous::getInvertedColor('');
         Miscellaneous::getInvertedColor(1);
@@ -676,7 +677,8 @@ class MiscellaneousTest extends BaseTestCase
 
     public function testGetInvertedColorWithInvalidValue()
     {
-        $this->expectException(InvalidColorHexValueException::class);
+        $this->setExpectedException(InvalidColorHexValueException::class);
+
         Miscellaneous::getInvertedColor('0011zz');
         Miscellaneous::getInvertedColor('001#zz');
         Miscellaneous::getInvertedColor('001!zz');

tests/Utilities/ReflectionTest.php

@@ -122,7 +122,7 @@ class ReflectionTest extends BaseTestCase
      */
     public function testGetChildClassesInvalidClass($invalidClass)
     {
-        $this->expectException(CannotResolveClassNameException::class);
+        $this->setExpectedException(CannotResolveClassNameException::class);
 
         self::assertNull(Reflection::getChildClasses($invalidClass));
         self::assertNull(Reflection::getChildClasses(123));
@@ -130,7 +130,7 @@ class ReflectionTest extends BaseTestCase
 
     public function testGetChildClassesNotExistingClass()
     {
-        $this->expectException(CannotResolveClassNameException::class);
+        $this->setExpectedException(CannotResolveClassNameException::class);
         self::assertEquals('', Reflection::getChildClasses('xyz'));
     }
 
@@ -161,13 +161,13 @@ class ReflectionTest extends BaseTestCase
 
     public function testGetOneChildClassWithMissingChildClasses()
     {
-        $this->expectException(MissingChildClassesException::class);
+        $this->setExpectedException(MissingChildClassesException::class);
         self::assertEquals('LoremIpsum', Reflection::getOneChildClass(C::class));
     }
 
     public function testGetOneChildClassWithTooManyChildClasses()
     {
-        $this->expectException(TooManyChildClassesException::class);
+        $this->setExpectedException(TooManyChildClassesException::class);
 
         self::assertEquals(B::class, Reflection::getOneChildClass(A::class));
         self::assertEquals(C::class, Reflection::getOneChildClass(A::class));
@@ -195,7 +195,7 @@ class ReflectionTest extends BaseTestCase
      */
     public function testUsesTraitInvalidClass($class, $trait)
     {
-        $this->expectException(CannotResolveClassNameException::class);
+        $this->setExpectedException(CannotResolveClassNameException::class);
         self::assertNull(Reflection::usesTrait($class, $trait));
     }
 
@@ -205,7 +205,7 @@ class ReflectionTest extends BaseTestCase
      */
     public function testUsesTraitInvalidTrait($trait)
     {
-        $this->expectException(CannotResolveClassNameException::class);
+        $this->setExpectedException(CannotResolveClassNameException::class);
         self::assertNull(Reflection::usesTrait(DateTime::class, $trait));
     }