jaxon-php / jaxon-mono

jaxon-annotations/src/Annotation/UploadAnnotation.php

Switch Indentation +24 added lines, -24 removed lines

@@ -28,42 +28,42 @@
  */
 class UploadAnnotation extends AbstractAnnotation
 {
-    /**
+/**
      * The name of the upload field
      *
      * @var string
      */
-    protected $sField = '';
+protected $sField = '';
 
-    /**
+/**
      * @inheritDoc
      */
-    public static function parseAnnotation($value)
-    {
-        $aParams = preg_split('/[\s]+/', $value, 2);
-        return count($aParams) === 1 ? ['field' => $aParams[0]] :
-            ['field' => $aParams[0], 'extra' => $aParams[1]];
-    }
+public static function parseAnnotation($value)
+{
+$aParams = preg_split('/[\s]+/', $value, 2);
+return count($aParams) === 1 ? ['field' => $aParams[0]] :
+['field' => $aParams[0], 'extra' => $aParams[1]];
+}
 
-    /**
+/**
      * @inheritDoc
      * @throws AnnotationException
      */
-    public function initAnnotation(array $properties)
-    {
-        if(count($properties) != 1 || !isset($properties['field']) ||
-            !is_string($properties['field']))
-        {
-            throw new AnnotationException('The @upload annotation requires a property "field" of type string');
-        }
-        $this->sField = $properties['field'];
-    }
+public function initAnnotation(array $properties)
+{
+if(count($properties) != 1 || !isset($properties['field']) ||
+!is_string($properties['field']))
+{
+throw new AnnotationException('The @upload annotation requires a property "field" of type string');
+}
+$this->sField = $properties['field'];
+}
 
-    /**
+/**
      * @inheritDoc
      */
-    public function saveValue(Metadata $xMetadata, string $sMethod = '*'): void
-    {
-        $xMetadata->upload($sMethod)->setValue($this->sField);
-    }
+public function saveValue(Metadata $xMetadata, string $sMethod = '*'): void
+{
+$xMetadata->upload($sMethod)->setValue($this->sField);
+}
 }

Spacing +2 added lines, -3 removed lines

