test(stdlib): 添加标准库函数的全面测试用例

- 添加数组搜索相关函数的测试 (in_array, array_search, array_key_exists, array_keys)
- 添加 base64 编码解码边界情况的测试
- 添加类和接口存在性检查函数的测试 (class_exists, interface_exists, trait_exists 等)
- 添加路径处理函数的边界测试 (dirname, basename)
- 添加类型检查函数的测试 (is_array, is_string, is_object 等)
- 添加数学函数的进制转换和类型检查测试
- 添加数学运算函数的测试 (exp, log, sqrt, 三角函数等)
- 添加字符串大小写转换函数的边界测试
- 添加字符串匹配检查函数的测试 (str_contains, str_starts_with, str_ends_with)
- 添加字符串比较函数的测试 (strlen, strcmp, strcasecmp 等)
- 添加字符串搜索函数的测试 (strstr, strpos, strrpos 等)
- 添加可数和可迭代类型检查的测试
- 添加类型转换函数的测试 (strval, intval, floatval, boolval)
- 添加 URL 编码解码函数的边界测试

tests/aot/stdlib/array_search.phpt

@@ -0,0 +1,58 @@
+--TEST--
+in_array / array_search / array_key_exists / array_keys
+--FILE--
+<?php
+// in_array
+var_dump(in_array(2, [1, 2, 3]));
+var_dump(in_array("a", [1, 2, 3]));
+var_dump(in_array(0, ["hello", "world"]));
+var_dump(in_array("1", [1, 2, 3], true));
+
+// array_search
+var_dump(array_search(2, [1, 2, 3]));
+var_dump(array_search("a", [1, 2, 3]));
+var_dump(array_search("1", [1, 2, 3], true));
+var_dump(array_search(2, ["a" => 1, "b" => 2, "c" => 3]));
+
+// array_key_exists
+var_dump(array_key_exists("a", ["a" => 1, "b" => 2]));
+var_dump(array_key_exists("c", ["a" => 1, "b" => 2]));
+var_dump(array_key_exists(0, [1, 2, 3]));
+var_dump(array_key_exists(3, [1, 2, 3]));
+
+// array_keys
+var_dump(array_keys(["a" => 1, "b" => 2, "c" => 3]));
+var_dump(array_keys([1, 2, 3]));
+var_dump(array_keys([]));
+?>
+--EXPECT--
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+int(1)
+bool(false)
+bool(false)
+string(1) "b"
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+array(3) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+}
+array(3) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+array(0) {
+}

tests/aot/stdlib/base64_edge.phpt

@@ -0,0 +1,36 @@
+--TEST--
+base64_encode / base64_decode edge cases
+--FILE--
+<?php
+// Empty string
+var_dump(base64_encode(""));
+var_dump(base64_decode(""));
+
+// Basic round-trip
+var_dump(base64_encode("Hello World!"));
+var_dump(base64_decode("SGVsbG8gV29ybGQh"));
+
+// Binary data
+$data = chr(0) . chr(1) . chr(255) . chr(127);
+var_dump(base64_encode($data));
+var_dump(base64_decode("AAH/fw==") === $data);
+
+// Strict mode: valid input
+var_dump(base64_decode("SGVsbG8gV29ybGQh", true));
+
+// Strict mode: invalid padding
+var_dump(base64_decode("====", true));
+
+// Non-strict mode: garbage input
+var_dump(base64_decode("!!!", false));
+?>
+--EXPECT--
+string(0) ""
+string(0) ""
+string(16) "SGVsbG8gV29ybGQh"
+string(12) "Hello World!"
+string(8) "AAH/fw=="
+bool(true)
+string(12) "Hello World!"
+bool(false)
+string(0) ""

tests/aot/stdlib/class_exists.phpt

