diff --git a/composer.json b/composer.json
index 7ff83e3..e0a38fd 100644
--- a/composer.json
+++ b/composer.json
@@ -11,12 +11,15 @@
     ],
     "minimum-stability": "stable",
     "require": {
-        "php": "^7.3 | ~8.0.0"
+        "php": "^7.4 | ~8.0.0",
+        "psr/container": "^1.0"
     },
     "require-dev": {
         "codeception/codeception": "^4.1",
         "php-coveralls/php-coveralls": "^v2.2.0",
-        "codeception/module-asserts": "^1.2"
+        "codeception/module-asserts": "^1.2",
+        "squizlabs/php_codesniffer": "^3.6",
+        "doctrine/coding-standard": "^9.0"
     },
     "autoload": {
         "psr-4": {
@@ -27,6 +30,12 @@
         "psr-4": {
             "Selami\\Resources\\" : "tests/resources/src/"
         }
+    },
+    "scripts": {
+
+        "cs-check": "vendor/bin/phpcs --standard=Doctrine",
+        "cs-fix": "vendor/bin/phpcbf --standard=Doctrine"
+
     }
 
 }
diff --git a/src/BaseUrlExtractor.php b/src/BaseUrlExtractor.php
index 3cbb706..32c6a2c 100644
--- a/src/BaseUrlExtractor.php
+++ b/src/BaseUrlExtractor.php
@@ -1,40 +1,45 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Stdlib;
 
+use function basename;
+use function strpos;
+use function substr;
+use function trim;
+
 class BaseUrlExtractor
 {
-    public static function getBaseUrl(array $httpServerData) : string
+    public static function getBaseUrl(array $httpServerData): string
     {
-        $protocol = self::getProtocol($httpServerData);
-        $host = self::getHost($httpServerData);
-        $uriPath = $httpServerData['REQUEST_URI'] ?? '';
-        $filename = $httpServerData['SCRIPT_FILENAME'] ?? '';
+        $protocol   = self::getProtocol($httpServerData);
+        $host       = self::getHost($httpServerData);
+        $uriPath    = $httpServerData['REQUEST_URI'] ?? '';
+        $filename   = $httpServerData['SCRIPT_FILENAME'] ?? '';
         $scriptName = $httpServerData['SCRIPT_NAME'];
-        $phpSelf = $httpServerData['PHP_SELF'];
-        $baseUrl = self::getRelativeBaseUrl($scriptName, $phpSelf, $filename);
+        $phpSelf    = $httpServerData['PHP_SELF'];
+        $baseUrl    = self::getRelativeBaseUrl($scriptName, $phpSelf, $filename);
+
         return trim($protocol . '://' . $host . $baseUrl, '/');
     }
 
-
-
-    public static function getProtocol(array $httpServerData) : string
+    public static function getProtocol(array $httpServerData): string
     {
         if (isset($httpServerData['HTTP_X_FORWARDED_PROTO'])) {
             return $httpServerData['HTTP_X_FORWARDED_PROTO'];
         }
-        return isset($httpServerData['HTTPS']) && $httpServerData['HTTPS'] !== 'Off' ? 'https': 'http';
+
+        return isset($httpServerData['HTTPS']) && $httpServerData['HTTPS'] !== 'Off' ? 'https' : 'http';
     }
 
-    public static function getHost($httpServerData) : string
+    public static function getHost($httpServerData): string
     {
         return $httpServerData['HTTP_HOST'];
     }
 
-    public static function getRelativeBaseUrl($scriptName, $phpSelf, $filename) : string
+    public static function getRelativeBaseUrl($scriptName, $phpSelf, $filename): string
     {
-
         // Backtrack up the SCRIPT_FILENAME to find the portion
         // matching PHP_SELF.
         $baseUrl  = '/';
@@ -42,8 +47,9 @@ public static function getRelativeBaseUrl($scriptName, $phpSelf, $filename) : st
         if ($basename) {
             $path     = ($phpSelf ? trim($phpSelf, '/') : '');
             $basePos  = strpos($path, $basename) ?: 0;
-            $baseUrl .= substr($path, 0, $basePos) ;
+            $baseUrl .= substr($path, 0, $basePos);
         }
+
         return $baseUrl;
     }
 }
diff --git a/src/CaseConverter.php b/src/CaseConverter.php
index f16d753..47e0e1a 100644
--- a/src/CaseConverter.php
+++ b/src/CaseConverter.php
@@ -1,53 +1,50 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Stdlib;
 