@@ -41,8 +41,7 @@ 
     public static function parseAnnotation($value)
     {
         $aParams = preg_split('/[\s]+/', $value, 2);
-        return count($aParams) === 1 ? ['field' => $aParams[0]] :
-            ['field' => $aParams[0], 'extra' => $aParams[1]];
+        return count($aParams) === 1 ? ['field' => $aParams[0]] : ['field' => $aParams[0], 'extra' => $aParams[1]];
     }
 
     /**
@@ -51,7 +50,7 @@ 
      */
     public function initAnnotation(array $properties)
     {
-        if(count($properties) != 1 || !isset($properties['field']) ||
+        if (count($properties) != 1 || !isset($properties['field']) ||
             !is_string($properties['field']))
         {
             throw new AnnotationException('The @upload annotation requires a property "field" of type string');

jaxon-annotations/src/Annotation/HookAnnotation.php

Switch Indentation +45 added lines, -45 removed lines

@@ -27,64 +27,64 @@
 
 abstract class HookAnnotation extends AbstractAnnotation
 {
-    /**
+/**
      * @var string
      */
-    protected $sMethod = '';
+protected $sMethod = '';
 
-    /**
+/**
      * @var array
      */
-    protected $aParams = [];
+protected $aParams = [];
 
-    /**
+/**
      *
      */
-    abstract protected static function getType(): string;
+abstract protected static function getType(): string;
 
-    /**
+/**
      * @inheritDoc
      */
-    public static function parseAnnotation($value)
-    {
-        $aParams = preg_split('/[\s]+/', $value, 2);
-        if(count($aParams) === 1)
-        {
-            return ['call' => rtrim($aParams[0])];
-        }
-        // The second parameter must be an array of callback parameter in json format.
-        return ['call' => rtrim($aParams[0]), 'with' => json_decode($aParams[1], false)];
-    }
+public static function parseAnnotation($value)
+{
+$aParams = preg_split('/[\s]+/', $value, 2);
+if(count($aParams) === 1)
+{
+return ['call' => rtrim($aParams[0])];
+}
+// The second parameter must be an array of callback parameter in json format.
+return ['call' => rtrim($aParams[0]), 'with' => json_decode($aParams[1], false)];
+}
 
-    /**
+/**
      * @inheritDoc
      * @throws AnnotationException
      */
-    public function initAnnotation(array $properties)
-    {
-        if(!isset($properties['call']) || !is_string($properties['call']))
-        {
-            throw new AnnotationException('The @' . $this->getType() .
-                ' annotation requires a property "call" of type string');
-        }
-        foreach(array_keys($properties) as $propName)
-        {
-            if($propName !== 'call' && $propName !== 'with')
-            {
-                throw new AnnotationException('Unknown property "' . $propName .
-                    '" in the @' . $this->getType() . ' annotation');
-            }
-        }
-        // Cannot use isset here, because it will return false in case $properties['with'] === null
-        if(array_key_exists('with', $properties))
-        {
-            if(!is_array($properties['with']))
-            {
-                throw new AnnotationException('The "with" property of the @' .
-                    $this->getType() . ' annotation must be of type array');
-            }
-            $this->aParams = $properties['with'];
-        }
-        $this->sMethod = $properties['call'];
-    }
+public function initAnnotation(array $properties)
+{
+if(!isset($properties['call']) || !is_string($properties['call']))
+{
+throw new AnnotationException('The @' . $this->getType() .
+    ' annotation requires a property "call" of type string');
+}
+foreach(array_keys($properties) as $propName)
+{
+if($propName !== 'call' && $propName !== 'with')
+{
+    throw new AnnotationException('Unknown property "' . $propName .
+        '" in the @' . $this->getType() . ' annotation');
+}
+}
+// Cannot use isset here, because it will return false in case $properties['with'] === null
+if(array_key_exists('with', $properties))
+{
+if(!is_array($properties['with']))
+{
+    throw new AnnotationException('The "with" property of the @' .
+        $this->getType() . ' annotation must be of type array');
+}
+$this->aParams = $properties['with'];
+}
+$this->sMethod = $properties['call'];
+}
 }

Spacing +6 added lines, -6 removed lines

@@ -48,7 +48,7 @@ 
     public static function parseAnnotation($value)
     {
         $aParams = preg_split('/[\s]+/', $value, 2);
-        if(count($aParams) === 1)
+        if (count($aParams) === 1)
         {
             return ['call' => rtrim($aParams[0])];
         }
@@ -62,23 +62,23 @@ 
      */
     public function initAnnotation(array $properties)
     {
-        if(!isset($properties['call']) || !is_string($properties['call']))
+        if (!isset($properties['call']) || !is_string($properties['call']))
         {
             throw new AnnotationException('The @' . $this->getType() .
                 ' annotation requires a property "call" of type string');
         }
-        foreach(array_keys($properties) as $propName)
+        foreach (array_keys($properties) as $propName)
         {
-            if($propName !== 'call' && $propName !== 'with')
+            if ($propName !== 'call' && $propName !== 'with')
             {
                 throw new AnnotationException('Unknown property "' . $propName .
                     '" in the @' . $this->getType() . ' annotation');
             }
         }
         // Cannot use isset here, because it will return false in case $properties['with'] === null
-        if(array_key_exists('with', $properties))
+        if (array_key_exists('with', $properties))
         {
-            if(!is_array($properties['with']))
+            if (!is_array($properties['with']))
             {
                 throw new AnnotationException('The "with" property of the @' .
                     $this->getType() . ' annotation must be of type array');

jaxon-annotations/src/AnnotationReader.php

Spacing +13 added lines, -13 removed lines

@@ -114,21 +114,21 @@ 
             fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
         );
         // First check if the class is excluded.
-        foreach($aAnnotations as $xAnnotation)
+        foreach ($aAnnotations as $xAnnotation)
         {
-            if(is_a($xAnnotation, ExcludeAnnotation::class))
+            if (is_a($xAnnotation, ExcludeAnnotation::class))
             {
                 $xAnnotation->saveValue($this->xMetadata);
             }
         }
-        if($this->xMetadata->isExcluded())
+        if ($this->xMetadata->isExcluded())
         {
             return;
         }
 
-        foreach($aAnnotations as $xAnnotation)
+        foreach ($aAnnotations as $xAnnotation)
         {
-            if(!is_a($xAnnotation, ExcludeAnnotation::class))
+            if (!is_a($xAnnotation, ExcludeAnnotation::class))
             {
                 $xAnnotation->saveValue($this->xMetadata);
             }
@@ -150,7 +150,7 @@ 
             $this->xManager->getPropertyAnnotations($sClass, $sProperty),
             function($xAnnotation) use($sProperty) {
                 // Save the property type
-                if(is_a($xAnnotation, VarAnnotation::class))
+                if (is_a($xAnnotation, VarAnnotation::class))
                 {
                     $this->aPropTypes[$sProperty] = $xAnnotation->type;
                 }
@@ -158,12 +158,12 @@ 
                 return is_a($xAnnotation, ContainerAnnotation::class);
             }
         );
-        if(count($aAnnotations) > 1)
+        if (count($aAnnotations) > 1)
         {
             throw new AnnotationException('Only one @di annotation is allowed on a property');
         }
 
-        foreach($aAnnotations as $xAnnotation)
+        foreach ($aAnnotations as $xAnnotation)
         {
             $xAnnotation->setAttr($sProperty);
             $xAnnotation->saveValue($this->xMetadata);
@@ -185,7 +185,7 @@ 
             $this->xManager->getMethodAnnotations($sClass, $sMethod),
             fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
         );
-        foreach($aAnnotations as $xAnnotation)
+        foreach ($aAnnotations as $xAnnotation)
         {
             $xAnnotation->saveValue($this->xMetadata, $sMethod);
         }
@@ -208,7 +208,7 @@ 
             $this->sCurrMemberType = AnnotationManager::MEMBER_CLASS;
 
             $this->getClassAttrs($sClass);
-            if($this->xMetadata->isExcluded())
+            if ($this->xMetadata->isExcluded())
             {
                 // The entire class is not to be exported.
                 return $this->xMetadata;
@@ -218,7 +218,7 @@ 
             $this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
 
             // Properties annotations
-            foreach($xInput->getProperties() as $sProperty)
+            foreach ($xInput->getProperties() as $sProperty)
             {
                 $this->getPropertyAttrs($sClass, $sProperty);
             }
@@ -226,14 +226,14 @@ 
             // Processing methods annotations
             $this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
 
-            foreach($xInput->getMethods() as $sMethod)
+            foreach ($xInput->getMethods() as $sMethod)
             {
                 $this->getMethodAttrs($sClass, $sMethod);
             }
 
             return $this->xMetadata;
         }
-        catch(AnnotationException $e)
+        catch (AnnotationException $e)
         {
             throw new SetupException($e->getMessage());
         }

Braces +1 added lines, -2 removed lines

@@ -232,8 +232,7 @@
             }
 
             return $this->xMetadata;
-        }
-        catch(AnnotationException $e)
+        } catch(AnnotationException $e)
         {
             throw new SetupException($e->getMessage());
         }

Switch Indentation +150 added lines, -150 removed lines

@@ -36,206 +36,206 @@
 
 class AnnotationReader implements MetadataReaderInterface
 {
-    /**
+/**
      * @var AnnotationManager
      */
-    protected $xManager;
+protected $xManager;
 
-    /**
+/**
      * @var Metadata
      */
-    protected $xMetadata;
+protected $xMetadata;
 
-    /**
+/**
      * Properties types, read from the "var" annotations.
      *
      * @var array
      */
-    protected $aPropTypes;
+protected $aPropTypes;
 
-    /**
+/**
      * The type of the class member being currently processed.
      *
      * @var string
      */
-    protected $sCurrMemberType;
+protected $sCurrMemberType;
 
-    /**
+/**
      * The constructor
      *
      * @param AnnotationManager $xManager
      */
-    public function __construct(AnnotationManager $xManager)
-    {
-        $this->xManager = $xManager;
-        $this->xManager->registry['upload'] = UploadAnnotation::class;
-        $this->xManager->registry['databag'] = DatabagAnnotation::class;
-        $this->xManager->registry['exclude'] = ExcludeAnnotation::class;
-        $this->xManager->registry['before'] = BeforeAnnotation::class;
-        $this->xManager->registry['after'] = AfterAnnotation::class;
-        $this->xManager->registry['di'] = ContainerAnnotation::class;
-        $this->xManager->registry['callback'] = CallbackAnnotation::class;
-        // Missing standard annotations.
-        // We need to define this, otherwise they throw an exception, and make the whole processing fail.
-        $this->xManager->registry['const'] = false;
-        $this->xManager->registry['inheritDoc'] = false;
-        $this->xManager->registry['template'] = false;
-        $this->xManager->registry['param-closure-this'] = false;
-    }
+public function __construct(AnnotationManager $xManager)
+{
+$this->xManager = $xManager;
+$this->xManager->registry['upload'] = UploadAnnotation::class;
+$this->xManager->registry['databag'] = DatabagAnnotation::class;
+$this->xManager->registry['exclude'] = ExcludeAnnotation::class;
+$this->xManager->registry['before'] = BeforeAnnotation::class;
+$this->xManager->registry['after'] = AfterAnnotation::class;
+$this->xManager->registry['di'] = ContainerAnnotation::class;
+$this->xManager->registry['callback'] = CallbackAnnotation::class;
+// Missing standard annotations.
+// We need to define this, otherwise they throw an exception, and make the whole processing fail.
+$this->xManager->registry['const'] = false;
+$this->xManager->registry['inheritDoc'] = false;
+$this->xManager->registry['template'] = false;
+$this->xManager->registry['param-closure-this'] = false;
+}
 
-    /**
+/**
      * @return array
      */
-    public function getPropTypes(): array
-    {
-        return $this->aPropTypes;
-    }
+public function getPropTypes(): array
+{
+return $this->aPropTypes;
+}
 
-    /**
+/**
      * @return bool
      */
-    public function annotationIsOnProperty(): bool
-    {
-        return $this->sCurrMemberType === AnnotationManager::MEMBER_PROPERTY;
-    }
+public function annotationIsOnProperty(): bool
+{
+return $this->sCurrMemberType === AnnotationManager::MEMBER_PROPERTY;
+}
 
-    /**
+/**
      * @param string $sClass
      *
      * @return void
      * @throws AnnotationException
      */
-    private function getClassAttrs(string $sClass): void
-    {
-        // Only keep the annotations declared in this package.
-        /** @var array<AbstractAnnotation> */
-        $aAnnotations = array_filter(
-            $this->xManager->getClassAnnotations($sClass),
-            fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
-        );
-        // First check if the class is excluded.
-        foreach($aAnnotations as $xAnnotation)
-        {
-            if(is_a($xAnnotation, ExcludeAnnotation::class))
-            {
-                $xAnnotation->saveValue($this->xMetadata);
-            }
-        }
-        if($this->xMetadata->isExcluded())
-        {
-            return;
-        }
-
-        foreach($aAnnotations as $xAnnotation)
-        {
-            if(!is_a($xAnnotation, ExcludeAnnotation::class))
-            {
-                $xAnnotation->saveValue($this->xMetadata);
-            }
-        }
-    }
+private function getClassAttrs(string $sClass): void
+{
+// Only keep the annotations declared in this package.
+/** @var array<AbstractAnnotation> */
+$aAnnotations = array_filter(
+$this->xManager->getClassAnnotations($sClass),
+fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
+);
+// First check if the class is excluded.
+foreach($aAnnotations as $xAnnotation)
+{
+if(is_a($xAnnotation, ExcludeAnnotation::class))
+{
+    $xAnnotation->saveValue($this->xMetadata);
+}
+}
+if($this->xMetadata->isExcluded())
+{
+return;
+}
 
-    /**
+foreach($aAnnotations as $xAnnotation)
+{
+if(!is_a($xAnnotation, ExcludeAnnotation::class))
+{
+    $xAnnotation->saveValue($this->xMetadata);
+}
+}
+}
+
+/**
      * @param string $sClass
      * @param string $sProperty
      *
      * @return void
      * @throws AnnotationException
      */
-    private function getPropertyAttrs(string $sClass, string $sProperty): void
+private function getPropertyAttrs(string $sClass, string $sProperty): void
+{
+/** @var array<ContainerAnnotation> */
+// Only keep the annotations declared in this package.
+$aAnnotations = array_filter(
+$this->xManager->getPropertyAnnotations($sClass, $sProperty),
+function($xAnnotation) use($sProperty) {
+    // Save the property type
+    if(is_a($xAnnotation, VarAnnotation::class))
     {
-        /** @var array<ContainerAnnotation> */
-        // Only keep the annotations declared in this package.
-        $aAnnotations = array_filter(
-            $this->xManager->getPropertyAnnotations($sClass, $sProperty),
-            function($xAnnotation) use($sProperty) {
-                // Save the property type
-                if(is_a($xAnnotation, VarAnnotation::class))
-                {
-                    $this->aPropTypes[$sProperty] = $xAnnotation->type;
-                }
-                // Only container annotations are allowed on properties
-                return is_a($xAnnotation, ContainerAnnotation::class);
-            }
-        );
-        if(count($aAnnotations) > 1)
-        {
-            throw new AnnotationException('Only one @di annotation is allowed on a property');
-        }
-
-        foreach($aAnnotations as $xAnnotation)
-        {
-            $xAnnotation->setAttr($sProperty);
-            $xAnnotation->saveValue($this->xMetadata);
-        }
+        $this->aPropTypes[$sProperty] = $xAnnotation->type;
     }
+    // Only container annotations are allowed on properties
+    return is_a($xAnnotation, ContainerAnnotation::class);
+}
+);
+if(count($aAnnotations) > 1)
+{
+throw new AnnotationException('Only one @di annotation is allowed on a property');
+}
 
-    /**
+foreach($aAnnotations as $xAnnotation)
+{
+$xAnnotation->setAttr($sProperty);
+$xAnnotation->saveValue($this->xMetadata);
+}
+}
+
+/**
      * @param string $sClass
      * @param string $sMethod
      *
      * @return void
      * @throws AnnotationException
      */
-    private function getMethodAttrs(string $sClass, string $sMethod): void
-    {
-        // Only keep the annotations declared in this package.
-        /** @var array<AbstractAnnotation> */
-        $aAnnotations = array_filter(
-            $this->xManager->getMethodAnnotations($sClass, $sMethod),
-            fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
-        );
-        foreach($aAnnotations as $xAnnotation)
-        {
-            $xAnnotation->saveValue($this->xMetadata, $sMethod);
-        }
-    }
+private function getMethodAttrs(string $sClass, string $sMethod): void
+{
+// Only keep the annotations declared in this package.
+/** @var array<AbstractAnnotation> */
+$aAnnotations = array_filter(
+$this->xManager->getMethodAnnotations($sClass, $sMethod),
+fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
+);
+foreach($aAnnotations as $xAnnotation)
+{
+$xAnnotation->saveValue($this->xMetadata, $sMethod);
+}
+}
 
-    /**
+/**
      * @inheritDoc
      * @throws SetupException
      */
-    public function getAttributes(InputData $xInput): Metadata
-    {
-        ContainerAnnotation::$xReader = $this;
-        $this->aPropTypes = [];
-        $this->xMetadata = new Metadata();
-        $sClass = $xInput->getReflectionClass()->getName();
-
-        try
-        {
-            // Processing class annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_CLASS;
-
-            $this->getClassAttrs($sClass);
-            if($this->xMetadata->isExcluded())
-            {
-                // The entire class is not to be exported.
-                return $this->xMetadata;
-            }
-
-            // Processing properties annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
-
-            // Properties annotations
-            foreach($xInput->getProperties() as $sProperty)
-            {
-                $this->getPropertyAttrs($sClass, $sProperty);
-            }
-
-            // Processing methods annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
-
-            foreach($xInput->getMethods() as $sMethod)
-            {
-                $this->getMethodAttrs($sClass, $sMethod);
-            }
-
-            return $this->xMetadata;
-        }
-        catch(AnnotationException $e)
-        {
-            throw new SetupException($e->getMessage());
-        }
-    }
+public function getAttributes(InputData $xInput): Metadata
+{
+ContainerAnnotation::$xReader = $this;
+$this->aPropTypes = [];
+$this->xMetadata = new Metadata();
+$sClass = $xInput->getReflectionClass()->getName();
+
+try
+{
+// Processing class annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_CLASS;
+
+$this->getClassAttrs($sClass);
+if($this->xMetadata->isExcluded())
+{
+    // The entire class is not to be exported.
+    return $this->xMetadata;
+}
+
+// Processing properties annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
+
+// Properties annotations
+foreach($xInput->getProperties() as $sProperty)
+{
+    $this->getPropertyAttrs($sClass, $sProperty);
+}
+
+// Processing methods annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
+
+foreach($xInput->getMethods() as $sMethod)
+{
+    $this->getMethodAttrs($sClass, $sMethod);
+}
+
+return $this->xMetadata;
+}
+catch(AnnotationException $e)
+{
+throw new SetupException($e->getMessage());
+}
+}
 }

jaxon-upload/tests/TestUpload/UploadHandlerTest.php

Switch Indentation +550 added lines, -550 removed lines

@@ -21,604 +21,604 @@
 
 class UploadHandlerTest extends TestCase
 {
-    /**
+/**
      * @var string
      */
-    protected $sNameWhite;
+protected $sNameWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathWhite;
+protected $sPathWhite;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeWhite;
+protected $sSizeWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sNameBlue;
+protected $sNameBlue;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathBlue;
+protected $sPathBlue;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeBlue;
+protected $sSizeBlue;
 
-    /**
+/**
      * @throws SetupException
      */
-    public function setUp(): void
-    {
-        jaxon()->di()->getPluginManager()->registerPlugins();
-        _register();
-        jaxon()->setOption('core.upload.enabled', true);
-        jaxon()->setOption('core.response.send', false);
-
-        $tmpDir = __DIR__ . '/../upload/tmp';
-        @mkdir($tmpDir);
-
-        $sSrcWhite = __DIR__ . '/../upload/src/white.png';
-        $this->sNameWhite = 'white.png';
-        $this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
-        $this->sSizeWhite = filesize($sSrcWhite);
-        // Copy the file to the temp dir.
-        @copy($sSrcWhite, $this->sPathWhite);
-
-        $sSrcBlue = __DIR__ . '/../upload/src/blue.png';
-        $this->sNameBlue = 'blue.png';
-        $this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
-        $this->sSizeBlue = filesize($sSrcBlue);
-        // Copy the file to the temp dir.
-        @copy($sSrcBlue, $this->sPathBlue);
-
-        jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
-    }
-
-    /**
+public function setUp(): void
+{
+jaxon()->di()->getPluginManager()->registerPlugins();
+_register();
+jaxon()->setOption('core.upload.enabled', true);
+jaxon()->setOption('core.response.send', false);
+
+$tmpDir = __DIR__ . '/../upload/tmp';
+@mkdir($tmpDir);
+
+$sSrcWhite = __DIR__ . '/../upload/src/white.png';
+$this->sNameWhite = 'white.png';
+$this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
+$this->sSizeWhite = filesize($sSrcWhite);
+// Copy the file to the temp dir.
+@copy($sSrcWhite, $this->sPathWhite);
+
+$sSrcBlue = __DIR__ . '/../upload/src/blue.png';
+$this->sNameBlue = 'blue.png';
+$this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
+$this->sSizeBlue = filesize($sSrcBlue);
+// Copy the file to the temp dir.
+@copy($sSrcBlue, $this->sPathBlue);
+
+jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
+}
+
+/**
      * @throws SetupException
      */
-    public function tearDown(): void
-    {
-        jaxon()->reset();
-        parent::tearDown();
-    }
+public function tearDown(): void
+{
+jaxon()->reset();
+parent::tearDown();
+}
 
-    /**
+/**
      * @throws RequestException
      */
-    public function testAjaxUpload()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUpload()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadMultipleFiles()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => [
-                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
-                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
-                    ],
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(2, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $xFile = $aFiles['image'][1];
-        $this->assertEquals('blue', $xFile->name());
-        $this->assertEquals($this->sNameBlue, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUploadMultipleFiles()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => [
+            new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+                UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+            new UploadedFile($this->sPathBlue, $this->sSizeBlue,
+                UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
+        ],
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(2, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$xFile = $aFiles['image'][1];
+$this->assertEquals('blue', $xFile->name());
+$this->assertEquals($this->sNameBlue, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadMultipleNames()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'white' => [
-                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                    ],
-                    'blue' => [
-                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
-                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
-                    ],
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(2, $aFiles);
-        $this->assertCount(1, $aFiles['white']);
-        $this->assertCount(1, $aFiles['blue']);
-        $xFile = $aFiles['white'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $xFile = $aFiles['blue'][0];
-        $this->assertEquals('blue', $xFile->name());
-        $this->assertEquals($this->sNameBlue, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUploadMultipleNames()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'white' => [
+            new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+                UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+        ],
+        'blue' => [
+            new UploadedFile($this->sPathBlue, $this->sSizeBlue,
+                UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
+        ],
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(2, $aFiles);
+$this->assertCount(1, $aFiles['white']);
+$this->assertCount(1, $aFiles['blue']);
+$xFile = $aFiles['white'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$xFile = $aFiles['blue'][0];
+$this->assertEquals('blue', $xFile->name());
+$this->assertEquals($this->sNameBlue, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadNameSanitizer()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->upload()->sanitizer(function($sFilename, $sVarName) {
-            return $sVarName === 'image' ? 'img_' . $sFilename : $sFilename;
-        });
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('img_white', $xFile->name());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testAjaxUploadNameSanitizer()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->upload()->sanitizer(function($sFilename, $sVarName) {
+return $sVarName === 'image' ? 'img_' . $sFilename : $sFilename;
+});
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('img_white', $xFile->name());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileTypeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.types', ['png']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileTypeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.types', ['png']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileTypeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.types', ['jpg']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileTypeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.types', ['jpg']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileExtensionValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.extensions', ['png']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileExtensionValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.extensions', ['png']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileExtensionValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.extensions', ['jpg']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileExtensionValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.extensions', ['jpg']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMaxSizeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.max-size', 30000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileMaxSizeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.max-size', 30000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMaxSizeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.max-size', 25000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileMaxSizeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.max-size', 25000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMinSizeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.min-size', 25000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileMinSizeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.min-size', 25000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMinSizeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.min-size', 30000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileMinSizeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.min-size', 30000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      * @throws SetupException
      */
-    public function testPsrAjaxUpload()
-    {
-        _register();
-        jaxon()->setOption('core.upload.enabled', true);
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        $xRequest = jaxon()->di()->g(ServerRequestCreator::class)
-            ->fromGlobals()
-            ->withParsedBody([
-                'jxncall' => json_encode([
-                    'type' => 'class',
-                    'name' => 'SampleUpload',
-                    'method' => 'myMethod',
-                    'args' => [],
-                ]),
-            ])
-            ->withUploadedFiles([
-                'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                    UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-            ])
-            ->withMethod('POST');
-
-        $xPsrConfigMiddleware = jaxon()->psr()->config(__DIR__ . '/../config/psr.php');
-        $xPsrAjaxMiddleware = jaxon()->psr()->ajax();
-        // PSR request handler that does nothing, useful to call the config middleware.
-        $xEmptyRequestHandler = new class implements RequestHandlerInterface
-        {
-            private $xPsr17Factory;
-
-            public function __construct()
-            {
-                $this->xPsr17Factory = new Psr17Factory();
-            }
-
-            public function handle(ServerRequestInterface $request): ResponseInterface
-            {
-                return $this->xPsr17Factory->createResponse();
-            }
-        };
-        // Call the config middleware
-        $xPsrConfigMiddleware->process($xRequest, $xEmptyRequestHandler);
-        // Call the ajax middleware
-        $xPsrResponse = $xPsrAjaxMiddleware->process($xRequest, $xEmptyRequestHandler);
-
-        // Both responses must have the same content and content type
-        $xJaxonResponse = jaxon()->getResponse();
-        $this->assertEquals($xPsrResponse->getBody()->__toString(), $xJaxonResponse->getOutput());
-        $this->assertEquals($xPsrResponse->getHeader('content-type')[0], $xJaxonResponse->getContentType());
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
+public function testPsrAjaxUpload()
+{
+_register();
+jaxon()->setOption('core.upload.enabled', true);
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+$xRequest = jaxon()->di()->g(ServerRequestCreator::class)
+->fromGlobals()
+->withParsedBody([
+    'jxncall' => json_encode([
+        'type' => 'class',
+        'name' => 'SampleUpload',
+        'method' => 'myMethod',
+        'args' => [],
+    ]),
+])
+->withUploadedFiles([
+    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+])
+->withMethod('POST');
+
+$xPsrConfigMiddleware = jaxon()->psr()->config(__DIR__ . '/../config/psr.php');
+$xPsrAjaxMiddleware = jaxon()->psr()->ajax();
+// PSR request handler that does nothing, useful to call the config middleware.
+$xEmptyRequestHandler = new class implements RequestHandlerInterface
+{
+private $xPsr17Factory;
+
+public function __construct()
+{
+    $this->xPsr17Factory = new Psr17Factory();
+}
+
+public function handle(ServerRequestInterface $request): ResponseInterface
+{
+    return $this->xPsr17Factory->createResponse();
+}
+};
+// Call the config middleware
+$xPsrConfigMiddleware->process($xRequest, $xEmptyRequestHandler);
+// Call the ajax middleware
+$xPsrResponse = $xPsrAjaxMiddleware->process($xRequest, $xEmptyRequestHandler);
+
+// Both responses must have the same content and content type
+$xJaxonResponse = jaxon()->getResponse();
+$this->assertEquals($xPsrResponse->getBody()->__toString(), $xJaxonResponse->getOutput());
+$this->assertEquals($xPsrResponse->getHeader('content-type')[0], $xJaxonResponse->getContentType());
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
 }

jaxon-upload/tests/TestUpload/UploadTest.php

Switch Indentation +507 added lines, -507 removed lines

@@ -16,560 +16,560 @@
 
 class UploadTest extends TestCase
 {
-    /**
+/**
      * @var string
      */
-    protected $sNameWhite;
+protected $sNameWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathWhite;
+protected $sPathWhite;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeWhite;
+protected $sSizeWhite;
 
-    /**
+/**
      * @var string
      */
-    protected $sNameBlue;
+protected $sNameBlue;
 
-    /**
+/**
      * @var string
      */
-    protected $sPathBlue;
+protected $sPathBlue;
 
-    /**
+/**
      * @var int
      */
-    protected $sSizeBlue;
+protected $sSizeBlue;
 
-    /**
+/**
      * @throws SetupException
      */
-    public function setUp(): void
-    {
-        _register();
-        jaxon()->setOption('core.upload.enabled', true);
-
-        jaxon()->setOption('core.response.send', false);
-        $tmpDir = __DIR__ . '/../upload/tmp';
-        @mkdir($tmpDir);
-
-        $sSrcWhite = __DIR__ . '/../upload/src/white.png';
-        $this->sNameWhite = 'white.png';
-        $this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
-        $this->sSizeWhite = filesize($sSrcWhite);
-        // Copy the file to the temp dir.
-        @copy($sSrcWhite, $this->sPathWhite);
-
-        $sSrcBlue = __DIR__ . '/../upload/src/blue.png';
-        $this->sNameBlue = 'blue.png';
-        $this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
-        $this->sSizeBlue = filesize($sSrcBlue);
-        // Copy the file to the temp dir.
-        @copy($sSrcBlue, $this->sPathBlue);
-
-        jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
-    }
-
-    /**
+public function setUp(): void
+{
+_register();
+jaxon()->setOption('core.upload.enabled', true);
+
+jaxon()->setOption('core.response.send', false);
+$tmpDir = __DIR__ . '/../upload/tmp';
+@mkdir($tmpDir);
+
+$sSrcWhite = __DIR__ . '/../upload/src/white.png';
+$this->sNameWhite = 'white.png';
+$this->sPathWhite = "$tmpDir/{$this->sNameWhite}";
+$this->sSizeWhite = filesize($sSrcWhite);
+// Copy the file to the temp dir.
+@copy($sSrcWhite, $this->sPathWhite);
+
+$sSrcBlue = __DIR__ . '/../upload/src/blue.png';
+$this->sNameBlue = 'blue.png';
+$this->sPathBlue = "$tmpDir/{$this->sNameBlue}";
+$this->sSizeBlue = filesize($sSrcBlue);
+// Copy the file to the temp dir.
+@copy($sSrcBlue, $this->sPathBlue);
+
+jaxon()->register(Jaxon::CALLABLE_CLASS, 'SampleUpload', __DIR__ . '/../src/sample.php');
+}
+
+/**
      * @throws SetupException
      */
-    public function tearDown(): void
-    {
-        jaxon()->reset();
-        parent::tearDown();
-    }
+public function tearDown(): void
+{
+jaxon()->reset();
+parent::tearDown();
+}
 
-    /**
+/**
      * @throws RequestException
      */
-    public function testAjaxUpload()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUpload()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadMultipleFiles()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => [
-                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
-                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
-                    ],
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(2, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $xFile = $aFiles['image'][1];
-        $this->assertEquals('blue', $xFile->name());
-        $this->assertEquals($this->sNameBlue, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUploadMultipleFiles()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => [
+            new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+                UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+            new UploadedFile($this->sPathBlue, $this->sSizeBlue,
+                UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
+        ],
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(2, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$xFile = $aFiles['image'][1];
+$this->assertEquals('blue', $xFile->name());
+$this->assertEquals($this->sNameBlue, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadMultipleNames()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'white' => [
-                        new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                    ],
-                    'blue' => [
-                        new UploadedFile($this->sPathBlue, $this->sSizeBlue,
-                            UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
-                    ],
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(2, $aFiles);
-        $this->assertCount(1, $aFiles['white']);
-        $this->assertCount(1, $aFiles['blue']);
-        $xFile = $aFiles['white'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $xFile = $aFiles['blue'][0];
-        $this->assertEquals('blue', $xFile->name());
-        $this->assertEquals($this->sNameBlue, $xFile->filename());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-    }
-
-    /**
+public function testAjaxUploadMultipleNames()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'white' => [
+            new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+                UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+        ],
+        'blue' => [
+            new UploadedFile($this->sPathBlue, $this->sSizeBlue,
+                UPLOAD_ERR_OK, $this->sNameBlue, 'png'),
+        ],
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(2, $aFiles);
+$this->assertCount(1, $aFiles['white']);
+$this->assertCount(1, $aFiles['blue']);
+$xFile = $aFiles['white'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$xFile = $aFiles['blue'][0];
+$this->assertEquals('blue', $xFile->name());
+$this->assertEquals($this->sNameBlue, $xFile->filename());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+}
+
+/**
      * @throws RequestException
      */
-    public function testAjaxUploadNameSanitizer()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->upload()->sanitizer(function($sFilename, $sVarName) {
-            return $sVarName === 'image' ? 'img_' . $sFilename : $sFilename;
-        });
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Uploaded files
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('img_white', $xFile->name());
-        $this->assertEquals('png', $xFile->type());
-        $this->assertEquals('png', $xFile->extension());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testAjaxUploadNameSanitizer()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->upload()->sanitizer(function($sFilename, $sVarName) {
+return $sVarName === 'image' ? 'img_' . $sFilename : $sFilename;
+});
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Uploaded files
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('img_white', $xFile->name());
+$this->assertEquals('png', $xFile->type());
+$this->assertEquals('png', $xFile->extension());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileTypeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.types', ['png']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileTypeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.types', ['png']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileTypeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.types', ['jpg']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileTypeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.types', ['jpg']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileExtensionValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.extensions', ['png']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileExtensionValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.extensions', ['png']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileExtensionValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.extensions', ['jpg']);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileExtensionValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.extensions', ['jpg']);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMaxSizeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.max-size', 30000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileMaxSizeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.max-size', 30000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMaxSizeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.max-size', 25000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileMaxSizeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.max-size', 25000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMinSizeValidationOk()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.min-size', 25000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        jaxon()->processRequest();
-
-        // Return the file name for the next test
-        $aFiles = jaxon()->upload()->files();
-        $this->assertCount(1, $aFiles);
-        $this->assertCount(1, $aFiles['image']);
-        $xFile = $aFiles['image'][0];
-        $this->assertEquals('white', $xFile->name());
-        $this->assertEquals($this->sNameWhite, $xFile->filename());
-    }
-
-    /**
+public function testUploadFileMinSizeValidationOk()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.min-size', 25000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+jaxon()->processRequest();
+
+// Return the file name for the next test
+$aFiles = jaxon()->upload()->files();
+$this->assertCount(1, $aFiles);
+$this->assertCount(1, $aFiles['image']);
+$xFile = $aFiles['image'][0];
+$this->assertEquals('white', $xFile->name());
+$this->assertEquals($this->sNameWhite, $xFile->filename());
+}
+
+/**
      * @throws RequestException
      */
-    public function testUploadFileMinSizeValidationError()
-    {
-        jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
-        jaxon()->setOption('upload.default.min-size', 30000);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'type' => 'class',
-                        'name' => 'SampleUpload',
-                        'method' => 'myMethod',
-                        'args' => [],
-                    ]),
-                ])
-                ->withUploadedFiles([
-                    'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
-                        UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
-        $this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
-        $this->expectException(RequestException::class);
-        jaxon()->processRequest();
-    }
-
-    /**
+public function testUploadFileMinSizeValidationError()
+{
+jaxon()->setOption('upload.default.dir', __DIR__ . '/../upload/dst');
+jaxon()->setOption('upload.default.min-size', 30000);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'type' => 'class',
+            'name' => 'SampleUpload',
+            'method' => 'myMethod',
+            'args' => [],
+        ]),
+    ])
+    ->withUploadedFiles([
+        'image' => new UploadedFile($this->sPathWhite, $this->sSizeWhite,
+            UPLOAD_ERR_OK, $this->sNameWhite, 'png'),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertTrue(jaxon()->di()->getRequestHandler()->canProcessRequest());
+$this->assertTrue(jaxon()->di()->getUploadHandler()->canProcessRequest(jaxon()->di()->getRequest()));
+$this->expectException(RequestException::class);
+jaxon()->processRequest();
+}
+
+/**
      * @throws RequestException
      */
-    public function testRequestWithNoPluginNoUpload()
-    {
-        jaxon()->setOption('core.upload.enabled', false);
-        // Send a request to the registered class
-        jaxon()->di()->set(ServerRequestInterface::class, function($c) {
-            return $c->g(ServerRequestCreator::class)
-                ->fromGlobals()
-                ->withParsedBody([
-                    'jxncall' => json_encode([
-                        'who' => 'Nobody',
-                        'args' => [],
-                    ]),
-                ])
-                ->withMethod('POST');
-        });
-
-        $this->assertFalse(jaxon()->di()->getRequestHandler()->canProcessRequest());
-    }
+public function testRequestWithNoPluginNoUpload()
+{
+jaxon()->setOption('core.upload.enabled', false);
+// Send a request to the registered class
+jaxon()->di()->set(ServerRequestInterface::class, function($c) {
+return $c->g(ServerRequestCreator::class)
+    ->fromGlobals()
+    ->withParsedBody([
+        'jxncall' => json_encode([
+            'who' => 'Nobody',
+            'args' => [],
+        ]),
+    ])
+    ->withMethod('POST');
+});
+
+$this->assertFalse(jaxon()->di()->getRequestHandler()->canProcessRequest());
+}
 }

jaxon-upload/tests/src/sample.php

Switch Indentation +5 added lines, -5 removed lines

@@ -4,9 +4,9 @@
 

 class SampleUpload

 {

-    public function myMethod()

-    {

-        $xResponse = jaxon()->getResponse();

-        $xResponse->alert('This is a response!!');

-    }

+public function myMethod()

+{

+$xResponse = jaxon()->getResponse();

+$xResponse->alert('This is a response!!');

+}

 }

jaxon-upload/tests/config/psr.php

Switch Indentation +15 added lines, -15 removed lines

@@ -1,19 +1,19 @@
 <?php
 
 return [
-    'app' => [
-    ],
-    'lib' => [
-        'core' => [
-            'debug' => [
-                'on' => false,
-            ],
-            'request' => [
-                'uri' => 'ajax.php',
-            ],
-            'prefix' => [
-                'class' => 'Jxn',
-            ],
-        ],
-    ],
+'app' => [
+],
+'lib' => [
+'core' => [
+'debug' => [
+    'on' => false,
+],
+'request' => [
+    'uri' => 'ajax.php',
+],
+'prefix' => [
+    'class' => 'Jxn',
+],
+],
+],
 ];

jaxon-upload/translations/es/upload.php

Switch Indentation +13 added lines, -13 removed lines

@@ -1,17 +1,17 @@
 <?php
 
 return [
-    'errors' => [
-        'upload' => [
-            'failed' => "El archivo :name no se ha podido subir.",
-            'access' => "No se tiene permiso de escritura el directorio de subida.",
-            'type' => "Los archivos de tipo :type no están permitidos.",
-            'extension' => "Los archivos con la extensión :extension no estan permitidos.",
-            'max-size' => "No se pueden subir archivos con peso :size. Muy grande.",
-            'min-size' => "No se pueden subir archivos con peso :size. Muy pequeño.",
-            'plugin' => "No se ha encontrado el plugin upload.",
-            'request' => "No hay datos de subida en la petición.",
-            'invalid' => "Los datos de subida no son válidos.",
-        ],
-    ],
+'errors' => [
+'upload' => [
+'failed' => "El archivo :name no se ha podido subir.",
+'access' => "No se tiene permiso de escritura el directorio de subida.",
+'type' => "Los archivos de tipo :type no están permitidos.",
+'extension' => "Los archivos con la extensión :extension no estan permitidos.",
+'max-size' => "No se pueden subir archivos con peso :size. Muy grande.",
+'min-size' => "No se pueden subir archivos con peso :size. Muy pequeño.",
+'plugin' => "No se ha encontrado el plugin upload.",
+'request' => "No hay datos de subida en la petición.",
+'invalid' => "Los datos de subida no son válidos.",
+],
+],
 ];

jaxon-upload/translations/en/upload.php

Switch Indentation +13 added lines, -13 removed lines

@@ -1,17 +1,17 @@
 <?php
 
 return [
-    'errors' => [
-        'upload' => [
-            'failed' => "The upload of file :name has failed.",
-            'access' => "Cannot get write access to upload directory.",
-            'type' => "Upload is not allowed for file of type :type.",
-            'extension' => "Upload is not allowed for file with extension :extension.",
-            'max-size' => "Upload is not allowed for file of size :size. Too big.",
-            'min-size' => "Upload is not allowed for file of size :size. Too small.",
-            'plugin' => "Upload plugin not found.",
-            'request' => "Upload data not available in the request.",
-            'invalid' => "Upload data are invalid.",
-        ],
-    ],
+'errors' => [
+'upload' => [
+'failed' => "The upload of file :name has failed.",
+'access' => "Cannot get write access to upload directory.",
+'type' => "Upload is not allowed for file of type :type.",
+'extension' => "Upload is not allowed for file with extension :extension.",
+'max-size' => "Upload is not allowed for file of size :size. Too big.",
+'min-size' => "Upload is not allowed for file of size :size. Too small.",
+'plugin' => "Upload plugin not found.",
+'request' => "Upload data not available in the request.",
+'invalid' => "Upload data are invalid.",
+],
+],
 ];