vanderlee / PHPSwaggerGen

SwaggerGen/Swagger/Type/StringType.php

Indentation +202 added lines, -202 removed lines

@@ -15,207 +15,207 @@
 class StringType extends AbstractType
 {
 
-    private static $formats = array(
-        'string' => '',
-        'byte' => 'byte',
-        'binary' => 'binary',
-        'password' => 'password',
-        'enum' => '',
-    );
-
-    /**
-     * Name of the type
-     * @var string
-     */
-    protected $format = '';
-    protected $pattern;
-    protected $default;
-    protected $maxLength;
-    protected $minLength;
-    protected $enum = [];
-
-    /**
-     * @param string $command The comment command
-     * @param string $data Any data added after the command
-     * @return AbstractType|boolean
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     */
-    public function handleCommand($command, $data = null)
-    {
-        switch (strtolower($command)) {
-            case 'default':
-                $this->default = $this->validateDefault($data);
-                return $this;
-
-            case 'pattern':
-                $this->pattern = $data;
-                return $this;
-
-            case 'enum':
-                if ($this->minLength !== null || $this->maxLength !== null) {
-                    throw new Exception("Enumeration not allowed in ranged string: '{$data}'");
-                }
-                $words = self::wordSplit($data);
-                $this->enum = is_array($this->enum) ? array_merge($this->enum, $words) : $words;
-                return $this;
-        }
-
-        return parent::handleCommand($command, $data);
-    }
-
-    /**
-     * Validate a default string value, depending on subtype
-     *
-     * @param string $value the value to validate
-     * @return string the value after validation (might become trimmed)
-     * @throws Exception
-     */
-    protected function validateDefault($value): string
-    {
-        if (empty($value)) {
-            if ($this->format) {
-                $type = $this->format;
-            } else {
-                $type = $this->enum ? 'enum' : 'string';
-            }
-            throw new Exception("Empty {$type} default");
-        }
-
-        // trim and unescape quotes if needed
-        if (mb_strlen($value) >= 2
-            && $value[0] === '"'
-            && $value[mb_strlen($value) - 1] === '"'
-        ) {
-            $value = stripcslashes(mb_substr($value, 1, -1));
-        }
-
-        if (!empty($this->enum) && !in_array($value, $this->enum, true)) {
-            throw new Exception("Invalid enum default: '{$value}'");
-        }
-
-        if ($this->maxLength !== null && mb_strlen($value) > $this->maxLength) {
-            if ($this->format) {
-                $type = $this->format;
-            } else {
-                $type = $this->enum ? 'enum' : 'string';
-            }
-            throw new Exception("Default {$type} length beyond maximum: '{$value}'");
-        }
-
-        if ($this->minLength !== null && mb_strlen($value) < $this->minLength) {
-            if ($this->format) {
-                $type = $this->format;
-            } else {
-                $type = $this->enum ? 'enum' : 'string';
-            }
-            throw new Exception("Default {$type} length beyond minimum: '{$value}'");
-        }
-
-        return $value;
-    }
-
-    public function toArray(): array
-    {
-        return self::arrayFilterNull(array_merge(array(
-            'type' => 'string',
-            'format' => empty($this->format) ? null : $this->format,
-            'pattern' => $this->pattern,
-            'default' => $this->default,
-            'minLength' => $this->minLength ? (int)$this->minLength : null,
-            'maxLength' => $this->maxLength ? (int)$this->maxLength : null,
-            'enum' => $this->enum,
-        ), parent::toArray()));
-    }
-
-    public function __toString()
-    {
-        return __CLASS__;
-    }
-
-    /**
-     * @throws Exception
-     */
-    protected function parseDefinition($definition): void
-    {
-        $definition = self::trim($definition);
-
-        $match = [];
-        if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_CONTENT . self::REGEX_RANGE . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
-            throw new Exception("Unparseable string definition: '{$definition}'");
-        }
-
-        $this->parseFormat($definition, $match);
-        $this->parseContent($definition, $match);
-        $this->parseRange($definition, $match);
-        $this->parseDefault($definition, $match);
-    }
-
-    /**
-     * @param string $definition
-     * @param string[] $match
-     * @throws Exception
-     */
-    private function parseFormat($definition, $match): void
-    {
-        $type = strtolower($match[1]);
-        if (!isset(self::$formats[$type])) {
-            throw new Exception("Not a string: '{$definition}'");
-        }
-        $this->format = self::$formats[$type];
-    }
-
-    /**
-     * @param string $definition
-     * @param string[] $match
-     */
-    private function parseContent($definition, $match): void
-    {
-        if (strtolower($match[1]) === 'enum') {
-            $this->enum = explode(',', $match[2]);
-        } else {
-            $this->pattern = empty($match[2]) ? null : $match[2];
-        }
-    }
-
-    /**
-     * @param string $definition
-     * @param string[] $match
-     * @throws Exception
-     * @throws Exception
-     */
-    private function parseRange($definition, $match): void
-    {
-
-        if (!empty($match[3])) {
-            if ($match[1] === 'enum') {
-                throw new Exception("Range not allowed in enumeration definition: '{$definition}'");
-            }
-            if ($match[4] === '' && $match[5] === '') {
-                throw new Exception("Empty string range: '{$definition}'");
-            }
-            $exclusiveMinimum = $match[3] === '<';
-            $this->minLength = $match[4] === '' ? null : $match[4];
-            $this->maxLength = $match[5] === '' ? null : $match[5];
-            $exclusiveMaximum = isset($match[6]) ? ($match[6] === '>') : null;
-            if ($this->minLength !== null && $this->maxLength !== null && $this->minLength > $this->maxLength) {
-                self::swap($this->minLength, $this->maxLength);
-                self::swap($exclusiveMinimum, $exclusiveMaximum);
-            }
-            $this->minLength = $this->minLength === null ? null : max(0, $exclusiveMinimum ? $this->minLength + 1 : $this->minLength);
-            $this->maxLength = $this->maxLength === null ? null : max(0, $exclusiveMaximum ? $this->maxLength - 1 : $this->maxLength);
-        }
-    }
-
-    /**
-     * @param string $definition
-     * @param string[] $match
-     * @throws Exception
-     */
-    private function parseDefault($definition, $match): void
-    {
-        $this->default = isset($match[7]) && $match[7] !== '' ? $this->validateDefault($match[7]) : null;
-    }
+	private static $formats = array(
+		'string' => '',
+		'byte' => 'byte',
+		'binary' => 'binary',
+		'password' => 'password',
+		'enum' => '',
+	);
+
+	/**
+	 * Name of the type
+	 * @var string
+	 */
+	protected $format = '';
+	protected $pattern;
+	protected $default;
+	protected $maxLength;
+	protected $minLength;
+	protected $enum = [];
+
+	/**
+	 * @param string $command The comment command
+	 * @param string $data Any data added after the command
+	 * @return AbstractType|boolean
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 */
+	public function handleCommand($command, $data = null)
+	{
+		switch (strtolower($command)) {
+			case 'default':
+				$this->default = $this->validateDefault($data);
+				return $this;
+
+			case 'pattern':
+				$this->pattern = $data;
+				return $this;
+
+			case 'enum':
+				if ($this->minLength !== null || $this->maxLength !== null) {
+					throw new Exception("Enumeration not allowed in ranged string: '{$data}'");
+				}
+				$words = self::wordSplit($data);
+				$this->enum = is_array($this->enum) ? array_merge($this->enum, $words) : $words;
+				return $this;
+		}
+
+		return parent::handleCommand($command, $data);
+	}
+
+	/**
+	 * Validate a default string value, depending on subtype
+	 *
+	 * @param string $value the value to validate
+	 * @return string the value after validation (might become trimmed)
+	 * @throws Exception
+	 */
+	protected function validateDefault($value): string
+	{
+		if (empty($value)) {
+			if ($this->format) {
+				$type = $this->format;
+			} else {
+				$type = $this->enum ? 'enum' : 'string';
+			}
+			throw new Exception("Empty {$type} default");
+		}
+
+		// trim and unescape quotes if needed
+		if (mb_strlen($value) >= 2
+			&& $value[0] === '"'
+			&& $value[mb_strlen($value) - 1] === '"'
+		) {
+			$value = stripcslashes(mb_substr($value, 1, -1));
+		}
+
+		if (!empty($this->enum) && !in_array($value, $this->enum, true)) {
+			throw new Exception("Invalid enum default: '{$value}'");
+		}
+
+		if ($this->maxLength !== null && mb_strlen($value) > $this->maxLength) {
+			if ($this->format) {
+				$type = $this->format;
+			} else {
+				$type = $this->enum ? 'enum' : 'string';
+			}
+			throw new Exception("Default {$type} length beyond maximum: '{$value}'");
+		}
+
+		if ($this->minLength !== null && mb_strlen($value) < $this->minLength) {
+			if ($this->format) {
+				$type = $this->format;
+			} else {
+				$type = $this->enum ? 'enum' : 'string';
+			}
+			throw new Exception("Default {$type} length beyond minimum: '{$value}'");
+		}
+
+		return $value;
+	}
+
+	public function toArray(): array
+	{
+		return self::arrayFilterNull(array_merge(array(
+			'type' => 'string',
+			'format' => empty($this->format) ? null : $this->format,
+			'pattern' => $this->pattern,
+			'default' => $this->default,
+			'minLength' => $this->minLength ? (int)$this->minLength : null,
+			'maxLength' => $this->maxLength ? (int)$this->maxLength : null,
+			'enum' => $this->enum,
+		), parent::toArray()));
+	}
+
+	public function __toString()
+	{
+		return __CLASS__;
+	}
+
+	/**
+	 * @throws Exception
+	 */
+	protected function parseDefinition($definition): void
+	{
+		$definition = self::trim($definition);
+
+		$match = [];
+		if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_CONTENT . self::REGEX_RANGE . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
+			throw new Exception("Unparseable string definition: '{$definition}'");
+		}
+
+		$this->parseFormat($definition, $match);
+		$this->parseContent($definition, $match);
+		$this->parseRange($definition, $match);
+		$this->parseDefault($definition, $match);
+	}
+
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 * @throws Exception
+	 */
+	private function parseFormat($definition, $match): void
+	{
+		$type = strtolower($match[1]);
+		if (!isset(self::$formats[$type])) {
+			throw new Exception("Not a string: '{$definition}'");
+		}
+		$this->format = self::$formats[$type];
+	}
+
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 */
+	private function parseContent($definition, $match): void
+	{
+		if (strtolower($match[1]) === 'enum') {
+			$this->enum = explode(',', $match[2]);
+		} else {
+			$this->pattern = empty($match[2]) ? null : $match[2];
+		}
+	}
+
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 * @throws Exception
+	 * @throws Exception
+	 */
+	private function parseRange($definition, $match): void
+	{
+
+		if (!empty($match[3])) {
+			if ($match[1] === 'enum') {
+				throw new Exception("Range not allowed in enumeration definition: '{$definition}'");
+			}
+			if ($match[4] === '' && $match[5] === '') {
+				throw new Exception("Empty string range: '{$definition}'");
+			}
+			$exclusiveMinimum = $match[3] === '<';
+			$this->minLength = $match[4] === '' ? null : $match[4];
+			$this->maxLength = $match[5] === '' ? null : $match[5];
+			$exclusiveMaximum = isset($match[6]) ? ($match[6] === '>') : null;
+			if ($this->minLength !== null && $this->maxLength !== null && $this->minLength > $this->maxLength) {
+				self::swap($this->minLength, $this->maxLength);
+				self::swap($exclusiveMinimum, $exclusiveMaximum);
+			}
+			$this->minLength = $this->minLength === null ? null : max(0, $exclusiveMinimum ? $this->minLength + 1 : $this->minLength);
+			$this->maxLength = $this->maxLength === null ? null : max(0, $exclusiveMaximum ? $this->maxLength - 1 : $this->maxLength);
+		}
+	}
+
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 * @throws Exception
+	 */
+	private function parseDefault($definition, $match): void
+	{
+		$this->default = isset($match[7]) && $match[7] !== '' ? $this->validateDefault($match[7]) : null;
+	}
 
 }