+use function lcfirst;
+use function mb_convert_case;
+use function mb_strtolower;
+use function preg_replace;
+use function str_replace;
+use function trim;
+
+use const MB_CASE_TITLE;
+
 class CaseConverter
 {
     /**
      * Returns PascalCase string
-     *
-     * @param string $source
-     * @param string $separator
-     * @return string
-     *
      */
-    public static function toPascalCase(string $source, string $separator = '_') : string
+    public static function toPascalCase(string $source, string $separator = '_'): string
     {
         // If the string is snake case
-        $modified = str_replace($separator, ' ', $source);
-        $lowercase = mb_strtolower($modified);
+        $modified              = str_replace($separator, ' ', $source);
+        $lowercase             = mb_strtolower($modified);
         $uppercaseFirstLetters = mb_convert_case($lowercase, MB_CASE_TITLE);
+
         return str_replace(' ', '', $uppercaseFirstLetters);
     }
 
     /**
      * Returns camelCase string
-     *
-     * @param string $source
-     * @param string $separator
-     * @return string
-     *
      */
-    public static function toCamelCase(string $source, string $separator = '_') : string
+    public static function toCamelCase(string $source, string $separator = '_'): string
     {
         return lcfirst(self::toPascalCase($source, $separator));
     }
 
     /**
      * Returns snake_case string
-     *
-     * @param string $source
-     * @param string $separator
-     * @return string
-     *
      */
-    public static function toSnakeCase(string $source, string $separator = '_') : string
+    public static function toSnakeCase(string $source, string $separator = '_'): string
     {
         // If the string is pascal/camel case
-        $modified = str_replace('  ', ' ', preg_replace('/[A-Z]+/', ' $0', $source));
+        $modified  = str_replace('  ', ' ', preg_replace('/[A-Z]+/', ' $0', $source));
         $lowercase = mb_strtolower(trim($modified));
+
         return str_replace(' ', $separator, $lowercase);
     }
 }
diff --git a/src/EqualsBuilder.php b/src/EqualsBuilder.php
index 34ca24f..71c0310 100644
--- a/src/EqualsBuilder.php
+++ b/src/EqualsBuilder.php
@@ -1,85 +1,97 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Stdlib;
 
 use ReflectionClass;
 