@@ -0,0 +1,48 @@
+--TEST--
+class_exists / interface_exists / trait_exists / enum_exists / defined
+--FILE--
+<?php
+class MyClass {}
+interface MyInterface {}
+trait MyTrait {}
+enum MyEnum { case Foo; }
+
+function main() {
+    define("MY_CONST", 42);
+
+    // class_exists
+    var_dump(class_exists("MyClass"));
+    var_dump(class_exists("MyClass", false));
+    var_dump(class_exists("NonexistentClass"));
+    var_dump(class_exists("NonexistentClass", false));
+
+    // interface_exists
+    var_dump(interface_exists("MyInterface"));
+    var_dump(interface_exists("NonexistentInterface"));
+
+    // trait_exists
+    var_dump(trait_exists("MyTrait"));
+    var_dump(trait_exists("NonexistentTrait"));
+
+    // enum_exists
+    var_dump(enum_exists("MyEnum"));
+    var_dump(enum_exists("NonexistentEnum"));
+
+    // defined
+    var_dump(defined("MY_CONST"));
+    var_dump(defined("UNDEFINED_CONST"));
+}
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)

tests/aot/stdlib/dirname_basename.phpt

@@ -0,0 +1,35 @@
+--TEST--
+dirname / basename edge cases
+--FILE--
+<?php
+function main() {
+    // dirname
+    var_dump(dirname("/usr/local/bin"));
+    var_dump(dirname("/usr/local/bin", 1));
+    var_dump(dirname("/usr/local/bin", 2));
+    var_dump(dirname("/usr/local/bin", 3));
+    var_dump(dirname("/usr/"));
+    var_dump(dirname("usr"));
+    var_dump(dirname(""));
+
+    // basename
+    var_dump(basename("/usr/local/bin"));
+    var_dump(basename("/usr/local/bin", "bin"));
+    var_dump(basename("/"));
+    var_dump(basename("usr"));
+    var_dump(basename(""));
+}
+?>
+--EXPECT--
+string(10) "/usr/local"
+string(10) "/usr/local"
+string(4) "/usr"
+string(1) "/"
+string(1) "/"
+string(1) "."
+string(0) ""
+string(3) "bin"
+string(3) "bin"
+string(0) ""
+string(3) "usr"
+string(0) ""

tests/aot/stdlib/is_type_check.phpt

@@ -0,0 +1,71 @@
+--TEST--
+is_* type check functions
+--FILE--
+<?php
+// is_array
+var_dump(is_array([]));
+var_dump(is_array([1,2,3]));
+var_dump(is_array("hello"));
+var_dump(is_array(42));
+
+// is_string
+var_dump(is_string(""));
+var_dump(is_string("hello"));
+var_dump(is_string(42));
+var_dump(is_string([]));
+
+// is_object
+var_dump(is_object(new stdClass()));
+var_dump(is_object([]));
+var_dump(is_object(null));
+
+// is_numeric
+var_dump(is_numeric(42));
+var_dump(is_numeric(3.14));
+var_dump(is_numeric("42"));
+var_dump(is_numeric("3.14"));
+var_dump(is_numeric("hello"));
+var_dump(is_numeric([]));
+
+// is_scalar
+var_dump(is_scalar(42));
+var_dump(is_scalar("hello"));
+var_dump(is_scalar(3.14));
+var_dump(is_scalar(true));
+var_dump(is_scalar([]));
+var_dump(is_scalar(null));
+
+// is_resource
+$f = fopen(__FILE__, "r");
+var_dump(is_resource($f));
+fclose($f);
+var_dump(is_resource(null));
+var_dump(is_resource(42));
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(false)

tests/aot/stdlib/math_base_is.phpt

