Improve exception messages

nyamsprod · nyamsprod · commit 0d9298a4a791 · 2022-09-02T16:16:49.000+02:00
diff --git a/src/Dictionary.php b/src/Dictionary.php
@@ -267,7 +267,7 @@ private static function filterForbiddenState(InnerList|Item $member): InnerList|
     {
         foreach ($member->parameters as $offset => $item) {
             if ($item->parameters->hasMembers()) {
-                throw new ForbiddenStateError('Parameter member `"'.$offset.'"` is in invalid state; Parameters instances can only contain bare items.');
+                throw new ForbiddenStateError('Parameter member "'.$offset.'" is in invalid state; Parameters instances can only contain bare items.');
             }
         }
 
diff --git a/src/InnerList.php b/src/InnerList.php
@@ -59,7 +59,7 @@ private static function filterForbiddenState(Item $member): Item
     {
         foreach ($member->parameters as $offset => $item) {
             if ($item->parameters->hasMembers()) {
-                throw new ForbiddenStateError('Parameter member `"'.$offset.'"` is in invalid state; Parameters instances can only contain bare items.');
+                throw new ForbiddenStateError('Parameter member "'.$offset.'" is in invalid state; Parameters instances can only contain bare items.');
             }
         }
 
diff --git a/src/InvalidOffset.php b/src/InvalidOffset.php
@@ -16,18 +16,18 @@ private function __construct(string $message)
     public static function dueToIndexNotFound(string|int $index): self
     {
         if (is_string($index)) {
-            return new self('The member index can not be the string `'.$index.'`.');
+            return new self('The member index can not be the string "'.$index.'".');
         }
 
-        return new self('No member exists with the index `'.$index.'`.');
+        return new self('No member exists with the index "'.$index.'".');
     }
 
     public static function dueToKeyNotFound(string|int $key): self
     {
         if (is_int($key)) {
-            return new self('The member key  can not be the integer`'.$key.'`.');
+            return new self('The member key  can not be the integer "'.$key.'".');
         }
 
-        return new self('No member exists with the key `'.$key.'`.');
+        return new self('No member exists with the key "'.$key.'".');
     }
 }
diff --git a/src/Item.php b/src/Item.php
@@ -117,7 +117,7 @@ private static function filterDecimal(float $value): float
     private static function filterString(string $value): string
     {
         if (1 === preg_match('/[^\x20-\x7E]/i', $value)) {
-            throw new SyntaxError('The string `'.$value.'` contains invalid characters.');
+            throw new SyntaxError('The string "'.$value.'" contains invalid characters.');
         }
 
         return $value;
@@ -149,13 +149,13 @@ public static function fromHttpValue(string $httpValue): self
 
         [$value, $parameters] = match (true) {
             1 === preg_match("/[\r\t\n]|[^\x20-\x7E]/", $itemString),
-            '' === $itemString => throw new SyntaxError("The HTTP textual representation `$httpValue` for an item contains invalid characters."),
+            '' === $itemString => throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for an item contains invalid characters.'),
             '"' === $itemString[0] => self::parseString($itemString),
             ':' === $itemString[0] => self::parseBytesSequence($itemString),
             '?' === $itemString[0] => self::parseBoolean($itemString),
             1 === preg_match('/^(-?\d)/', $itemString) => self::parseNumber($itemString),
             1 === preg_match('/^([a-z*])/i', $itemString) => self::parseToken($itemString),
-            default => throw new SyntaxError("The HTTP textual representation `$httpValue` for an item is unknown or unsupported."),
+            default => throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for an item is unknown or unsupported.'),
         };
 
         return new self($value, Parameters::fromHttpValue($parameters));
@@ -174,7 +174,7 @@ private static function parseToken(string $string): array
         }
 
         if (1 !== preg_match('/'.$regexp.'/i', $string, $found)) {
-            throw new SyntaxError("The HTTP textual representation `$string` for a Token contains invalid characters.");
+            throw new SyntaxError("The HTTP textual representation \"$string\" for a Token contains invalid characters.");
         }
 
         return [
@@ -191,7 +191,7 @@ private static function parseToken(string $string): array
     private static function parseBoolean(string $string): array
     {
         if (1 !== preg_match('/^\?[01]/', $string)) {
-            throw new SyntaxError("The HTTP textual representation `$string` for a boolean contains invalid characters.");
+            throw new SyntaxError("The HTTP textual representation \"$string\" for a boolean contains invalid characters.");
         }
 
         return [$string[1] === '1', substr($string, 2)];
@@ -205,7 +205,7 @@ private static function parseBoolean(string $string): array
     private static function parseBytesSequence(string $string): array
     {
         if (1 !== preg_match('/^:(?<bytes>[a-z\d+\/=]*):/i', $string, $matches)) {
-            throw new SyntaxError("The HTTP textual representation `$string` for a byte sequence contains invalid characters.");
+            throw new SyntaxError("The HTTP textual representation \"$string\" for a byte sequence contains invalid characters.");
         }
 
         return [ByteSequence::fromEncoded($matches['bytes']), substr($string, strlen($matches[0]))];
@@ -224,13 +224,13 @@ private static function parseNumber(string $string): array
         }
 
         if (1 !== preg_match('/'.$regexp.'/', $string, $found)) {
-            throw new SyntaxError("The HTTP textual representation `$string` for a number contains invalid characters.");
+            throw new SyntaxError("The HTTP textual representation \"$string\" for a number contains invalid characters.");
         }
 
         $number = match (true) {
             1 === preg_match('/^-?\d{1,12}\.\d{1,3}$/', $found['number']) => (float) $found['number'],
             1 === preg_match('/^-?\d{1,15}$/', $found['number']) => (int) $found['number'],
-            default => throw new SyntaxError("The HTTP textual representation `$string` for a number contain too many digits."),
+            default => throw new SyntaxError("The HTTP textual representation \"$string\" for a number contain too many digits."),
         };
 
         return [$number, substr($string, strlen($found['number']))];
@@ -261,19 +261,19 @@ private static function parseString(string $string): array
             }
 
             if ($string === '') {
-                throw new SyntaxError("The HTTP textual representation `$originalString` for a string contains an invalid end string.");
+                throw new SyntaxError("The HTTP textual representation \"$originalString\" for a string contains an invalid end string.");
             }
 
             $char = $string[0];
             $string = substr($string, 1);
             if (!in_array($char, ['"', '\\'], true)) {
-                throw new SyntaxError("The HTTP textual representation `$originalString` for a string contains invalid characters.");
+                throw new SyntaxError("The HTTP textual representation \"$originalString\" for a string contains invalid characters.");
             }
 
             $returnValue .= $char;
         }
 
-        throw new SyntaxError("The HTTP textual representation `$originalString` for a string contains an invalid end string.");
+        throw new SyntaxError("The HTTP textual representation \"$originalString\" for a string contains an invalid end string.");
     }
 
     /**
diff --git a/src/MapKey.php b/src/MapKey.php
@@ -22,7 +22,7 @@ public static function fromString(string $httpValue): self
     {
         $instance = self::fromStringBeginning($httpValue);
         if ($instance->value !== $httpValue) {
-            throw new SyntaxError("No valid http value key could be extracted from `$httpValue`.");
+            throw new SyntaxError("No valid http value key could be extracted from \"$httpValue\".");
         }
 
         return $instance;
@@ -34,7 +34,7 @@ public static function fromString(string $httpValue): self
     public static function fromStringBeginning(string $httpValue): self
     {
         if (1 !== preg_match('/^(?<key>[a-z*][a-z\d.*_-]*)/', $httpValue, $found)) {
-            throw new SyntaxError("No valid http value key could be extracted from `$httpValue`.");
+            throw new SyntaxError("No valid http value key could be extracted from \"$httpValue\".");
         }
 
         return new self($found['key']);
diff --git a/src/OrderedList.php b/src/OrderedList.php
@@ -63,7 +63,7 @@ private static function filterForbiddenState(InnerList|Item $member): InnerList|
     {
         foreach ($member->parameters as $offset => $item) {
             if ($item->parameters->hasMembers()) {
-                throw new ForbiddenStateError('Parameter member `"'.$offset.'"` is in invalid state; Parameters instances can only contain bare items.');
+                throw new ForbiddenStateError('Parameter member "'.$offset.'" is in invalid state; Parameters instances can only contain bare items.');
             }
         }
 
diff --git a/src/Parameters.php b/src/Parameters.php
@@ -46,7 +46,7 @@ private static function filterMember(Item $item, string|int $offset = null): Ite
 
         $message = 'Parameters instances can only contain bare items.';
         if (null !== $offset) {
-            $message = 'Parameter member `"'.$offset.'"` is in invalid state; '.$message;
+            $message = 'Parameter member "'.$offset.'" is in invalid state; '.$message;
         }
 
         throw new ForbiddenStateError($message);
@@ -121,7 +121,7 @@ public static function fromHttpValue(string $httpValue): self
         foreach (explode(';', $httpValue) as $pair) {
             [$key, $value] = explode('=', $pair, 2) + [1 => '?1'];
             if (rtrim($key) !== $key || ltrim($value) !== $value) {
-                throw new SyntaxError("The HTTP textual representation `$pair` for a parameter pair contains invalid characters.");
+                throw new SyntaxError("The HTTP textual representation \"$pair\" for a parameter pair contains invalid characters.");
             }
 
             $key = trim($key);
@@ -139,7 +139,7 @@ public static function fromHttpValue(string $httpValue): self
     public function toHttpValue(): string
     {
         $formatter = fn (Item $member, string $offset): string => match (true) {
-            $member->parameters->hasMembers() => throw new ForbiddenStateError('Parameter member `"'.$offset.'"` is in invalid state; Parameters instances can only contain bare items.'),
+            $member->parameters->hasMembers() => throw new ForbiddenStateError('Parameter member "'.$offset.'" is in invalid state; Parameters instances can only contain bare items.'),
             true === $member->value() => ';'.$offset,
             default => ';'.$offset.'='.$member->toHttpValue(),
         };
diff --git a/src/Parser.php b/src/Parser.php
@@ -86,13 +86,13 @@ public static function parseInnerList(string $httpValue): array
     {
         $remainder = ltrim($httpValue, ' ');
         if ('(' !== $remainder[0]) {
-            throw new SyntaxError("The HTTP textual representation `$httpValue` for a inner list is missing a parenthesis.");
+            throw new SyntaxError("The HTTP textual representation \"$httpValue\" for a inner list is missing a parenthesis.");
         }
 
         [$list, $offset] = self::parseInnerListValue($remainder);
         $remainder = self::removeOptionalWhiteSpaces(substr($remainder, $offset));
         if ('' !== $remainder) {
-            throw new SyntaxError("The HTTP textual representation `$httpValue` for a inner list contains invalid data.");
+            throw new SyntaxError("The HTTP textual representation \"$httpValue\" for a inner list contains invalid data.");
         }
 
         return $list;
@@ -190,11 +190,11 @@ private static function parseInnerListValue(string $httpValue): array
 
             $list[] = Item::from($value, $parameters);
             if ('' !== $remainder && !in_array($remainder[0], [' ', ')'], true)) {
-                throw new SyntaxError("The HTTP textual representation `$remainder` for a inner list is using invalid characters.");
+                throw new SyntaxError("The HTTP textual representation \"$remainder\" for a inner list is using invalid characters.");
             }
         }
 
-        throw new SyntaxError("Unexpected end of line for The HTTP textual representation `$remainder` for a inner list.");
+        throw new SyntaxError("Unexpected end of line for The HTTP textual representation \"$remainder\" for a inner list.");
     }
 
     /**
@@ -255,7 +255,7 @@ private static function parseParameters(string $httpValue): array
     private static function parseBoolean(string $httpValue): array
     {
         if (1 !== preg_match('/^\?[01]/', $httpValue)) {
-            throw new SyntaxError("Invalid character in the HTTP textual representation of a boolean value `$httpValue`.");
+            throw new SyntaxError("Invalid character in the HTTP textual representation of a boolean value \"$httpValue\".");
         }
 
         return ['1' === $httpValue[1], 2];
@@ -275,7 +275,7 @@ private static function parseNumber(string $httpValue): array
         return match (true) {
             1 === preg_match('/^-?\d{1,12}\.\d{1,3}$/', $found['number']) => [(float) $found['number'], strlen($found['number'])],
             1 === preg_match('/^-?\d{1,15}$/', $found['number']) => [(int) $found['number'], strlen($found['number'])],
-            default => throw new SyntaxError("The number format in the HTTP textual representation `$httpValue` contains too much digit."),
+            default => throw new SyntaxError("The number format in the HTTP textual representation \"$httpValue\" contains too much digit."),
         };
     }
 
@@ -301,7 +301,7 @@ private static function parseString(string $httpValue): array
             }
 
             if (1 === preg_match("/[^\x20-\x7E]/", $char)) {
-                throw new SyntaxError("Invalid character in the HTTP textual representation of a string `$httpValue`.");
+                throw new SyntaxError("Invalid character in the HTTP textual representation of a string \"$httpValue\".");
             }
 
             $httpValue = substr($httpValue, 1);
@@ -314,13 +314,13 @@ private static function parseString(string $httpValue): array
             $offset += 1;
             $httpValue = substr($httpValue, 1);
             if (!in_array($char, ['"', '\\'], true)) {
-                throw new SyntaxError("Invalid characters in the HTTP textual representation of a string `$httpValue`.");
+                throw new SyntaxError("Invalid characters in the HTTP textual representation of a string \"$httpValue\".");
             }
 
             $output .= $char;
         }
 
-        throw new SyntaxError("Invalid end of string in the HTTP textual representation of a string `$httpValue`.");
+        throw new SyntaxError("Invalid end of string in the HTTP textual representation of a string \"$httpValue\".");
     }
 
     /**
@@ -347,7 +347,7 @@ private static function parseToken(string $httpValue): array
     private static function parseByteSequence(string $httpValue): array
     {
         if (1 !== preg_match('/^(?<sequence>:(?<byte>[a-z\d+\/=]*):)/i', $httpValue, $matches)) {
-            throw new SyntaxError("Invalid characters in the HTTP textual representation of a Byte Sequence `$httpValue`.");
+            throw new SyntaxError("Invalid characters in the HTTP textual representation of a Byte Sequence \"$httpValue\".");
         }
 
         return [ByteSequence::fromEncoded($matches['byte']), strlen($matches['sequence'])];

Original file line number	Diff line number	Diff line change
`@@ -267,7 +267,7 @@ private static function filterForbiddenState(InnerList\|Item $member): InnerList\|`
`267`	`267`	`{`
`268`	`268`	`foreach ($member->parameters as $offset => $item) {`
`269`	`269`	`if ($item->parameters->hasMembers()) {`
`270`		- throw new ForbiddenStateError('Parameter member `"'.$offset.'"` is in invalid state; Parameters instances can only contain bare items.');
	`270`	`+ throw new ForbiddenStateError('Parameter member "'.$offset.'" is in invalid state; Parameters instances can only contain bare items.');`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ private static function filterForbiddenState(Item $member): Item`
`59`	`59`	`{`
`60`	`60`	`foreach ($member->parameters as $offset => $item) {`
`61`	`61`	`if ($item->parameters->hasMembers()) {`
`62`		- throw new ForbiddenStateError('Parameter member `"'.$offset.'"` is in invalid state; Parameters instances can only contain bare items.');
	`62`	`+ throw new ForbiddenStateError('Parameter member "'.$offset.'" is in invalid state; Parameters instances can only contain bare items.');`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
Original file line number	Diff line number	Diff line change
`@@ -16,18 +16,18 @@ private function __construct(string $message)`
`16`	`16`	`public static function dueToIndexNotFound(string\|int $index): self`
`17`	`17`	`{`
`18`	`18`	`if (is_string($index)) {`
`19`		- return new self('The member index can not be the string `'.$index.'`.');
	`19`	`+ return new self('The member index can not be the string "'.$index.'".');`
`20`	`20`	`}`
`21`	`21`
`22`		- return new self('No member exists with the index `'.$index.'`.');
	`22`	`+ return new self('No member exists with the index "'.$index.'".');`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public static function dueToKeyNotFound(string\|int $key): self`
`26`	`26`	`{`
`27`	`27`	`if (is_int($key)) {`
`28`		- return new self('The member key can not be the integer`'.$key.'`.');
	`28`	`+ return new self('The member key can not be the integer "'.$key.'".');`
`29`	`29`	`}`
`30`	`30`
`31`		- return new self('No member exists with the key `'.$key.'`.');
	`31`	`+ return new self('No member exists with the key "'.$key.'".');`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ private static function filterDecimal(float $value): float`
`117`	`117`	`private static function filterString(string $value): string`
`118`	`118`	`{`
`119`	`119`	`if (1 === preg_match('/[^\x20-\x7E]/i', $value)) {`
`120`		- throw new SyntaxError('The string `'.$value.'` contains invalid characters.');
	`120`	`+ throw new SyntaxError('The string "'.$value.'" contains invalid characters.');`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`return $value;`
`@@ -149,13 +149,13 @@ public static function fromHttpValue(string $httpValue): self`
`149`	`149`
`150`	`150`	`[$value, $parameters] = match (true) {`
`151`	`151`	`1 === preg_match("/[\r\t\n]\|[^\x20-\x7E]/", $itemString),`
`152`		- '' === $itemString => throw new SyntaxError("The HTTP textual representation `$httpValue` for an item contains invalid characters."),
	`152`	`+ '' === $itemString => throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for an item contains invalid characters.'),`
`153`	`153`	`'"' === $itemString[0] => self::parseString($itemString),`
`154`	`154`	`':' === $itemString[0] => self::parseBytesSequence($itemString),`
`155`	`155`	`'?' === $itemString[0] => self::parseBoolean($itemString),`
`156`	`156`	`1 === preg_match('/^(-?\d)/', $itemString) => self::parseNumber($itemString),`
`157`	`157`	`1 === preg_match('/^([a-z*])/i', $itemString) => self::parseToken($itemString),`
`158`		- default => throw new SyntaxError("The HTTP textual representation `$httpValue` for an item is unknown or unsupported."),
	`158`	`+ default => throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for an item is unknown or unsupported.'),`
`159`	`159`	`};`
`160`	`160`
`161`	`161`	`return new self($value, Parameters::fromHttpValue($parameters));`
`@@ -174,7 +174,7 @@ private static function parseToken(string $string): array`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`if (1 !== preg_match('/'.$regexp.'/i', $string, $found)) {`
`177`		- throw new SyntaxError("The HTTP textual representation `$string` for a Token contains invalid characters.");
	`177`	`+ throw new SyntaxError("The HTTP textual representation \"$string\" for a Token contains invalid characters.");`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`return [`
`@@ -191,7 +191,7 @@ private static function parseToken(string $string): array`
`191`	`191`	`private static function parseBoolean(string $string): array`
`192`	`192`	`{`
`193`	`193`	`if (1 !== preg_match('/^\?[01]/', $string)) {`
`194`		- throw new SyntaxError("The HTTP textual representation `$string` for a boolean contains invalid characters.");
	`194`	`+ throw new SyntaxError("The HTTP textual representation \"$string\" for a boolean contains invalid characters.");`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`return [$string[1] === '1', substr($string, 2)];`
`@@ -205,7 +205,7 @@ private static function parseBoolean(string $string): array`
`205`	`205`	`private static function parseBytesSequence(string $string): array`
`206`	`206`	`{`
`207`	`207`	`if (1 !== preg_match('/^:(?<bytes>[a-z\d+\/=]*):/i', $string, $matches)) {`
`208`		- throw new SyntaxError("The HTTP textual representation `$string` for a byte sequence contains invalid characters.");
	`208`	`+ throw new SyntaxError("The HTTP textual representation \"$string\" for a byte sequence contains invalid characters.");`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`return [ByteSequence::fromEncoded($matches['bytes']), substr($string, strlen($matches[0]))];`
`@@ -224,13 +224,13 @@ private static function parseNumber(string $string): array`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`if (1 !== preg_match('/'.$regexp.'/', $string, $found)) {`
`227`		- throw new SyntaxError("The HTTP textual representation `$string` for a number contains invalid characters.");
	`227`	`+ throw new SyntaxError("The HTTP textual representation \"$string\" for a number contains invalid characters.");`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`$number = match (true) {`
`231`	`231`	`1 === preg_match('/^-?\d{1,12}\.\d{1,3}$/', $found['number']) => (float) $found['number'],`
`232`	`232`	`1 === preg_match('/^-?\d{1,15}$/', $found['number']) => (int) $found['number'],`
`233`		- default => throw new SyntaxError("The HTTP textual representation `$string` for a number contain too many digits."),
	`233`	`+ default => throw new SyntaxError("The HTTP textual representation \"$string\" for a number contain too many digits."),`
`234`	`234`	`};`
`235`	`235`
`236`	`236`	`return [$number, substr($string, strlen($found['number']))];`
`@@ -261,19 +261,19 @@ private static function parseString(string $string): array`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`if ($string === '') {`
`264`		- throw new SyntaxError("The HTTP textual representation `$originalString` for a string contains an invalid end string.");
	`264`	`+ throw new SyntaxError("The HTTP textual representation \"$originalString\" for a string contains an invalid end string.");`
`265`	`265`	`}`
`266`	`266`
`267`	`267`	`$char = $string[0];`
`268`	`268`	`$string = substr($string, 1);`
`269`	`269`	`if (!in_array($char, ['"', '\\'], true)) {`
`270`		- throw new SyntaxError("The HTTP textual representation `$originalString` for a string contains invalid characters.");
	`270`	`+ throw new SyntaxError("The HTTP textual representation \"$originalString\" for a string contains invalid characters.");`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`$returnValue .= $char;`
`274`	`274`	`}`
`275`	`275`
`276`		- throw new SyntaxError("The HTTP textual representation `$originalString` for a string contains an invalid end string.");
	`276`	`+ throw new SyntaxError("The HTTP textual representation \"$originalString\" for a string contains an invalid end string.");`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public static function fromString(string $httpValue): self`
`22`	`22`	`{`
`23`	`23`	`$instance = self::fromStringBeginning($httpValue);`
`24`	`24`	`if ($instance->value !== $httpValue) {`
`25`		- throw new SyntaxError("No valid http value key could be extracted from `$httpValue`.");
	`25`	`+ throw new SyntaxError("No valid http value key could be extracted from \"$httpValue\".");`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`return $instance;`
`@@ -34,7 +34,7 @@ public static function fromString(string $httpValue): self`
`34`	`34`	`public static function fromStringBeginning(string $httpValue): self`
`35`	`35`	`{`
`36`	`36`	`if (1 !== preg_match('/^(?<key>[a-z][a-z\d._-]*)/', $httpValue, $found)) {`
`37`		- throw new SyntaxError("No valid http value key could be extracted from `$httpValue`.");
	`37`	`+ throw new SyntaxError("No valid http value key could be extracted from \"$httpValue\".");`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`return new self($found['key']);`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ private static function filterForbiddenState(InnerList\|Item $member): InnerList\|`
`63`	`63`	`{`
`64`	`64`	`foreach ($member->parameters as $offset => $item) {`
`65`	`65`	`if ($item->parameters->hasMembers()) {`
`66`		- throw new ForbiddenStateError('Parameter member `"'.$offset.'"` is in invalid state; Parameters instances can only contain bare items.');
	`66`	`+ throw new ForbiddenStateError('Parameter member "'.$offset.'" is in invalid state; Parameters instances can only contain bare items.');`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
Original file line number	Diff line number	Diff line change
`@@ -86,13 +86,13 @@ public static function parseInnerList(string $httpValue): array`
`86`	`86`	`{`
`87`	`87`	`$remainder = ltrim($httpValue, ' ');`
`88`	`88`	`if ('(' !== $remainder[0]) {`
`89`		- throw new SyntaxError("The HTTP textual representation `$httpValue` for a inner list is missing a parenthesis.");
	`89`	`+ throw new SyntaxError("The HTTP textual representation \"$httpValue\" for a inner list is missing a parenthesis.");`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`[$list, $offset] = self::parseInnerListValue($remainder);`
`93`	`93`	`$remainder = self::removeOptionalWhiteSpaces(substr($remainder, $offset));`
`94`	`94`	`if ('' !== $remainder) {`
`95`		- throw new SyntaxError("The HTTP textual representation `$httpValue` for a inner list contains invalid data.");
	`95`	`+ throw new SyntaxError("The HTTP textual representation \"$httpValue\" for a inner list contains invalid data.");`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`return $list;`
`@@ -190,11 +190,11 @@ private static function parseInnerListValue(string $httpValue): array`
`190`	`190`
`191`	`191`	`$list[] = Item::from($value, $parameters);`
`192`	`192`	`if ('' !== $remainder && !in_array($remainder[0], [' ', ')'], true)) {`
`193`		- throw new SyntaxError("The HTTP textual representation `$remainder` for a inner list is using invalid characters.");
	`193`	`+ throw new SyntaxError("The HTTP textual representation \"$remainder\" for a inner list is using invalid characters.");`
`194`	`194`	`}`
`195`	`195`	`}`
`196`	`196`
`197`		- throw new SyntaxError("Unexpected end of line for The HTTP textual representation `$remainder` for a inner list.");
	`197`	`+ throw new SyntaxError("Unexpected end of line for The HTTP textual representation \"$remainder\" for a inner list.");`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`/**`
`@@ -255,7 +255,7 @@ private static function parseParameters(string $httpValue): array`
`255`	`255`	`private static function parseBoolean(string $httpValue): array`
`256`	`256`	`{`
`257`	`257`	`if (1 !== preg_match('/^\?[01]/', $httpValue)) {`
`258`		- throw new SyntaxError("Invalid character in the HTTP textual representation of a boolean value `$httpValue`.");
	`258`	`+ throw new SyntaxError("Invalid character in the HTTP textual representation of a boolean value \"$httpValue\".");`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`return ['1' === $httpValue[1], 2];`
`@@ -275,7 +275,7 @@ private static function parseNumber(string $httpValue): array`
`275`	`275`	`return match (true) {`
`276`	`276`	`1 === preg_match('/^-?\d{1,12}\.\d{1,3}$/', $found['number']) => [(float) $found['number'], strlen($found['number'])],`
`277`	`277`	`1 === preg_match('/^-?\d{1,15}$/', $found['number']) => [(int) $found['number'], strlen($found['number'])],`
`278`		- default => throw new SyntaxError("The number format in the HTTP textual representation `$httpValue` contains too much digit."),
	`278`	`+ default => throw new SyntaxError("The number format in the HTTP textual representation \"$httpValue\" contains too much digit."),`
`279`	`279`	`};`
`280`	`280`	`}`
`281`	`281`
`@@ -301,7 +301,7 @@ private static function parseString(string $httpValue): array`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`if (1 === preg_match("/[^\x20-\x7E]/", $char)) {`
`304`		- throw new SyntaxError("Invalid character in the HTTP textual representation of a string `$httpValue`.");
	`304`	`+ throw new SyntaxError("Invalid character in the HTTP textual representation of a string \"$httpValue\".");`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`$httpValue = substr($httpValue, 1);`
`@@ -314,13 +314,13 @@ private static function parseString(string $httpValue): array`
`314`	`314`	`$offset += 1;`
`315`	`315`	`$httpValue = substr($httpValue, 1);`
`316`	`316`	`if (!in_array($char, ['"', '\\'], true)) {`
`317`		- throw new SyntaxError("Invalid characters in the HTTP textual representation of a string `$httpValue`.");
	`317`	`+ throw new SyntaxError("Invalid characters in the HTTP textual representation of a string \"$httpValue\".");`
`318`	`318`	`}`
`319`	`319`
`320`	`320`	`$output .= $char;`
`321`	`321`	`}`
`322`	`322`
`323`		- throw new SyntaxError("Invalid end of string in the HTTP textual representation of a string `$httpValue`.");
	`323`	`+ throw new SyntaxError("Invalid end of string in the HTTP textual representation of a string \"$httpValue\".");`
`324`	`324`	`}`
`325`	`325`
`326`	`326`	`/**`
`@@ -347,7 +347,7 @@ private static function parseToken(string $httpValue): array`
`347`	`347`	`private static function parseByteSequence(string $httpValue): array`
`348`	`348`	`{`
`349`	`349`	`if (1 !== preg_match('/^(?<sequence>:(?<byte>[a-z\d+\/=]*):)/i', $httpValue, $matches)) {`
`350`		- throw new SyntaxError("Invalid characters in the HTTP textual representation of a Byte Sequence `$httpValue`.");
	`350`	`+ throw new SyntaxError("Invalid characters in the HTTP textual representation of a Byte Sequence \"$httpValue\".");`
`351`	`351`	`}`
`352`	`352`
`353`	`353`	`return [ByteSequence::fromEncoded($matches['byte']), strlen($matches['sequence'])];`