+use function is_object;
+
 /**
- * Class EqualsBuilder
- *
  * This class provides methods to build a equals method for any class. Intended to be use to compare Value Objects.
- * @package Selami\Stdlib
- *
  */
 
 final class EqualsBuilder
 {
     private $isEquals = true;
 
-    public static function create() : EqualsBuilder
+    public static function create(): EqualsBuilder
     {
         return new static();
     }
+
     public function append($leftHandedValue, $rightHandedValue)
     {
         if ($this->isEquals === false) {
             return $this;
         }
+
         if ($this->checkIfValuesAreAnObjectAndEqual($leftHandedValue, $rightHandedValue)) {
             return $this;
         }
+
         if ($this->checkForSameType($leftHandedValue, $rightHandedValue)) {
             return $this;
         }
+
         return $this;
     }
 
-    private function checkForSameType($leftHandedValue, $rightHandedValue) :bool
+    private function checkForSameType($leftHandedValue, $rightHandedValue): bool
     {
         if ($leftHandedValue !== $rightHandedValue) {
             $this->isEquals = false;
+
             return false;
         }
+
         return true;
     }
 
-    private function checkIfValuesAreAnObjectAndEqual($leftHandedValue, $rightHandedValue) : bool
+    private function checkIfValuesAreAnObjectAndEqual($leftHandedValue, $rightHandedValue): bool
     {
         if (! $this->checkIfValuesAreAnObject($leftHandedValue, $rightHandedValue)) {
             return false;
         }
-        if (get_class($leftHandedValue) !== get_class($rightHandedValue)) {
+
+        if ($leftHandedValue::class !== $rightHandedValue::class) {
             $this->isEquals = false;
+
             return false;
         }
+
         if (! $this->compareObjectProperties($leftHandedValue, $rightHandedValue)) {
             $this->isEquals = false;
+
             return false;
         }
+
         return true;
     }
-    private function checkIfValuesAreAnObject($leftHandedValue, $rightHandedValue) : bool
+
+    private function checkIfValuesAreAnObject($leftHandedValue, $rightHandedValue): bool
     {
-        return (is_object($leftHandedValue) && is_object($rightHandedValue));
+        return is_object($leftHandedValue) && is_object($rightHandedValue);
     }
 
-    private function compareObjectProperties($leftHandedObject, $rightHandedObject) : bool
+    private function compareObjectProperties($leftHandedObject, $rightHandedObject): bool
     {
-        $reflectionOfLeftHandedObject = new ReflectionClass($leftHandedObject);
-        $propertiesOfLeftHandedObject = $this->getPropertiesAsAnArray($leftHandedObject, $reflectionOfLeftHandedObject);
+        $reflectionOfLeftHandedObject  = new ReflectionClass($leftHandedObject);
+        $propertiesOfLeftHandedObject  = $this->getPropertiesAsAnArray($leftHandedObject, $reflectionOfLeftHandedObject);
         $reflectionOfRightHandedObject = new ReflectionClass($rightHandedObject);
         $propertiesOfRightHandedObject = $this->getPropertiesAsAnArray(
             $rightHandedObject,
             $reflectionOfRightHandedObject
         );
+
         return $this->checkValuesRecursively($propertiesOfRightHandedObject, $propertiesOfLeftHandedObject);
     }
 
     private function checkValuesRecursively(
         array $propertiesOfLeftHandedObject,
         array $propertiesOfRightHandedObject
-    ) : bool {
+    ): bool {
         $innerEqualsBuilder = self::create();
         foreach ($propertiesOfLeftHandedObject as $propertyName => $propertyValue) {
             $innerEqualsBuilder = $innerEqualsBuilder->append(
@@ -87,22 +99,25 @@ private function checkValuesRecursively(
                 $propertiesOfRightHandedObject[$propertyName]
             );
         }
+
         return $innerEqualsBuilder->isEquals();
     }
 
-    private function getPropertiesAsAnArray($sourceObject, $object) :array
+    private function getPropertiesAsAnArray($sourceObject, $object): array
     {
         $propertyList = [];
         foreach ($object->getProperties() as $property) {
             if ($property->isProtected() || $property->isPrivate()) {
                 $property->setAccessible(true);
             }
+
             $propertyList[$property->name] = $property->getValue($sourceObject);
         }
+
         return $propertyList;
     }
 
-    public function isEquals() : bool
+    public function isEquals(): bool
     {
         return $this->isEquals;
     }
diff --git a/src/Exception/ClassOrMethodCouldNotBeFound.php b/src/Exception/ClassOrMethodCouldNotBeFound.php
index 161c6d8..69c099b 100644
--- a/src/Exception/ClassOrMethodCouldNotBeFound.php
+++ b/src/Exception/ClassOrMethodCouldNotBeFound.php
@@ -1,9 +1,11 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Stdlib\Exception;
 
-class ClassOrMethodCouldNotBeFound extends \InvalidArgumentException
-{
+use InvalidArgumentException;
 
+class ClassOrMethodCouldNotBeFound extends InvalidArgumentException
+{
 }
diff --git a/src/Exception/InvalidArgumentException.php b/src/Exception/InvalidArgumentException.php
index 8684f38..a0848eb 100644
--- a/src/Exception/InvalidArgumentException.php
+++ b/src/Exception/InvalidArgumentException.php
@@ -1,9 +1,9 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Stdlib\Exception;
 
 class InvalidArgumentException extends \InvalidArgumentException
 {
-
 }
diff --git a/src/Exception/InvalidSemverPatternException.php b/src/Exception/InvalidSemverPatternException.php
index c04d064..1495aad 100644
--- a/src/Exception/InvalidSemverPatternException.php
+++ b/src/Exception/InvalidSemverPatternException.php
@@ -1,9 +1,11 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Stdlib\Exception;
 
-class InvalidSemverPatternException extends \InvalidArgumentException
-{
+use InvalidArgumentException;
 
+class InvalidSemverPatternException extends InvalidArgumentException
+{
 }
diff --git a/src/Git/Version.php b/src/Git/Version.php
index 9dd8dfe..fe41f36 100644
--- a/src/Git/Version.php
+++ b/src/Git/Version.php
@@ -1,13 +1,17 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Stdlib\Git;
 
+use function exec;
+
 final class Version
 {
     public static function short()
     {
         exec('git describe --always', $versionMiniHash);
+
         return $versionMiniHash[0];
     }
 }
diff --git a/src/Pipeline/InvalidStageException.php b/src/Pipeline/InvalidStageException.php
new file mode 100644
index 0000000..e5491ee
--- /dev/null
+++ b/src/Pipeline/InvalidStageException.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Selami\Stdlib\Pipeline;
+
+use Exception;
+
+class InvalidStageException extends Exception
+{
+}
diff --git a/src/Pipeline/Pipeline.php b/src/Pipeline/Pipeline.php
new file mode 100644
index 0000000..438cdb1
--- /dev/null
+++ b/src/Pipeline/Pipeline.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Selami\Stdlib\Pipeline;
+
+use Psr\Container\ContainerInterface;
+
+class Pipeline implements PipelineInterface
+{
+    private ContainerInterface $container;
+    private array $stages = [];
+
+    public function __construct(ContainerInterface $container)
+    {
+        $this->container = $container;
+    }
+
+    public function fromContainer(string $className): callable
+    {
+        if (! $this->container->has($className)) {
+            throw new StageDoesNotExistException('DIC does not have requested stage service:' . $className);
+        }
+
+        return $this->container->get($className);
+    }
+
+    public function pipe(callable $stage): PipelineInterface
+    {
+        $this->stages[] = $stage;
+
+         return $this;
+    }
+
+    public function process($payload)
+    {
+        foreach ($this->stages as $stage) {
+            $payload = $stage($payload);
+        }
+
+        return $payload;
+    }
+}
diff --git a/src/Pipeline/PipelineFactory.php b/src/Pipeline/PipelineFactory.php
new file mode 100644
index 0000000..cfc768d
--- /dev/null
+++ b/src/Pipeline/PipelineFactory.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Selami\Stdlib\Pipeline;
+
+use Psr\Container\ContainerInterface;
+
+class PipelineFactory
+{
+    public function __invoke(ContainerInterface $container): Pipeline
+    {
+        return new Pipeline($container);
+    }
+}
diff --git a/src/Pipeline/PipelineInterface.php b/src/Pipeline/PipelineInterface.php
new file mode 100644
index 0000000..23454a0
--- /dev/null
+++ b/src/Pipeline/PipelineInterface.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Selami\Stdlib\Pipeline;
+
+interface PipelineInterface
+{
+    public function pipe(callable $stage): PipelineInterface;
+
+    public function fromContainer(string $className): callable;
+
+    public function process($payload): void;
+}
diff --git a/src/Pipeline/StageDoesNotExistException.php b/src/Pipeline/StageDoesNotExistException.php
new file mode 100644
index 0000000..d99120d
--- /dev/null
+++ b/src/Pipeline/StageDoesNotExistException.php
@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Selami\Stdlib\Pipeline;
+
+use Exception;
+
+class StageDoesNotExistException extends Exception
+{
+}
diff --git a/src/Pipeline/StageInterface.php b/src/Pipeline/StageInterface.php
new file mode 100644
index 0000000..9068841
--- /dev/null
+++ b/src/Pipeline/StageInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Selami\Stdlib\Pipeline;
+
+interface StageInterface
+{
+    public function __invoke($payload): void;
+}
diff --git a/src/Resolver.php b/src/Resolver.php
index f083256..5fb630f 100644
--- a/src/Resolver.php
+++ b/src/Resolver.php
@@ -1,35 +1,32 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Stdlib;
 
+use ReflectionException;
 use ReflectionMethod;
 use ReflectionParameter;
 use Selami\Stdlib\Exception\ClassOrMethodCouldNotBeFound;
-use Selami\Stdlib\Exception\InvalidArgumentException;
-use ReflectionException;
+
+use function assert;
+use function class_exists;
+use function is_array;
+use function method_exists;
+use function sprintf;
 
 class Resolver
 {
-    const ARRAY = 'array';
-    const CALLABLE = 'callable';
-    const BOOLEAN = 'boolean';
-    const FLOAT = 'float';
-    const INTEGER = 'int';
-    const STRING = 'string';
-    const ITERABLE = 'iterable';
+    public const ARRAY    = 'array';
+    public const CALLABLE = 'callable';
+    public const BOOLEAN  = 'boolean';
+    public const FLOAT    = 'float';
+    public const INTEGER  = 'int';
+    public const STRING   = 'string';
+    public const ITERABLE = 'iterable';
 
-    /**
-     * @param string $className
-     * @param string $methodName
-     * @return array
-     * @throws InvalidArgumentException
-     * @throws ClassOrMethodCouldNotBeFound
-     */
-
-    public static function getParameterHints(string $className, string $methodName) : array
+    public static function getParameterHints(string $className, string $methodName): array
     {
-
         self::checkClassName($className);
         self::checkMethodName($className, $methodName);
         try {
@@ -39,49 +36,47 @@ public static function getParameterHints(string $className, string $methodName)
                 sprintf('%s::%s coulnd not be found.', $className, $methodName)
             );
         }
-        /**
-         * @var array $parameters
-         */
+
         $parameters = $method->getParameters();
+        assert(is_array($parameters));
         $parameterHints = [];
         foreach ($parameters as $param) {
-            $parameter = self::getParamType($param);
+            $parameter                          = self::getParamType($param);
             $parameterHints[$parameter['name']] = $parameter['type'];
         }
+
         return $parameterHints;
     }
 
-    private static function checkClassName(string $className) : void
+    private static function checkClassName(string $className): void
     {
         if (! class_exists($className)) {
-            throw new InvalidArgumentException(
+            throw new ClassOrMethodCouldNotBeFound(
                 sprintf('%s class does not exist!', $className)
             );
         }
     }
 
-    private static function checkMethodName(string $className, string $methodName) : void
+    private static function checkMethodName(string $className, string $methodName): void
     {
         if (! method_exists($className, $methodName)) {
-            throw new InvalidArgumentException(
+            throw new ClassOrMethodCouldNotBeFound(
                 sprintf('%s does not have method named %s!', $className, $methodName)
             );
         }
     }
 
-    /**
-     * @param ReflectionParameter $parameter
-     * @return array
-     * @throws ClassOrMethodCouldNotBeFound
-     */
-    private static function getParamType(ReflectionParameter $parameter) :array
+    private static function getParamType(ReflectionParameter $parameter): array
     {
         $type = $parameter->getType();
         if ($type->isBuiltin()) {
             return ['name' => $parameter->name, 'type' => $type->getName()];
         }
+
         try {
-            return ['name' => $parameter->name, 'type' => $parameter->getClass()->name];
+            self::checkClassName($type->getName());
+
+            return ['name' => $parameter->name, 'type' => $type->getName()];
         } catch (ReflectionException $e) {
             throw new ClassOrMethodCouldNotBeFound($e->getMessage());
         }
diff --git a/src/Semver.php b/src/Semver.php
index 6ac5ab1..b7d588e 100644
--- a/src/Semver.php
+++ b/src/Semver.php
@@ -1,14 +1,16 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Stdlib;
 
 use Selami\Stdlib\Exception\InvalidSemverPatternException;
 
+use function preg_match;
+use function sprintf;
+
 /**
- * Class Semver
  * Semantic Versioning 2.0.0 compatible version handling
- * @package Selami\Stdlib
  */
 final class Semver
 {
@@ -20,28 +22,30 @@ final class Semver
 
     private function __construct(int $major, int $minor, int $patch, ?string $preRelase = null)
     {
-        $this->major = $major;
-        $this->minor = $minor;
-        $this->patch = $patch;
+        $this->major      = $major;
+        $this->minor      = $minor;
+        $this->patch      = $patch;
         $this->preRelease = $preRelase;
     }
 
-    public static function createFromString(string $version) : self
+    public static function createFromString(string $version): self
     {
         $preRelease = null;
-        if (!preg_match(self::$semverPattern, $version, $match)) {
+        if (! preg_match(self::$semverPattern, $version, $match)) {
             throw new InvalidSemverPatternException(
                 sprintf('%s is not valid semver compatible version name', $version)
             );
         }
-        [,$major, $minor, $patch, $preRelease] = $match;
+
+        [, $major, $minor, $patch, $preRelease] = $match;
         if ($preRelease === '') {
             $preRelease = null;
         }
+
         return new self((int) $major, (int) $minor, (int) $patch, $preRelease);
     }
 
-    public function getCurrent() : string
+    public function getCurrent(): string
     {
         return $this->major . '.'
             . $this->minor . '.'
@@ -49,16 +53,17 @@ public function getCurrent() : string
             . $this->preRelease;
     }
 
-    public function getNextPatchRelease() : string
+    public function getNextPatchRelease(): string
     {
         $patch = $this->patch;
         if ($this->preRelease === null) {
             $patch++;
         }
+
         return $this->major . '.' . $this->minor . '.' . $patch;
     }
 
-    public function getNextMinorRelease() : string
+    public function getNextMinorRelease(): string
     {
         $minor = $this->minor;
         $patch = $this->patch;
@@ -67,10 +72,11 @@ public function getNextMinorRelease() : string
 
             $patch = 0;
         }
+
         return $this->major . '.' . $minor . '.' . $patch;
     }
 
-    public function getNextMajorRelease() : string
+    public function getNextMajorRelease(): string
     {
         $major = $this->major;
         $minor = $this->minor;
@@ -80,6 +86,7 @@ public function getNextMajorRelease() : string
             $minor = 0;
             $patch = 0;
         }
+
         return $major . '.' . $minor . '.' . $patch;
     }
 }
diff --git a/tests/_support/Helper/Unit.php b/tests/_support/Helper/Unit.php
index 6064d37..c762ac5 100644
--- a/tests/_support/Helper/Unit.php
+++ b/tests/_support/Helper/Unit.php
@@ -1,10 +1,14 @@
 <?php
+
+declare(strict_types=1);
+
 namespace Helper;
 
+use Codeception\Module;
+
 // here you can define custom actions
 // all public methods declared in helper class will be available in $I
 
-class Unit extends \Codeception\Module
+class Unit extends Module
 {
-
 }
diff --git a/tests/_support/UnitTester.php b/tests/_support/UnitTester.php
index 2835357..70e0c39 100644
--- a/tests/_support/UnitTester.php
+++ b/tests/_support/UnitTester.php
@@ -1,8 +1,13 @@
 <?php
 
+declare(strict_types=1);
+
+use Codeception\Actor;
+use Codeception\Lib\Friend;
 
 /**
  * Inherited Methods
+ *
  * @method void wantToTest($text)
  * @method void wantTo($text)
  * @method void execute($callable)
@@ -12,14 +17,12 @@
  * @method void am($role)
  * @method void lookForwardTo($achieveValue)
  * @method void comment($description)
- * @method \Codeception\Lib\Friend haveFriend($name, $actorClass = NULL)
- *
+ * @method Friend haveFriend($name, $actorClass = null)
  * @SuppressWarnings(PHPMD)
-*/
-class UnitTester extends \Codeception\Actor
+ */
+class UnitTester extends Actor
 {
     use _generated\UnitTesterActions;
-
    /**
     * Define custom actions here
     */
diff --git a/tests/_support/_generated/UnitTesterActions.php b/tests/_support/_generated/UnitTesterActions.php
index 82a46ea..4d5f6fd 100644
--- a/tests/_support/_generated/UnitTesterActions.php
+++ b/tests/_support/_generated/UnitTesterActions.php
@@ -1,4 +1,4 @@
-<?php  //[STAMP] 46e793584ef93b822a37f97506eb0f06
+<?php  //[STAMP] cca48000e7b4e8e1a7243a960fa0a581
 namespace _generated;
 
 // This class was automatically generated by build task
diff --git a/tests/resources/src/TypeHintedClass.php b/tests/resources/src/TypeHintedClass.php
index c1bffef..1770c82 100644
--- a/tests/resources/src/TypeHintedClass.php
+++ b/tests/resources/src/TypeHintedClass.php
@@ -1,11 +1,12 @@
 <?php
+
 declare(strict_types=1);
 
 namespace Selami\Resources;
 
+use Codeception\Test\NonExistingClass;
 use Codeception\Test\Test;
 use Codeception\Test\Unit;
-use Codeception\Test\NonExistingClass;
 
 class TypeHintedClass
 {
@@ -13,11 +14,12 @@ public function __construct(Test $test, Unit $unit)
     {
     }
 
-    public function method(array $config, Unit $unit) : void
+    public function method(array $config, Unit $unit): void
     {
         // does nothing
     }
-    public function method2(array $config, NonExistingClass $unit) : void
+
+    public function method2(array $config, NonExistingClass $unit): void
     {
         // does nothing
     }
diff --git a/tests/unit/BaseUrlExtractorTest.php b/tests/unit/BaseUrlExtractorTest.php
index 432b73b..339c1b6 100644
--- a/tests/unit/BaseUrlExtractorTest.php
+++ b/tests/unit/BaseUrlExtractorTest.php
@@ -1,62 +1,61 @@
 <?php
 
+declare(strict_types=1);
+
+use Codeception\Test\Unit;
 use Selami\Stdlib\BaseUrlExtractor;
 
-class myBaseUrlExtractor extends \Codeception\Test\Unit
+class myBaseUrlExtractor extends Unit
 {
-    /**
-     * @var \UnitTester
-     */
-    protected $tester;
+    protected UnitTester $tester;
 
-    protected function _before()
+    protected function _before(): void
     {
     }
 
-    protected function _after()
+    protected function _after(): void
     {
     }
 
     /**
-     * @test
      * @param array $serverData
-     * @param string $expected
+     *
+     * @test
      * @dataProvider serverRequestDataProvider
      */
-    public function shouldFindBaseUrlSuccessfully(array $serverData, string $expected)
+    public function shouldFindBaseUrlSuccessfully(array $serverData, string $expected): void
     {
         $_SERVER = $serverData;
         $baseUrl = BaseUrlExtractor::getBaseUrl($serverData);
         $this->assertEquals($expected, $baseUrl);
     }
 
-
     public function serverRequestDataProvider()
     {
         return [
             [
                 json_decode('{"REQUEST_URI":"\/test\/level-1\/level-2","SCRIPT_FILENAME":"\/mnt\/public\/site1\/test\/index.php","HTTP_HOST":"127.0.0.1:8080","SCRIPT_NAME":"\/test\/index.php","PHP_SELF":"\/test\/index.php\/level-1\/level-2","ORIG_SCRIPT_NAME":""}', true),
-                'http://127.0.0.1:8080/test'
+                'http://127.0.0.1:8080/test',
             ],
             [
                 json_decode('{"REQUEST_URI":"\/tr\/basvuru\/bilgiler\/3","SCRIPT_FILENAME":"\/mnt\/public\/site1\/index.php","HTTP_HOST":"127.0.0.1:8080","SCRIPT_NAME":"\/index.php","PHP_SELF":"\/index.php\/tr\/basvuru\/bilgiler\/3","ORIG_SCRIPT_NAME":""}', true),
-                'http://127.0.0.1:8080'
+                'http://127.0.0.1:8080',
             ],
             [
                 json_decode('{"REQUEST_URI":"\/","SCRIPT_FILENAME":"\/mnt\/public\/site1\/index.php","HTTP_HOST":"127.0.0.1:8080","SCRIPT_NAME":"\/index.php","PHP_SELF":"\/index.php","ORIG_SCRIPT_NAME":""}', true),
-                'http://127.0.0.1:8080'
+                'http://127.0.0.1:8080',
             ],
             [
                 json_decode('{"REQUEST_URI":"\/tr","SCRIPT_FILENAME":"\/mnt\/public\/site1\/index.php","HTTP_HOST":"127.0.0.1:8080","SCRIPT_NAME":"\/index.php","PHP_SELF":"\/index.php\/tr","ORIG_SCRIPT_NAME":""}', true),
-                'http://127.0.0.1:8080'
+                'http://127.0.0.1:8080',
             ],
             [
                 json_decode('{"REQUEST_URI":"\/index.php","SCRIPT_FILENAME":"\/mnt\/public\/site1\/index.php","HTTP_HOST":"127.0.0.1:8080","SCRIPT_NAME":"\/index.php","PHP_SELF":"\/index.php","ORIG_SCRIPT_NAME":""}', true),
-                'http://127.0.0.1:8080'
+                'http://127.0.0.1:8080',
             ],
             [
                 json_decode('{"REQUEST_URI":"\/test\/index.php","SCRIPT_FILENAME":"\/mnt\/public\/site1\/test\/index.php","HTTP_HOST":"127.0.0.1:8080","SCRIPT_NAME":"\/test\/index.php","PHP_SELF":"\/test\/index.php","ORIG_SCRIPT_NAME":""}', true),
-                'http://127.0.0.1:8080/test'
+                'http://127.0.0.1:8080/test',
             ],
         ];
     }
diff --git a/tests/unit/CaseConverterTest.php b/tests/unit/CaseConverterTest.php
index b282c25..ecd3c2c 100644
--- a/tests/unit/CaseConverterTest.php
+++ b/tests/unit/CaseConverterTest.php
@@ -1,93 +1,87 @@
 <?php
 
+declare(strict_types=1);
+
 namespace SelamiTest;
 
 use Codeception\Test\Unit;
 use Selami\Stdlib\CaseConverter;
+use UnitTester;
 
 class CaseConverterTest extends Unit
 {
-    /**
-     * @var \UnitTester
-     */
-    protected $tester;
+    protected UnitTester $tester;
 
-    protected function _before()
+    protected function _before(): void
     {
     }
 
-    protected function _after()
+    protected function _after(): void
     {
     }
 
-
     /**
      * @test
      * @dataProvider pascalCaseDataProvider
-     *
      * @var string $source
      * @var string $expected
      */
-    public function shouldConvertStringToPascalCaseSuccessfully(string $source, string $expected) : void
+    public function shouldConvertStringToPascalCaseSuccessfully(string $source, string $expected): void
     {
         $result = CaseConverter::toPascalCase($source);
         $this->assertEquals($expected, $result);
     }
 
-    public function pascalCaseDataProvider() : array
+    public function pascalCaseDataProvider(): array
     {
         return [
             ['Kedibey ve Mirmir', 'KedibeyVeMirmir'],
             ['KEDIBEY VE MIRMIR', 'KedibeyVeMirmir'],
             ['kedibey ve mirmir', 'KedibeyVeMirmir'],
-            ['kedibey_ve_mirmir', 'KedibeyVeMirmir']
+            ['kedibey_ve_mirmir', 'KedibeyVeMirmir'],
         ];
     }
 
-
     /**
      * @test
      * @dataProvider camelCaseDataProvider
-     *
      * @var string $source
      * @var string $expected
      */
-    public function shouldConvertStringToCamelCaseSuccessfully(string $source, string $expected) : void
+    public function shouldConvertStringToCamelCaseSuccessfully(string $source, string $expected): void
     {
         $result = CaseConverter::toCamelCase($source);
         $this->assertEquals($expected, $result);
     }
 
-    public function camelCaseDataProvider() : array
+    public function camelCaseDataProvider(): array
     {
         return [
             ['Kedibey ve Mirmir', 'kedibeyVeMirmir'],
             ['KEDIBEY VE MIRMIR', 'kedibeyVeMirmir'],
             ['kedibey ve mirmir', 'kedibeyVeMirmir'],
-            ['kedibey_ve_mirmir', 'kedibeyVeMirmir']
+            ['kedibey_ve_mirmir', 'kedibeyVeMirmir'],
         ];
     }
 
-
     /**
      * @test
      * @dataProvider snakeCaseDataProvider
-     *
      * @var string $source
      * @var string $expected
      */
-    public function shouldConvertStringToSnakeCaseSuccessfully(string $source, string $expected) : void
+    public function shouldConvertStringToSnakeCaseSuccessfully(string $source, string $expected): void
     {
         $result = CaseConverter::toSnakeCase($source);
         $this->assertEquals($expected, $result);
     }
 
-    public function snakeCaseDataProvider() : array
+    public function snakeCaseDataProvider(): array
     {
         return [
             ['Kedibey ve Mirmir', 'kedibey_ve_mirmir'],
             ['kedibey ve mirmir', 'kedibey_ve_mirmir'],
-            ['KedibeyVeMirmir', 'kedibey_ve_mirmir']
+            ['KedibeyVeMirmir', 'kedibey_ve_mirmir'],
         ];
     }
 }
diff --git a/tests/unit/EqualsBuilderTest.php b/tests/unit/EqualsBuilderTest.php
index fa9b07e..89f53c3 100644
--- a/tests/unit/EqualsBuilderTest.php
+++ b/tests/unit/EqualsBuilderTest.php
@@ -1,31 +1,30 @@
 <?php
 
+declare(strict_types=1);
+
 namespace SelamiTest;
 
 use Codeception\Test\Unit;
 use Selami\Stdlib\EqualsBuilder;
+use stdClass;
+use UnitTester;
 
 class EqualsBuilderTest extends Unit
 {
-    /**
-     * @var \UnitTester
-     */
-    protected $tester;
+    protected UnitTester $tester;
 
-    protected function _before()
+    protected function _before(): void
     {
     }
 
-    protected function _after()
+    protected function _after(): void
     {
     }
 
-
     /**
      * @test
-     *
      */
-    public function shouldReturnTrueForEqualValues() : void
+    public function shouldReturnTrueForEqualValues(): void
     {
         $result = EqualsBuilder::create()
             ->append(1, 1)
@@ -34,15 +33,16 @@ public function shouldReturnTrueForEqualValues() : void
             ->isEquals();
         $this->assertTrue($result);
     }
+
     /**
-     * @test
-     * @dataProvider returnFalseDataProvider
      * @param array $firstValues
      * @param array $secondValues
      * @param array $thirdValues
      *
+     * @test
+     * @dataProvider returnFalseDataProvider
      */
-    public function shouldReturnFalseForEqualValues(array $firstValues, array $secondValues, array $thirdValues) : void
+    public function shouldReturnFalseForEqualValues(array $firstValues, array $secondValues, array $thirdValues): void
     {
         $result = EqualsBuilder::create()
             ->append($firstValues[0], $firstValues[1])
@@ -58,7 +58,7 @@ public function returnFalseDataProvider()
             [[1, 2], ['str', 'str'], [0.1, 0,1]],
             [[2, 2], ['str', 'string'], [0.1, 0,1]],
             [[2, 2], ['str', 'str'], [ new TestValueObject(2, 'Kedibey'), new TestValueObject(2, 'Mırmır')]],
-            [[2, 2], ['str', 'str'], [ new TestValueObject(2, 'Kedibey'), new \stdClass()]],
+            [[2, 2], ['str', 'str'], [ new TestValueObject(2, 'Kedibey'), new stdClass()]],
         ];
     }
 }
diff --git a/tests/unit/ResolverTest.php b/tests/unit/ResolverTest.php
index 4139ba5..d30e06b 100644
--- a/tests/unit/ResolverTest.php
+++ b/tests/unit/ResolverTest.php
@@ -1,24 +1,25 @@
 <?php
 
+declare(strict_types=1);
+
 namespace SelamiTest;
 
-use Selami;
-use Selami\Resources\TypeHintedClass;
 use Codeception\Test\Test;
 use Codeception\Test\Unit;
+use Selami;
+use Selami\Resources\TypeHintedClass;
+use Selami\Stdlib\Exception\ClassOrMethodCouldNotBeFound;
+use UnitTester;
 
 class ResolverTest extends Unit
 {
-    /**
-     * @var \UnitTester
-     */
-    protected $tester;
+    protected UnitTester $tester;
 
-    protected function _before()
+    protected function _before(): void
     {
     }
 
-    protected function _after()
+    protected function _after(): void
     {
     }
 
@@ -29,47 +30,46 @@ protected function _after()
      * @var array $expected
      * @dataProvider typeHintDataProvider
      */
-    public function getTypeHintClassesSuccessfully(string $className, string $methodName, array $expected) : void
+    public function getTypeHintClassesSuccessfully(string $className, string $methodName, array $expected): void
     {
         $returned = Selami\Stdlib\Resolver::getParameterHints($className, $methodName);
 
         $this->assertEquals($expected, $returned);
     }
 
-    public function typeHintDataProvider() : array
+    public function typeHintDataProvider(): array
     {
         return [
             [TypeHintedClass::class, '__construct', ['test' => Test::class, 'unit' => Unit::class]],
-            [TypeHintedClass::class, 'method', ['config'=>'array', 'unit' => Unit::class]]
+            [TypeHintedClass::class, 'method', ['config' => 'array', 'unit' => Unit::class]],
         ];
     }
 
     /**
      * @test
      */
-    public function getTypeHintClassesShouldThrowExceptionForNonExistingClass() : void
+    public function getTypeHintClassesShouldThrowExceptionForNonExistingClass(): void
     {
-        $this->expectException(\InvalidArgumentException::class);
-
+        $this->expectException(ClassOrMethodCouldNotBeFound::class);
         Selami\Stdlib\Resolver::getParameterHints('NonExistingClass', '__construct');
     }
 
     /**
      * @test
      */
-    public function getTypeHintClassesShouldThrowExceptionForNonExistingMethod() : void
+    public function getTypeHintClassesShouldThrowExceptionForNonExistingMethod(): void
     {
-        $this->expectException(\InvalidArgumentException::class);
+        $this->expectException(ClassOrMethodCouldNotBeFound::class);
 
         Selami\Stdlib\Resolver::getParameterHints(TypeHintedClass::class, 'nonExistingMethod');
     }
+
     /**
      * @test
      */
-    public function getTypeHintClassesShouldThrowExceptionForNonExistingClassHint() : void
+    public function getTypeHintClassesShouldThrowExceptionForNonExistingClassHint(): void
     {
-        $this->expectException(\InvalidArgumentException::class);
-
-        Selami\Stdlib\Resolver::getParameterHints(TypeHintedClass::class, 'method2');
+        $this->expectException(ClassOrMethodCouldNotBeFound::class);
+        $result = Selami\Stdlib\Resolver::getParameterHints(TypeHintedClass::class, 'method2');
     }
 }
diff --git a/tests/unit/SemverTest.php b/tests/unit/SemverTest.php
index 81461b5..8afb74c 100644
--- a/tests/unit/SemverTest.php
+++ b/tests/unit/SemverTest.php
@@ -1,71 +1,73 @@
 <?php
+
+declare(strict_types=1);
+
 namespace SelamiTest;
 
+use Codeception\Test\Unit;
 use Selami\Stdlib\Exception\InvalidSemverPatternException;
 use Selami\Stdlib\Semver;
+use UnitTester;
 
-class SemverTest extends \Codeception\Test\Unit
+class SemverTest extends Unit
 {
-    /**
-     * @var \UnitTester
-     */
-    protected $tester;
-    
-    protected function _before()
+    protected UnitTester $tester;
+
+    protected function _before(): void
     {
     }
 
-    protected function _after()
+    protected function _after(): void
     {
     }
 
     /**
      * @test
      */
-    public function shouldReturnCurrentVersionSuccessfully() : void
+    public function shouldReturnCurrentVersionSuccessfully(): void
     {
         $version = '2.0.6';
-        $semver = Semver::createFromString($version);
+        $semver  = Semver::createFromString($version);
         $this->assertEquals($version, $semver->getCurrent());
     }
 
     /**
      * @test
      */
-    public function shouldReturnNextPatchVersionSuccessfully() : void
+    public function shouldReturnNextPatchVersionSuccessfully(): void
     {
         $version = '2.0.6';
-        $semver = Semver::createFromString($version);
+        $semver  = Semver::createFromString($version);
         $this->assertEquals('2.0.7', $semver->getNextPatchRelease());
     }
 
     /**
      * @test
      */
-    public function shouldReturnNextMinorVersionSuccessfully() : void
+    public function shouldReturnNextMinorVersionSuccessfully(): void
     {
         $version = '2.0.6';
-        $semver = Semver::createFromString($version);
+        $semver  = Semver::createFromString($version);
         $this->assertEquals('2.1.0', $semver->getNextMinorRelease());
     }
 
     /**
      * @test
      */
-    public function shouldReturnNextMajorVersionSuccessfully() : void
+    public function shouldReturnNextMajorVersionSuccessfully(): void
     {
         $version = '2.0.6';
-        $semver = Semver::createFromString($version);
+        $semver  = Semver::createFromString($version);
         $this->assertEquals('3.0.0', $semver->getNextMajorRelease());
     }
 
     /**
      * @test
      */
-    public function shouldReturnNextVersionsWithPreReleaseSuccessfully() : void
+    public function shouldReturnNextVersionsWithPreReleaseSuccessfully(): void
     {
         $version = '2.0.6-alpha.1';
-        $semver = Semver::createFromString($version);
+        $semver  = Semver::createFromString($version);
         $this->assertEquals('2.0.6-alpha.1', $semver->getCurrent());
         $this->assertEquals('2.0.6', $semver->getNextMajorRelease());
         $this->assertEquals('2.0.6', $semver->getNextMinorRelease());
@@ -75,11 +77,11 @@ public function shouldReturnNextVersionsWithPreReleaseSuccessfully() : void
     /**
      * @test
      */
-    public function shouldFailForInvalidVersion() : void
+    public function shouldFailForInvalidVersion(): void
     {
         $this->expectException(InvalidSemverPatternException::class);
         $version = '2.0.a';
-        $semver = Semver::createFromString($version);
+        $semver  = Semver::createFromString($version);
         $this->assertEquals('3.0.6', $semver->getNextMajorRelease());
     }
 }