@@ -0,0 +1,47 @@
+--TEST--
+Math functions: base conversion and is_* checks
+--FILE--
+<?php
+// decbin / decoct / dechex
+var_dump(decbin(0));
+var_dump(decbin(10));
+var_dump(decoct(0));
+var_dump(decoct(10));
+var_dump(dechex(0));
+var_dump(dechex(255));
+
+// bindec / octdec / hexdec
+var_dump(bindec("1010"));
+var_dump(bindec("0"));
+var_dump(octdec("12"));
+var_dump(octdec("0"));
+var_dump(hexdec("FF"));
+var_dump(hexdec("0"));
+
+// is_finite / is_infinite / is_nan
+var_dump(is_finite(0));
+var_dump(is_finite(log(0)));
+var_dump(is_infinite(0));
+var_dump(is_infinite(log(0)));
+var_dump(is_nan(0));
+var_dump(is_nan(sqrt(-1)));
+?>
+--EXPECT--
+string(1) "0"
+string(4) "1010"
+string(1) "0"
+string(2) "12"
+string(1) "0"
+string(2) "ff"
+int(10)
+int(0)
+int(10)
+int(0)
+int(255)
+int(0)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(true)

tests/aot/stdlib/math_exp_log.phpt

@@ -0,0 +1,55 @@
+--TEST--
+Math functions: exp, log, sqrt, hypot, deg2rad, rad2deg, pi, fmod, fdiv, fpow
+--FILE--
+<?php
+// pi
+var_dump(round(pi(), 10));
+
+// exp / expm1
+var_dump(round(exp(0), 10));
+var_dump(round(exp(1), 6));
+var_dump(round(expm1(0), 10));
+
+// log / log10 / log1p
+var_dump(round(log(1), 10));
+var_dump(round(log(M_E), 10));
+var_dump(round(log10(10), 10));
+var_dump(round(log1p(0), 10));
+
+// sqrt
+var_dump(round(sqrt(4), 10));
+var_dump(round(sqrt(2), 6));
+
+// hypot
+var_dump(round(hypot(3, 4), 10));
+
+// deg2rad / rad2deg
+var_dump(round(deg2rad(180), 10));
+var_dump(round(rad2deg(M_PI), 10));
+
+// fmod
+var_dump(round(fmod(5.7, 1.3), 6));
+
+// fdiv
+var_dump(round(fdiv(5, 2), 1));
+
+// fpow
+var_dump(round(fpow(2, 8), 10));
+?>
+--EXPECT--
+float(3.1415926536)
+float(1)
+float(2.718282)
+float(0)
+float(0)
+float(1)
+float(1)
+float(0)
+float(2)
+float(1.414214)
+float(5)
+float(3.1415926536)
+float(180)
+float(0.5)
+float(2.5)
+float(256)

tests/aot/stdlib/math_trig.phpt

@@ -0,0 +1,49 @@
+--TEST--
+Math functions: sin, cos, tan, asin, acos, atan, atan2
+--FILE--
+<?php
+// sin / cos / tan
+var_dump(round(sin(0), 10));
+var_dump(round(sin(M_PI / 2), 10));
+var_dump(round(cos(0), 10));
+var_dump(round(cos(M_PI), 10));
+var_dump(round(tan(0), 10));
+var_dump(round(tan(M_PI / 4), 10));
+
+// asin / acos / atan
+var_dump(round(asin(0), 10));
+var_dump(round(acos(1), 10));
+var_dump(round(atan(0), 10));
+
+// atan2
+var_dump(round(atan2(1, 0), 10));
+var_dump(round(atan2(0, 1), 10));
+
+// Sinh, cosh, tanh
+var_dump(round(sinh(0), 10));
+var_dump(round(cosh(0), 10));
+var_dump(round(tanh(0), 10));
+
+// asinh, acosh, atanh
+var_dump(round(asinh(0), 10));
+var_dump(round(acosh(1), 10));
+var_dump(round(atanh(0), 10));
+?>
+--EXPECT--
+float(0)
+float(1)
+float(1)
+float(-1)
+float(0)
+float(1)
+float(0)
+float(0)
+float(0)
+float(1.5707963268)
+float(0)
+float(0)
+float(1)
+float(0)
+float(0)
+float(0)
+float(0)

tests/aot/stdlib/misc_stdlib.phpt

