/** * Casts given value from a PHP type to one acceptable by database * * @param mixed $value value to be converted to database equivalent * @return mixed */ public function toDatabase($value) { if ($value === null || $value === '') { return null; } return parent::toDatabase($value); }
public function testFromStringWithStringArrayArray() { $arrayType = MixedType::fromString("string[][]"); $this->assertInstanceOf("Skrz\\Meta\\Reflection\\ArrayType", $arrayType); $this->assertInstanceOf("Skrz\\Meta\\Reflection\\ArrayType", $arrayType->getBaseType()); /** @var ArrayType $baseType */ $baseType = $arrayType->getBaseType(); $this->assertSame(StringType::getInstance(), $baseType->getBaseType()); $this->assertSame($arrayType, MixedType::fromString("string[][]")); }
/** * @param Node $node * A node to check types on * * @return UnionType * The resulting type(s) of the binary operation */ public function visitBinaryConcat(Node $node) : UnionType { return StringType::instance()->asUnionType(); }
/** * @dataProvider providerForNotString */ public function testNotString($input) { $rule = new StringType(); $this->assertFalse($rule->validate($input)); }
/** * Checks if a number is in a range * * @param integer $num number to check for * @param integer $lower lower bound * @param integer $upper upper bound * * @return boolean whether the number is in the range or not */ public function numberInRangeInclusive($num, $lower, $upper) { return $this->_type->numberInRangeInclusive($num, $lower, $upper); }
/** * Visit a node with kind `\ast\AST_CLASS_CONST` * * @param Node $node * A node of the type indicated by the method name that we'd * like to figure out the type that it produces. * * @return UnionType * The set of types that are possibly produced by the * given node */ public function visitClassConst(Node $node) : UnionType { $constant_name = $node->children['const']; if ($constant_name == 'class') { return StringType::instance()->asUnionType(); // class name fetch } try { $defining_clazz = AST::classFromNodeInContext($node, $this->context, $this->code_base, false); } catch (CodeBaseException $exception) { $class_name = $node->children['class']->children['name'] ?? ''; Log::err(Log::EUNDEF, "Can't access constant {$constant_name} from undeclared class {$class_name}", $this->context->getFile(), $node->lineno); return new UnionType(); } catch (NodeException $exception) { $class_name = $node->children['class']->children['name'] ?? ''; Log::err(Log::EUNDEF, "Can't access constant {$constant_name} from undeclared class {$class_name}", $this->context->getFile(), $node->lineno); // If we can't figure out what kind of a call // this is, don't worry about it return new UnionType(); } if (!$defining_clazz->hasConstantWithName($this->code_base, $constant_name)) { Log::err(Log::EUNDEF, "Can't access undeclared constant {$defining_clazz->getName()}::{$constant_name}", $this->context->getFile(), $node->lineno); return new UnionType(); } return $defining_clazz->getConstantWithName($this->code_base, $constant_name)->getUnionType(); }
public function highlightCode($cppCodeString, $title = "") { $braceTracer = new BraceTrace(); $cppCode = new CppCode($cppCodeString, $title); if ($this->buildLines) { $cppCode->lines = array(); } if ($this->buildFormattedLines) { $cppCode->formattedLines = array(); } // Following variables are declared in settings.php file global $fontSizeInPt; global $MAXIMUM_CHARS_PER_LINE; global $cppKeywords; //refers to C++ standard keywordr global $nokiaQtClasses; //refers to Nokia Qt classes global $gtkPlusClasses; //refers to GTK+ classes global $wxWidgetsClasses; //refers to wxWidgets classes global $braceTraceStart; global $braceTraceEnd; global $ignoreMaxCharsForStrings; $showLineNumber = $this->showLineNumber; $supportNokiaQtClasses = $this->supportNokiaQtClasses; $supportGtkPlusClasses = $this->supportGtkPlusClasses; $supportWxWidgetsClasses = $this->supportWxWidgetsClasses; $supportBraceTrace = $this->supportBraceTrace; $in_char_block = false; //identifies if current character is inside single quote block $in_comment_block = false; //identifies if current character is inside /**/ block $in_single_line_comment = false; //identifies if current character is inside // block $in_string_block = false; //identifies if current character is inside double quote block $output = "<pre class='Code'>"; //initialize output if ($cppCode->title != "") { $output .= "<center><table class='Title'><tr><td align=center>{$cppCode->title}</td></tr></table></center>"; } $output .= "<table><tr><td><table border=0>"; $lines = explode("\n", $cppCodeString); //break cppCodeString by lines $currLine = 1; foreach ($lines as &$thisLine) { //you may use buildLines to not push $thisLine to $cppCode->lines in order to save memory if you like if ($this->buildLines) { array_push($cppCode->lines, $thisLine); } $spaceAdded = false; $currFormattedLine = "<tr id='" . substr(md5($title), 0, 4) . "-line{$currLine}-c'>"; if ($showLineNumber) { $currFormattedLine .= "<td class='Line-TD' align='right'><span class='Line'><font size={$fontSizeInPt}><a name='" . substr(md5($title), 0, 4) . "-line{$currLine}'>" . $currLine . "</a></font></span></td>"; //Add an extra space for better code reading $currFormattedLine .= "<td> </td>"; } $currFormattedLine .= "<td align='left'><font size={$fontSizeInPt}>"; if (!$showLineNumber) { $currFormattedLine .= "<a name='" . substr(md5($title), 0, 4) . "-line{$currLine}'>"; } if (trim($thisLine) == "") { $currFormattedLine .= " "; } if ($in_comment_block) { $currFormattedLine .= "<span class='Comment'>"; } $i = 0; $n = 0; $nCol = 0; for ($i = 0; $i < strlen($thisLine); $i++) { if ($nCol > $MAXIMUM_CHARS_PER_LINE) { if (($in_string_block || $in_char_block) && $ignoreMaxCharsForStrings) { //we are in string block and ignoring condition because of ignoreMaxCharsForStrings flag } else { //break line if maximum characters reached $currFormattedLine .= '<br/>'; $nCol = 0; } } //checks each character in line and transform every character accordingly switch ($thisLine[$i]) { case ' ': $currFormattedLine .= " "; //converts each <space> with $nCol++; //next column break; case '<': $currFormattedLine .= "<"; //converts < to < $nCol++; //next column break; case '>': $currFormattedLine .= ">"; //converts > to > $nCol++; //next column break; case '&': $currFormattedLine .= "&"; //converts & to & $nCol++; //next column break; case '\\t': $n = 4; //converts \t to 4 $nCol += $n; //4 columns added for (; $n > 0; $n--) { $currFormattedLine .= " "; } break; case '\\': if ($i > 0 && $thisLine[$i - 1] == '\\') { $thisLine[$i] = " "; } $currFormattedLine .= "\\"; $nCol++; break; case '/': /*this is complex case. we have mulitple conditions. 1. /* 2. // 3. "something/with/slash/in/quotes" 4. '/' */ if (!$in_comment_block && !$in_string_block && !$in_single_line_comment && !$in_char_block) { //if none of above condition is not true then check next character, if it is "/" then it is single line comment if ($thisLine[$i + 1] == '/') { $in_single_line_comment = true; $currFormattedLine .= "<span class='Comment'>"; } else { if ($thisLine[$i + 1] == '*') { $currFormattedLine .= "<span class='Comment'>"; $in_comment_block = true; } } } else { if ($in_comment_block) { //if it was in comment block i.e, /* then ignore everything until we found * if ($i > 0 && $thisLine[$i - 1] == '*') { //close comment block because we are in / switch case $currFormattedLine .= "/</span>"; $nCol++; $in_comment_block = false; break; } } } //add / to output $currFormattedLine .= "/"; //next column $nCol++; break; case '\'': if (!$in_string_block && !$in_comment_block && !$in_single_line_comment) { //if above flags are not set then check to see if previous character was \ if yes then simply add single quote to output //example: 'test comment \' and this ' //in above example \' has to be inside quotes and should not break highlighting if ($i > 0 && $thisLine[$i - 1] == '\\') { $currFormattedLine .= "'"; } else { //reverse it, because it means end the quote $in_char_block = !$in_char_block; //if now character block has started add "span" for string if ($in_char_block) { $currFormattedLine .= "<span class='String'>'"; //notice ' that means add ' inside span } else { //otherwise end span, notice ' just before </span> $currFormattedLine .= "'</span>"; } } } else { //if it's in string block " or comment block /* or single line comment // then simply add single quote $currFormattedLine .= "'"; } $nCol++; //next column break; case "\"": if (!$in_char_block && !$in_comment_block && !$in_single_line_comment) { //if its not in character block ' not in comment block /* or not in single line comment // //then do the same thing as above, check the previous character. //example, "test\"this" //in above example, it will print "test\"this" as is if ($i > 0 && $thisLine[$i - 1] == '\\') { $currFormattedLine .= """; } else { //reverse the flag $in_string_block = !$in_string_block; if ($in_string_block) { //if after reverse, its in its in string block, then add <span> $currFormattedLine .= "<span class='String'>""; } else { //otherwise end the span $currFormattedLine .= ""</span>"; } } } else { $currFormattedLine .= """; //if its in char block or comment block or single line block then simply add quote } $nCol++; break; default: //for all other cases there are posibilities: //next chracter is digit //next chracter or letter is special class //next character or letter is special keywords (C++ keyword) if (!$in_char_block && !$in_comment_block && !$in_single_line_comment && !$in_string_block) { if ($supportBraceTrace) { if (in_array($thisLine[$i], $braceTraceStart)) { $nCol++; $currFormattedLine .= $braceTracer->getStartMarkup(substr(md5($title), 0, 4), $currLine, $nCol, $thisLine[$i]); break; } if (in_array($thisLine[$i], $braceTraceEnd)) { $nCol++; $currFormattedLine .= $braceTracer->getEndMarkup($thisLine[$i]); break; } } if (StringType::isdigit($thisLine[$i])) { //if it's digit $word_arr = array(); for ($j = 0; StringType::isalnum($thisLine[$i + $j]) || $thisLine[$i + $j] == '.'; $j++) { $word_arr[$j] = $thisLine[$i + $j]; } $i += $j - 1; $nCol += $j; $wd = implode("", $word_arr); $currFormattedLine .= "<span class='Number'>{$wd}</span>"; break; } if (StringType::isalpha($thisLine[$i]) || $thisLine[$i] == '#' || $thisLine[$i] == '_') { $word_arr = array(); for ($j = 0; StringType::isalnum($thisLine[$i + $j]) || $thisLine[$i + $j] == '#' || $thisLine[$i + $j] == '_'; $j++) { $word_arr[$j] = $thisLine[$i + $j]; } $i += $j - 1; $nCol += $j; $wd = implode("", $word_arr); //if word is one of $keywords array if (in_array($wd, $cppKeywords)) { $currFormattedLine .= "<span class='Keyword'>" . htmlentities($wd) . "</span>"; } else { //if word is one of $nokiaQtClasses array if (in_array($wd, $nokiaQtClasses)) { if ($supportNokiaQtClasses) { $currFormattedLine .= "<span class='SpecialClass'><a href='" . getNokiaQtClassUrl($wd) . "' class='SpecialClass'>" . htmlentities($wd) . "</a></span>"; } else { $currFormattedLine .= htmlentities("{$wd}"); } } else { if (in_array($wd, $gtkPlusClasses)) { if ($supportGtkPlusClasses) { $currFormattedLine .= "<span class='SpecialClass'><a href='" . getGtkPlusClassUrl($wd) . "' class='SpecialClass'>" . htmlentities($wd) . "</a></span>"; } else { $currFormattedLine .= htmlentities("{$wd}"); } } else { if (in_array($wd, $wxWidgetsClasses)) { if ($supportWxWidgetsClasses) { $currFormattedLine .= "<span class='SpecialClass'><a href='" . getWxWidgetsClassUrl($wd) . "' class='SpecialClass'>" . htmlentities($wd) . "</a></span>"; } else { $currFormattedLine .= htmlentities("{$wd}"); } } else { $currFormattedLine .= htmlentities("{$wd}"); } } } } break; } } $currFormattedLine .= htmlentities($thisLine[$i]); $nCol++; break; } } if ($in_single_line_comment) { //if single line comment and because this is end of line, so end single line comment and end flag $currFormattedLine .= "</span>"; $in_single_line_comment = false; } if ($this->buildFormattedLines) { //push current formatted line ($currFormattedLine) to formattedLines array //but note: this is what's used later in getLines($start,$end) function. array_push($cppCode->formattedLines, $currFormattedLine); } if (!$showLineNumber) { $currFormattedLine .= "</a>"; } $currFormattedLine .= "</font>"; $output .= $currFormattedLine; $currLine++; //next line } if ($in_char_block || $in_string_block) { //if it is in char block or string block then end this before string/char block after parsing finished $currFormattedLine .= "</span>"; if ($this->buildFormattedLines) { //append ending </span> to current line in formattedLines array $cppCode->formattedLines[$currLines - 1] = $cppCode->formattedLines[$currLines - 1] . $currFormattedLine; } $output .= $currFormattedLine; } if ($in_comment_block) { //if it is in comment block end this block after parsing finished $currFormattedLine .= "</span>"; if ($this->buildFormattedLines) { //append ending </span> to current line in formattedLines array $cppCode->formattedLines[$currLines - 1] = $cppCode->formattedLines[$currLines - 1] . $currFormattedLine; } $output .= $currFormattedLine; } $output .= "</font></td></tr></table></td></tr></table></pre>"; //final output $cppCode->formattedCode = $output; return $cppCode; }
/** * Visit a node with kind `\ast\AST_METHOD` * * @param Node $node * A node to parse * * @return Context * A new or an unchanged context resulting from * parsing the node */ public function visitMethod(Node $node) : Context { // Bomb out if we're not in a class context $clazz = $this->getContextClass(); $method_name = $node->name; $method_fqsen = FullyQualifiedMethodName::fromStringInContext($method_name, $this->context); // Hunt for an available alternate ID if necessary $alternate_id = 0; while ($this->code_base->hasMethod($method_fqsen)) { $method_fqsen = $method_fqsen->withAlternateId(++$alternate_id); } $method = Method::fromNode(clone $this->context, $this->code_base, $node); // Override the FQSEN with the found alternate ID $method->setFQSEN($method_fqsen); $clazz->addMethod($this->code_base, $method); if ('__construct' === $method_name) { $clazz->setIsParentConstructorCalled(false); } else { if ('__invoke' === $method_name) { $clazz->getUnionType()->addType(CallableType::instance()); } else { if ('__toString' === $method_name) { $clazz->getUnionType()->addType(StringType::instance()); } } } // Send the context into the method $context = $this->context->withMethodFQSEN($method->getFQSEN()); // Add each method parameter to the scope. We clone it // so that changes to the variable don't alter the // parameter definition foreach ($method->getParameterList() as $parameter) { $context->addScopeVariable(clone $parameter); } return $context; }
/** * Check to see if the given Clazz is a duplicate * * @param Method $method * The method we're analyzing arguments for * * @param Node $node * The node holding the method call we're looking at * * @param Context $context * The context in which we see the call * * @param CodeBase $code_base * * @return null * * @see \Phan\Deprecated\Pass2::arg_check * Formerly `function arg_check` */ private static function analyzeInternalArgumentType(Method $method, Node $node, Context $context, CodeBase $code_base) { $arglist = $node->children['args']; $argcount = count($arglist->children); switch ($method->getName()) { case 'join': case 'implode': // (string glue, array pieces), // (array pieces, string glue) or // (array pieces) if ($argcount == 1) { self::analyzeNodeUnionTypeCast($arglist->children[0], $context, $code_base, ArrayType::instance()->asUnionType(), "arg#1(pieces) is %s but {$method->getFQSEN()}() takes array when passed only 1 arg"); return; } else { if ($argcount == 2) { $arg1_type = UnionType::fromNode($context, $code_base, $arglist->children[0]); $arg2_type = UnionType::fromNode($context, $code_base, $arglist->children[1]); if ((string) $arg1_type == 'array') { if (!$arg1_type->canCastToUnionType(StringType::instance()->asUnionType())) { Log::err(Log::EPARAM, "arg#2(glue) is {$arg2_type} but {$method->getFQSEN()}() takes string when arg#1 is array", $context->getFile(), $context->getLineNumberStart()); } } else { if ((string) $arg1_type == 'string') { if (!$arg2_type->canCastToUnionType(ArrayType::instance()->asUnionType())) { Log::err(Log::EPARAM, "arg#2(pieces) is {$arg2_type} but {$method->getFQSEN()}() takes array when arg#1 is string", $context->getFile(), $context->getLineNumberStart()); } } } return; } } // Any other arg counts we will let the regular // checks handle break; case 'array_udiff': case 'array_diff_uassoc': case 'array_uintersect_assoc': case 'array_intersect_ukey': if ($argcount < 3) { Log::err(Log::EPARAM, "call with {$argcount} arg(s) to {$method->getFQSEN()}() which requires {$method->getNumberOfRequiredParameters()} arg(s)", $context->getFile(), $context->getLineNumberStart()); return; } self::analyzeNodeUnionTypeCast($arglist->children[$argcount - 1], $context, $code_base, CallableType::instance()->asUnionType(), "The last argument to {$method->getFQSEN()} must be a callable"); for ($i = 0; $i < $argcount - 1; $i++) { self::analyzeNodeUnionTypeCast($arglist->children[$i], $context, $code_base, CallableType::instance()->asUnionType(), "arg#" . ($i + 1) . " is %s but {$method->getFQSEN()}() takes array"); } return; case 'array_diff_uassoc': case 'array_uintersect_uassoc': if ($argcount < 4) { Log::err(Log::EPARAM, "call with {$argcount} arg(s) to {$method->getFQSEN()}() which requires {$method->getNumberOfRequiredParameters()} arg(s)", $context->getFile(), $context->getLineNumberStart()); return; } // The last 2 arguments must be a callable and there // can be a variable number of arrays before it self::analyzeNodeUnionTypeCast($arglist->children[$argcount - 1], $context, $code_base, CallableType::instance()->asUnionType(), "The last argument to {$method->getFQSEN()} must be a callable"); self::analyzeNodeUnionTypeCast($arglist->children[$argcount - 2], $context, $code_base, CallableType::instance()->asUnionType(), "The second last argument to {$method->getFQSEN()} must be a callable"); for ($i = 0; $i < $argcount - 2; $i++) { self::analyzeNodeUnionTypeCast($arglist->children[$i], $context, $code_base, ArrayType::instance()->asUnionType(), "arg#" . ($i + 1) . " is %s but {$method->getFQSEN()}() takes array"); } return; case 'strtok': // (string str, string token) or (string token) if ($argcount == 1) { // If we have just one arg it must be a string token self::analyzeNodeUnionTypeCast($arglist->children[0], $context, $code_base, ArrayType::instance()->asUnionType(), "arg#1(token) is %s but {$method->getFQSEN()}() takes string when passed only one arg"); } // The arginfo check will handle the other case break; case 'min': case 'max': if ($argcount == 1) { // If we have just one arg it must be an array if (!self::analyzeNodeUnionTypeCast($arglist->children[0], $context, $code_base, ArrayType::instance()->asUnionType(), "arg#1(values) is %s but {$method->getFQSEN()}() takes array when passed only one arg")) { return; } } // The arginfo check will handle the other case break; default: break; } }
/** * 与えられた値を、指定された型に変換して返します。 * @link https://heycam.github.io/webidl/#idl-types Web IDL (Second Edition) * @link https://www.w3.org/TR/WebIDL/#idl-types Web IDL * @param string $type * @param mixed $value * @param array $pseudoTypes callback interface 型、列挙型、callback 関数型、または dictionary 型の識別子をキーとした型情報の配列。 * @return mixed */ public static function to($type, $value, $pseudoTypes = null) { switch ($type) { case 'any': $returnValue = $value; break; case 'boolean': $returnValue = BooleanType::toBoolean($value); break; case '[EnforceRange] byte': $returnValue = IntegerType::toByte($value, '[EnforceRange]'); break; case '[Clamp] byte': $returnValue = IntegerType::toByte($value, '[Clamp]'); break; case 'byte': $returnValue = IntegerType::toByte($value); break; case '[EnforceRange] octet': $returnValue = IntegerType::toOctet($value, '[EnforceRange]'); break; case '[Clamp] octet': $returnValue = IntegerType::toOctet($value, '[Clamp]'); break; case 'octet': $returnValue = IntegerType::toOctet($value); break; case '[EnforceRange] short': $returnValue = IntegerType::toShort($value, '[EnforceRange]'); break; case '[Clamp] short': $returnValue = IntegerType::toShort($value, '[Clamp]'); break; case 'short': $returnValue = IntegerType::toShort($value); break; case '[EnforceRange] unsigned short': $returnValue = IntegerType::toUnsignedShort($value, '[EnforceRange]'); break; case '[Clamp] unsigned short': $returnValue = IntegerType::toUnsignedShort($value, '[Clamp]'); break; case 'unsigned short': $returnValue = IntegerType::toUnsignedShort($value); break; case '[EnforceRange] long': $returnValue = IntegerType::toLong($value, '[EnforceRange]'); break; case '[Clamp] long': $returnValue = IntegerType::toLong($value, '[Clamp]'); break; case 'long': $returnValue = IntegerType::toLong($value); break; case '[EnforceRange] unsigned long': $returnValue = IntegerType::toUnsignedLong($value, '[EnforceRange]'); break; case '[Clamp] unsigned long': $returnValue = IntegerType::toUnsignedLong($value, '[Clamp]'); break; case 'unsigned long': $returnValue = IntegerType::toUnsignedLong($value); break; case '[EnforceRange] long long': $returnValue = IntegerType::toLongLong($value, '[EnforceRange]'); break; case '[Clamp] long long': $returnValue = IntegerType::toLongLong($value, '[Clamp]'); break; case 'long long': $returnValue = IntegerType::toLongLong($value); break; case '[EnforceRange] unsigned long long': $returnValue = IntegerType::toUnsignedLongLong($value, '[EnforceRange]'); break; case '[Clamp] unsigned long long': $returnValue = IntegerType::toUnsignedLongLong($value, '[Clamp]'); break; case 'unsigned long long': $returnValue = IntegerType::toUnsignedLongLong($value); break; case 'float': $returnValue = FloatType::toFloat($value); break; case 'unrestricted float': $returnValue = FloatType::toUnrestrictedFloat($value); break; case 'double': $returnValue = FloatType::toDouble($value); break; case 'unrestricted double': $returnValue = FloatType::toUnrestrictedDouble($value); break; case 'DOMString': $returnValue = StringType::toDOMString($value); break; case 'ByteString': $returnValue = StringType::toByteString($value); break; case 'USVString': $returnValue = StringType::toUSVString($value); break; case 'object': $returnValue = ObjectType::toObject($value); break; case 'Date': $returnValue = ObjectType::toInterface($value, 'DateTimeInterface'); break; case 'RegExp': $returnValue = RegExpType::toRegExp($value); break; case 'Error': $returnValue = self::to('(esperecyan\\webidl\\Error or DOMException)', $value, $pseudoTypes); break; case 'DOMException': $returnValue = ObjectType::toInterface($value, 'DOMException'); break; default: $pattern = '/^(?:(?<nullable>.+)\\?|sequence<(?<sequence>.+)>|(?<array>.+)\\[]|(?<union>\\(.+\\))|FrozenArray<(?<FrozenArray>.+)>)$/u'; if (preg_match($pattern, $type, $matches) === 1) { if (!empty($matches['nullable'])) { $returnValue = NullableType::toNullable($value, $matches['nullable'], $pseudoTypes); } elseif (!empty($matches['sequence'])) { $returnValue = SequenceType::toSequence($value, $matches['sequence'], $pseudoTypes); } elseif (!empty($matches['array'])) { $returnValue = SequenceType::toArray($value, $matches['array'], $pseudoTypes); } elseif (!empty($matches['union'])) { $returnValue = UnionType::toUnion($value, $matches['union'], $pseudoTypes); } elseif (!empty($matches['FrozenArray'])) { $returnValue = SequenceType::toFrozenArray($value, $matches['FrozenArray'], $pseudoTypes); } } elseif (isset($pseudoTypes[$type])) { $pseudoType = $pseudoTypes[$type]; switch ($pseudoType) { case 'callback interface': case 'single operation callback interface': $returnValue = ObjectType::toCallbackInterface($value, $pseudoType === 'single operation callback interface'); break; case 'callback function': $returnValue = ObjectType::toCallbackFunction($value); break; default: if (is_string($pseudoType) || isset($pseudoType[0])) { $returnValue = StringType::toEnumerationValue($value, $type, $pseudoType); } else { $returnValue = DictionaryType::toDictionary($value, $type, $pseudoTypes); } } } else { $returnValue = ObjectType::toInterface($value, $type); } } return $returnValue; }
/** * @param string $value * @param string[]|string $enum * @expectedException \DomainException * @expectedExceptionMessage Expected DOMString (a UTF-8 string) and valid EnumTest value, got * @dataProvider invalidEnumerationValueProvider2 */ public function testInvalidEnumerationValue3($value, $enum) { StringType::toEnumerationValue($value, 'EnumTest', $enum); }