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

- 测试 gettype 函数对不同数据类型的返回值
- 验证 ucfirst 函数首字母大写功能
- 检查 floor 和 ceil 数学函数的正确性
- 测试 max 和 min 函数的数值比较功能
- 验证 uniqid 函数生成唯一标识符的能力
- 测试

tests/std/array/001.phpt

@@ -0,0 +1,66 @@
+--TEST--
+array_diff: string-based comparison
+--FILE--
+<?php
+function main() {
+    // array_diff compares values as strings, not loose equality
+    $a = [1, 2, 3, "1"];
+    $b = ["1"];
+    $r = array_diff($a, $b);
+    var_dump($r);
+
+    // 0 and false both become "" as string, but 0 != false via string compare
+    // 0 → "0", false → "" — they differ as strings, so false NOT excluded
+    $c = [0, 1];
+    $d = [false];
+    $r = array_diff($c, $d);
+    var_dump($r);
+
+    // Null becomes "" as string
+    $e = [null, 1, 2];
+    $f = [""];
+    $r = array_diff($e, $f);
+    var_dump($r);
+
+    // Keys preserved
+    $g = ["a" => "hello", "b" => "world"];
+    $h = ["hello"];
+    $r = array_diff($g, $h);
+    var_dump($r);
+
+    // Numeric strings match integers (both become same string)
+    $i = [100, 200, 300];
+    $j = ["200"];
+    $r = array_diff($i, $j);
+    var_dump($r);
+}
+?>
+--EXPECT--
+array(2) {
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(2) {
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+array(1) {
+  ["b"]=>
+  string(5) "world"
+}
+array(2) {
+  [0]=>
+  int(100)
+  [2]=>
+  int(300)
+}

tests/std/array/002.phpt

@@ -0,0 +1,47 @@
+--TEST--
+array_intersect: string-based comparison
+--FILE--
+<?php
+function main() {
+    // array_intersect compares values as strings
+    $a = [1, 2, 3, "1"];
+    $b = ["1", 4];
+    $r = array_intersect($a, $b);
+    var_dump($r);
+
+    // Numeric strings match integers
+    $c = [100, 200, 300];
+    $d = ["200", "500"];
+    $r = array_intersect($c, $d);
+    var_dump($r);
+
+    // Keys preserved from first array
+    $e = ["a" => "hello", "b" => "world"];
+    $f = ["world", "extra"];
+    $r = array_intersect($e, $f);
+    var_dump($r);
+
+    // Empty result
+    $g = [1, 2, 3];
+    $h = [4, 5, 6];
+    $r = array_intersect($g, $h);
+    var_dump($r);
+}
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(1)
+  [3]=>
+  string(1) "1"
+}
+array(1) {
+  [1]=>
+  int(200)
+}
+array(1) {
+  ["b"]=>
+  string(5) "world"
+}
+array(0) {
+}

tests/std/array/003.phpt

@@ -0,0 +1,53 @@
+--TEST--
+array_unique: sort flags
+--FILE--
+<?php
+function main() {
+    // SORT_STRING (default) - string comparison, 1 and "1" match
+    $a = ["a" => 1, "b" => "1", "c" => 2, "d" => "2"];
+    $r = array_unique($a, SORT_STRING);
+    var_dump($r);
+
+    // SORT_REGULAR - uses zend_compare, 1 and "1" match
+    $b = ["a" => 1, "b" => "1", "c" => 2, "d" => "2"];
+    $r = array_unique($b, SORT_REGULAR);
+    var_dump($r);
+
+    // SORT_NUMERIC - numeric comparison
+    $c = ["a" => 1, "b" => "1.0", "c" => 2, "d" => "2.5"];
+    $r = array_unique($c, SORT_NUMERIC);
+    var_dump($r);
+
+    // Keys preserved (first occurrence kept)
+    $d = ["a" => "red", "b" => "green", "c" => "red"];
+    $r = array_unique($d);
+    var_dump($r);
+}
+?>
+--EXPECT--
+array(2) {
+  ["a"]=>
+  int(1)
+  ["c"]=>
+  int(2)
+}
+array(2) {
+  ["a"]=>
+  int(1)
+  ["c"]=>
+  int(2)
+}
+array(3) {
+  ["a"]=>
+  int(1)
+  ["c"]=>
+  int(2)
+  ["d"]=>
+  string(3) "2.5"
+}
+array(2) {
+  ["a"]=>
+  string(3) "red"
+  ["b"]=>
+  string(5) "green"
+}

tests/std/array/004.phpt

@@ -0,0 +1,44 @@
+--TEST--
+array_shift: non-packed re-indexing
+--FILE--
+<?php
+function main() {
+    // Non-packed (string-keyed) array: shift re-indexes integer keys
+    $a = ["a" => 1, "b" => 2, 0 => 3, 1 => 4];
+    $v = array_shift($a);
+    var_dump($v);
+    var_dump($a);
+
+    // Mixed keys with gaps
+    $b = [5 => "first", "key" => "second", 10 => "third"];
+    $v = array_shift($b);
+    var_dump($v);
+    var_dump($b);
+
+    // Single element
+    $c = ["only" => "one"];
+    $v = array_shift($c);
+    var_dump($v);
+    var_dump($c);
+}
+?>
+--EXPECT--
+int(1)
+array(3) {
+  ["b"]=>
+  int(2)
+  [0]=>
+  int(3)
+  [1]=>
+  int(4)
+}
+string(5) "first"
+array(2) {
+  ["key"]=>
+  string(6) "second"
+  [0]=>
+  string(5) "third"
+}
+string(3) "one"
+array(0) {
+}

tests/std/array/005.phpt

@@ -0,0 +1,48 @@
+--TEST--
+array_unshift: preserves string keys
+--FILE--
+<?php
+function main() {
+    // String keys preserved, int keys re-indexed
+    $a = ["a" => 1, "b" => 2];
+    $c = array_unshift($a, "new1", "new2");
+    var_dump($c);
+    var_dump($a);
+
+    // Mixed integer and string keys
+    $b = [0 => "zero", "key" => "value"];
+    array_unshift($b, "prepended");
+    var_dump($b);
+
+    // Return value is new count
+    $d = [];
+    $c = array_unshift($d, "x");
+    var_dump($c);
+    var_dump($d);
+}
+?>
+--EXPECT--
+int(4)
+array(4) {
+  [0]=>
+  string(4) "new1"
+  [1]=>
+  string(4) "new2"
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  int(2)
+}
+array(3) {
+  [0]=>
+  string(9) "prepended"
+  [1]=>
+  string(4) "zero"
+  ["key"]=>
+  string(5) "value"
+}
+int(1)
+array(1) {
+  [0]=>
+  string(1) "x"
+}

tests/std/array/006.phpt

@@ -0,0 +1,46 @@
+--TEST--
+ksort: flag handling
+--FILE--
+<?php
+function main() {
+    // SORT_REGULAR (default) — string comparison of keys
+    $a = ["c" => 1, "a" => 2, "b" => 3];
+    ksort($a);
+    var_dump($a);
+
+    // SORT_NUMERIC — numeric key comparison
+    $b = ["10" => "ten", "2" => "two", "1" => "one"];
+    ksort($b, SORT_NUMERIC);
+    var_dump($b);
+
+    // Mixed int and string keys
+    $c = ["b" => 1, 0 => 2, "a" => 3];
+    ksort($c);
+    var_dump($c);
+}
+?>
+--EXPECT--
+array(3) {
+  ["a"]=>
+  int(2)
+  ["b"]=>
+  int(3)
+  ["c"]=>
+  int(1)
+}
+array(3) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [10]=>
+  string(3) "ten"
+}
+array(3) {
+  [0]=>
+  int(2)
+  ["a"]=>
+  int(3)
+  ["b"]=>
+  int(1)
+}