@@ -0,0 +1,62 @@
+--TEST--
+crc32 / uniqid / print_r / gettype / array_is_list
+--FILE--
+<?php
+// crc32
+var_dump(crc32(""));
+var_dump(crc32("hello"));
+var_dump(crc32("Hello World!"));
+var_dump(is_int(crc32("test")));
+
+// uniqid
+$id = uniqid();
+var_dump(is_string($id) && !empty($id));
+$id2 = uniqid("prefix_");
+var_dump(str_starts_with($id2, "prefix_"));
+$id3 = uniqid("", true);
+var_dump(strlen($id3) > 13);
+
+// print_r with return=true
+var_dump(print_r("hello", true));
+var_dump(str_contains(print_r([1, 2, 3], true), "[0] => 1"));
+var_dump(str_contains(print_r(["a" => 1], true), "[a]"));
+
+// gettype
+var_dump(gettype(null));
+var_dump(gettype(true));
+var_dump(gettype(42));
+var_dump(gettype(3.14));
+var_dump(gettype("hello"));
+var_dump(gettype([]));
+var_dump(gettype(new stdClass()));
+
+// array_is_list
+var_dump(array_is_list([]));
+var_dump(array_is_list([1, 2, 3]));
+var_dump(array_is_list([0 => "a", 1 => "b"]));
+var_dump(array_is_list([1 => "a", 0 => "b"]));
+var_dump(array_is_list(["a" => 1, "b" => 2]));
+?>
+--EXPECT--
+int(0)
+int(907060870)
+int(472456355)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+string(5) "hello"
+bool(true)
+bool(true)
+string(4) "NULL"
+string(7) "boolean"
+string(7) "integer"
+string(6) "double"
+string(6) "string"
+string(5) "array"
+string(6) "object"
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)

tests/aot/stdlib/number_format_edge.phpt

@@ -0,0 +1,35 @@
+--TEST--
+number_format edge cases
+--FILE--
+<?php
+// Basic usage
+var_dump(number_format(1234.5678));
+var_dump(number_format(1234.5678, 2));
+var_dump(number_format(1234.5678, 2, ",", "."));
+var_dump(number_format(1234.5678, 2, ".", ""));
+
+// Zero and negative
+var_dump(number_format(0));
+var_dump(number_format(-1234.56));
+var_dump(number_format(-1234.56, 1));
+
+// Large numbers
+var_dump(number_format(1000000));
+var_dump(number_format(1000000.5, 1));
+
+// Integer input
+var_dump(number_format(42));
+var_dump(number_format(42, 3));
+?>
+--EXPECT--
+string(5) "1,235"
+string(8) "1,234.57"
+string(8) "1.234,57"
+string(7) "1234.57"
+string(1) "0"
+string(6) "-1,235"
+string(8) "-1,234.6"
+string(9) "1,000,000"
+string(11) "1,000,000.5"
+string(2) "42"
+string(6) "42.000"

tests/aot/stdlib/string_case.phpt

@@ -0,0 +1,41 @@
+--TEST--
+lcfirst / ucfirst / strtolower / strtoupper edge cases
+--FILE--
+<?php
+// lcfirst
+var_dump(lcfirst(""));
+var_dump(lcfirst("Hello"));
+var_dump(lcfirst("HELLO"));
+var_dump(lcfirst("hELLO"));
+
+// ucfirst
+var_dump(ucfirst(""));
+var_dump(ucfirst("hello"));
+var_dump(ucfirst("Hello"));
+var_dump(ucfirst("hELLO"));
+
+// strtolower
+var_dump(strtolower(""));
+var_dump(strtolower("HELLO"));
+var_dump(strtolower("Hello World"));
+
+// strtoupper
+var_dump(strtoupper(""));
+var_dump(strtoupper("hello"));
+var_dump(strtoupper("Hello World"));
+?>
+--EXPECT--
+string(0) ""
+string(5) "hello"
+string(5) "hELLO"
+string(5) "hELLO"
+string(0) ""
+string(5) "Hello"
+string(5) "Hello"
+string(5) "HELLO"
+string(0) ""
+string(5) "hello"
+string(11) "hello world"
+string(0) ""
+string(5) "HELLO"
+string(11) "HELLO WORLD"