Upper-Lower-Casing +3 added lines, -3 removed lines

@@ -80,7 +80,7 @@ 
             } else {
                 $type = $this->enum ? 'enum' : 'string';
             }
-            throw new Exception("Empty {$type} default");
+            throw new Exception("empty {$type} default");
         }
 
         // trim and unescape quotes if needed
@@ -101,7 +101,7 @@ 
             } else {
                 $type = $this->enum ? 'enum' : 'string';
             }
-            throw new Exception("Default {$type} length beyond maximum: '{$value}'");
+            throw new Exception("default {$type} length beyond maximum: '{$value}'");
         }
 
         if ($this->minLength !== null && mb_strlen($value) < $this->minLength) {
@@ -110,7 +110,7 @@ 
             } else {
                 $type = $this->enum ? 'enum' : 'string';
             }
-            throw new Exception("Default {$type} length beyond minimum: '{$value}'");
+            throw new Exception("default {$type} length beyond minimum: '{$value}'");
         }
 
         return $value;

tests/Swagger/Type/StringTypeTest.php

Indentation +303 added lines, -303 removed lines

@@ -9,308 +9,308 @@
 class StringTypeTest extends TestCase
 {
 
-    protected $parent;
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructNotAString()
-    {
-        $this->expectException(SwaggerException::class, "Not a string: 'wrong'");
-
-        $object = new StringType($this->parent, 'wrong');
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructEmptyRange()
-    {
-        $this->expectException(SwaggerException::class, "Empty string range: 'string[,]=1'");
-
-        $object = new StringType($this->parent, 'string[,]=1');
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructDefaultTooLongInclusive()
-    {
-        $this->expectException(SwaggerException::class, "Default string length beyond maximum: 'long'");
-
-        $object = new StringType($this->parent, 'string[,3]=long');
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructDefaultTooLongExclusive()
-    {
-        $this->expectException(SwaggerException::class, "Default string length beyond maximum: 'long'");
-
-        $object = new StringType($this->parent, 'string[,4>=long');
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructDefaultTooShortInclusive()
-    {
-        $this->expectException(SwaggerException::class, "Default string length beyond minimum: 'short'");
-
-        $object = new StringType($this->parent, 'string[6,]=short');
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructDefaultTooShortExclusive()
-    {
-        $this->expectException(SwaggerException::class, "Default string length beyond minimum: 'short'");
-
-        $object = new StringType($this->parent, 'string<5,]=short');
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructString()
-    {
-        $object = new StringType($this->parent, 'string');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->assertSame(array(
-            'type' => 'string',
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructStringEmptyDefault()
-    {
-        $this->expectException(SwaggerException::class, "Unparseable string definition: 'string='");
-
-        $object = new StringType($this->parent, 'string= ');
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructStringDefaultLengthInclusive()
-    {
-        $object = new StringType($this->parent, 'string[4,4]=word');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'default' => 'word',
-            'minLength' => 4,
-            'maxLength' => 4,
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructStringDefaultLengthExclusive()
-    {
-        $object = new StringType($this->parent, 'string<3,5>=word');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'default' => 'word',
-            'minLength' => 4,
-            'maxLength' => 4,
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructStringDefaultWithWhitespace()
-    {
-        $object = new StringType($this->parent, 'string="white space"');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'default' => 'white space',
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructBinary()
-    {
-        $object = new StringType($this->parent, 'binary');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'format' => 'binary',
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructEnumRange()
-    {
-        $this->expectException(SwaggerException::class, "Range not allowed in enumeration definition: 'enum(a,b)[,]'");
-
-        $object = new StringType($this->parent, 'enum(a,b)[,]');
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructEnumInvalidDefault()
-    {
-        $this->expectException(SwaggerException::class, "Invalid enum default: 'c'");
-
-        $object = new StringType($this->parent, 'enum(a,b)=c');
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructEnum()
-    {
-        $object = new StringType($this->parent, 'enum(a,b)');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'enum' => array('a', 'b'),
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructEnumWithDefault()
-    {
-        $object = new StringType($this->parent, 'enum(a,b)=a');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'default' => 'a',
-            'enum' => array('a', 'b'),
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers StringType::__construct
-     */
-    public function testConstructPattern()
-    {
-        $object = new StringType($this->parent, 'string([a-z])');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'pattern' => '[a-z]',
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
-     */
-    public function testCommandDefaultNoValue()
-    {
-        $object = new StringType($this->parent, 'string');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->expectException(SwaggerException::class, "Empty string default");
-        $object->handleCommand('default', '');
-    }
-
-    /**
-     * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
-     */
-    public function testCommandDefault()
-    {
-        $object = new StringType($this->parent, 'string');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $object->handleCommand('default', 'word');
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'default' => 'word',
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
-     */
-    public function testCommandPattern()
-    {
-        $object = new StringType($this->parent, 'string');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $object->handleCommand('pattern', '[a-z]');
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'pattern' => '[a-z]',
-        ), $object->toArray());
-    }
-
-    /**
-     * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
-     */
-    public function testCommandEnumWhenRange()
-    {
-        $object = new StringType($this->parent, 'string[0,]');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $this->expectException(SwaggerException::class, "Enumeration not allowed in ranged string: 'red green blue'");
-
-        $object->handleCommand('enum', 'red green blue');
-    }
-
-    /**
-     * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
-     */
-    public function testCommandEnum()
-    {
-        $object = new StringType($this->parent, 'string');
-
-        $this->assertInstanceOf(StringType::class, $object);
-
-        $object->handleCommand('enum', 'red green blue');
-
-        $this->assertSame(array(
-            'type' => 'string',
-            'enum' => array('red', 'green', 'blue'),
-        ), $object->toArray());
-    }
-
-    protected function setUp(): void
-    {
-        $this->parent = $this->getMockForAbstractClass(AbstractObject::class);
-    }
-
-    protected function assertPreConditions(): void
-    {
-        $this->assertInstanceOf(AbstractObject::class, $this->parent);
-    }
+	protected $parent;
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructNotAString()
+	{
+		$this->expectException(SwaggerException::class, "Not a string: 'wrong'");
+
+		$object = new StringType($this->parent, 'wrong');
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructEmptyRange()
+	{
+		$this->expectException(SwaggerException::class, "Empty string range: 'string[,]=1'");
+
+		$object = new StringType($this->parent, 'string[,]=1');
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructDefaultTooLongInclusive()
+	{
+		$this->expectException(SwaggerException::class, "Default string length beyond maximum: 'long'");
+
+		$object = new StringType($this->parent, 'string[,3]=long');
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructDefaultTooLongExclusive()
+	{
+		$this->expectException(SwaggerException::class, "Default string length beyond maximum: 'long'");
+
+		$object = new StringType($this->parent, 'string[,4>=long');
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructDefaultTooShortInclusive()
+	{
+		$this->expectException(SwaggerException::class, "Default string length beyond minimum: 'short'");
+
+		$object = new StringType($this->parent, 'string[6,]=short');
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructDefaultTooShortExclusive()
+	{
+		$this->expectException(SwaggerException::class, "Default string length beyond minimum: 'short'");
+
+		$object = new StringType($this->parent, 'string<5,]=short');
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructString()
+	{
+		$object = new StringType($this->parent, 'string');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->assertSame(array(
+			'type' => 'string',
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructStringEmptyDefault()
+	{
+		$this->expectException(SwaggerException::class, "Unparseable string definition: 'string='");
+
+		$object = new StringType($this->parent, 'string= ');
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructStringDefaultLengthInclusive()
+	{
+		$object = new StringType($this->parent, 'string[4,4]=word');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'default' => 'word',
+			'minLength' => 4,
+			'maxLength' => 4,
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructStringDefaultLengthExclusive()
+	{
+		$object = new StringType($this->parent, 'string<3,5>=word');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'default' => 'word',
+			'minLength' => 4,
+			'maxLength' => 4,
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructStringDefaultWithWhitespace()
+	{
+		$object = new StringType($this->parent, 'string="white space"');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'default' => 'white space',
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructBinary()
+	{
+		$object = new StringType($this->parent, 'binary');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'format' => 'binary',
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructEnumRange()
+	{
+		$this->expectException(SwaggerException::class, "Range not allowed in enumeration definition: 'enum(a,b)[,]'");
+
+		$object = new StringType($this->parent, 'enum(a,b)[,]');
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructEnumInvalidDefault()
+	{
+		$this->expectException(SwaggerException::class, "Invalid enum default: 'c'");
+
+		$object = new StringType($this->parent, 'enum(a,b)=c');
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructEnum()
+	{
+		$object = new StringType($this->parent, 'enum(a,b)');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'enum' => array('a', 'b'),
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructEnumWithDefault()
+	{
+		$object = new StringType($this->parent, 'enum(a,b)=a');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'default' => 'a',
+			'enum' => array('a', 'b'),
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers StringType::__construct
+	 */
+	public function testConstructPattern()
+	{
+		$object = new StringType($this->parent, 'string([a-z])');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'pattern' => '[a-z]',
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
+	 */
+	public function testCommandDefaultNoValue()
+	{
+		$object = new StringType($this->parent, 'string');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->expectException(SwaggerException::class, "Empty string default");
+		$object->handleCommand('default', '');
+	}
+
+	/**
+	 * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
+	 */
+	public function testCommandDefault()
+	{
+		$object = new StringType($this->parent, 'string');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$object->handleCommand('default', 'word');
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'default' => 'word',
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
+	 */
+	public function testCommandPattern()
+	{
+		$object = new StringType($this->parent, 'string');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$object->handleCommand('pattern', '[a-z]');
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'pattern' => '[a-z]',
+		), $object->toArray());
+	}
+
+	/**
+	 * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
+	 */
+	public function testCommandEnumWhenRange()
+	{
+		$object = new StringType($this->parent, 'string[0,]');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$this->expectException(SwaggerException::class, "Enumeration not allowed in ranged string: 'red green blue'");
+
+		$object->handleCommand('enum', 'red green blue');
+	}
+
+	/**
+	 * @covers \SwaggerGen\Swagger\Type\StringType->handleCommand
+	 */
+	public function testCommandEnum()
+	{
+		$object = new StringType($this->parent, 'string');
+
+		$this->assertInstanceOf(StringType::class, $object);
+
+		$object->handleCommand('enum', 'red green blue');
+
+		$this->assertSame(array(
+			'type' => 'string',
+			'enum' => array('red', 'green', 'blue'),
+		), $object->toArray());
+	}
+
+	protected function setUp(): void
+	{
+		$this->parent = $this->getMockForAbstractClass(AbstractObject::class);
+	}
+
+	protected function assertPreConditions(): void
+	{
+		$this->assertInstanceOf(AbstractObject::class, $this->parent);
+	}
 
 }