tests/std/array/007.phpt

@@ -0,0 +1,37 @@
+--TEST--
+array_sum / array_product: type handling
+--FILE--
+<?php
+function main() {
+    // Non-numeric strings contribute 0 as int (not float)
+    var_dump(array_sum([1, 2, "abc"]));
+    var_dump(array_product([1, 2, "abc"]));
+
+    // Numeric float strings produce float
+    var_dump(array_sum([1, "2.5"]));
+    var_dump(array_product([2, "2.5"]));
+
+    // Pure ints produce int
+    var_dump(array_sum([1, 2, 3]));
+    var_dump(array_product([1, 2, 3]));
+
+    // Actual floats produce float
+    var_dump(array_sum([1, 2.5]));
+    var_dump(array_product([2, 2.5]));
+
+    // Empty array
+    var_dump(array_sum([]));
+    var_dump(array_product([]));
+}
+?>
+--EXPECT--
+int(3)
+int(0)
+float(3.5)
+float(5)
+int(6)
+int(6)
+float(3.5)
+float(5)
+int(0)
+int(1)

tests/std/array/008.phpt

@@ -0,0 +1,69 @@
+--TEST--
+array_combine: non-int/non-string key handling
+--FILE--
+<?php
+function main() {
+    // Basic combine
+    $keys = ["a", "b", "c"];
+    $values = [1, 2, 3];
+    $r = array_combine($keys, $values);
+    var_dump($r);
+
+    // Integer keys
+    $keys2 = [10, 20, 30];
+    $values2 = ["a", "b", "c"];
+    $r = array_combine($keys2, $values2);
+    var_dump($r);
+
+    // Float keys become string keys
+    $keys3 = [1.5, 2.5];
+    $values3 = ["first", "second"];
+    $r = array_combine($keys3, $values3);
+    var_dump($r);
+
+    // Null key becomes empty string key
+    $keys4 = [null];
+    $values4 = ["null_key"];
+    $r = array_combine($keys4, $values4);
+    var_dump($r);
+
+    // Boolean key: true→"1"→1 (int via symtable), false→"" (string)
+    $keys5 = [true, false];
+    $values5 = ["true_val", "false_val"];
+    $r = array_combine($keys5, $values5);
+    var_dump($r);
+}
+?>
+--EXPECT--
+array(3) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  int(2)
+  ["c"]=>
+  int(3)
+}
+array(3) {
+  [10]=>
+  string(1) "a"
+  [20]=>
+  string(1) "b"
+  [30]=>
+  string(1) "c"
+}
+array(2) {
+  ["1.5"]=>
+  string(5) "first"
+  ["2.5"]=>
+  string(6) "second"
+}
+array(1) {
+  [""]=>
+  string(8) "null_key"
+}
+array(2) {
+  [1]=>
+  string(8) "true_val"
+  [""]=>
+  string(9) "false_val"
+}