tests/aot/stdlib/string_check.phpt

@@ -0,0 +1,41 @@
+--TEST--
+str_contains / str_starts_with / str_ends_with edge cases
+--FILE--
+<?php
+// str_contains
+var_dump(str_contains("", ""));
+var_dump(str_contains("hello", ""));
+var_dump(str_contains("hello", "ll"));
+var_dump(str_contains("hello", "xy"));
+var_dump(str_contains("", "a"));
+
+// str_starts_with
+var_dump(str_starts_with("", ""));
+var_dump(str_starts_with("hello", ""));
+var_dump(str_starts_with("hello", "he"));
+var_dump(str_starts_with("hello", "lo"));
+var_dump(str_starts_with("", "a"));
+
+// str_ends_with
+var_dump(str_ends_with("", ""));
+var_dump(str_ends_with("hello", ""));
+var_dump(str_ends_with("hello", "lo"));
+var_dump(str_ends_with("hello", "he"));
+var_dump(str_ends_with("", "a"));
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)

tests/aot/stdlib/string_cmp.phpt

@@ -0,0 +1,45 @@
+--TEST--
+strlen / strcmp / strcasecmp / strncmp / strncasecmp
+--FILE--
+<?php
+// strlen
+var_dump(strlen(""));
+var_dump(strlen("hello"));
+var_dump(strlen("Hello World!"));
+
+// strcmp
+var_dump(strcmp("abc", "abc"));
+var_dump(strcmp("abc", "abd"));
+var_dump(strcmp("abd", "abc"));
+
+// strcasecmp
+var_dump(strcasecmp("ABC", "abc"));
+var_dump(strcasecmp("ABC", "abd"));
+var_dump(strcasecmp("ABD", "abc"));
+
+// strncmp
+var_dump(strncmp("abc123", "abc456", 3));
+var_dump(strncmp("abc123", "abd123", 3));
+var_dump(strncmp("abd123", "abc123", 3));
+
+// strncasecmp
+var_dump(strncasecmp("ABC123", "abc456", 3));
+var_dump(strncasecmp("ABC123", "ABD123", 3));
+var_dump(strncasecmp("ABD123", "ABC123", 3));
+?>
+--EXPECT--
+int(0)
+int(5)
+int(12)
+int(0)
+int(-1)
+int(1)
+int(0)
+int(-1)
+int(1)
+int(0)
+int(-1)
+int(1)
+int(0)
+int(-1)
+int(1)

tests/aot/stdlib/string_search.phpt

@@ -0,0 +1,33 @@
+--TEST--
+strstr / strrpos / strpos / stripos
+--FILE--
+<?php
+// strstr
+var_dump(strstr("hello world", "world"));
+var_dump(strstr("hello world", "world", true));
+var_dump(strstr("hello world", "xyz"));
+
+// strrpos
+var_dump(strrpos("hello world hello", "hello"));
+var_dump(strrpos("hello world hello", "hello", -5));
+var_dump(strrpos("hello world", "xyz"));
+
+// strpos
+var_dump(strpos("hello world", "world"));
+var_dump(strpos("hello world", "xyz"));
+
+// stripos
+var_dump(stripos("Hello World", "world"));
+var_dump(stripos("Hello World", "xyz"));
+?>
+--EXPECT--
+string(5) "world"
+string(6) "hello "
+bool(false)
+int(12)
+int(12)
+bool(false)
+int(6)
+bool(false)
+int(6)
+bool(false)

tests/aot/stdlib/type_check.phpt

@@ -0,0 +1,68 @@
+--TEST--
+is_countable / is_iterable / method_exists / property_exists
+--FILE--
+<?php
+class TestClass {
+    public function foo() {}
+    public static function bar() {}
+}
+
+class PropClass {
+    public $x = 1;
+    private $y = 2;
+    public static $z = 3;
+}
+
+function main() {
+    // is_countable
+    var_dump(is_countable([]));
+    var_dump(is_countable([1,2,3]));
+    var_dump(is_countable("hello"));
+    var_dump(is_countable(42));
+    var_dump(is_countable(null));
+
+    // is_iterable
+    var_dump(is_iterable([]));
+    var_dump(is_iterable([1,2,3]));
+    var_dump(is_iterable("hello"));
+    var_dump(is_iterable(42));
+    var_dump(is_iterable(new stdClass()));
+
+    // method_exists
+    $obj = new TestClass();
+    var_dump(method_exists($obj, "foo"));
+    var_dump(method_exists($obj, "bar"));
+    var_dump(method_exists($obj, "baz"));
+    var_dump(method_exists("TestClass", "foo"));
+    var_dump(method_exists("TestClass", "nonexistent"));
+
+    // property_exists
+    $p = new PropClass();
+    var_dump(property_exists($p, "x"));
+    var_dump(property_exists($p, "y"));
+    var_dump(property_exists($p, "z"));
+    var_dump(property_exists($p, "nonexistent"));
+    var_dump(property_exists("PropClass", "x"));
+}
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(true)

tests/aot/stdlib/type_conv.phpt

@@ -0,0 +1,55 @@
+--TEST--
+strval / intval / floatval / boolval type conversions
+--FILE--
+<?php
+function main() {
+    // strval
+    var_dump(strval(42));
+    var_dump(strval(1.5));
+    var_dump(strval(true));
+    var_dump(strval(false));
+    var_dump(strval(null));
+
+    // intval
+    var_dump(intval(42));
+    var_dump(intval(3.14));
+    var_dump(intval("42"));
+    var_dump(intval("3.14"));
+    var_dump(intval(true));
+    var_dump(intval(false));
+
+    // floatval
+    var_dump(floatval(42));
+    var_dump(floatval("3.14"));
+    var_dump(floatval("42"));
+
+    // boolval
+    var_dump(boolval(1));
+    var_dump(boolval(0));
+    var_dump(boolval(""));
+    var_dump(boolval("hello"));
+    var_dump(boolval([]));
+    var_dump(boolval([1]));
+}
+?>
+--EXPECT--
+string(2) "42"
+string(3) "1.5"
+string(1) "1"
+string(0) ""
+string(0) ""
+int(42)
+int(3)
+int(42)
+int(3)
+int(1)
+int(0)
+float(42)
+float(3.14)
+float(42)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(true)

tests/aot/stdlib/url_edge.phpt

@@ -0,0 +1,44 @@
+--TEST--
+urlencode / urldecode / rawurlencode / rawurldecode edge cases
+--FILE--
+<?php
+// Empty string
+var_dump(urlencode(""));
+var_dump(urldecode(""));
+var_dump(rawurlencode(""));
+var_dump(rawurldecode(""));
+
+// Basic encoding
+var_dump(urlencode("hello world"));
+var_dump(urldecode("hello+world"));
+var_dump(rawurlencode("hello world"));
+var_dump(rawurldecode("hello%20world"));
+
+// Special characters
+var_dump(urlencode("äöü"));
+var_dump(rawurlencode("äöü"));
+
+// Reserved characters: + and = are encoded the same by both functions
+var_dump(urlencode("a+b=c"));
+var_dump(rawurlencode("a+b=c"));
+
+// Round-trip
+$orig = "Hello World! @#$%^&*()";
+var_dump(urldecode(urlencode($orig)) === $orig);
+var_dump(rawurldecode(rawurlencode($orig)) === $orig);
+?>
+--EXPECT--
+string(0) ""
+string(0) ""
+string(0) ""
+string(0) ""
+string(11) "hello+world"
+string(11) "hello world"
+string(13) "hello%20world"
+string(11) "hello world"
+string(18) "%C3%A4%C3%B6%C3%BC"
+string(18) "%C3%A4%C3%B6%C3%BC"
+string(9) "a%2Bb%3Dc"
+string(9) "a%2Bb%3Dc"
+bool(true)
+bool(true)