test(array): 添加数组函数测试用例

tests/std/array/009.phpt

@@ -0,0 +1,408 @@
+--TEST--
+Test key(), current(), next() & reset() functions
+--FILE--
+<?php
+
+$basic_arrays = array (
+  array(0),  // array with element as 0
+  array(1),  // array with single element
+  array(1,2, 3, -1, -2, -3),               // array of integers
+  array(1.1, 2.2, 3.3, -1.1, -2.2, -3.3),  // array of floats
+  array('a', 'b', 'c', "ab", "ac", "ad"),  // string array
+  array("a" => "apple", "b" => "book", "c" => "cook"),  // associative array
+  array('d' => 'drink', 'p' => 'port', 's' => 'set'),   // another associative array
+  array(1 => 'One', 2 => 'two', 3 => "three")           // associative array with key as integers
+);
+
+$varient_arrays = array (
+   array(),    // empty array
+   array(""),  // array with null string
+   array(NULL),// array with NULL
+   array(null),// array with null
+   array(NULL, true, null, "", 1), // mixed array
+   array(-1 => "test", -2 => "rest", 2 => "two",
+         "" => "string", 0 => "zero", "" => "" ) // mixed array
+);
+
+echo "*** Testing basic operations ***\n";
+$loop_count = 1;
+foreach ($basic_arrays as $sub_array )  {
+  echo "-- Iteration $loop_count --\n";
+  $loop_count++;
+  $c = count ($sub_array);
+  $c++; // increment by one to create the situation of accessing beyond array size
+  while ( $c ) {
+    var_dump( current($sub_array)); // current element
+    var_dump( key($sub_array) );    // key of the current element
+    var_dump( next($sub_array) );   // move to next element
+    $c --;
+  }
+  var_dump( reset($sub_array) );    // reset the internal pointer to first element
+  var_dump( key($sub_array) );      // access the array after reset
+  var_dump( $sub_array );           // dump the array to see that its intact
+
+  echo "\n";
+}
+
+echo "\n*** Testing possible variations ***\n";
+$loop_count = 1;
+foreach ($varient_arrays as $sub_array )  {
+  echo "-- Iteration $loop_count --\n";
+  $loop_count++;
+  $c = count ($sub_array);
+  $c++; // increment by one to create the situation of accessing beyond array size
+  while ( $c ) {
+    var_dump( current($sub_array)); // current element
+    var_dump( key($sub_array) );    // key of the current element
+    var_dump( next($sub_array) );   // move to next element
+    $c --;
+  }
+  var_dump( reset($sub_array) );    // reset the internal pointer to first element
+  var_dump( key($sub_array) );      // access the array after reset
+  var_dump( $sub_array );           // dump the array to see that its intact
+  echo "\n";
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing basic operations ***
+-- Iteration 1 --
+int(0)
+int(0)
+bool(false)
+bool(false)
+NULL
+bool(false)
+int(0)
+int(0)
+array(1) {
+  [0]=>
+  int(0)
+}
+
+-- Iteration 2 --
+int(1)
+int(0)
+bool(false)
+bool(false)
+NULL
+bool(false)
+int(1)
+int(0)
+array(1) {
+  [0]=>
+  int(1)
+}
+
+-- Iteration 3 --
+int(1)
+int(0)
+int(2)
+int(2)
+int(1)
+int(3)
+int(3)
+int(2)
+int(-1)
+int(-1)
+int(3)
+int(-2)
+int(-2)
+int(4)
+int(-3)
+int(-3)
+int(5)
+bool(false)
+bool(false)
+NULL
+bool(false)
+int(1)
+int(0)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(-1)
+  [4]=>
+  int(-2)
+  [5]=>
+  int(-3)
+}
+
+-- Iteration 4 --
+float(1.1)
+int(0)
+float(2.2)
+float(2.2)
+int(1)
+float(3.3)
+float(3.3)
+int(2)
+float(-1.1)
+float(-1.1)
+int(3)
+float(-2.2)
+float(-2.2)
+int(4)
+float(-3.3)
+float(-3.3)
+int(5)
+bool(false)
+bool(false)
+NULL
+bool(false)
+float(1.1)
+int(0)
+array(6) {
+  [0]=>
+  float(1.1)
+  [1]=>
+  float(2.2)
+  [2]=>
+  float(3.3)
+  [3]=>
+  float(-1.1)
+  [4]=>
+  float(-2.2)
+  [5]=>
+  float(-3.3)
+}
+
+-- Iteration 5 --
+string(1) "a"
+int(0)
+string(1) "b"
+string(1) "b"
+int(1)
+string(1) "c"
+string(1) "c"
+int(2)
+string(2) "ab"
+string(2) "ab"
+int(3)
+string(2) "ac"
+string(2) "ac"
+int(4)
+string(2) "ad"
+string(2) "ad"
+int(5)
+bool(false)
+bool(false)
+NULL
+bool(false)
+string(1) "a"
+int(0)
+array(6) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+  [3]=>
+  string(2) "ab"
+  [4]=>
+  string(2) "ac"
+  [5]=>
+  string(2) "ad"
+}
+
+-- Iteration 6 --
+string(5) "apple"
+string(1) "a"
+string(4) "book"
+string(4) "book"
+string(1) "b"
+string(4) "cook"
+string(4) "cook"
+string(1) "c"
+bool(false)
+bool(false)
+NULL
+bool(false)
+string(5) "apple"
+string(1) "a"
+array(3) {
+  ["a"]=>
+  string(5) "apple"
+  ["b"]=>
+  string(4) "book"
+  ["c"]=>
+  string(4) "cook"
+}
+
+-- Iteration 7 --
+string(5) "drink"
+string(1) "d"
+string(4) "port"
+string(4) "port"
+string(1) "p"
+string(3) "set"
+string(3) "set"
+string(1) "s"
+bool(false)
+bool(false)
+NULL
+bool(false)
+string(5) "drink"
+string(1) "d"
+array(3) {
+  ["d"]=>
+  string(5) "drink"
+  ["p"]=>
+  string(4) "port"
+  ["s"]=>
+  string(3) "set"
+}
+
+-- Iteration 8 --
+string(3) "One"
+int(1)
+string(3) "two"
+string(3) "two"
+int(2)
+string(5) "three"
+string(5) "three"
+int(3)
+bool(false)
+bool(false)
+NULL
+bool(false)
+string(3) "One"
+int(1)
+array(3) {
+  [1]=>
+  string(3) "One"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+}
+
+
+*** Testing possible variations ***
+-- Iteration 1 --
+bool(false)
+NULL
+bool(false)
+bool(false)
+NULL
+array(0) {
+}
+
+-- Iteration 2 --
+string(0) ""
+int(0)
+bool(false)
+bool(false)
+NULL
+bool(false)
+string(0) ""
+int(0)
+array(1) {
+  [0]=>
+  string(0) ""
+}
+
+-- Iteration 3 --
+NULL
+int(0)
+bool(false)
+bool(false)
+NULL
+bool(false)
+NULL
+int(0)
+array(1) {
+  [0]=>
+  NULL
+}
+
+-- Iteration 4 --
+NULL
+int(0)
+bool(false)
+bool(false)
+NULL
+bool(false)
+NULL
+int(0)
+array(1) {
+  [0]=>
+  NULL
+}
+
+-- Iteration 5 --
+NULL
+int(0)
+bool(true)
+bool(true)
+int(1)
+NULL
+NULL
+int(2)
+string(0) ""
+string(0) ""
+int(3)
+int(1)
+int(1)
+int(4)
+bool(false)
+bool(false)
+NULL
+bool(false)
+NULL
+int(0)
+array(5) {
+  [0]=>
+  NULL
+  [1]=>
+  bool(true)
+  [2]=>
+  NULL
+  [3]=>
+  string(0) ""
+  [4]=>
+  int(1)
+}
+
+-- Iteration 6 --
+string(4) "test"
+int(-1)
+string(4) "rest"
+string(4) "rest"
+int(-2)
+string(3) "two"
+string(3) "two"
+int(2)
+string(0) ""
+string(0) ""
+string(0) ""
+string(4) "zero"
+string(4) "zero"
+int(0)
+bool(false)
+bool(false)
+NULL
+bool(false)
+string(4) "test"
+int(-1)
+array(5) {
+  [-1]=>
+  string(4) "test"
+  [-2]=>
+  string(4) "rest"
+  [2]=>
+  string(3) "two"
+  [""]=>
+  string(0) ""
+  [0]=>
+  string(4) "zero"
+}
+
+Done

tests/std/array/array_all_basic.phpt

@@ -0,0 +1,59 @@
+--TEST--
+Test array_all() function : basic functionality
+--SKIPIF--
+--FILE--
+<?php
+
+function even($input, $key) {
+  return $input % 2 === 0;
+}
+
+class SmallerTenClass {
+    public static function smallerTen($input, $key) {
+        return $input < 10;
+    }
+}
+
+function return_nothing($value, $key) {
+    // return nothing
+}
+
+function main() {
+$array1 = [
+    "a" => 1,
+    "b" => 2,
+    "c" => 3,
+    "d" => 4,
+    "e" => 5,
+];
+
+$array2 = [
+    1, 2, 3, 4, 5
+];
+
+var_dump(array_all($array1, fn($value, $key) => $value > 0));
+var_dump(array_all($array2, fn($value, $key) => $value > 0));
+var_dump(array_all($array2, fn($value, $key) => $value > 1));
+var_dump(array_all([], fn($value, $key) => true));
+
+var_dump(array_all($array1, 'even'));
+
+var_dump(array_all($array1, 'return_nothing'));
+
+var_dump(array_all($array1, [
+    'SmallerTenClass',
+    'smallerTen'
+]));
+
+var_dump(array_all($array1, "SmallerTenClass::smallerTen"));
+}
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)

tests/std/array/array_any_basic.phpt

@@ -0,0 +1,51 @@
+--TEST--
+Test array_any() function : basic functionality
+--SKIPIF--
+<?php //die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function even($input, $key)
+{
+    return $input % 2 === 0;
+}
+class EvenClass
+{
+    public static function even($input, $key)
+    {
+        return $input % 2 === 0;
+    }
+}
+
+function return_nothing($value, $key)
+{
+    // return nothing
+}
+
+function main()
+{
+    $array1 = ["a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5];
+    $array2 = [1, 2, 3, 4, 5];
+    var_dump(array_any($array1, fn($value, $key) => $value > 3));
+    var_dump(array_any($array2, fn($value, $key) => $value > 3));
+    var_dump(array_any($array2, fn($value, $key) => $value > 5));
+    var_dump(array_any([], fn($value, $key) => true));
+    var_dump(array_any($array1, fn($value, $key) => $key === "c"));
+    var_dump(array_any($array1, fn($value, $key) => false));
+    var_dump(array_any($array1, 'even'));
+    var_dump(array_any($array1, 'return_nothing'));
+    var_dump(array_any($array1, ['EvenClass', 'even']));
+    var_dump(array_any($array1, "EvenClass::even"));
+}
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(true)

tests/std/array/array_change_key_case.phpt

@@ -0,0 +1,811 @@
+--TEST--
+Test array_change_key_case() function
+--FILE--
+<?php
+$arrays = array (
+  array (),
+  array (0),
+  array (1),
+  array (-1),
+  array (0, 2, 3, 4, 5),
+  array (1, 2, 3, 4, 5),
+  array ("" => 1),
+  array ("a" => 1),
+  array ("Z" => 1),
+  array ("one" => 1),
+  array ("ONE" => 1),
+  array ("OnE" => 1),
+  array ("oNe" => 1),
+  array ("one" => 1, "two" => 2),
+  array ("ONE" => 1, "two" => 2),
+  array ("OnE" => 1, "two" => 2),
+  array ("oNe" => 1, "two" => 2),
+  array ("one" => 1, "TWO" => 2),
+  array ("ONE" => 1, "TWO" => 2),
+  array ("OnE" => 1, "TWO" => 2),
+  array ("oNe" => 1, "TWO" => 2),
+  array ("one" => 1, "TwO" => 2),
+  array ("ONE" => 1, "TwO" => 2),
+  array ("OnE" => 1, "TwO" => 2),
+  array ("oNe" => 1, "TwO" => 2),
+  array ("one" => 1, "tWo" => 2),
+  array ("ONE" => 1, "tWo" => 2),
+  array ("OnE" => 1, "tWo" => 2),
+  array ("oNe" => 1, "tWo" => 2),
+  array ("one" => 1, 2),
+  array ("ONE" => 1, 2),
+  array ("OnE" => 1, 2),
+  array ("oNe" => 1, 2),
+  array ("ONE" => 1, "TWO" => 2, "THREE" => 3, "FOUR" => "four"),
+  array ("one" => 1, "two" => 2, "three" => 3, "four" => "FOUR"),
+  array ("ONE" => 1, "TWO" => 2, "three" => 3, "four" => "FOUR"),
+  array ("one" => 1, "two" => 2, "THREE" => 3, "FOUR" => "four")
+);
+
+echo "*** Testing basic operations ***\n";
+$loop_counter = 1;
+foreach ($arrays as $item) {
+        echo "** Iteration $loop_counter **\n"; $loop_counter++;
+    var_dump(array_change_key_case($item));
+    var_dump(array_change_key_case($item, CASE_UPPER));
+    var_dump(array_change_key_case($item, CASE_LOWER));
+    echo "\n";
+}
+
+echo "end\n";
+?>
+--EXPECT--
+*** Testing basic operations ***
+** Iteration 1 **
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+
+** Iteration 2 **
+array(1) {
+  [0]=>
+  int(0)
+}
+array(1) {
+  [0]=>
+  int(0)
+}
+array(1) {
+  [0]=>
+  int(0)
+}
+
+** Iteration 3 **
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+
+** Iteration 4 **
+array(1) {
+  [0]=>
+  int(-1)
+}
+array(1) {
+  [0]=>
+  int(-1)
+}
+array(1) {
+  [0]=>
+  int(-1)
+}
+
+** Iteration 5 **
+array(5) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+}
+array(5) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+}
+array(5) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+}
+
+** Iteration 6 **
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+}
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+}
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+}
+
+** Iteration 7 **
+array(1) {
+  [""]=>
+  int(1)
+}
+array(1) {
+  [""]=>
+  int(1)
+}
+array(1) {
+  [""]=>
+  int(1)
+}
+
+** Iteration 8 **
+array(1) {
+  ["a"]=>
+  int(1)
+}
+array(1) {
+  ["A"]=>
+  int(1)
+}
+array(1) {
+  ["a"]=>
+  int(1)
+}
+
+** Iteration 9 **
+array(1) {
+  ["z"]=>
+  int(1)
+}
+array(1) {
+  ["Z"]=>
+  int(1)
+}
+array(1) {
+  ["z"]=>
+  int(1)
+}
+
+** Iteration 10 **
+array(1) {
+  ["one"]=>
+  int(1)
+}
+array(1) {
+  ["ONE"]=>
+  int(1)
+}
+array(1) {
+  ["one"]=>
+  int(1)
+}
+
+** Iteration 11 **
+array(1) {
+  ["one"]=>
+  int(1)
+}
+array(1) {
+  ["ONE"]=>
+  int(1)
+}
+array(1) {
+  ["one"]=>
+  int(1)
+}
+
+** Iteration 12 **
+array(1) {
+  ["one"]=>
+  int(1)
+}
+array(1) {
+  ["ONE"]=>
+  int(1)
+}
+array(1) {
+  ["one"]=>
+  int(1)
+}
+
+** Iteration 13 **
+array(1) {
+  ["one"]=>
+  int(1)
+}
+array(1) {
+  ["ONE"]=>
+  int(1)
+}
+array(1) {
+  ["one"]=>
+  int(1)
+}
+
+** Iteration 14 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 15 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 16 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 17 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 18 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 19 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 20 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 21 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 22 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 23 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 24 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 25 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 26 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 27 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 28 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 29 **
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+
+** Iteration 30 **
+array(2) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+
+** Iteration 31 **
+array(2) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+
+** Iteration 32 **
+array(2) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+
+** Iteration 33 **
+array(2) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+array(2) {
+  ["ONE"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  int(2)
+}
+
+** Iteration 34 **
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  ["four"]=>
+  string(4) "four"
+}
+array(4) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+  ["THREE"]=>
+  int(3)
+  ["FOUR"]=>
+  string(4) "four"
+}
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  ["four"]=>
+  string(4) "four"
+}
+
+** Iteration 35 **
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  ["four"]=>
+  string(4) "FOUR"
+}
+array(4) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+  ["THREE"]=>
+  int(3)
+  ["FOUR"]=>
+  string(4) "FOUR"
+}
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  ["four"]=>
+  string(4) "FOUR"
+}
+
+** Iteration 36 **
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  ["four"]=>
+  string(4) "FOUR"
+}
+array(4) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+  ["THREE"]=>
+  int(3)
+  ["FOUR"]=>
+  string(4) "FOUR"
+}
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  ["four"]=>
+  string(4) "FOUR"
+}
+
+** Iteration 37 **
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  ["four"]=>
+  string(4) "four"
+}
+array(4) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+  ["THREE"]=>
+  int(3)
+  ["FOUR"]=>
+  string(4) "four"
+}
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  ["four"]=>
+  string(4) "four"
+}
+
+end

tests/std/array/array_change_key_case_variation.phpt

@@ -0,0 +1,50 @@
+--TEST--
+Test array_change_key_case() function - 2
+--FILE--
+<?php
+
+$item = array ("one" => 1, "two" => 2, "THREE" => 3, "FOUR" => "four");
+
+/* use 'case' argument other than CASE_LOWER & CASE_UPPER */
+try {
+    var_dump(array_change_key_case($item, "CASE_UPPER"));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump(array_change_key_case($item, 5));
+
+/* when keys are different in terms of only case */
+/* should return one value key pair with key being in lowercase */
+var_dump( array_change_key_case( array("ONE" => 1, "one" => 3, "One" => 4) ) );
+
+/* should return one value key pair with key being in uppercase */
+var_dump( array_change_key_case( array("ONE" => 1, "one" => 2, "One" => 3), CASE_UPPER ) );
+var_dump( array_change_key_case( array("ONE" => 1, "one" => 1, "One" => 2), 5 ) );
+
+echo "end\n";
+?>
+--EXPECT--
+array_change_key_case(): Argument #2 ($case) must be of type int, string given
+array(4) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+  ["THREE"]=>
+  int(3)
+  ["FOUR"]=>
+  string(4) "four"
+}
+array(1) {
+  ["one"]=>
+  int(4)
+}
+array(1) {
+  ["ONE"]=>
+  int(3)
+}
+array(1) {
+  ["ONE"]=>
+  int(2)
+}
+end

tests/std/array/array_change_key_case_variation3.phpt

@@ -0,0 +1,167 @@
+--TEST--
+Test array_change_key_case() function : usage variations - different data types as keys
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Pass arrays with different data types as keys to array_change_key_case()
+ * to test conversion
+ */
+
+echo "*** Testing array_change_key_case() : usage variations ***\n";
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// heredoc string
+$heredoc = <<<EOT
+hello world
+EOT;
+
+// arrays of different data types to be passed to $input argument
+$inputs = array(
+
+       // int data
+/*1*/  'int' => array(
+       0 => 'zero',
+       1 => 'one',
+       12345 => 'positive',
+       -2345 => 'negative',
+       ),
+
+       // null data
+/*3*/ 'null uppercase' => array(
+       NULL => 'null 1',
+       ),
+       'null lowercase' => array(
+       null => 'null 2',
+       ),
+
+       // boolean data
+/*4*/ 'bool lowercase' => array(
+       true => 'lowert',
+       false => 'lowerf',
+       ),
+       'bool uppercase' => array(
+       TRUE => 'uppert',
+       FALSE => 'upperf',
+       ),
+
+       // empty data
+/*5*/ 'empty double quotes' => array(
+       "" => 'emptyd',
+       ),
+       'empty single quotes' => array(
+       '' => 'emptys',
+       ),
+
+       // string data
+/*6*/ 'string' => array(
+       "stringd" => 'stringd',
+       'strings' => 'strings',
+       $heredoc => 'stringh',
+       ),
+
+       // undefined data
+/*8*/ 'undefined' => array(
+       @$undefined_var => 'undefined',
+       ),
+
+       // unset data
+/*9*/ 'unset' => array(
+       @$unset_var => 'unset',
+       ),
+);
+
+// loop through each sub-array of $inputs to check the behavior of array_change_key_case()
+$iterator = 1;
+foreach($inputs as $key => $input) {
+  echo "\n-- Iteration $iterator : $key data --\n";
+  var_dump( array_change_key_case($input, CASE_UPPER) );
+  $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_change_key_case() : usage variations ***
+
+-- Iteration 1 : int data --
+array(4) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [12345]=>
+  string(8) "positive"
+  [-2345]=>
+  string(8) "negative"
+}
+
+-- Iteration 2 : null uppercase data --
+array(1) {
+  [""]=>
+  string(6) "null 1"
+}
+
+-- Iteration 3 : null lowercase data --
+array(1) {
+  [""]=>
+  string(6) "null 2"
+}
+
+-- Iteration 4 : bool lowercase data --
+array(2) {
+  [1]=>
+  string(6) "lowert"
+  [0]=>
+  string(6) "lowerf"
+}
+
+-- Iteration 5 : bool uppercase data --
+array(2) {
+  [1]=>
+  string(6) "uppert"
+  [0]=>
+  string(6) "upperf"
+}
+
+-- Iteration 6 : empty double quotes data --
+array(1) {
+  [""]=>
+  string(6) "emptyd"
+}
+
+-- Iteration 7 : empty single quotes data --
+array(1) {
+  [""]=>
+  string(6) "emptys"
+}
+
+-- Iteration 8 : string data --
+array(3) {
+  ["STRINGD"]=>
+  string(7) "stringd"
+  ["STRINGS"]=>
+  string(7) "strings"
+  ["HELLO WORLD"]=>
+  string(7) "stringh"
+}
+
+-- Iteration 9 : undefined data --
+array(1) {
+  [""]=>
+  string(9) "undefined"
+}
+
+-- Iteration 10 : unset data --
+array(1) {
+  [""]=>
+  string(5) "unset"
+}
+Done

tests/std/array/array_change_key_case_variation4.phpt

@@ -0,0 +1,132 @@
+--TEST--
+Test array_change_key_case() function : usage variations - different int values for $case
+--FILE--
+<?php
+/*
+ * Pass different integer values as $case argument to array_change_key_case() to test behaviour
+ */
+
+echo "*** Testing array_change_key_case() : usage variations ***\n";
+
+$input = array('One' => 'un', 'TWO' => 'deux', 'three' => 'trois');
+for ($i = -5; $i <=5; $i += 1){
+    echo "\n-- \$sort argument is $i --\n";
+    $temp = $input;
+    var_dump(array_change_key_case($temp, $i));
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_change_key_case() : usage variations ***
+
+-- $sort argument is -5 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is -4 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is -3 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is -2 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is -1 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is 0 --
+array(3) {
+  ["one"]=>
+  string(2) "un"
+  ["two"]=>
+  string(4) "deux"
+  ["three"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is 1 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is 2 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is 3 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is 4 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+
+-- $sort argument is 5 --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+Done

tests/std/array/array_change_key_case_variation5.phpt

@@ -0,0 +1,40 @@
+--TEST--
+Test array_change_key_case() function : usage variations - position of internal pointer
+--FILE--
+<?php
+/*
+ * Check the position of the internal array pointer after calling the function
+ */
+
+echo "*** Testing array_change_key_case() : usage variations ***\n";
+
+$input = array ('one' => 'un', 'two' => 'deux', 'three' => 'trois');
+
+echo "\n-- Call array_change_key_case() --\n";
+var_dump($result = array_change_key_case($input, CASE_UPPER));
+
+echo "-- Position of Internal Pointer in Result: --\n";
+echo key($result) . " => " . current($result) . "\n";
+echo "\n-- Position of Internal Pointer in Original Array: --\n";
+echo key($input) . " => " . current ($input) . "\n";
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_change_key_case() : usage variations ***
+
+-- Call array_change_key_case() --
+array(3) {
+  ["ONE"]=>
+  string(2) "un"
+  ["TWO"]=>
+  string(4) "deux"
+  ["THREE"]=>
+  string(5) "trois"
+}
+-- Position of Internal Pointer in Result: --
+ONE => un
+
+-- Position of Internal Pointer in Original Array: --
+one => un
+Done

tests/std/array/array_change_key_case_variation6.phpt

@@ -0,0 +1,66 @@
+--TEST--
+Test array_change_key_case() function : usage variations - multidimensional arrays
+--FILE--
+<?php
+/*
+ * Test how array_change_key_case() converts keys in multi-dimensional arrays
+ */
+
+echo "*** Testing array_change_key_case() : usage variations ***\n";
+
+$input = array('English' => array('one' => 1, 'two' => 2, 'three' => 3),
+               'French'  => array('un' => 1, 'deux' => 2, 'trois' => 3),
+               'German'  => array('eins' => 1, 'zwei' => 2, 'drei' => 3));
+
+echo "\n-- Pass a two-dimensional array as \$input argument --\n";
+var_dump(array_change_key_case($input, CASE_UPPER));
+
+echo "\n-- Pass a sub-array as \$input argument --\n";
+var_dump(array_change_key_case($input['English'], CASE_UPPER));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_change_key_case() : usage variations ***
+
+-- Pass a two-dimensional array as $input argument --
+array(3) {
+  ["ENGLISH"]=>
+  array(3) {
+    ["one"]=>
+    int(1)
+    ["two"]=>
+    int(2)
+    ["three"]=>
+    int(3)
+  }
+  ["FRENCH"]=>
+  array(3) {
+    ["un"]=>
+    int(1)
+    ["deux"]=>
+    int(2)
+    ["trois"]=>
+    int(3)
+  }
+  ["GERMAN"]=>
+  array(3) {
+    ["eins"]=>
+    int(1)
+    ["zwei"]=>
+    int(2)
+    ["drei"]=>
+    int(3)
+  }
+}
+
+-- Pass a sub-array as $input argument --
+array(3) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+  ["THREE"]=>
+  int(3)
+}
+Done

tests/std/array/array_change_key_case_variation7.phpt

@@ -0,0 +1,57 @@
+--TEST--
+Test array_change_key_case() function : usage variations - referenced variables
+--FILE--
+<?php
+/*
+ * Test array_change_key_case() when:
+ * 1. Passed a referenced variable
+ * 2. Passed an argument by reference
+ */
+
+echo "*** Testing array_change_key_case() : usage variations ***\n";
+
+$input = array('one' => 1, 'two' => 2, 'ABC' => 'xyz');
+
+echo "\n-- \$input argument is a reference to array --\n";
+$new_input = &$input;
+echo "Result:\n";
+var_dump(array_change_key_case($new_input, CASE_UPPER));
+echo "Original:\n";
+var_dump($input);
+echo "Referenced:\n";
+var_dump($new_input);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_change_key_case() : usage variations ***
+
+-- $input argument is a reference to array --
+Result:
+array(3) {
+  ["ONE"]=>
+  int(1)
+  ["TWO"]=>
+  int(2)
+  ["ABC"]=>
+  string(3) "xyz"
+}
+Original:
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["ABC"]=>
+  string(3) "xyz"
+}
+Referenced:
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["ABC"]=>
+  string(3) "xyz"
+}
+Done

tests/std/array/array_change_key_case_variation8.phpt

@@ -0,0 +1,124 @@
+--TEST--
+Test array_change_key_case() function : usage variations - Different strings as keys
+--SKIPIF--
+<?php die("skip AOT empty string key handling differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * Test how array_change_key_case() behaves with different strings
+ */
+
+echo "*** Testing array_change_key_case() : usage variations ***\n";
+
+$inputs = array (
+    // group of escape sequences
+    array(null => 1, NULL => 2, "\a" => 3, "\cx" => 4, "\e" => 5, "\f" => 6, "\n" => 7, "\t" => 8, "\xhh" => 9, "\ddd" => 10, "\v" => 11),
+
+    // array contains combination of capital/small letters
+    array("lemoN" => 1, "Orange" => 2, "banana" => 3, "apple" => 4, "Test" => 5, "TTTT" => 6, "ttt" => 7, "ww" => 8, "x" => 9, "X" => 10, "oraNGe" => 11, "BANANA" => 12)
+);
+
+foreach($inputs as $input) {
+    echo "\n-- \$case = default --\n";
+    var_dump(array_change_key_case($input));
+    echo "-- \$case = upper --\n";
+    var_dump(array_change_key_case($input, CASE_UPPER));
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_change_key_case() : usage variations ***
+
+-- $case = default --
+array(10) {
+  [""]=>
+  int(2)
+  ["\a"]=>
+  int(3)
+  ["\cx"]=>
+  int(4)
+  [""]=>
+  int(5)
+  [""]=>
+  int(6)
+  ["
+"]=>
+  int(7)
+  ["	"]=>
+  int(8)
+  ["\xhh"]=>
+  int(9)
+  ["\ddd"]=>
+  int(10)
+  [""]=>
+  int(11)
+}
+-- $case = upper --
+array(10) {
+  [""]=>
+  int(2)
+  ["\A"]=>
+  int(3)
+  ["\CX"]=>
+  int(4)
+  [""]=>
+  int(5)
+  [""]=>
+  int(6)
+  ["
+"]=>
+  int(7)
+  ["	"]=>
+  int(8)
+  ["\XHH"]=>
+  int(9)
+  ["\DDD"]=>
+  int(10)
+  [""]=>
+  int(11)
+}
+
+-- $case = default --
+array(9) {
+  ["lemon"]=>
+  int(1)
+  ["orange"]=>
+  int(11)
+  ["banana"]=>
+  int(12)
+  ["apple"]=>
+  int(4)
+  ["test"]=>
+  int(5)
+  ["tttt"]=>
+  int(6)
+  ["ttt"]=>
+  int(7)
+  ["ww"]=>
+  int(8)
+  ["x"]=>
+  int(10)
+}
+-- $case = upper --
+array(9) {
+  ["LEMON"]=>
+  int(1)
+  ["ORANGE"]=>
+  int(11)
+  ["BANANA"]=>
+  int(12)
+  ["APPLE"]=>
+  int(4)
+  ["TEST"]=>
+  int(5)
+  ["TTTT"]=>
+  int(6)
+  ["TTT"]=>
+  int(7)
+  ["WW"]=>
+  int(8)
+  ["X"]=>
+  int(10)
+}
+Done

tests/std/array/array_chunk2.phpt

@@ -0,0 +1,154 @@
+--TEST--
+basic array_chunk test
+--FILE--
+<?php
+$input_array = array('a', 'b', 'c', 'd', 'e');
+
+try {
+    var_dump(array_chunk($input_array, 0));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(array_chunk($input_array, 0, true));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+var_dump(array_chunk($input_array, 1));
+var_dump(array_chunk($input_array, 1, true));
+var_dump(array_chunk($input_array, 2));
+var_dump(array_chunk($input_array, 2, true));
+var_dump(array_chunk($input_array, 10));
+var_dump(array_chunk($input_array, 10, true));
+?>
+--EXPECT--
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+array(5) {
+  [0]=>
+  array(1) {
+    [0]=>
+    string(1) "a"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(1) "b"
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    string(1) "c"
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    string(1) "d"
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    string(1) "e"
+  }
+}
+array(5) {
+  [0]=>
+  array(1) {
+    [0]=>
+    string(1) "a"
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    string(1) "b"
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    string(1) "c"
+  }
+  [3]=>
+  array(1) {
+    [3]=>
+    string(1) "d"
+  }
+  [4]=>
+  array(1) {
+    [4]=>
+    string(1) "e"
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(1) "c"
+    [1]=>
+    string(1) "d"
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    string(1) "e"
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+  }
+  [1]=>
+  array(2) {
+    [2]=>
+    string(1) "c"
+    [3]=>
+    string(1) "d"
+  }
+  [2]=>
+  array(1) {
+    [4]=>
+    string(1) "e"
+  }
+}
+array(1) {
+  [0]=>
+  array(5) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+    [3]=>
+    string(1) "d"
+    [4]=>
+    string(1) "e"
+  }
+}
+array(1) {
+  [0]=>
+  array(5) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+    [3]=>
+    string(1) "d"
+    [4]=>
+    string(1) "e"
+  }
+}

tests/std/array/array_chunk_basic1.phpt

@@ -0,0 +1,132 @@
+--TEST--
+Test array_chunk() function : basic functionality - default 'preserve_keys'
+--FILE--
+<?php
+echo "*** Testing array_chunk() : basic functionality ***\n";
+$size = 2;
+
+$input_arrays = array (
+  // array with default keys - numeric values
+  array(1, 2, 3, 4, 5),
+
+  // array with default keys - string values
+  array('value1', "value2", "value3"),
+
+  // associative arrays - key as string
+  array('key1' => 1, "key2" => 2, "key3" => 3),
+
+  // associative arrays - key as numeric
+  array(1 => 'one', 2 => "two", 3 => "three"),
+
+  // array containing elements with/without keys
+  array(1 => 'one','two', 3 => 'three', 4, "five" => 5)
+
+);
+
+$count = 1;
+// loop through each element of the array for input
+foreach ($input_arrays as $input_array){
+  echo "\n-- Iteration $count --\n";
+  var_dump( array_chunk($input_array, $size) );
+  $count++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_chunk() : basic functionality ***
+
+-- Iteration 1 --
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(5)
+  }
+}
+
+-- Iteration 2 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(6) "value1"
+    [1]=>
+    string(6) "value2"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(6) "value3"
+  }
+}
+
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(3) "one"
+    [1]=>
+    string(3) "two"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(5) "three"
+  }
+}
+
+-- Iteration 5 --
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(3) "one"
+    [1]=>
+    string(3) "two"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(5) "three"
+    [1]=>
+    int(4)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(5)
+  }
+}
+Done

tests/std/array/array_chunk_basic2.phpt

@@ -0,0 +1,216 @@
+--TEST--
+Test array_chunk() function : basic functionality - 'preserve_keys' as true/false
+--FILE--
+<?php
+echo "*** Testing array_chunk() : basic functionality ***\n";
+$size = 2;
+
+$input_arrays = array(
+  // array with default keys - numeric values
+  array(1, 2, 3, 4, 5),
+
+  // array with default keys - string values
+  array('value1', "value2", "value3"),
+
+  // associative arrays - key as string
+  array('key1' => 1, "key2" => 2, "key3" => 3),
+
+  // associative arrays - key as numeric
+  array(1 => 'one', 2 => "two", 3 => "three"),
+
+  // array containing elements with/without keys
+  array(1 => 'one','two', 3 => 'three', 4, "five" => 5)
+);
+
+$count = 1;
+// loop through each element of the array for input
+foreach ($input_arrays as $input_array){
+  echo "\n-- Iteration $count --\n";
+  var_dump( array_chunk($input_array, $size, true) );
+  var_dump( array_chunk($input_array, $size, false) );
+  $count++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_chunk() : basic functionality ***
+
+-- Iteration 1 --
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [2]=>
+  array(1) {
+    [4]=>
+    int(5)
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(5)
+  }
+}
+
+-- Iteration 2 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(6) "value1"
+    [1]=>
+    string(6) "value2"
+  }
+  [1]=>
+  array(1) {
+    [2]=>
+    string(6) "value3"
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(6) "value1"
+    [1]=>
+    string(6) "value2"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(6) "value3"
+  }
+}
+
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  array(2) {
+    ["key1"]=>
+    int(1)
+    ["key2"]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    ["key3"]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  array(2) {
+    [1]=>
+    string(3) "one"
+    [2]=>
+    string(3) "two"
+  }
+  [1]=>
+  array(1) {
+    [3]=>
+    string(5) "three"
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(3) "one"
+    [1]=>
+    string(3) "two"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(5) "three"
+  }
+}
+
+-- Iteration 5 --
+array(3) {
+  [0]=>
+  array(2) {
+    [1]=>
+    string(3) "one"
+    [2]=>
+    string(3) "two"
+  }
+  [1]=>
+  array(2) {
+    [3]=>
+    string(5) "three"
+    [4]=>
+    int(4)
+  }
+  [2]=>
+  array(1) {
+    ["five"]=>
+    int(5)
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(3) "one"
+    [1]=>
+    string(3) "two"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(5) "three"
+    [1]=>
+    int(4)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(5)
+  }
+}
+Done

tests/std/array/array_chunk_variation10.phpt

@@ -0,0 +1,154 @@
+--TEST--
+array_chunk() - variation 10
+--FILE--
+<?php
+$array = array (1 => 1, 2 => 2, 3 => 3);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(3) {
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+}
+[1]
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [2]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [3]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[2]
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [3]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[3]
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}

tests/std/array/array_chunk_variation11.phpt

@@ -0,0 +1,88 @@
+--TEST--
+array_chunk() - variation 11
+--FILE--
+<?php
+$array = array (0 => 0, 3 => 2);
+
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(0)
+  [3]=>
+  int(2)
+}
+[1]
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [3]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+
+[2]
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [3]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(2)
+  }
+}

tests/std/array/array_chunk_variation12.phpt

@@ -0,0 +1,154 @@
+--TEST--
+array_chunk() - variation 12
+--FILE--
+<?php
+$array = array (1 => 1, 5 => 2, 8 => 3);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(3) {
+  [1]=>
+  int(1)
+  [5]=>
+  int(2)
+  [8]=>
+  int(3)
+}
+[1]
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [5]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [8]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[2]
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [1]=>
+    int(1)
+    [5]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [8]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[3]
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [1]=>
+    int(1)
+    [5]=>
+    int(2)
+    [8]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}

tests/std/array/array_chunk_variation13.phpt

@@ -0,0 +1,87 @@
+--TEST--
+array_chunk() - variation 13
+--FILE--
+<?php
+$array = array (1, 2);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+[1]
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+
+[2]
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+}

tests/std/array/array_chunk_variation14.phpt

@@ -0,0 +1,154 @@
+--TEST--
+array_chunk() - variation 14
+--FILE--
+<?php
+$array = array (0, 1, 2);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+[1]
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(1)
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    int(2)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+
+[2]
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [2]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+
+[3]
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+}

tests/std/array/array_chunk_variation15.phpt

@@ -0,0 +1,154 @@
+--TEST--
+array_chunk() - variation 15
+--FILE--
+<?php
+$array = array (1, 2, 3);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+[1]
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[2]
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [2]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[3]
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}

tests/std/array/array_chunk_variation16.phpt

@@ -0,0 +1,233 @@
+--TEST--
+array_chunk() - variation 16
+--FILE--
+<?php
+$array = array (0, 1, 2, 3);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+}
+[1]
+array(4) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(4) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(1)
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    int(2)
+  }
+  [3]=>
+  array(1) {
+    [3]=>
+    int(3)
+  }
+}
+array(4) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[2]
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(3)
+  }
+}
+
+[3]
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [3]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[4]
+array(1) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+}

tests/std/array/array_chunk_variation17.phpt

@@ -0,0 +1,233 @@
+--TEST--
+array_chunk() - variation 17
+--FILE--
+<?php
+$array = array (1, 2, 3, 4);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+}
+[1]
+array(4) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+array(4) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    int(3)
+  }
+  [3]=>
+  array(1) {
+    [3]=>
+    int(4)
+  }
+}
+array(4) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+
+[2]
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+  }
+}
+
+[3]
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  array(1) {
+    [3]=>
+    int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+
+[4]
+array(1) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+}
+array(1) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+}
+array(1) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+}

tests/std/array/array_chunk_variation18.phpt

@@ -0,0 +1,333 @@
+--TEST--
+array_chunk() - variation 18
+--FILE--
+<?php
+$array = array (0, 1, 2, 3, 4);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(5) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+}
+[1]
+array(5) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+array(5) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(1)
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    int(2)
+  }
+  [3]=>
+  array(1) {
+    [3]=>
+    int(3)
+  }
+  [4]=>
+  array(1) {
+    [4]=>
+    int(4)
+  }
+}
+array(5) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+
+[2]
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(3)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+  [2]=>
+  array(1) {
+    [4]=>
+    int(4)
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(3)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+
+[3]
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+  }
+}
+
+[4]
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+  [1]=>
+  array(1) {
+    [4]=>
+    int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+}
+
+[5]
+array(1) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+  }
+}
+array(1) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+  }
+}
+array(1) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+  }
+}

tests/std/array/array_chunk_variation21.phpt

@@ -0,0 +1,41 @@
+--TEST--
+array_chunk() - variation 21
+--FILE--
+<?php
+$array = array ("a" => 1);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(1) {
+  ["a"]=>
+  int(1)
+}
+[1]
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    ["a"]=>
+    int(1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}

tests/std/array/array_chunk_variation22.phpt

@@ -0,0 +1,87 @@
+--TEST--
+array_chunk() - variation 22
+--FILE--
+<?php
+$array = array ("b" => 1, "c" => 2);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(2) {
+  ["b"]=>
+  int(1)
+  ["c"]=>
+  int(2)
+}
+[1]
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    ["b"]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    ["c"]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+
+[2]
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    ["b"]=>
+    int(1)
+    ["c"]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+}

tests/std/array/array_chunk_variation23.phpt

@@ -0,0 +1,436 @@
+--TEST--
+array_chunk() - variation 23
+--FILE--
+<?php
+$array = array ("p" => 1, "q" => 2, "r" => 3, "s" => 4, "u" => 5, "v" => 6);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(6) {
+  ["p"]=>
+  int(1)
+  ["q"]=>
+  int(2)
+  ["r"]=>
+  int(3)
+  ["s"]=>
+  int(4)
+  ["u"]=>
+  int(5)
+  ["v"]=>
+  int(6)
+}
+[1]
+array(6) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    int(5)
+  }
+  [5]=>
+  array(1) {
+    [0]=>
+    int(6)
+  }
+}
+array(6) {
+  [0]=>
+  array(1) {
+    ["p"]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    ["q"]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    ["r"]=>
+    int(3)
+  }
+  [3]=>
+  array(1) {
+    ["s"]=>
+    int(4)
+  }
+  [4]=>
+  array(1) {
+    ["u"]=>
+    int(5)
+  }
+  [5]=>
+  array(1) {
+    ["v"]=>
+    int(6)
+  }
+}
+array(6) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(4)
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    int(5)
+  }
+  [5]=>
+  array(1) {
+    [0]=>
+    int(6)
+  }
+}
+
+[2]
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    ["p"]=>
+    int(1)
+    ["q"]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    ["r"]=>
+    int(3)
+    ["s"]=>
+    int(4)
+  }
+  [2]=>
+  array(2) {
+    ["u"]=>
+    int(5)
+    ["v"]=>
+    int(6)
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+  }
+}
+
+[3]
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(5)
+    [2]=>
+    int(6)
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    ["p"]=>
+    int(1)
+    ["q"]=>
+    int(2)
+    ["r"]=>
+    int(3)
+  }
+  [1]=>
+  array(3) {
+    ["s"]=>
+    int(4)
+    ["u"]=>
+    int(5)
+    ["v"]=>
+    int(6)
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(5)
+    [2]=>
+    int(6)
+  }
+}
+
+[4]
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+  }
+}
+array(2) {
+  [0]=>
+  array(4) {
+    ["p"]=>
+    int(1)
+    ["q"]=>
+    int(2)
+    ["r"]=>
+    int(3)
+    ["s"]=>
+    int(4)
+  }
+  [1]=>
+  array(2) {
+    ["u"]=>
+    int(5)
+    ["v"]=>
+    int(6)
+  }
+}
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+  }
+}
+
+[5]
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(6)
+  }
+}
+array(2) {
+  [0]=>
+  array(5) {
+    ["p"]=>
+    int(1)
+    ["q"]=>
+    int(2)
+    ["r"]=>
+    int(3)
+    ["s"]=>
+    int(4)
+    ["u"]=>
+    int(5)
+  }
+  [1]=>
+  array(1) {
+    ["v"]=>
+    int(6)
+  }
+}
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(6)
+  }
+}
+
+[6]
+array(1) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+}
+array(1) {
+  [0]=>
+  array(6) {
+    ["p"]=>
+    int(1)
+    ["q"]=>
+    int(2)
+    ["r"]=>
+    int(3)
+    ["s"]=>
+    int(4)
+    ["u"]=>
+    int(5)
+    ["v"]=>
+    int(6)
+  }
+}
+array(1) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+}

tests/std/array/array_chunk_variation24.phpt

@@ -0,0 +1,41 @@
+--TEST--
+array_chunk() - variation 24
+--FILE--
+<?php
+$array = array ("a" => "A");
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(1) {
+  ["a"]=>
+  string(1) "A"
+}
+[1]
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    string(1) "A"
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    ["a"]=>
+    string(1) "A"
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    string(1) "A"
+  }
+}

tests/std/array/array_chunk_variation25.phpt

@@ -0,0 +1,436 @@
+--TEST--
+array_chunk() - variation 25
+--FILE--
+<?php
+$array = array ("p" => "A", "q" => "B", "r" => "C", "s" => "D", "u" => "E", "v" => "F");
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(6) {
+  ["p"]=>
+  string(1) "A"
+  ["q"]=>
+  string(1) "B"
+  ["r"]=>
+  string(1) "C"
+  ["s"]=>
+  string(1) "D"
+  ["u"]=>
+  string(1) "E"
+  ["v"]=>
+  string(1) "F"
+}
+[1]
+array(6) {
+  [0]=>
+  array(1) {
+    [0]=>
+    string(1) "A"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(1) "B"
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    string(1) "C"
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    string(1) "D"
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    string(1) "E"
+  }
+  [5]=>
+  array(1) {
+    [0]=>
+    string(1) "F"
+  }
+}
+array(6) {
+  [0]=>
+  array(1) {
+    ["p"]=>
+    string(1) "A"
+  }
+  [1]=>
+  array(1) {
+    ["q"]=>
+    string(1) "B"
+  }
+  [2]=>
+  array(1) {
+    ["r"]=>
+    string(1) "C"
+  }
+  [3]=>
+  array(1) {
+    ["s"]=>
+    string(1) "D"
+  }
+  [4]=>
+  array(1) {
+    ["u"]=>
+    string(1) "E"
+  }
+  [5]=>
+  array(1) {
+    ["v"]=>
+    string(1) "F"
+  }
+}
+array(6) {
+  [0]=>
+  array(1) {
+    [0]=>
+    string(1) "A"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(1) "B"
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    string(1) "C"
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    string(1) "D"
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    string(1) "E"
+  }
+  [5]=>
+  array(1) {
+    [0]=>
+    string(1) "F"
+  }
+}
+
+[2]
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(1) "C"
+    [1]=>
+    string(1) "D"
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    string(1) "E"
+    [1]=>
+    string(1) "F"
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    ["p"]=>
+    string(1) "A"
+    ["q"]=>
+    string(1) "B"
+  }
+  [1]=>
+  array(2) {
+    ["r"]=>
+    string(1) "C"
+    ["s"]=>
+    string(1) "D"
+  }
+  [2]=>
+  array(2) {
+    ["u"]=>
+    string(1) "E"
+    ["v"]=>
+    string(1) "F"
+  }
+}
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(1) "C"
+    [1]=>
+    string(1) "D"
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    string(1) "E"
+    [1]=>
+    string(1) "F"
+  }
+}
+
+[3]
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+    [2]=>
+    string(1) "C"
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    string(1) "D"
+    [1]=>
+    string(1) "E"
+    [2]=>
+    string(1) "F"
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    ["p"]=>
+    string(1) "A"
+    ["q"]=>
+    string(1) "B"
+    ["r"]=>
+    string(1) "C"
+  }
+  [1]=>
+  array(3) {
+    ["s"]=>
+    string(1) "D"
+    ["u"]=>
+    string(1) "E"
+    ["v"]=>
+    string(1) "F"
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+    [2]=>
+    string(1) "C"
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    string(1) "D"
+    [1]=>
+    string(1) "E"
+    [2]=>
+    string(1) "F"
+  }
+}
+
+[4]
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+    [2]=>
+    string(1) "C"
+    [3]=>
+    string(1) "D"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(1) "E"
+    [1]=>
+    string(1) "F"
+  }
+}
+array(2) {
+  [0]=>
+  array(4) {
+    ["p"]=>
+    string(1) "A"
+    ["q"]=>
+    string(1) "B"
+    ["r"]=>
+    string(1) "C"
+    ["s"]=>
+    string(1) "D"
+  }
+  [1]=>
+  array(2) {
+    ["u"]=>
+    string(1) "E"
+    ["v"]=>
+    string(1) "F"
+  }
+}
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+    [2]=>
+    string(1) "C"
+    [3]=>
+    string(1) "D"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(1) "E"
+    [1]=>
+    string(1) "F"
+  }
+}
+
+[5]
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+    [2]=>
+    string(1) "C"
+    [3]=>
+    string(1) "D"
+    [4]=>
+    string(1) "E"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(1) "F"
+  }
+}
+array(2) {
+  [0]=>
+  array(5) {
+    ["p"]=>
+    string(1) "A"
+    ["q"]=>
+    string(1) "B"
+    ["r"]=>
+    string(1) "C"
+    ["s"]=>
+    string(1) "D"
+    ["u"]=>
+    string(1) "E"
+  }
+  [1]=>
+  array(1) {
+    ["v"]=>
+    string(1) "F"
+  }
+}
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+    [2]=>
+    string(1) "C"
+    [3]=>
+    string(1) "D"
+    [4]=>
+    string(1) "E"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(1) "F"
+  }
+}
+
+[6]
+array(1) {
+  [0]=>
+  array(6) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+    [2]=>
+    string(1) "C"
+    [3]=>
+    string(1) "D"
+    [4]=>
+    string(1) "E"
+    [5]=>
+    string(1) "F"
+  }
+}
+array(1) {
+  [0]=>
+  array(6) {
+    ["p"]=>
+    string(1) "A"
+    ["q"]=>
+    string(1) "B"
+    ["r"]=>
+    string(1) "C"
+    ["s"]=>
+    string(1) "D"
+    ["u"]=>
+    string(1) "E"
+    ["v"]=>
+    string(1) "F"
+  }
+}
+array(1) {
+  [0]=>
+  array(6) {
+    [0]=>
+    string(1) "A"
+    [1]=>
+    string(1) "B"
+    [2]=>
+    string(1) "C"
+    [3]=>
+    string(1) "D"
+    [4]=>
+    string(1) "E"
+    [5]=>
+    string(1) "F"
+  }
+}

tests/std/array/array_chunk_variation26.phpt

@@ -0,0 +1,41 @@
+--TEST--
+array_chunk() - variation 26
+--FILE--
+<?php
+$array =array (0);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  int(0)
+}
+[1]
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+}

tests/std/array/array_chunk_variation27.phpt

@@ -0,0 +1,41 @@
+--TEST--
+array_chunk() - variation 27
+--FILE--
+<?php
+$array = array (1);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  int(1)
+}
+[1]
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}

tests/std/array/array_chunk_variation28.phpt

@@ -0,0 +1,41 @@
+--TEST--
+array_chunk() - variation 28
+--FILE--
+<?php
+$array = array (-1);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  int(-1)
+}
+[1]
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(-1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(-1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(-1)
+  }
+}

tests/std/array/array_chunk_variation29.phpt

@@ -0,0 +1,87 @@
+--TEST--
+array_chunk() - variation 29
+--FILE--
+<?php
+$array = array (0, 2);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(2)
+}
+[1]
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+
+[2]
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(2)
+  }
+}

tests/std/array/array_chunk_variation30.phpt

@@ -0,0 +1,154 @@
+--TEST--
+array_chunk() - variation 30
+--FILE--
+<?php
+$array = array (1, 2, 3);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+[1]
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[2]
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [2]=>
+    int(3)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+
+[3]
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}

tests/std/array/array_chunk_variation31.phpt

@@ -0,0 +1,41 @@
+--TEST--
+array_chunk() - variation 31
+--FILE--
+<?php
+$array = array (1 => 0);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(1) {
+  [1]=>
+  int(0)
+}
+[1]
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [1]=>
+    int(0)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+}

tests/std/array/array_chunk_variation32.phpt

@@ -0,0 +1,41 @@
+--TEST--
+array_chunk() - variation 32
+--FILE--
+<?php
+$array = array (2 => 1);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(1) {
+  [2]=>
+  int(1)
+}
+[1]
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [2]=>
+    int(1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}

tests/std/array/array_chunk_variation4.phpt

@@ -0,0 +1,114 @@
+--TEST--
+Test array_chunk() function : usage variations - array with diff. sub arrays
+--FILE--
+<?php
+/*
+* Testing array_chunk() function - input array containing different sub arrays
+*/
+
+echo "*** Testing array_chunk() : usage variations ***\n";
+
+$size = 2;
+
+// input array
+$input_array = array (
+  "array1" => array(),
+  "array2" => array(1, 2, 3),
+  "array3" =>  array(1)
+);
+
+echo "\n-- Testing array_chunk() by supplying an array containing different sub arrays & 'preserve_key' as default --\n";
+var_dump( array_chunk($input_array, $size) );
+
+echo "\n-- Testing array_chunk() by supplying an array containing different sub arrays & 'preserve_key' = true --\n";
+var_dump( array_chunk($input_array, $size, true) );
+
+echo "\n-- Testing array_chunk() by supplying an array containing different sub arrays & 'preserve_key' = false --\n";
+var_dump( array_chunk($input_array, $size, false) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_chunk() : usage variations ***
+
+-- Testing array_chunk() by supplying an array containing different sub arrays & 'preserve_key' as default --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    array(0) {
+    }
+    [1]=>
+    array(3) {
+      [0]=>
+      int(1)
+      [1]=>
+      int(2)
+      [2]=>
+      int(3)
+    }
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    array(1) {
+      [0]=>
+      int(1)
+    }
+  }
+}
+
+-- Testing array_chunk() by supplying an array containing different sub arrays & 'preserve_key' = true --
+array(2) {
+  [0]=>
+  array(2) {
+    ["array1"]=>
+    array(0) {
+    }
+    ["array2"]=>
+    array(3) {
+      [0]=>
+      int(1)
+      [1]=>
+      int(2)
+      [2]=>
+      int(3)
+    }
+  }
+  [1]=>
+  array(1) {
+    ["array3"]=>
+    array(1) {
+      [0]=>
+      int(1)
+    }
+  }
+}
+
+-- Testing array_chunk() by supplying an array containing different sub arrays & 'preserve_key' = false --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    array(0) {
+    }
+    [1]=>
+    array(3) {
+      [0]=>
+      int(1)
+      [1]=>
+      int(2)
+      [2]=>
+      int(3)
+    }
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    array(1) {
+      [0]=>
+      int(1)
+    }
+  }
+}
+Done

tests/std/array/array_chunk_variation5.phpt

@@ -0,0 +1,140 @@
+--TEST--
+Test array_chunk() function : usage variations - different 'size' values
+--FILE--
+<?php
+/*
+ * Testing array_chunk() function with following conditions
+ *   1. -ve size value
+ *   2. size value is more than the no. of elements in the input array
+ *   3. size value is zero
+ *   4. Decimal size value
+*/
+
+echo "*** Testing array_chunk() : usage variations ***\n";
+
+// input array
+$input_array = array(1, 2, 3);
+
+// different magnitude's
+$sizes = array(-1, count($input_array) + 1, 0, 1);
+
+// loop through the array for size argument
+foreach ($sizes as $size){
+    echo "\n-- Testing array_chunk() when size = $size --\n";
+    try {
+        var_dump( array_chunk($input_array, $size) );
+    } catch (\ValueError $e) {
+        echo $e->getMessage() . "\n";
+    }
+    try {
+        var_dump( array_chunk($input_array, $size, true) );
+    } catch (\ValueError $e) {
+        echo $e->getMessage() . "\n";
+    }
+    try {
+        var_dump( array_chunk($input_array, $size, false) );
+    } catch (\ValueError $e) {
+        echo $e->getMessage() . "\n";
+    }
+}
+?>
+--EXPECT--
+*** Testing array_chunk() : usage variations ***
+
+-- Testing array_chunk() when size = -1 --
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+
+-- Testing array_chunk() when size = 4 --
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+
+-- Testing array_chunk() when size = 0 --
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+
+-- Testing array_chunk() when size = 1 --
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    int(3)
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(3)
+  }
+}

tests/std/array/array_chunk_variation6.phpt

@@ -0,0 +1,129 @@
+--TEST--
+Test array_chunk() function : usage variations - different arrays
+--FILE--
+<?php
+/*
+ * Testing array_chunk() function with following conditions
+ *   1. array without elements
+ *   2. associative array with duplicate keys
+ *   3. array with one element
+*/
+
+echo "*** Testing array_chunk() : usage variations ***\n";
+
+// input array
+$input_arrays = array (
+
+  // array without elements
+  "array1" => array(),
+
+  // array with one element
+  "array2" => array(1),
+
+  // associative array with duplicate keys
+  "array3" => array("a" => 1, "b" => 2, "c" => 3, "a" => 4, "d" => 5)
+
+);
+
+$size = 2;
+$count = 1;
+
+echo "\n-- Testing array_chunk() by supplying various arrays --\n";
+
+// loop through the array for 'array' argument
+foreach ($input_arrays as $input_array){
+  echo "\n-- Iteration $count --\n";
+  var_dump( array_chunk($input_array, $size) );
+  var_dump( array_chunk($input_array, $size, true) );
+  var_dump( array_chunk($input_array, $size, false) );
+  $count++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_chunk() : usage variations ***
+
+-- Testing array_chunk() by supplying various arrays --
+
+-- Iteration 1 --
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(5)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    ["a"]=>
+    int(4)
+    ["b"]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    ["c"]=>
+    int(3)
+    ["d"]=>
+    int(5)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(5)
+  }
+}
+Done

tests/std/array/array_chunk_variation7.phpt

@@ -0,0 +1,85 @@
+--TEST--
+Test array_chunk() function : usage variations - references
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+/*
+ * Testing array_chunk() function with following conditions
+ *   1. input array containing references
+*/
+
+echo "*** Testing array_chunk() : usage variations ***\n";
+
+$size = 2;
+
+echo "\n-- Testing array_chunk(), input array containing references \n";
+
+$numbers=array(1, 2, 3, 4);
+// reference array
+$input_array = array (
+  "one" => &$numbers[0],
+  "two" => &$numbers[1],
+  "three" => &$numbers[2],
+  "four" => &$numbers[3]
+);
+
+var_dump( array_chunk($input_array, $size) );
+var_dump( array_chunk($input_array, $size, true) );
+var_dump( array_chunk($input_array, $size, false) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_chunk() : usage variations ***
+
+-- Testing array_chunk(), input array containing references 
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    &int(1)
+    [1]=>
+    &int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    &int(3)
+    [1]=>
+    &int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    ["one"]=>
+    &int(1)
+    ["two"]=>
+    &int(2)
+  }
+  [1]=>
+  array(2) {
+    ["three"]=>
+    &int(3)
+    ["four"]=>
+    &int(4)
+  }
+}
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    &int(1)
+    [1]=>
+    &int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    &int(3)
+    [1]=>
+    &int(4)
+  }
+}
+Done

tests/std/array/array_chunk_variation8.phpt

@@ -0,0 +1,41 @@
+--TEST--
+array_chunk() - variation 8
+--FILE--
+<?php
+$array = array (3 => -1);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(1) {
+  [3]=>
+  int(-1)
+}
+[1]
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(-1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [3]=>
+    int(-1)
+  }
+}
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(-1)
+  }
+}

tests/std/array/array_chunk_variation9.phpt

@@ -0,0 +1,87 @@
+--TEST--
+array_chunk() - variation 9
+--FILE--
+<?php
+$array = array (1 => 0, 2 => 2);
+var_dump ($array);
+for ($i = 1; $i < (sizeof($array) + 1); $i++) {
+    echo "[$i]\n";
+    var_dump (array_chunk ($array, $i));
+    var_dump (array_chunk ($array, $i, TRUE));
+    var_dump (array_chunk ($array, $i, FALSE));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(2) {
+  [1]=>
+  int(0)
+  [2]=>
+  int(2)
+}
+[1]
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    [1]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [2]=>
+    int(2)
+  }
+}
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+
+[2]
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [1]=>
+    int(0)
+    [2]=>
+    int(2)
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(2)
+  }
+}

tests/std/array/array_column_basic.phpt

@@ -0,0 +1,259 @@
+--TEST--
+Test array_column() function: basic functionality
+--SKIPIF--
+<?php die("skip AOT array_column with float keys differs from PHP"); ?>
+--FILE--
+<?php
+class Foo
+{
+    public function __toString(): string {
+        return 'last_name';
+    }
+}
+class Bar
+{
+    public function __toString(): string {
+        return 'first_name';
+    }
+}
+function main()
+{
+    echo "*** Testing array_column() : basic functionality ***\n";
+    /* Array representing a possible record set returned from a database */
+    $records = array(array('id' => 1, 'first_name' => 'John', 'last_name' => 'Doe'), array('id' => 2, 'first_name' => 'Sally', 'last_name' => 'Smith'), array('id' => 3, 'first_name' => 'Jane', 'last_name' => 'Jones'));
+    echo "-- first_name column from recordset --\n";
+    var_dump(array_column($records, 'first_name'));
+    echo "-- id column from recordset --\n";
+    var_dump(array_column($records, 'id'));
+    echo "-- last_name column from recordset, keyed by value from id column --\n";
+    var_dump(array_column($records, 'last_name', 'id'));
+    echo "-- last_name column from recordset, keyed by value from first_name column --\n";
+    var_dump(array_column($records, 'last_name', 'first_name'));
+    echo "\n*** Testing multiple data types ***\n";
+    $fh = fopen(__FILE__, 'r', true);
+    $values = array(array('id' => 1, 'value' => new stdClass()), array('id' => 2, 'value' => 34.2345), array('id' => 3, 'value' => true), array('id' => 4, 'value' => false), array('id' => 5, 'value' => null), array('id' => 6, 'value' => 1234), array('id' => 7, 'value' => 'Foo'), array('id' => 8, 'value' => $fh));
+    var_dump(array_column($values, 'value'));
+    var_dump(array_column($values, 'value', 'id'));
+    echo "\n*** Testing numeric column keys ***\n";
+    $numericCols = array(array('aaa', '111'), array('bbb', '222'), array('ccc', '333', -1 => 'ddd'));
+    var_dump(array_column($numericCols, 1));
+    var_dump(array_column($numericCols, 1, 0));
+    var_dump(array_column($numericCols, 1, 0.123));
+    var_dump(array_column($numericCols, 1, -1));
+    echo "\n*** Testing failure to find specified column ***\n";
+    var_dump(array_column($numericCols, 2));
+    var_dump(array_column($numericCols, 'foo'));
+    var_dump(array_column($numericCols, 0, 'foo'));
+    var_dump(array_column($numericCols, 3.14));
+    echo "\n*** Testing single dimensional array ***\n";
+    $singleDimension = array('foo', 'bar', 'baz');
+    var_dump(array_column($singleDimension, 1));
+    echo "\n*** Testing columns not present in all rows ***\n";
+    $mismatchedColumns = array(array('a' => 'foo', 'b' => 'bar', 'e' => 'bbb'), array('a' => 'baz', 'c' => 'qux', 'd' => 'aaa'), array('a' => 'eee', 'b' => 'fff', 'e' => 'ggg'));
+    var_dump(array_column($mismatchedColumns, 'c'));
+    var_dump(array_column($mismatchedColumns, 'c', 'a'));
+    var_dump(array_column($mismatchedColumns, 'a', 'd'));
+    var_dump(array_column($mismatchedColumns, 'a', 'e'));
+    var_dump(array_column($mismatchedColumns, 'b'));
+    var_dump(array_column($mismatchedColumns, 'b', 'a'));
+    echo "\n*** Testing use of object converted to string ***\n";
+    $f = new Foo();
+    $b = new Bar();
+    var_dump(array_column($records, $f));
+    var_dump(array_column($records, $f, $b));
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+*** Testing array_column() : basic functionality ***
+-- first_name column from recordset --
+array(3) {
+  [0]=>
+  string(4) "John"
+  [1]=>
+  string(5) "Sally"
+  [2]=>
+  string(4) "Jane"
+}
+-- id column from recordset --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+-- last_name column from recordset, keyed by value from id column --
+array(3) {
+  [1]=>
+  string(3) "Doe"
+  [2]=>
+  string(5) "Smith"
+  [3]=>
+  string(5) "Jones"
+}
+-- last_name column from recordset, keyed by value from first_name column --
+array(3) {
+  ["John"]=>
+  string(3) "Doe"
+  ["Sally"]=>
+  string(5) "Smith"
+  ["Jane"]=>
+  string(5) "Jones"
+}
+
+*** Testing multiple data types ***
+array(8) {
+  [0]=>
+  object(stdClass)#%d (0) {
+  }
+  [1]=>
+  float(34.2345)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(false)
+  [4]=>
+  NULL
+  [5]=>
+  int(1234)
+  [6]=>
+  string(3) "Foo"
+  [7]=>
+  resource(%d) of type (stream)
+}
+array(8) {
+  [1]=>
+  object(stdClass)#%d (0) {
+  }
+  [2]=>
+  float(34.2345)
+  [3]=>
+  bool(true)
+  [4]=>
+  bool(false)
+  [5]=>
+  NULL
+  [6]=>
+  int(1234)
+  [7]=>
+  string(3) "Foo"
+  [8]=>
+  resource(%d) of type (stream)
+}
+
+*** Testing numeric column keys ***
+array(3) {
+  [0]=>
+  string(3) "111"
+  [1]=>
+  string(3) "222"
+  [2]=>
+  string(3) "333"
+}
+array(3) {
+  ["aaa"]=>
+  string(3) "111"
+  ["bbb"]=>
+  string(3) "222"
+  ["ccc"]=>
+  string(3) "333"
+}
+
+Deprecated: Implicit conversion from float 0.123 to int loses precision in %s on line %d
+array(3) {
+  ["aaa"]=>
+  string(3) "111"
+  ["bbb"]=>
+  string(3) "222"
+  ["ccc"]=>
+  string(3) "333"
+}
+array(3) {
+  [0]=>
+  string(3) "111"
+  [1]=>
+  string(3) "222"
+  ["ddd"]=>
+  string(3) "333"
+}
+
+*** Testing failure to find specified column ***
+array(0) {
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  string(3) "aaa"
+  [1]=>
+  string(3) "bbb"
+  [2]=>
+  string(3) "ccc"
+}
+
+Deprecated: Implicit conversion from float 3.14 to int loses precision in %s on line %d
+array(0) {
+}
+
+*** Testing single dimensional array ***
+array(0) {
+}
+
+*** Testing columns not present in all rows ***
+array(1) {
+  [0]=>
+  string(3) "qux"
+}
+array(1) {
+  ["baz"]=>
+  string(3) "qux"
+}
+array(3) {
+  [0]=>
+  string(3) "foo"
+  ["aaa"]=>
+  string(3) "baz"
+  [1]=>
+  string(3) "eee"
+}
+array(3) {
+  ["bbb"]=>
+  string(3) "foo"
+  [0]=>
+  string(3) "baz"
+  ["ggg"]=>
+  string(3) "eee"
+}
+array(2) {
+  [0]=>
+  string(3) "bar"
+  [1]=>
+  string(3) "fff"
+}
+array(2) {
+  ["foo"]=>
+  string(3) "bar"
+  ["eee"]=>
+  string(3) "fff"
+}
+
+*** Testing use of object converted to string ***
+array(3) {
+  [0]=>
+  string(3) "Doe"
+  [1]=>
+  string(5) "Smith"
+  [2]=>
+  string(5) "Jones"
+}
+array(3) {
+  ["John"]=>
+  string(3) "Doe"
+  ["Sally"]=>
+  string(5) "Smith"
+  ["Jane"]=>
+  string(5) "Jones"
+}
+Done

tests/std/array/array_column_numeric_string_key.phpt

@@ -0,0 +1,23 @@
+--TEST--
+array_column() treats numeric string keys as usual
+--FILE--
+<?php
+
+$array = [[42 => 'a'], [42 => 'b']];
+var_dump(array_column($array, 42));
+var_dump(array_column($array, "42"));
+
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+}
+array(2) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+}

tests/std/array/array_column_object_cast.phpt

@@ -0,0 +1,38 @@
+--TEST--
+Test array_column() function: basic functionality
+--FILE--
+<?php
+class ColumnKeyClass
+{
+    function __toString(): string {
+        return 'first_name';
+    }
+}
+class IndexKeyClass
+{
+    function __toString(): string {
+        return 'id';
+    }
+}
+function main()
+{
+    $column_key = new ColumnKeyClass();
+    $index_key = new IndexKeyClass();
+    // Array representing a possible record set returned from a database
+    $records = array(array('id' => 2135, 'first_name' => 'John', 'last_name' => 'XXX'), array('id' => 3245, 'first_name' => 'Sally', 'last_name' => 'Smith'));
+    $firstNames = array_column($records, $column_key, $index_key);
+    print_r($firstNames);
+    var_dump($column_key);
+    var_dump($index_key);
+}
+?>
+--EXPECT--
+Array
+(
+    [2135] => John
+    [3245] => Sally
+)
+object(ColumnKeyClass)#1 (0) {
+}
+object(IndexKeyClass)#2 (0) {
+}

tests/std/array/array_column_property_visibility.phpt

@@ -0,0 +1,31 @@
+--TEST--
+array_column() respects property visibility
+--FILE--
+<?php
+class Test
+{
+    private $prop;
+    public function __construct($value)
+    {
+        $this->prop = $value;
+    }
+    public function __isset($name): bool
+    {
+        return true;
+    }
+    public function __get($name)
+    {
+        return "__get({$this->prop})";
+    }
+}
+function main()
+{
+    $arr = [new Test("foobar")];
+    var_dump(array_column($arr, "prop"));
+}
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  string(13) "__get(foobar)"
+}

tests/std/array/array_column_scalar_index_strict_types.phpt

@@ -0,0 +1,66 @@
+--TEST--
+Test array_column(): Index argument with various types in strict type mode
+--SKIPIF--
+<?php die("skip AOT does not enforce strict_types for internal function calls"); ?>
+--FILE--
+<?php
+declare(strict_types=1);
+
+function main() {
+    echo "\n-- Testing array_column() column key parameter should be a string or an integer (testing bool) --\n";
+    try {
+        var_dump(array_column([['php7', 'foo'], ['php8', 'bar']], false));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+    try {
+        var_dump(array_column([['php7', 'foo'], ['php8', 'bar']], true));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+
+    echo "\n-- Testing array_column() column key parameter should be a string or integer (testing array) --\n";
+    try {
+        var_dump(array_column([['php7', 'foo'], ['php8', 'bar']], array()));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+
+    echo "\n-- Testing array_column() index key parameter should be a string or an integer (testing bool) --\n";
+    try {
+        var_dump(array_column([['php' => 7, 'foo'], ['php' => 8, 'bar']], 'php', false));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+    try {
+        var_dump(array_column([['php' => 7, 'foo'], ['php' => 8, 'bar']], 'php', true));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+
+    echo "\n-- Testing array_column() index key parameter should be a string or integer (testing array) --\n";
+    try {
+        var_dump(array_column([['php' => 7, 'foo'], ['php' => 8, 'bar']], 'php', array()));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+
+    echo "DONE\n";
+}
+?>
+--EXPECT--
+-- Testing array_column() column key parameter should be a string or an integer (testing bool) --
+array_column(): Argument #2 ($column_key) must be of type string|int|null, false given
+array_column(): Argument #2 ($column_key) must be of type string|int|null, true given
+
+-- Testing array_column() column key parameter should be a string or integer (testing array) --
+array_column(): Argument #2 ($column_key) must be of type string|int|null, array given
+
+-- Testing array_column() index key parameter should be a string or an integer (testing bool) --
+array_column(): Argument #3 ($index_key) must be of type string|int|null, false given
+array_column(): Argument #3 ($index_key) must be of type string|int|null, true given
+
+-- Testing array_column() index key parameter should be a string or integer (testing array) --
+array_column(): Argument #3 ($index_key) must be of type string|int|null, array given
+
+DONE

tests/std/array/array_column_scalar_index_weak_types.phpt

@@ -0,0 +1,83 @@
+--TEST--
+Test array_column(): Index argument with various types in weak type mode
+--SKIPIF--
+--FILE--
+<?php
+
+function main() {
+    echo "\n-- Testing array_column() column key parameter should be a string or an integer (testing bool) --\n";
+    try {
+        var_dump(array_column([['php7', 'foo'], ['php8', 'bar']], false));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+    try {
+        var_dump(array_column([['php7', 'foo'], ['php8', 'bar']], true));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+
+    echo "\n-- Testing array_column() column key parameter should be a string or integer (testing array) --\n";
+    try {
+        var_dump(array_column([['php7', 'foo'], ['php8', 'bar']], array()));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+
+    echo "\n-- Testing array_column() index key parameter should be a string or an integer (testing bool) --\n";
+    try {
+        var_dump(array_column([['php' => 7, 'foo'], ['php' => 8, 'bar']], 'php', false));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+    try {
+        var_dump(array_column([['php' => 7, 'foo'], ['php' => 8, 'bar']], 'php', true));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+
+    echo "\n-- Testing array_column() index key parameter should be a string or integer (testing array) --\n";
+    try {
+        var_dump(array_column([['php' => 7, 'foo'], ['php' => 8, 'bar']], 'php', array()));
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+
+    echo "DONE\n";
+}
+?>
+--EXPECT--
+-- Testing array_column() column key parameter should be a string or an integer (testing bool) --
+array(2) {
+  [0]=>
+  string(4) "php7"
+  [1]=>
+  string(4) "php8"
+}
+array(2) {
+  [0]=>
+  string(3) "foo"
+  [1]=>
+  string(3) "bar"
+}
+
+-- Testing array_column() column key parameter should be a string or integer (testing array) --
+array_column(): Argument #2 ($column_key) must be of type string|int|null, array given
+
+-- Testing array_column() index key parameter should be a string or an integer (testing bool) --
+array(2) {
+  ["foo"]=>
+  int(7)
+  ["bar"]=>
+  int(8)
+}
+array(2) {
+  [0]=>
+  int(7)
+  [1]=>
+  int(8)
+}
+
+-- Testing array_column() index key parameter should be a string or integer (testing array) --
+array_column(): Argument #3 ($index_key) must be of type string|int|null, array given
+DONE

tests/std/array/array_column_variant.phpt

@@ -0,0 +1,86 @@
+--TEST--
+Test array_column() function: variant functionality
+--FILE--
+<?php
+/* Array from Bug Request #64493 test script */
+$rows = array(
+  456 => array('id' => '3', 'title' => 'Foo', 'date' => '2013-03-25'),
+  457 => array('id' => '5', 'title' => 'Bar', 'date' => '2012-05-20'),
+);
+
+echo "-- pass null as second parameter to get back all columns indexed by third parameter --\n";
+var_dump(array_column($rows, null, 'id'));
+
+echo "-- pass null as second parameter and bogus third param to get back zero-indexed array of all columns --\n";
+var_dump(array_column($rows, null, 'foo'));
+
+echo "-- pass null as second parameter and no third param to get back array_values(input) --\n";
+var_dump(array_column($rows, null));
+
+echo "Done\n";
+?>
+--EXPECT--
+-- pass null as second parameter to get back all columns indexed by third parameter --
+array(2) {
+  [3]=>
+  array(3) {
+    ["id"]=>
+    string(1) "3"
+    ["title"]=>
+    string(3) "Foo"
+    ["date"]=>
+    string(10) "2013-03-25"
+  }
+  [5]=>
+  array(3) {
+    ["id"]=>
+    string(1) "5"
+    ["title"]=>
+    string(3) "Bar"
+    ["date"]=>
+    string(10) "2012-05-20"
+  }
+}
+-- pass null as second parameter and bogus third param to get back zero-indexed array of all columns --
+array(2) {
+  [0]=>
+  array(3) {
+    ["id"]=>
+    string(1) "3"
+    ["title"]=>
+    string(3) "Foo"
+    ["date"]=>
+    string(10) "2013-03-25"
+  }
+  [1]=>
+  array(3) {
+    ["id"]=>
+    string(1) "5"
+    ["title"]=>
+    string(3) "Bar"
+    ["date"]=>
+    string(10) "2012-05-20"
+  }
+}
+-- pass null as second parameter and no third param to get back array_values(input) --
+array(2) {
+  [0]=>
+  array(3) {
+    ["id"]=>
+    string(1) "3"
+    ["title"]=>
+    string(3) "Foo"
+    ["date"]=>
+    string(10) "2013-03-25"
+  }
+  [1]=>
+  array(3) {
+    ["id"]=>
+    string(1) "5"
+    ["title"]=>
+    string(3) "Bar"
+    ["date"]=>
+    string(10) "2012-05-20"
+  }
+}
+Done

tests/std/array/array_column_variant_objects.phpt

@@ -0,0 +1,142 @@
+--TEST--
+Test array_column() function: testing with objects
+--FILE--
+<?php
+class User
+{
+    public $id, $first_name, $last_name;
+    public function __construct($id, $first_name, $last_name)
+    {
+        $this->id = $id;
+        $this->first_name = $first_name;
+        $this->last_name = $last_name;
+    }
+}
+function newUser($id, $first_name, $last_name)
+{
+    $o = new stdClass();
+    $o->{0} = $id;
+    $o->{1} = $first_name;
+    $o->{2} = $last_name;
+    return $o;
+}
+class Something
+{
+    public function __isset($name): bool
+    {
+        return $name == 'first_name';
+    }
+    public function __get($name)
+    {
+        return new User(4, 'Jack', 'Sparrow');
+    }
+}
+function main()
+{
+    $records = array(newUser(1, 'John', 'Doe'), newUser(2, 'Sally', 'Smith'), newUser(3, 'Jane', 'Jones'), new User(1, 'John', 'Doe'), new User(2, 'Sally', 'Smith'), new User(3, 'Jane', 'Jones'), new Something());
+    echo "*** Testing array_column() : object property fetching (numeric property names) ***\n";
+    echo "-- first_name column from recordset --\n";
+    var_dump(array_column($records, 1));
+    echo "-- id column from recordset --\n";
+    var_dump(array_column($records, 0));
+    echo "-- last_name column from recordset, keyed by value from id column --\n";
+    var_dump(array_column($records, 2, 0));
+    echo "-- last_name column from recordset, keyed by value from first_name column --\n";
+    var_dump(array_column($records, 2, 1));
+    echo "*** Testing array_column() : object property fetching (string property names) ***\n";
+    echo "-- first_name column from recordset --\n";
+    var_dump(array_column($records, 'first_name'));
+    echo "-- id column from recordset --\n";
+    var_dump(array_column($records, 'id'));
+    echo "-- last_name column from recordset, keyed by value from id column --\n";
+    var_dump(array_column($records, 'last_name', 'id'));
+    echo "-- last_name column from recordset, keyed by value from first_name column --\n";
+    var_dump(array_column($records, 'last_name', 'first_name'));
+    echo "Done\n";
+}
+?>
+--EXPECT--
+*** Testing array_column() : object property fetching (numeric property names) ***
+-- first_name column from recordset --
+array(3) {
+  [0]=>
+  string(4) "John"
+  [1]=>
+  string(5) "Sally"
+  [2]=>
+  string(4) "Jane"
+}
+-- id column from recordset --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+-- last_name column from recordset, keyed by value from id column --
+array(3) {
+  [1]=>
+  string(3) "Doe"
+  [2]=>
+  string(5) "Smith"
+  [3]=>
+  string(5) "Jones"
+}
+-- last_name column from recordset, keyed by value from first_name column --
+array(3) {
+  ["John"]=>
+  string(3) "Doe"
+  ["Sally"]=>
+  string(5) "Smith"
+  ["Jane"]=>
+  string(5) "Jones"
+}
+*** Testing array_column() : object property fetching (string property names) ***
+-- first_name column from recordset --
+array(4) {
+  [0]=>
+  string(4) "John"
+  [1]=>
+  string(5) "Sally"
+  [2]=>
+  string(4) "Jane"
+  [3]=>
+  object(User)#8 (3) {
+    ["id"]=>
+    int(4)
+    ["first_name"]=>
+    string(4) "Jack"
+    ["last_name"]=>
+    string(7) "Sparrow"
+  }
+}
+-- id column from recordset --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+-- last_name column from recordset, keyed by value from id column --
+array(3) {
+  [1]=>
+  string(3) "Doe"
+  [2]=>
+  string(5) "Smith"
+  [3]=>
+  string(5) "Jones"
+}
+-- last_name column from recordset, keyed by value from first_name column --
+array(3) {
+  ["John"]=>
+  string(3) "Doe"
+  ["Sally"]=>
+  string(5) "Smith"
+  ["Jane"]=>
+  string(5) "Jones"
+}
+Done

tests/std/array/array_combine.phpt

@@ -0,0 +1,155 @@
+--TEST--
+basic array_combine test
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support $$ variable variables");
+?>
+--FILE--
+<?php
+$array1 = array('green', 'red', 'yellow');
+$array2 = array('1', '2', '3');
+$array3 = array(0, 1, 2);
+$array4 = array(TRUE, FALSE, NULL);
+$a = array_combine($array1, $array1);
+$b = array_combine($array1, $array2);
+$c = array_combine($array1, $array3);
+$d = array_combine($array1, $array4);
+$e = array_combine($array2, $array1);
+$f = array_combine($array2, $array2);
+$g = array_combine($array2, $array3);
+$h = array_combine($array2, $array4);
+$i = array_combine($array3, $array1);
+$j = array_combine($array3, $array2);
+$k = array_combine($array3, $array3);
+$l = array_combine($array3, $array4);
+$m = array_combine($array4, $array1);
+$n = array_combine($array4, $array2);
+$o = array_combine($array4, $array3);
+$p = array_combine($array4, $array4);
+
+$letters = range('a', 'p');
+foreach ($letters as $letter) {
+    var_dump($$letter);
+}
+?>
+--EXPECT--
+array(3) {
+  ["green"]=>
+  string(5) "green"
+  ["red"]=>
+  string(3) "red"
+  ["yellow"]=>
+  string(6) "yellow"
+}
+array(3) {
+  ["green"]=>
+  string(1) "1"
+  ["red"]=>
+  string(1) "2"
+  ["yellow"]=>
+  string(1) "3"
+}
+array(3) {
+  ["green"]=>
+  int(0)
+  ["red"]=>
+  int(1)
+  ["yellow"]=>
+  int(2)
+}
+array(3) {
+  ["green"]=>
+  bool(true)
+  ["red"]=>
+  bool(false)
+  ["yellow"]=>
+  NULL
+}
+array(3) {
+  [1]=>
+  string(5) "green"
+  [2]=>
+  string(3) "red"
+  [3]=>
+  string(6) "yellow"
+}
+array(3) {
+  [1]=>
+  string(1) "1"
+  [2]=>
+  string(1) "2"
+  [3]=>
+  string(1) "3"
+}
+array(3) {
+  [1]=>
+  int(0)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+array(3) {
+  [1]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [3]=>
+  NULL
+}
+array(3) {
+  [0]=>
+  string(5) "green"
+  [1]=>
+  string(3) "red"
+  [2]=>
+  string(6) "yellow"
+}
+array(3) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  string(1) "2"
+  [2]=>
+  string(1) "3"
+}
+array(3) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+array(3) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(false)
+  [2]=>
+  NULL
+}
+array(2) {
+  [1]=>
+  string(5) "green"
+  [""]=>
+  string(6) "yellow"
+}
+array(2) {
+  [1]=>
+  string(1) "1"
+  [""]=>
+  string(1) "3"
+}
+array(2) {
+  [1]=>
+  int(0)
+  [""]=>
+  int(2)
+}
+array(2) {
+  [1]=>
+  bool(true)
+  [""]=>
+  NULL
+}

tests/std/array/array_combine_basic.phpt

@@ -0,0 +1,46 @@
+--TEST--
+Test array_combine() function : basic functionality
+--FILE--
+<?php
+echo "*** Testing array_combine() : basic functionality ***\n";
+
+/* Different arrays for $keys and $values arguments */
+
+// array with default keys for $keys and $values arguments
+$keys_array = array(1, 2);
+$values_array = array(3,4);
+var_dump( array_combine($keys_array, $values_array) );
+
+// associative arrays for $keys and $values arguments
+$keys_array = array(1 => "a", 2 => 'b');
+$values_array = array(3 => 'c', 4 => "d");
+var_dump( array_combine($keys_array, $values_array) );
+
+// mixed array for $keys and $values arguments
+$keys_array = array(1, 2 => "b");
+$values_array = array(3 => 'c', 4);
+var_dump( array_combine($keys_array, $values_array) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_combine() : basic functionality ***
+array(2) {
+  [1]=>
+  int(3)
+  [2]=>
+  int(4)
+}
+array(2) {
+  ["a"]=>
+  string(1) "c"
+  ["b"]=>
+  string(1) "d"
+}
+array(2) {
+  [1]=>
+  string(1) "c"
+  ["b"]=>
+  int(4)
+}
+Done

tests/std/array/array_combine_error2.phpt

@@ -0,0 +1,48 @@
+--TEST--
+Test array_combine() function : error conditions - empty array
+--FILE--
+<?php
+echo "*** Testing array_combine() : error conditions specific to array_combine() ***\n";
+
+// Testing array_combine by passing empty arrays to $keys and $values arguments
+echo "\n-- Testing array_combine() function with empty arrays --\n";
+var_dump( array_combine(array(), array()) );
+
+// Testing array_combine by passing empty array to $keys
+echo "\n-- Testing array_combine() function with empty array for \$keys argument --\n";
+try {
+    var_dump( array_combine(array(), array(1, 2)) );
+} catch (\ValueError $e) {
+    echo $e->getMessage();
+}
+
+// Testing array_combine by passing empty array to $values
+echo "\n-- Testing array_combine() function with empty array for \$values argument --\n";
+try {
+    var_dump( array_combine(array(1, 2), array()) );
+} catch (\ValueError $e) {
+    echo $e->getMessage();
+}
+
+// Testing array_combine with arrays having unequal number of elements
+echo "\n-- Testing array_combine() function by passing array with unequal number of elements --\n";
+try {
+    var_dump( array_combine(array(1, 2), array(1, 2, 3)) );
+} catch (\ValueError $e) {
+    echo $e->getMessage();
+}
+
+?>
+--EXPECT--
+*** Testing array_combine() : error conditions specific to array_combine() ***
+
+-- Testing array_combine() function with empty arrays --
+array(0) {
+}
+
+-- Testing array_combine() function with empty array for $keys argument --
+array_combine(): Argument #1 ($keys) and argument #2 ($values) must have the same number of elements
+-- Testing array_combine() function with empty array for $values argument --
+array_combine(): Argument #1 ($keys) and argument #2 ($values) must have the same number of elements
+-- Testing array_combine() function by passing array with unequal number of elements --
+array_combine(): Argument #1 ($keys) and argument #2 ($values) must have the same number of elements

tests/std/array/array_combine_variation3.phpt

@@ -0,0 +1,275 @@
+--TEST--
+Test array_combine() function : usage variations - different arrays(Bug#43424)
+--SKIPIF--
+<?php die("skip AOT float-to-string key precision differs from PHP"); ?>
+--FILE--
+<?php
+ini_set("serialize_precision", "14");
+/*
+* Passing different types of arrays to both $keys and $values arguments and testing whether
+* array_combine() behaves in an expected way with the arguments passed to the function
+*/
+
+echo "*** Testing array_combine() : Passing different types of arrays to both \$keys and \$values argument ***\n";
+/* Different heredoc strings passed as argument to arrays */
+// heredoc with blank line
+$blank_line = <<<EOT
+
+
+EOT;
+
+// heredoc with multiline string
+$multiline_string = <<<EOT
+hello world
+The quick brown fox jumped over;
+the lazy dog
+This is a double quoted string
+EOT;
+
+// heredoc with different whitespaces
+$diff_whitespaces = <<<EOT
+hello\r world\t
+1111\t\t != 2222\v\v
+heredoc\ndouble quoted string. with\vdifferent\fwhite\vspaces
+EOT;
+
+// heredoc with quoted strings and numeric values
+$numeric_string = <<<EOT
+11 < 12. 123 >22
+'single quoted string'
+"double quoted string"
+2222 != 1111.\t 0000 = 0000\n
+EOT;
+
+// arrays passed to $keys argument
+$arrays = array (
+/*1*/  array(1, 2), // with default keys and numeric values
+       array(1.1, 2.2), // with default keys & float values
+       array(false,true), // with default keys and boolean values
+       array(), // empty array
+/*5*/  array(NULL), // with NULL
+       array("a\v\f","aaaa\r","b","b\tbbb","c","\[\]\!\@\#\$\%\^\&\*\(\)\{\}"),  // with double quoted strings
+       array('a\v\f','aaaa\r','b','b\tbbb','c','\[\]\!\@\#\$\%\^\&\*\(\)\{\}'),  // with single quoted strings
+       array("h1" => $blank_line, "h2" => $multiline_string, "h3" => $diff_whitespaces, $numeric_string),  // with heredocs
+
+       // associative arrays
+/*9*/  array(1 => "one", 2 => "two", 3 => "three"),  // explicit numeric keys, string values
+       array("one" => 1, "two" => 2, "three" => 3 ),  // string keys & numeric values
+       array( 1 => 10, 2 => 20, 4 => 40, 3 => 30),  // explicit numeric keys and numeric values
+       array( "one" => "ten", "two" => "twenty", "three" => "thirty"),  // string key/value
+       array("one" => 1, 2 => "two", 4 => "four"),  //mixed
+
+       // associative array, containing null/empty/boolean values as key/value
+/*14*/ array(NULL => "NULL", null => "null", "NULL" => NULL, "null" => null),
+       array(true => "true", false => "false", "false" => false, "true" => true),
+       array("" => "emptyd", '' => 'emptys', "emptyd" => "", 'emptys' => ''),
+       array(1 => '', 2 => "", 3 => NULL, 4 => null, 5 => false, 6 => true),
+       array('' => 1, "" => 2, NULL => 3, null => 4, false => 5, true => 6),
+
+       // array with repetitive keys
+/*19*/ array("One" => 1, "two" => 2, "One" => 10, "two" => 20, "three" => 3)
+);
+
+// loop through each sub-array within $arrays to check the behavior of array_combine()
+// same arrays are passed to both $keys and $values
+$iterator = 1;
+foreach($arrays as $array) {
+  echo "-- Iteration $iterator --\n";
+  var_dump( array_combine($array, $array) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_combine() : Passing different types of arrays to both $keys and $values argument ***
+-- Iteration 1 --
+array(2) {
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+-- Iteration 2 --
+array(2) {
+  ["1.1"]=>
+  float(1.1)
+  ["2.2"]=>
+  float(2.2)
+}
+-- Iteration 3 --
+array(2) {
+  [""]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+-- Iteration 4 --
+array(0) {
+}
+-- Iteration 5 --
+array(1) {
+  [""]=>
+  NULL
+}
+-- Iteration 6 --
+array(6) {
+  ["a"]=>
+  string(3) "a"
+  ["aaaa
"]=>
+  string(5) "aaaa
"
+  ["b"]=>
+  string(1) "b"
+  ["b	bbb"]=>
+  string(5) "b	bbb"
+  ["c"]=>
+  string(1) "c"
+  ["\[\]\!\@\#$\%\^\&\*\(\)\{\}"]=>
+  string(27) "\[\]\!\@\#$\%\^\&\*\(\)\{\}"
+}
+-- Iteration 7 --
+array(6) {
+  ["a\v\f"]=>
+  string(5) "a\v\f"
+  ["aaaa\r"]=>
+  string(6) "aaaa\r"
+  ["b"]=>
+  string(1) "b"
+  ["b\tbbb"]=>
+  string(6) "b\tbbb"
+  ["c"]=>
+  string(1) "c"
+  ["\[\]\!\@\#\$\%\^\&\*\(\)\{\}"]=>
+  string(28) "\[\]\!\@\#\$\%\^\&\*\(\)\{\}"
+}
+-- Iteration 8 --
+array(4) {
+  ["
+"]=>
+  string(1) "
+"
+  ["hello world
+The quick brown fox jumped over;
+the lazy dog
+This is a double quoted string"]=>
+  string(88) "hello world
+The quick brown fox jumped over;
+the lazy dog
+This is a double quoted string"
+  ["hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+  ["11 < 12. 123 >22
+'single quoted string'
+"double quoted string"
+2222 != 1111.	 0000 = 0000
+"]=>
+  string(90) "11 < 12. 123 >22
+'single quoted string'
+"double quoted string"
+2222 != 1111.	 0000 = 0000
+"
+}
+-- Iteration 9 --
+array(3) {
+  ["one"]=>
+  string(3) "one"
+  ["two"]=>
+  string(3) "two"
+  ["three"]=>
+  string(5) "three"
+}
+-- Iteration 10 --
+array(3) {
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+}
+-- Iteration 11 --
+array(4) {
+  [10]=>
+  int(10)
+  [20]=>
+  int(20)
+  [40]=>
+  int(40)
+  [30]=>
+  int(30)
+}
+-- Iteration 12 --
+array(3) {
+  ["ten"]=>
+  string(3) "ten"
+  ["twenty"]=>
+  string(6) "twenty"
+  ["thirty"]=>
+  string(6) "thirty"
+}
+-- Iteration 13 --
+array(3) {
+  [1]=>
+  int(1)
+  ["two"]=>
+  string(3) "two"
+  ["four"]=>
+  string(4) "four"
+}
+-- Iteration 14 --
+array(2) {
+  ["null"]=>
+  string(4) "null"
+  [""]=>
+  NULL
+}
+-- Iteration 15 --
+array(4) {
+  ["true"]=>
+  string(4) "true"
+  ["false"]=>
+  string(5) "false"
+  [""]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+-- Iteration 16 --
+array(2) {
+  ["emptys"]=>
+  string(6) "emptys"
+  [""]=>
+  string(0) ""
+}
+-- Iteration 17 --
+array(2) {
+  [""]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+-- Iteration 18 --
+array(3) {
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+  [6]=>
+  int(6)
+}
+-- Iteration 19 --
+array(3) {
+  [10]=>
+  int(10)
+  [20]=>
+  int(20)
+  [3]=>
+  int(3)
+}
+Done

tests/std/array/array_combine_variation4.phpt

@@ -0,0 +1,150 @@
+--TEST--
+Test array_combine() function : usage variations - associative array with different keys(Bug#43424)
+--SKIPIF--
+<?php die("skip AOT float-to-string key precision differs from PHP"); ?>
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    ini_set("serialize_precision", "14");
+    /*
+     * Testing the functionality of array_combine() by passing different
+     * associative arrays having different possible keys to $keys argument and
+     * associative arrays having different possible keys to $values argument.
+    */
+    echo "*** Testing array_combine() : assoc array with diff keys to both \$keys and \$values argument ***\n";
+    // get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // get a resource variable
+    $fp = fopen(__FILE__, "r");
+    // get a heredoc string
+    $heredoc = <<<EOT
+    Hello world
+    EOT;
+    // different variations of associative arrays to be passed to $arr1 argument
+    $arrays = array(
+        // empty array
+        /*1*/
+        array(),
+        // arrays with integer keys
+        array(0 => "0"),
+        array(1 => "1"),
+        array(1 => "1", 2 => "2", 3 => "3", 4 => "4"),
+        // arrays with string keys
+        /*7*/
+        array('\tHello' => 111, 're\td' => "color", '\v\fworld' => 2.2, 'pen\n' => 33),
+        array("\tHello" => 111, "re\td" => "color", "\v\fworld" => 2.2, "pen\n" => 33),
+        array("hello", $heredoc => "string"),
+        // heredoc
+        // array with object, unset variable and resource variable
+        /*10*/
+        array(@$unset_var => "hello", $fp => 'resource'),
+        // array with mixed keys
+        /*11*/
+        array('hello' => 1, "fruit" => 2.2, $fp => 'resource', 133 => "int", @$unset_var => "unset", $heredoc => "heredoc"),
+    );
+    // array to be passsed to $arr2 argument
+    $arr2 = array(0 => 0, 2 => "float", 4 => "f3", 33333333 => "f4", "\tHello" => 111, 2.2, 'color', "Hello world" => "string", "pen\n" => 33, 133 => "int");
+    // loop through each sub-array within $arrays to check the behavior of array_combine()
+    // same arrays are passed to both $keys and $values
+    $iterator = 1;
+    foreach ($arrays as $array) {
+        echo "-- Iteration {$iterator} --\n";
+        var_dump(array_combine($array, $array));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_combine() : assoc array with diff keys to both $keys and $values argument ***
+
+Warning: Resource ID#%d used as offset, casting to integer (%d) in %s on line %d
+
+Warning: Resource ID#%d used as offset, casting to integer (%d) in %s on line %d
+-- Iteration 1 --
+array(0) {
+}
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  string(1) "0"
+}
+-- Iteration 3 --
+array(1) {
+  [1]=>
+  string(1) "1"
+}
+-- Iteration 4 --
+array(4) {
+  [1]=>
+  string(1) "1"
+  [2]=>
+  string(1) "2"
+  [3]=>
+  string(1) "3"
+  [4]=>
+  string(1) "4"
+}
+-- Iteration 5 --
+array(4) {
+  [111]=>
+  int(111)
+  ["color"]=>
+  string(5) "color"
+  ["2.2"]=>
+  float(2.2)
+  [33]=>
+  int(33)
+}
+-- Iteration 6 --
+array(4) {
+  [111]=>
+  int(111)
+  ["color"]=>
+  string(5) "color"
+  ["2.2"]=>
+  float(2.2)
+  [33]=>
+  int(33)
+}
+-- Iteration 7 --
+array(2) {
+  ["hello"]=>
+  string(5) "hello"
+  ["string"]=>
+  string(6) "string"
+}
+-- Iteration 8 --
+array(2) {
+  ["hello"]=>
+  string(5) "hello"
+  ["resource"]=>
+  string(8) "resource"
+}
+-- Iteration 9 --
+array(6) {
+  [1]=>
+  int(1)
+  ["2.2"]=>
+  float(2.2)
+  ["resource"]=>
+  string(8) "resource"
+  ["int"]=>
+  string(3) "int"
+  ["unset"]=>
+  string(5) "unset"
+  ["heredoc"]=>
+  string(7) "heredoc"
+}
+Done

tests/std/array/array_combine_variation5.phpt

@@ -0,0 +1,172 @@
+--TEST--
+Test array_combine() function : usage variations - associative array with different values(Bug#43424)
+--SKIPIF--
+<?php die("skip AOT float-to-string key precision differs from PHP"); ?>
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    ini_set("serialize_precision", "14");
+    /*
+    * Testing the functionality of array_combine() by passing various
+    * associative arrays having different possible values to $keys argument and
+    * associative arrays having different possible values to $values argument.
+    */
+    echo "*** Testing array_combine() : assoc array with diff values to both \$keys and \$values argument ***\n";
+    // get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // get a resource variable
+    $fp = fopen(__FILE__, "r");
+    // get a heredoc string
+    $heredoc = <<<EOT
+    Hello world
+    EOT;
+    // different variations of associative array
+    $arrays = array(
+        // empty array
+        /*1*/
+        array(),
+        // arrays with integer values
+        array('0' => 0),
+        array("1" => 1),
+        array("one" => 1, 'two' => 2, "three" => 3, 4 => 4),
+        // arrays with float values
+        /*5*/
+        array("float" => 2.3333),
+        array("f1" => 1.2, 'f2' => 3.33, 3 => 4.89999922839999, 'f4' => 33333333.333),
+        // arrays with string values
+        /*7*/
+        array(111 => "\tHello", "red" => "col\tor", 2 => "\v\fworld", 3 => "pen\n"),
+        array(111 => '\tHello', "red" => 'col\tor', 2 => '\v\fworld', 3 => 'pen\n'),
+        array(1 => "hello", "heredoc" => $heredoc),
+        // array with object, unset variable and resource variable
+        /*10*/
+        array(11 => new classA(), "unset" => @$unset_var, "resource" => $fp),
+        // array with mixed values
+        /*11*/
+        array(1 => 'hello', 2 => new classA(), 222 => "fruit", 'resource' => $fp, "int" => 133, "float" => 444.432, "unset" => @$unset_var, "heredoc" => $heredoc),
+    );
+    // loop through each sub-array within $arrays to check the behavior of array_combine()
+    $iterator = 1;
+    foreach ($arrays as $array) {
+        echo "-- Iteration {$iterator} --\n";
+        var_dump(array_combine($array, $array));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_combine() : assoc array with diff values to both $keys and $values argument ***
+-- Iteration 1 --
+array(0) {
+}
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  int(0)
+}
+-- Iteration 3 --
+array(1) {
+  [1]=>
+  int(1)
+}
+-- Iteration 4 --
+array(4) {
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+}
+-- Iteration 5 --
+array(1) {
+  ["2.3333"]=>
+  float(2.3333)
+}
+-- Iteration 6 --
+array(4) {
+  ["1.2"]=>
+  float(1.2)
+  ["3.33"]=>
+  float(3.33)
+  ["4.8999992284"]=>
+  float(4.89999922839999)
+  ["33333333.333"]=>
+  float(33333333.333)
+}
+-- Iteration 7 --
+array(4) {
+  ["	Hello"]=>
+  string(6) "	Hello"
+  ["col	or"]=>
+  string(6) "col	or"
+  ["world"]=>
+  string(7) "world"
+  ["pen
+"]=>
+  string(4) "pen
+"
+}
+-- Iteration 8 --
+array(4) {
+  ["\tHello"]=>
+  string(7) "\tHello"
+  ["col\tor"]=>
+  string(7) "col\tor"
+  ["\v\fworld"]=>
+  string(9) "\v\fworld"
+  ["pen\n"]=>
+  string(5) "pen\n"
+}
+-- Iteration 9 --
+array(2) {
+  ["hello"]=>
+  string(5) "hello"
+  ["Hello world"]=>
+  string(11) "Hello world"
+}
+-- Iteration 10 --
+array(3) {
+  ["Class A object"]=>
+  object(classA)#%d (0) {
+  }
+  [""]=>
+  NULL
+  ["Resource id #%d"]=>
+  resource(%d) of type (stream)
+}
+-- Iteration 11 --
+array(8) {
+  ["hello"]=>
+  string(5) "hello"
+  ["Class A object"]=>
+  object(classA)#%d (0) {
+  }
+  ["fruit"]=>
+  string(5) "fruit"
+  ["Resource id #%d"]=>
+  resource(%d) of type (stream)
+  [133]=>
+  int(133)
+  ["444.432"]=>
+  float(444.432)
+  [""]=>
+  NULL
+  ["Hello world"]=>
+  string(11) "Hello world"
+}
+Done

tests/std/array/array_combine_variation6.phpt

@@ -0,0 +1,47 @@
+--TEST--
+Test array_combine() function : usage variations - binary safe checking
+--FILE--
+<?php
+/*
+* Testing the behavior of array_combine() by passing array with
+* binary values for $keys and $values argument.
+*/
+
+echo "*** Testing array_combine() : binary safe checking ***\n";
+
+// array with binary values
+$arr_binary = array(b"hello", b"world");
+$arr_normal = array("hello", "world");
+
+// array with binary value for $keys and $values argument
+var_dump( array_combine($arr_binary, $arr_binary) );
+
+// array with binary value for $values argument
+var_dump( array_combine($arr_normal, $arr_binary) );
+
+// array with binary value for $keys argument
+var_dump( array_combine($arr_binary, $arr_normal) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_combine() : binary safe checking ***
+array(2) {
+  ["hello"]=>
+  string(5) "hello"
+  ["world"]=>
+  string(5) "world"
+}
+array(2) {
+  ["hello"]=>
+  string(5) "hello"
+  ["world"]=>
+  string(5) "world"
+}
+array(2) {
+  ["hello"]=>
+  string(5) "hello"
+  ["world"]=>
+  string(5) "world"
+}
+Done

tests/std/array/array_count_values.phpt

@@ -0,0 +1,94 @@
+--TEST--
+array_count_values()
+--FILE--
+<?php
+$arrays = array (
+    array (),
+    array (0),
+    array (1),
+    array (-1),
+    array (0, 0),
+    array (0, 1),
+    array (1, 1),
+    array (1, "hello", 1, "world", "hello"),
+    array ("hello", "world", "hello"),
+    array ("", "world", "", "hello", "world", "hello", "hello", "world", "hello"),
+    array (0, array (1, "hello", 1, "world", "hello")),
+    array (1, array (1, "hello", 1, "world", "hello"), array (1, "hello", 1, "world", "hello"), array (1, "hello", 1, "world", "hello")),
+);
+
+foreach ($arrays as $item) {
+    var_dump (@array_count_values ($item));
+    echo "\n";
+}
+?>
+--EXPECT--
+array(0) {
+}
+
+array(1) {
+  [0]=>
+  int(1)
+}
+
+array(1) {
+  [1]=>
+  int(1)
+}
+
+array(1) {
+  [-1]=>
+  int(1)
+}
+
+array(1) {
+  [0]=>
+  int(2)
+}
+
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+}
+
+array(1) {
+  [1]=>
+  int(2)
+}
+
+array(3) {
+  [1]=>
+  int(2)
+  ["hello"]=>
+  int(2)
+  ["world"]=>
+  int(1)
+}
+
+array(2) {
+  ["hello"]=>
+  int(2)
+  ["world"]=>
+  int(1)
+}
+
+array(3) {
+  [""]=>
+  int(2)
+  ["world"]=>
+  int(3)
+  ["hello"]=>
+  int(4)
+}
+
+array(1) {
+  [0]=>
+  int(1)
+}
+
+array(1) {
+  [1]=>
+  int(1)
+}

tests/std/array/array_count_values2.phpt

@@ -0,0 +1,43 @@
+--TEST--
+basic array_count_values test
+--FILE--
+<?php
+$array1 = array(1,
+                "hello",
+                1,
+                "world",
+                "hello",
+                "",
+                "rabbit",
+                "foo",
+                "Foo",
+                TRUE,
+                FALSE,
+                NULL,
+                0);
+var_dump(array_count_values($array1));
+?>
+--EXPECTF--
+Warning:%S Can only count string and integer values, entry skipped in %s on line %d
+
+Warning:%S Can only count string and integer values, entry skipped in %s on line %d
+
+Warning:%S Can only count string and integer values, entry skipped in %s on line %d
+array(8) {
+  [1]=>
+  int(2)
+  ["hello"]=>
+  int(2)
+  ["world"]=>
+  int(1)
+  [""]=>
+  int(1)
+  ["rabbit"]=>
+  int(1)
+  ["foo"]=>
+  int(1)
+  ["Foo"]=>
+  int(1)
+  [0]=>
+  int(1)
+}

tests/std/array/array_count_values_variation.phpt

@@ -0,0 +1,41 @@
+--TEST--
+Test array_count_values() function : Test all normal parameter variations
+--FILE--
+<?php
+class A
+{
+    static function hello()
+    {
+        echo "Hello\n";
+    }
+}
+function main()
+{
+    /*
+     * Test behaviour with parameter variations
+     */
+    echo "*** Testing array_count_values() : parameter variations ***\n";
+    $ob = new A();
+    $fp = fopen("array_count_file", "w+");
+    $arrays = array("bobk" => "bobv", "val", 6 => "val6", $fp, $ob);
+    var_dump(@array_count_values($arrays));
+    echo "\n";
+    echo "Done";
+}
+?>
+--CLEAN--
+<?php
+    unlink("array_count_file");
+?>
+--EXPECT--
+*** Testing array_count_values() : parameter variations ***
+array(3) {
+  ["bobv"]=>
+  int(1)
+  ["val"]=>
+  int(1)
+  ["val6"]=>
+  int(1)
+}
+
+Done

tests/std/array/array_diff_1.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Test array_diff when non-array is passed
+--FILE--
+<?php
+//-=-=-=-=-
+$a = array();
+$b = 3;
+$c = array(5);
+try {
+    array_diff($a, $b, $c);
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+//-=-=-=-=-=-
+echo "OK!";
+?>
+--EXPECT--
+array_diff(): Argument #2 must be of type array, int given
+OK!

tests/std/array/array_diff_assoc.phpt

@@ -0,0 +1,46 @@
+--TEST--
+basic array_diff_assoc test
+--FILE--
+<?php
+$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red", "");
+$array2 = array("a" => "green", "yellow", "red", TRUE);
+$array3 = array("red", "a"=>"brown", "");
+$result[] = array_diff_assoc($array1, $array2);
+$result[] = array_diff_assoc($array1, $array3);
+$result[] = array_diff_assoc($array2, $array3);
+$result[] = array_diff_assoc($array1, $array2, $array3);
+print_r($result);
+?>
+--EXPECT--
+Array
+(
+    [0] => Array
+        (
+            [b] => brown
+            [c] => blue
+            [0] => red
+            [1] => 
+        )
+
+    [1] => Array
+        (
+            [a] => green
+            [b] => brown
+            [c] => blue
+        )
+
+    [2] => Array
+        (
+            [a] => green
+            [0] => yellow
+            [1] => red
+            [2] => 1
+        )
+
+    [3] => Array
+        (
+            [b] => brown
+            [c] => blue
+        )
+
+)

tests/std/array/array_diff_assoc_basic.phpt

@@ -0,0 +1,84 @@
+--TEST--
+Test array_diff_assoc() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of array_diff_assoc
+ */
+
+echo "*** Testing array_diff_assoc() : basic functionality ***\n";
+$array_default_key = array('one',       2,            'three', '4');
+$array_numeric_key = array(1 => 'one',  2=> 'two',    3 => 4);
+$array_string_key  = array('one' => 1, 'two' => '2', '3' => 'three');
+
+
+
+echo "-- Compare Default keys to numeric keys --\n";
+var_dump(array_diff_assoc($array_default_key, $array_numeric_key));
+var_dump(array_diff_assoc($array_numeric_key, $array_default_key));
+
+
+echo "\n-- Compare Default keys to string keys --\n";
+var_dump(array_diff_assoc($array_default_key, $array_numeric_key));
+var_dump(array_diff_assoc($array_numeric_key, $array_default_key));
+
+
+echo "\n-- Compare numeric keys to string keys --\n";
+var_dump(array_diff_assoc($array_numeric_key, $array_string_key));
+var_dump(array_diff_assoc($array_string_key, $array_numeric_key));
+
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : basic functionality ***
+-- Compare Default keys to numeric keys --
+array(3) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  [2]=>
+  string(5) "three"
+}
+array(2) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+
+-- Compare Default keys to string keys --
+array(3) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  [2]=>
+  string(5) "three"
+}
+array(2) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+
+-- Compare numeric keys to string keys --
+array(3) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  int(4)
+}
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  string(1) "2"
+  [3]=>
+  string(5) "three"
+}
+Done

tests/std/array/array_diff_assoc_variation1.phpt

@@ -0,0 +1,179 @@
+--TEST--
+Test array_diff_assoc() function : usage variations  - unexpected values for 'array1' argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Pass array_diff_assoc arguments that are not arrays in place of $array1
+     */
+    echo "*** Testing array_diff_assoc() : usage variations ***\n";
+    $array = array(1, 2, 3);
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    // get a resource variable
+    $fp = fopen(__FILE__, "r");
+    //array of unexpected values to be passed to $array1 argument
+    $inputs = array(
+        // int data
+        /*1*/
+        0,
+        1,
+        12345,
+        -2345,
+        // float data
+        /*5*/
+        10.5,
+        -10.5,
+        123456789000.0,
+        1.23456789E-9,
+        0.5,
+        // null data
+        /*10*/
+        NULL,
+        null,
+        // boolean data
+        /*12*/
+        true,
+        false,
+        TRUE,
+        FALSE,
+        // empty data
+        /*16*/
+        "",
+        '',
+        // string data
+        /*18*/
+        "string",
+        'string',
+        $heredoc,
+        // binary data
+        /*21*/
+        "binary",
+        (string) "binary",
+        // object data
+        /*23*/
+        new classA(),
+        // undefined data
+        /*24*/
+        @$undefined_var,
+        // unset data
+        /*25*/
+        @$unset_var,
+        // resource variable
+        /*26*/
+        $fp,
+    );
+    // loop through each element of $inputs to check the behavior of array_diff_assoc
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "\n-- Iteration {$iterator} --\n";
+        try {
+            var_dump(array_diff_assoc($input, $array));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : usage variations ***
+
+-- Iteration 1 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 2 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 3 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 4 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 5 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 6 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 7 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 8 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 9 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 10 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 11 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 12 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, true given
+
+-- Iteration 13 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, false given
+
+-- Iteration 14 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, true given
+
+-- Iteration 15 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, false given
+
+-- Iteration 16 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 17 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 18 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 19 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 20 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 21 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 22 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 23 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, classA given
+
+-- Iteration 24 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 25 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 26 --
+array_diff_assoc(): Argument #1 ($array) must be of type array, resource given
+Done

tests/std/array/array_diff_assoc_variation10.phpt

@@ -0,0 +1,43 @@
+--TEST--
+Test array_diff_assoc() function : usage variations - binary safe check
+--FILE--
+<?php
+/*
+ * Test how array_diff_assoc() compares binary data
+ */
+
+echo "*** Testing array_diff_assoc() : usage variations ***\n";
+
+$array1 = array( b"1",
+                 b"hello",
+                 "world",
+                 "str1" => "hello",
+                 "str2" => "world");
+
+$array2 = array( b"1" => 'hello',
+                 b"world",
+                 "hello",
+                 'test');
+
+var_dump(array_diff_assoc($array1, $array2));
+var_dump(array_diff_assoc($array2, $array1));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : usage variations ***
+array(3) {
+  [0]=>
+  string(1) "1"
+  ["str1"]=>
+  string(5) "hello"
+  ["str2"]=>
+  string(5) "world"
+}
+array(2) {
+  [3]=>
+  string(5) "hello"
+  [4]=>
+  string(4) "test"
+}
+Done

tests/std/array/array_diff_assoc_variation2.phpt

@@ -0,0 +1,179 @@
+--TEST--
+Test array_diff_assoc() function : usage variations  - unexpected values for 'array1' argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * pass array_diff_assoc arguments which are not arrays in place of $array2
+     */
+    echo "\n*** Testing array_diff_assoc() : usage variations ***\n";
+    $array = array(1, 2, 3);
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    // get a resource variable
+    $fp = fopen(__FILE__, "r");
+    //array of unexpected values to be passed to $array1 argument
+    $inputs = array(
+        // int data
+        /*1*/
+        0,
+        1,
+        12345,
+        -2345,
+        // float data
+        /*5*/
+        10.5,
+        -10.5,
+        123456789000.0,
+        1.23456789E-9,
+        0.5,
+        // null data
+        /*10*/
+        NULL,
+        null,
+        // boolean data
+        /*12*/
+        true,
+        false,
+        TRUE,
+        FALSE,
+        // empty data
+        /*16*/
+        "",
+        '',
+        // string data
+        /*18*/
+        "string",
+        'string',
+        $heredoc,
+        // binary data
+        /*21*/
+        "binary",
+        (string) "binary",
+        // object data
+        /*23*/
+        new classA(),
+        // undefined data
+        /*24*/
+        @$undefined_var,
+        // unset data
+        /*25*/
+        @$unset_var,
+        // resource variable
+        /*26*/
+        $fp,
+    );
+    // loop through each element of $inputs to check the behavior of array_diff_assoc
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "\n-- Iteration {$iterator} --\n";
+        try {
+            var_dump(array_diff_assoc($array, $input));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : usage variations ***
+
+-- Iteration 1 --
+array_diff_assoc(): Argument #2 must be of type array, int given
+
+-- Iteration 2 --
+array_diff_assoc(): Argument #2 must be of type array, int given
+
+-- Iteration 3 --
+array_diff_assoc(): Argument #2 must be of type array, int given
+
+-- Iteration 4 --
+array_diff_assoc(): Argument #2 must be of type array, int given
+
+-- Iteration 5 --
+array_diff_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 6 --
+array_diff_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 7 --
+array_diff_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 8 --
+array_diff_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 9 --
+array_diff_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 10 --
+array_diff_assoc(): Argument #2 must be of type array, null given
+
+-- Iteration 11 --
+array_diff_assoc(): Argument #2 must be of type array, null given
+
+-- Iteration 12 --
+array_diff_assoc(): Argument #2 must be of type array, true given
+
+-- Iteration 13 --
+array_diff_assoc(): Argument #2 must be of type array, false given
+
+-- Iteration 14 --
+array_diff_assoc(): Argument #2 must be of type array, true given
+
+-- Iteration 15 --
+array_diff_assoc(): Argument #2 must be of type array, false given
+
+-- Iteration 16 --
+array_diff_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 17 --
+array_diff_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 18 --
+array_diff_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 19 --
+array_diff_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 20 --
+array_diff_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 21 --
+array_diff_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 22 --
+array_diff_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 23 --
+array_diff_assoc(): Argument #2 must be of type array, classA given
+
+-- Iteration 24 --
+array_diff_assoc(): Argument #2 must be of type array, null given
+
+-- Iteration 25 --
+array_diff_assoc(): Argument #2 must be of type array, null given
+
+-- Iteration 26 --
+array_diff_assoc(): Argument #2 must be of type array, resource given
+Done

tests/std/array/array_diff_assoc_variation3.phpt

@@ -0,0 +1,165 @@
+--TEST--
+Test array_diff_assoc() function : variation - array containing different data types
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Test how array_diff_assoc() compares indexed arrays containing different data types
+     */
+    echo "\n*** Testing array_diff_assoc() : usage variations ***\n";
+    $array = array(1, 2, 3);
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    //array of different data types to be passed to $arr1 argument
+    $inputs = array(
+        // int data
+        /*1*/
+        'int' => array(0, 1, 12345, -2345),
+        // float data
+        /*2*/
+        'float' => array(10.5, -10.5, 123456789000.0, 1.23456789E-9, 0.5),
+        // null data
+        /*3*/
+        'null' => array(NULL, null),
+        // boolean data
+        /*4*/
+        'bool' => array(true, false, TRUE, FALSE),
+        // empty data
+        /*5*/
+        'empty' => array("", ''),
+        // string data
+        /*6*/
+        'string' => array("string", 'string', $heredoc),
+        // binary data
+        /*7*/
+        'binary' => array("binary", (string) "binary"),
+        // object data
+        /*8*/
+        'object' => array(new classA()),
+        // undefined data
+        /*9*/
+        'undefined' => array(@$undefined_var),
+        // unset data
+        /*10*/
+        'unset' => array(@$unset_var),
+    );
+    // loop through each element of $inputs to check the behavior of array_diff_assoc
+    $iterator = 1;
+    foreach ($inputs as $key => $input) {
+        echo "\n-- Iteration {$iterator} --\n";
+        var_dump(array_diff_assoc($input, $array));
+        $iterator++;
+    }
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_diff_assoc() : usage variations ***
+
+-- Iteration 1 --
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(12345)
+  [3]=>
+  int(-2345)
+}
+
+-- Iteration 2 --
+array(5) {
+  [0]=>
+  float(10.5)
+  [1]=>
+  float(-10.5)
+  [2]=>
+  float(123456789000)
+  [3]=>
+  float(1.23456789E-9)
+  [4]=>
+  float(0.5)
+}
+
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+
+-- Iteration 4 --
+array(3) {
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(false)
+}
+
+-- Iteration 5 --
+array(2) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+}
+
+-- Iteration 6 --
+array(3) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(6) "string"
+  [2]=>
+  string(11) "hello world"
+}
+
+-- Iteration 7 --
+array(2) {
+  [0]=>
+  string(6) "binary"
+  [1]=>
+  string(6) "binary"
+}
+
+-- Iteration 8 --
+array(1) {
+  [0]=>
+  object(classA)#%d (0) {
+  }
+}
+
+-- Iteration 9 --
+array(1) {
+  [0]=>
+  NULL
+}
+
+-- Iteration 10 --
+array(1) {
+  [0]=>
+  NULL
+}
+Done

tests/std/array/array_diff_assoc_variation4.phpt

@@ -0,0 +1,156 @@
+--TEST--
+Test array_diff_assoc() function : usage variations - arrays with different data types as keys
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Test how array_diff_assoc() compares arrays containing different data types
+ * as keys
+ */
+
+echo "\n*** Testing array_diff_assoc() : usage variations ***\n";
+
+$array = array(1, 2, 3);
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// heredoc string
+$heredoc = <<<EOT
+hello world
+EOT;
+
+//Different data types as keys to be passed to $arr1 argument
+$inputs = array(
+
+       // int data
+/*1*/
+'int' => array(
+       0 => 'zero',
+       1 => 'one',
+       12345 => 'positive',
+       -2345 => 'negative'),
+
+       // null data
+/*3*/
+'null' => array(
+       NULL => 'null 1',
+       null => 'null 2'),
+
+       // boolean data
+/*4*/
+'bool' => array(
+       true => 'boolt',
+       false => 'boolf',
+       TRUE => 'boolT',
+       FALSE => 'boolF'),
+
+       // empty data
+/*5*/
+'empty' => array(
+      "" => 'emptyd',
+      '' => 'emptys'),
+
+       // string data
+/*6*/
+'string' => array(
+      "string" => 'stringd',
+      'string' => 'strings',
+      $heredoc => 'stringh'),
+
+       // binary data
+/*7*/
+'binary' => array(
+      b"binary1" => 'binary 1',
+      (binary)"binary2" => 'binary 2'),
+
+       // undefined data
+/*8*/
+'undefined' => array(
+      @$undefined_var => 'undefined'),
+
+       // unset data
+/*9*/
+'unset' => array(
+      @$unset_var => 'unset'),
+
+);
+
+// loop through each element of $inputs to check the behavior of array_diff_assoc
+$iterator = 1;
+foreach($inputs as $key => $input) {
+  echo "\n-- Iteration $iterator --\n";
+  var_dump( array_diff_assoc($input, $array));
+  $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : usage variations ***
+
+-- Iteration 1 --
+array(4) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [12345]=>
+  string(8) "positive"
+  [-2345]=>
+  string(8) "negative"
+}
+
+-- Iteration 2 --
+array(1) {
+  [""]=>
+  string(6) "null 2"
+}
+
+-- Iteration 3 --
+array(2) {
+  [1]=>
+  string(5) "boolT"
+  [0]=>
+  string(5) "boolF"
+}
+
+-- Iteration 4 --
+array(1) {
+  [""]=>
+  string(6) "emptys"
+}
+
+-- Iteration 5 --
+array(2) {
+  ["string"]=>
+  string(7) "strings"
+  ["hello world"]=>
+  string(7) "stringh"
+}
+
+-- Iteration 6 --
+array(2) {
+  ["binary1"]=>
+  string(8) "binary 1"
+  ["binary2"]=>
+  string(8) "binary 2"
+}
+
+-- Iteration 7 --
+array(1) {
+  [""]=>
+  string(9) "undefined"
+}
+
+-- Iteration 8 --
+array(1) {
+  [""]=>
+  string(5) "unset"
+}
+Done

tests/std/array/array_diff_assoc_variation5.phpt

@@ -0,0 +1,141 @@
+--TEST--
+Test array_diff_assoc() function : usage variations - compare integers, floats and strings
+--FILE--
+<?php
+/*
+ * Test how array_diff_assoc compares integers, floats and string
+ */
+
+echo "*** Testing array_diff_assoc() : usage variations ***\n";
+$arr_default_int = array(1, 2, 3, 'a');
+$arr_float = array(0 => 1.00, 1 => 2.00, 2 => 3.00, 'b');
+$arr_string = array('1', '2', '3', 'c');
+$arr_string_float = array('0' => '1.00', '1.00' => '2.00', '2.00' => '3.00', 'd');
+
+echo "-- Result of comparing integers and floating point numbers: --\n";
+var_dump(array_diff_assoc($arr_default_int, $arr_float));
+var_dump(array_diff_assoc($arr_float, $arr_default_int));
+
+echo "-- Result of comparing integers and strings containing an integers : --\n";
+var_dump(array_diff_assoc($arr_default_int, $arr_string));
+var_dump(array_diff_assoc($arr_string, $arr_default_int));
+
+echo "-- Result of comparing integers and strings containing floating points : --\n";
+var_dump(array_diff_assoc($arr_default_int, $arr_string_float));
+var_dump(array_diff_assoc($arr_string_float, $arr_default_int));
+
+echo "-- Result of comparing floating points and strings containing integers : --\n";
+var_dump(array_diff_assoc($arr_float, $arr_string));
+var_dump(array_diff_assoc($arr_string, $arr_float));
+
+echo "-- Result of comparing floating points and strings containing floating point: --\n";
+var_dump(array_diff_assoc($arr_float, $arr_string_float));
+var_dump(array_diff_assoc($arr_string_float, $arr_float));
+
+echo "-- Result of comparing strings containing integers and strings containing floating points : --\n";
+var_dump(array_diff_assoc($arr_string, $arr_string_float));
+var_dump(array_diff_assoc($arr_string_float, $arr_string));
+
+echo "-- Result of comparing more than two arrays: --\n";
+var_dump(array_diff_assoc($arr_default_int, $arr_float, $arr_string, $arr_string_float));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : usage variations ***
+-- Result of comparing integers and floating point numbers: --
+array(1) {
+  [3]=>
+  string(1) "a"
+}
+array(1) {
+  [3]=>
+  string(1) "b"
+}
+-- Result of comparing integers and strings containing an integers : --
+array(1) {
+  [3]=>
+  string(1) "a"
+}
+array(1) {
+  [3]=>
+  string(1) "c"
+}
+-- Result of comparing integers and strings containing floating points : --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  string(1) "a"
+}
+array(4) {
+  [0]=>
+  string(4) "1.00"
+  ["1.00"]=>
+  string(4) "2.00"
+  ["2.00"]=>
+  string(4) "3.00"
+  [1]=>
+  string(1) "d"
+}
+-- Result of comparing floating points and strings containing integers : --
+array(1) {
+  [3]=>
+  string(1) "b"
+}
+array(1) {
+  [3]=>
+  string(1) "c"
+}
+-- Result of comparing floating points and strings containing floating point: --
+array(4) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(2)
+  [2]=>
+  float(3)
+  [3]=>
+  string(1) "b"
+}
+array(4) {
+  [0]=>
+  string(4) "1.00"
+  ["1.00"]=>
+  string(4) "2.00"
+  ["2.00"]=>
+  string(4) "3.00"
+  [1]=>
+  string(1) "d"
+}
+-- Result of comparing strings containing integers and strings containing floating points : --
+array(4) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  string(1) "2"
+  [2]=>
+  string(1) "3"
+  [3]=>
+  string(1) "c"
+}
+array(4) {
+  [0]=>
+  string(4) "1.00"
+  ["1.00"]=>
+  string(4) "2.00"
+  ["2.00"]=>
+  string(4) "3.00"
+  [1]=>
+  string(1) "d"
+}
+-- Result of comparing more than two arrays: --
+array(1) {
+  [3]=>
+  string(1) "a"
+}
+Done

tests/std/array/array_diff_assoc_variation6.phpt

@@ -0,0 +1,192 @@
+--TEST--
+Test array_diff_assoc() function : usage variations - strict string comparison check
+--SKIPIF--
+<?php die("skip AOT float-to-string key precision differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * Test how array_diff_assoc behaves
+ * 1. When comparing an array that has similar elements
+ *    but has been created in a different order
+ * 2. When doing a strict comparison of string representation
+ */
+
+echo "*** Testing array_diff_assoc() : usage variations ***\n";
+
+$array = array ('zero',
+                1 => 1,
+                'two' => 2.00000000000001);
+
+$inputs = array (
+
+//default keys => string values
+/*1*/	array('2.00000000000001', '1', 'zero', 'a'),
+
+//numeric keys => string values
+/*2*/	array(2 => '2.00000000000001',
+              1 => '1',
+              0 => 'zero',
+              3 => 'a'),
+
+//string keys => string values
+/*3*/	array('2' => '2.00000000000001',
+              '1' => '1',
+              '0' => 'zero',
+              '3' => 'a') ,
+
+//default keys => numeric values
+/*4*/	array(2, 1, 0),
+
+//numeric keys => numeric values
+/*5*/	array(2 => 2,
+              1 => 1,
+              0 => 0),
+
+//string keys => numeric values
+/*6*/	array('two' => 2,
+              '1' => 1,
+              '0' => 0),
+
+//default keys => float values
+/*7*/	array(2.00000000000001, 1.00, 0.01E-9),
+
+//numeric keys => float values
+/*8*/	array(2 => 2.00000000000001,
+              1 =>  1.00,
+              0 => 0.01E-9),
+
+//string keys => float values
+/*9*/	array ('two' => 2.00000000000001,
+               '1' => 1.00,
+               '0' =>0.01E-9)
+);
+
+// loop through each element of $inputs to check the behavior of array_diff_assoc
+$iterator = 1;
+foreach($inputs as $input) {
+  echo "\n-- Iteration $iterator --\n";
+  var_dump(array_diff_assoc($array, $input));
+  var_dump(array_diff_assoc($input, $array));
+  $iterator++;
+};
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : usage variations ***
+
+-- Iteration 1 --
+array(2) {
+  [0]=>
+  string(4) "zero"
+  ["two"]=>
+  float(2.00000000000001)
+}
+array(3) {
+  [0]=>
+  string(16) "2.00000000000001"
+  [2]=>
+  string(4) "zero"
+  [3]=>
+  string(1) "a"
+}
+
+-- Iteration 2 --
+array(1) {
+  ["two"]=>
+  float(2.00000000000001)
+}
+array(2) {
+  [2]=>
+  string(16) "2.00000000000001"
+  [3]=>
+  string(1) "a"
+}
+
+-- Iteration 3 --
+array(1) {
+  ["two"]=>
+  float(2.00000000000001)
+}
+array(2) {
+  [2]=>
+  string(16) "2.00000000000001"
+  [3]=>
+  string(1) "a"
+}
+
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  string(4) "zero"
+  ["two"]=>
+  float(2.00000000000001)
+}
+array(2) {
+  [0]=>
+  int(2)
+  [2]=>
+  int(0)
+}
+
+-- Iteration 5 --
+array(2) {
+  [0]=>
+  string(4) "zero"
+  ["two"]=>
+  float(2.00000000000001)
+}
+array(2) {
+  [2]=>
+  int(2)
+  [0]=>
+  int(0)
+}
+
+-- Iteration 6 --
+array(1) {
+  [0]=>
+  string(4) "zero"
+}
+array(1) {
+  [0]=>
+  int(0)
+}
+
+-- Iteration 7 --
+array(2) {
+  [0]=>
+  string(4) "zero"
+  ["two"]=>
+  float(2.00000000000001)
+}
+array(2) {
+  [0]=>
+  float(2.00000000000001)
+  [2]=>
+  float(1.0E-11)
+}
+
+-- Iteration 8 --
+array(2) {
+  [0]=>
+  string(4) "zero"
+  ["two"]=>
+  float(2.00000000000001)
+}
+array(2) {
+  [2]=>
+  float(2.00000000000001)
+  [0]=>
+  float(1.0E-11)
+}
+
+-- Iteration 9 --
+array(1) {
+  [0]=>
+  string(4) "zero"
+}
+array(1) {
+  [0]=>
+  float(1.0E-11)
+}
+Done

tests/std/array/array_diff_assoc_variation7.phpt

@@ -0,0 +1,97 @@
+--TEST--
+Test array_diff_assoc() function : usage variations - arrays containing referenced variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support cross-type variable reassignment");
+?>
+
+--FILE--
+<?php
+/*
+ * Tests how array_diff_assoc compares
+ * 1. Referenced variables
+ * 2. Arrays that have been referenced to each other
+ */
+
+echo "*** Testing array_diff_assoc() : usage variations ***\n";
+
+$a = 'a';
+
+$arr1 = array('a', 'b', 'c', $a);
+$arr2 = array('a' => 1, 'b' => 2, 'c' => 3, &$a);
+
+echo "-- Results when \$a = $a: --\n";
+var_dump(array_diff_assoc($arr1, $arr2));
+var_dump(array_diff_assoc($arr2, $arr1));
+
+$a = 4;
+
+echo "-- Results when \$a has been changed to $a: --\n";
+var_dump(array_diff_assoc($arr1, $arr2));
+var_dump(array_diff_assoc($arr2, $arr1));
+
+$arr2 = &$arr1;
+
+echo "-- Results when \$arr2 is referenced to \$arr1 --\n";
+var_dump(array_diff_assoc($arr1, $arr2));
+var_dump(array_diff_assoc($arr2, $arr1));
+
+$arr1 = array('zero' => 'x', 'one' => 'y', 'two' => 'z');
+
+echo "-- Results when \$arr1 is changed --\n";
+var_dump(array_diff_assoc($arr1, $arr2));
+var_dump(array_diff_assoc($arr2, $arr1));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : usage variations ***
+-- Results when $a = a: --
+array(3) {
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+  [3]=>
+  string(1) "a"
+}
+array(3) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  int(2)
+  ["c"]=>
+  int(3)
+}
+-- Results when $a has been changed to 4: --
+array(4) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+  [3]=>
+  string(1) "a"
+}
+array(4) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  int(2)
+  ["c"]=>
+  int(3)
+  [0]=>
+  &int(4)
+}
+-- Results when $arr2 is referenced to $arr1 --
+array(0) {
+}
+array(0) {
+}
+-- Results when $arr1 is changed --
+array(0) {
+}
+array(0) {
+}
+Done

tests/std/array/array_diff_assoc_variation8.phpt

@@ -0,0 +1,42 @@
+--TEST--
+Test array_diff_assoc() function : usage variations - array containing duplicate keys and values
+--FILE--
+<?php
+/*
+ * Test how array_diff_assoc() behaves when comparing:
+ * 1. the order of the array
+ * 2. duplicate values
+ * 3. duplicate key names
+ */
+
+echo "*** Testing array_diff_assoc() : variation ***\n";
+
+$array_index = array('a', 'b', 'c', 0 => 'd', 'b');   //duplicate key (0), duplicate value (b)
+$array_assoc = array ('2' => 'c',   //same key=>value pair, different order
+                      '1' => 'b',
+                      '0' => 'a',
+                      'b' => '3',   //key and value from array_index swapped
+                      'c' => 2);    //same as above, using integer
+
+var_dump(array_diff_assoc($array_index, $array_assoc));
+var_dump(array_diff_assoc($array_assoc, $array_index));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : variation ***
+array(2) {
+  [0]=>
+  string(1) "d"
+  [3]=>
+  string(1) "b"
+}
+array(3) {
+  [0]=>
+  string(1) "a"
+  ["b"]=>
+  string(1) "3"
+  ["c"]=>
+  int(2)
+}
+Done

tests/std/array/array_diff_assoc_variation9.phpt

@@ -0,0 +1,134 @@
+--TEST--
+Test array_diff_assoc() function : usage variations - compare multidimensional arrays
+--FILE--
+<?php
+/*
+ * Test how array_diff_assoc behaves when comparing
+ * multi-dimensional arrays
+ */
+
+echo "*** Testing array_diff_assoc() : usage variations ***\n";
+
+$array1 = array('sub_array1' => array (1, 2, 3),
+                'sub_array2' => array ('a', 'b', 'c'));
+$array2 = array('sub_arraya' => array (1, 3, 5),
+                'sub_arrayb' => array ('a', 'z', 'y'));
+
+echo "-- Compare two 2-D arrays --\n";
+var_dump(array_diff_assoc($array1, $array2));
+var_dump(array_diff_assoc($array2, $array1));
+
+echo "\n-- Compare subarrays from two 2-D arrays --\n";
+var_dump(array_diff_assoc($array1['sub_array1'], $array2['sub_arraya']));
+var_dump(array_diff_assoc($array2['sub_arraya'], $array1['sub_array1']));
+var_dump(array_diff_assoc($array1['sub_array2'], $array2['sub_arrayb']));
+var_dump(array_diff_assoc($array2['sub_arrayb'], $array1['sub_array1']));
+
+echo "\n-- Compare a subarray from one 2-D array and one 2-D array --\n";
+var_dump(array_diff_assoc($array1['sub_array1'], $array2));
+var_dump(array_diff_assoc($array1, $array2['sub_arraya']));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff_assoc() : usage variations ***
+-- Compare two 2-D arrays --
+array(2) {
+  ["sub_array1"]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  ["sub_array2"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+array(2) {
+  ["sub_arraya"]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(3)
+    [2]=>
+    int(5)
+  }
+  ["sub_arrayb"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "z"
+    [2]=>
+    string(1) "y"
+  }
+}
+
+-- Compare subarrays from two 2-D arrays --
+array(2) {
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(2) {
+  [1]=>
+  int(3)
+  [2]=>
+  int(5)
+}
+array(2) {
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+}
+array(3) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "z"
+  [2]=>
+  string(1) "y"
+}
+
+-- Compare a subarray from one 2-D array and one 2-D array --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(2) {
+  ["sub_array1"]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  ["sub_array2"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+Done

tests/std/array/array_diff_basic.phpt

@@ -0,0 +1,110 @@
+--TEST--
+Test array_diff() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of array_diff
+ */
+
+echo "*** Testing array_diff() : basic functionality ***\n";
+
+//Test indexed array with integers as elements
+$array_int1 = array (1, 2, 3, 4);
+$array_int2 = array (3, 4, 5, 6);
+
+echo "-- Test indexed array with integers as elements --\n";
+var_dump(array_diff($array_int1, $array_int2));
+var_dump(array_diff($array_int2, $array_int1));
+
+
+//Test indexed array with strings as elements
+$array_string1 = array ('one', 'two', 'three', 'four');
+$array_string2 = array ('three', 'four', 'five', 'six');
+
+echo "-- Test indexed array with strings as elements --\n";
+var_dump(array_diff($array_string1, $array_string2));
+var_dump(array_diff($array_string2, $array_string1));
+
+//Test associative array with strings as keys and integers as elements
+$array_assoc_int1 = array ('one' => 1, 'two' => 2, 'three' => 3, 'four' => 4);
+$array_assoc_int2 = array ('three' => 3, 'four' => 4, 'five' => 5, 'six' => 6);
+
+echo "-- Test associative array with strings as keys and integers as elements --\n";
+var_dump(array_diff($array_assoc_int1, $array_assoc_int2));
+var_dump(array_diff($array_assoc_int2, $array_assoc_int1));
+
+//Test associative array with strings as keys and elements
+$array_assoc_str1 = array ('one' => 'un', 'two' => 'deux', 'three' => 'trois', 'four' => 'quatre');
+$array_assoc_str2 = array ('three' => 'trois', 'four' => 'quatre', 'five' => 'cinq', 'six' => 'six');
+
+echo "-- Test associative array with strings as keys and integers as elements --\n";
+var_dump(array_diff($array_assoc_str1, $array_assoc_str2));
+var_dump(array_diff($array_assoc_str2, $array_assoc_str1));
+
+echo "-- Test array_diff with more than 2 arguments --\n";
+var_dump(array_diff($array_int1, $array_int2, $array_string1, $array_string2));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff() : basic functionality ***
+-- Test indexed array with integers as elements --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  [2]=>
+  int(5)
+  [3]=>
+  int(6)
+}
+-- Test indexed array with strings as elements --
+array(2) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+}
+array(2) {
+  [2]=>
+  string(4) "five"
+  [3]=>
+  string(3) "six"
+}
+-- Test associative array with strings as keys and integers as elements --
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["five"]=>
+  int(5)
+  ["six"]=>
+  int(6)
+}
+-- Test associative array with strings as keys and integers as elements --
+array(2) {
+  ["one"]=>
+  string(2) "un"
+  ["two"]=>
+  string(4) "deux"
+}
+array(2) {
+  ["five"]=>
+  string(4) "cinq"
+  ["six"]=>
+  string(3) "six"
+}
+-- Test array_diff with more than 2 arguments --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+Done

tests/std/array/array_diff_key.phpt

@@ -0,0 +1,286 @@
+--TEST--
+Test of the array_diff_key() and array_diff_ukey()
+--FILE--
+<?php
+// 7, 11, 1000
+function comp_func($a, $b)
+{
+    if ($a === $b) {
+        return 0;
+    }
+    return $a > $b ? 1 : -1;
+}
+function main()
+{
+    $a = array(1, 6, 2, -20, 15, 1200, -2500);
+    $b = array(0, 7, 2, -20, 11, 1100, -2500);
+    $c = array(0, 6, 2, -20, 19, 1000, -2500);
+    $d = array(3, 8, -2, -20, 14, 900, -2600);
+    $a_f = array_flip($a);
+    $b_f = array_flip($b);
+    $c_f = array_flip($c);
+    $d_f = array_flip($d);
+    $i = 1;
+    /* give nicer values */
+    foreach ($a_f as $k => &$a_f_el) {
+        $a_f_el = $k * 2;
+    }
+    foreach ($b_f as $k => &$b_f_el) {
+        $b_f_el = $k * 2;
+    }
+    foreach ($c_f as $k => &$c_f_el) {
+        $c_f_el = $k * 2;
+    }
+    foreach ($d_f as $k => &$d_f_el) {
+        $d_f_el = $k * 2;
+    }
+    echo "------ Test {$i} --------\n";
+    $i++;
+    // 1
+    var_dump(array_diff_key($a_f, $b_f));
+    // keys -> 1, 6, 15, 1200
+    var_dump(array_diff_ukey($a_f, $b_f, "comp_func"));
+    // 1, 6, 15, 1200
+    echo "------ Test {$i} --------\n";
+    $i++;
+    // 2
+    var_dump(array_diff_key($a_f, $c_f));
+    // keys -> 1, 15, 1200
+    var_dump(array_diff_ukey($a_f, $c_f, "comp_func"));
+    // 1, 15, 1200
+    echo "------ Test {$i} --------\n";
+    $i++;
+    // 3
+    var_dump(array_diff_key($a_f, $d_f));
+    // 1, 6, 2, 15, 1200, -2500
+    var_dump(array_diff_ukey($a_f, $d_f, "comp_func"));
+    // 1, 6, 2, 15, 1200, -2500
+    echo "------ Test {$i} --------\n";
+    $i++;
+    // 4
+    var_dump(array_diff_key($a_f, $b_f, $c_f));
+    // 1, 15, 1200
+    var_dump(array_diff_ukey($a_f, $b_f, $c_f, "comp_func"));
+    // 1, 15, 1200
+    echo "------ Test {$i} --------\n";
+    $i++;
+    // 5
+    var_dump(array_diff_key($a_f, $b_f, $d_f));
+    // 1, 6, 15, 1200
+    var_dump(array_diff_ukey($a_f, $b_f, $d_f, "comp_func"));
+    // 1, 6, 15, 1200
+    echo "------ Test {$i} --------\n";
+    $i++;
+    // 6
+    var_dump(array_diff_key($a_f, $b_f, $c_f, $d_f));
+    // 1, 15, 1200
+    var_dump(array_diff_ukey($a_f, $b_f, $c_f, $d_f, "comp_func"));
+    //1, 15, 1200
+    echo "------ Test {$i} --------\n";
+    $i++;
+    // 7
+    var_dump(array_diff_key($b_f, $c_f));
+    // 7, 11, 1100
+    var_dump(array_diff_ukey($b_f, $c_f, "comp_func"));
+    //7, 11, 1100
+    echo "------ Test {$i} --------\n";
+    $i++;
+    // 8
+    var_dump(array_diff_key($b_f, $d_f));
+    //0, 7, 2, 11, 1100, -2500
+    var_dump(array_diff_ukey($b_f, $d_f, "comp_func"));
+    //0, 7, 2, 11, 1100, -2500
+    echo "------ Test {$i} --------\n";
+    $i++;
+    // 9
+    var_dump(array_diff_key($b_f, $c_f, $d_f));
+    // 7, 11, 1100
+    var_dump(array_diff_ukey($b_f, $c_f, $d_f, "comp_func"));
+}
+?>
+--EXPECT--
+------ Test 1 --------
+array(4) {
+  [1]=>
+  int(2)
+  [6]=>
+  int(12)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+array(4) {
+  [1]=>
+  int(2)
+  [6]=>
+  int(12)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+------ Test 2 --------
+array(3) {
+  [1]=>
+  int(2)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+array(3) {
+  [1]=>
+  int(2)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+------ Test 3 --------
+array(6) {
+  [1]=>
+  int(2)
+  [6]=>
+  int(12)
+  [2]=>
+  int(4)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+  [-2500]=>
+  &int(-5000)
+}
+array(6) {
+  [1]=>
+  int(2)
+  [6]=>
+  int(12)
+  [2]=>
+  int(4)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+  [-2500]=>
+  &int(-5000)
+}
+------ Test 4 --------
+array(3) {
+  [1]=>
+  int(2)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+array(3) {
+  [1]=>
+  int(2)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+------ Test 5 --------
+array(4) {
+  [1]=>
+  int(2)
+  [6]=>
+  int(12)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+array(4) {
+  [1]=>
+  int(2)
+  [6]=>
+  int(12)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+------ Test 6 --------
+array(3) {
+  [1]=>
+  int(2)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+array(3) {
+  [1]=>
+  int(2)
+  [15]=>
+  int(30)
+  [1200]=>
+  int(2400)
+}
+------ Test 7 --------
+array(3) {
+  [7]=>
+  int(14)
+  [11]=>
+  int(22)
+  [1100]=>
+  int(2200)
+}
+array(3) {
+  [7]=>
+  int(14)
+  [11]=>
+  int(22)
+  [1100]=>
+  int(2200)
+}
+------ Test 8 --------
+array(6) {
+  [0]=>
+  int(0)
+  [7]=>
+  int(14)
+  [2]=>
+  int(4)
+  [11]=>
+  int(22)
+  [1100]=>
+  int(2200)
+  [-2500]=>
+  &int(-5000)
+}
+array(6) {
+  [0]=>
+  int(0)
+  [7]=>
+  int(14)
+  [2]=>
+  int(4)
+  [11]=>
+  int(22)
+  [1100]=>
+  int(2200)
+  [-2500]=>
+  &int(-5000)
+}
+------ Test 9 --------
+array(3) {
+  [7]=>
+  int(14)
+  [11]=>
+  int(22)
+  [1100]=>
+  int(2200)
+}
+array(3) {
+  [7]=>
+  int(14)
+  [11]=>
+  int(22)
+  [1100]=>
+  int(2200)
+}

tests/std/array/array_diff_key2.phpt

@@ -0,0 +1,44 @@
+--TEST--
+basic array_diff_key test
+--FILE--
+<?php
+$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red", "");
+$array2 = array("a" => "green", "yellow", "red", TRUE);
+$array3 = array("red", "a"=>"brown", "");
+$result[] = array_diff_key($array1, $array2);
+$result[] = array_diff_key($array1, $array3);
+$result[] = array_diff_key($array2, $array3);
+$result[] = array_diff_key($array1, $array2, $array3);
+
+var_dump($result);
+
+?>
+--EXPECT--
+array(4) {
+  [0]=>
+  array(2) {
+    ["b"]=>
+    string(5) "brown"
+    ["c"]=>
+    string(4) "blue"
+  }
+  [1]=>
+  array(2) {
+    ["b"]=>
+    string(5) "brown"
+    ["c"]=>
+    string(4) "blue"
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    bool(true)
+  }
+  [3]=>
+  array(2) {
+    ["b"]=>
+    string(5) "brown"
+    ["c"]=>
+    string(4) "blue"
+  }
+}

tests/std/array/array_diff_key_basic.phpt

@@ -0,0 +1,18 @@
+--TEST--
+Test array_diff_key() : basic functionality
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
+$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
+var_dump(array_diff_key($array1, $array2));
+?>
+--EXPECT--
+array(2) {
+  ["red"]=>
+  int(2)
+  ["purple"]=>
+  int(4)
+}

tests/std/array/array_diff_key_variation1.phpt

@@ -0,0 +1,196 @@
+--TEST--
+Test array_diff_key() function : usage variation - Passing unexpected values to first argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_diff_key() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
+    $array3 = array(1, 2, 3, 4, 5);
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    //resource variable
+    $fp = fopen(__FILE__, "r");
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    //array of values to iterate over
+    $inputs = array(
+        // int data
+        'int 0' => 0,
+        'int 1' => 1,
+        'int 12345' => 12345,
+        'int -12345' => -12345,
+        // float data
+        'float 10.5' => 10.5,
+        'float -10.5' => -10.5,
+        'float 12.3456789000e10' => 123456789000.0,
+        'float -12.3456789000e10' => -123456789000.0,
+        'float .5' => 0.5,
+        // null data
+        'uppercase NULL' => NULL,
+        'lowercase null' => null,
+        // boolean data
+        'lowercase true' => true,
+        'lowercase false' => false,
+        'uppercase TRUE' => TRUE,
+        'uppercase FALSE' => FALSE,
+        // empty data
+        'empty string DQ' => "",
+        'empty string SQ' => '',
+        // string data
+        'string DQ' => "string",
+        'string SQ' => 'string',
+        'mixed case string' => "sTrInG",
+        'heredoc' => $heredoc,
+        // object data
+        'instance of classWithToString' => new classWithToString(),
+        'instance of classWithoutToString' => new classWithoutToString(),
+        // undefined data
+        'undefined var' => @$undefined_var,
+        // unset data
+        'unset var' => @$unset_var,
+        // resource data
+        'resource' => $fp,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_diff_key($value, $array2));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_diff_key($value, $array2, $array3));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_diff_key() : usage variation ***
+
+--int 0--
+array_diff_key(): Argument #1 ($array) must be of type array, int given
+array_diff_key(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_diff_key(): Argument #1 ($array) must be of type array, int given
+array_diff_key(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_diff_key(): Argument #1 ($array) must be of type array, int given
+array_diff_key(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_diff_key(): Argument #1 ($array) must be of type array, int given
+array_diff_key(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+array_diff_key(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_diff_key(): Argument #1 ($array) must be of type array, null given
+array_diff_key(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_diff_key(): Argument #1 ($array) must be of type array, null given
+array_diff_key(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_diff_key(): Argument #1 ($array) must be of type array, true given
+array_diff_key(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_diff_key(): Argument #1 ($array) must be of type array, false given
+array_diff_key(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_diff_key(): Argument #1 ($array) must be of type array, true given
+array_diff_key(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_diff_key(): Argument #1 ($array) must be of type array, false given
+array_diff_key(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+array_diff_key(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_diff_key(): Argument #1 ($array) must be of type array, classWithToString given
+array_diff_key(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_diff_key(): Argument #1 ($array) must be of type array, classWithoutToString given
+array_diff_key(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_diff_key(): Argument #1 ($array) must be of type array, null given
+array_diff_key(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_diff_key(): Argument #1 ($array) must be of type array, null given
+array_diff_key(): Argument #1 ($array) must be of type array, null given
+
+--resource--
+array_diff_key(): Argument #1 ($array) must be of type array, resource given
+array_diff_key(): Argument #1 ($array) must be of type array, resource given

tests/std/array/array_diff_key_variation2.phpt

@@ -0,0 +1,196 @@
+--TEST--
+Test array_diff_key() function : usage variation - Passing unexpected values to second argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_diff_key() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array1 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
+    $array3 = array(1, 2, 3, 4, 5);
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    //resource variable
+    $fp = fopen(__FILE__, "r");
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    //array of values to iterate over
+    $inputs = array(
+        // int data
+        'int 0' => 0,
+        'int 1' => 1,
+        'int 12345' => 12345,
+        'int -12345' => -12345,
+        // float data
+        'float 10.5' => 10.5,
+        'float -10.5' => -10.5,
+        'float 12.3456789000e10' => 123456789000.0,
+        'float -12.3456789000e10' => -123456789000.0,
+        'float .5' => 0.5,
+        // null data
+        'uppercase NULL' => NULL,
+        'lowercase null' => null,
+        // boolean data
+        'lowercase true' => true,
+        'lowercase false' => false,
+        'uppercase TRUE' => TRUE,
+        'uppercase FALSE' => FALSE,
+        // empty data
+        'empty string DQ' => "",
+        'empty string SQ' => '',
+        // string data
+        'string DQ' => "string",
+        'string SQ' => 'string',
+        'mixed case string' => "sTrInG",
+        'heredoc' => $heredoc,
+        // object data
+        'instance of classWithToString' => new classWithToString(),
+        'instance of classWithoutToString' => new classWithoutToString(),
+        // undefined data
+        'undefined var' => @$undefined_var,
+        // unset data
+        'unset var' => @$unset_var,
+        // resource data
+        'resource' => $fp,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_diff_key($array1, $value));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_diff_key($array1, $value, $array3));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_diff_key() : usage variation ***
+
+--int 0--
+array_diff_key(): Argument #2 must be of type array, int given
+array_diff_key(): Argument #2 must be of type array, int given
+
+--int 1--
+array_diff_key(): Argument #2 must be of type array, int given
+array_diff_key(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_diff_key(): Argument #2 must be of type array, int given
+array_diff_key(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_diff_key(): Argument #2 must be of type array, int given
+array_diff_key(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_diff_key(): Argument #2 must be of type array, float given
+array_diff_key(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_diff_key(): Argument #2 must be of type array, float given
+array_diff_key(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_diff_key(): Argument #2 must be of type array, float given
+array_diff_key(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_diff_key(): Argument #2 must be of type array, float given
+array_diff_key(): Argument #2 must be of type array, float given
+
+--float .5--
+array_diff_key(): Argument #2 must be of type array, float given
+array_diff_key(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_diff_key(): Argument #2 must be of type array, null given
+array_diff_key(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_diff_key(): Argument #2 must be of type array, null given
+array_diff_key(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_diff_key(): Argument #2 must be of type array, true given
+array_diff_key(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_diff_key(): Argument #2 must be of type array, false given
+array_diff_key(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_diff_key(): Argument #2 must be of type array, true given
+array_diff_key(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_diff_key(): Argument #2 must be of type array, false given
+array_diff_key(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_diff_key(): Argument #2 must be of type array, string given
+array_diff_key(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_diff_key(): Argument #2 must be of type array, string given
+array_diff_key(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_diff_key(): Argument #2 must be of type array, string given
+array_diff_key(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_diff_key(): Argument #2 must be of type array, string given
+array_diff_key(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_diff_key(): Argument #2 must be of type array, string given
+array_diff_key(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_diff_key(): Argument #2 must be of type array, string given
+array_diff_key(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_diff_key(): Argument #2 must be of type array, classWithToString given
+array_diff_key(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_diff_key(): Argument #2 must be of type array, classWithoutToString given
+array_diff_key(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_diff_key(): Argument #2 must be of type array, null given
+array_diff_key(): Argument #2 must be of type array, null given
+
+--unset var--
+array_diff_key(): Argument #2 must be of type array, null given
+array_diff_key(): Argument #2 must be of type array, null given
+
+--resource--
+array_diff_key(): Argument #2 must be of type array, resource given
+array_diff_key(): Argument #2 must be of type array, resource given

tests/std/array/array_diff_key_variation4.phpt

@@ -0,0 +1,54 @@
+--TEST--
+Test array_diff_key() function : usage variation - Passing integer indexed array
+--FILE--
+<?php
+echo "*** Testing array_diff_key() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$input_array = array(-07 => '-07', 0xA => '0xA');
+
+$input_arrays = array(
+      'decimal indexed' => array(10 => '10', '-17' => '-17'),
+      'octal indexed' => array(-011 => '-011', 012 => '012'),
+      'hexa  indexed' => array(0x12 => '0x12', -0x7 => '-0x7', ),
+);
+
+// loop through each element of the array for arr1
+foreach($input_arrays as $key =>$value) {
+      echo "\n--$key--\n";
+      var_dump( array_diff_key($input_array, $value) );
+      var_dump( array_diff_key($value, $input_array) );
+}
+?>
+--EXPECT--
+*** Testing array_diff_key() : usage variation ***
+
+--decimal indexed--
+array(1) {
+  [-7]=>
+  string(3) "-07"
+}
+array(1) {
+  [-17]=>
+  string(3) "-17"
+}
+
+--octal indexed--
+array(1) {
+  [-7]=>
+  string(3) "-07"
+}
+array(1) {
+  [-9]=>
+  string(4) "-011"
+}
+
+--hexa  indexed--
+array(1) {
+  [10]=>
+  string(3) "0xA"
+}
+array(1) {
+  [18]=>
+  string(4) "0x12"
+}

tests/std/array/array_diff_key_variation6.phpt

@@ -0,0 +1,30 @@
+--TEST--
+Test array_diff_key() function : usage variation - Passing boolean indexed array
+--SKIPIF--
+--FILE--
+<?php
+echo "*** Testing array_diff_key() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$input_array = array(0 => '0', 1 => '1', -10 => '-10', 'true' => 1, 'false' => 0);
+$boolean_indx_array = array(true => 'boolt', false => 'boolf', TRUE => 'boolT', FALSE => 'boolF');
+
+echo "\n-- Testing array_diff_key() function with boolean indexed array --\n";
+// loop through each element of the array for arr1
+var_dump( array_diff_key($input_array, $boolean_indx_array) );
+var_dump( array_diff_key($boolean_indx_array, $input_array) );
+?>
+--EXPECT--
+*** Testing array_diff_key() : usage variation ***
+
+-- Testing array_diff_key() function with boolean indexed array --
+array(3) {
+  [-10]=>
+  string(3) "-10"
+  ["true"]=>
+  int(1)
+  ["false"]=>
+  int(0)
+}
+array(0) {
+}

tests/std/array/array_diff_key_variation7.phpt

@@ -0,0 +1,57 @@
+--TEST--
+Test array_diff_key() function : usage variation - Passing null,unset and undefined variable indexed array
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+echo "*** Testing array_diff_key() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$input_array = array(10 => '10', "" => 'empty');
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+$input_arrays = array(
+      'null indexed' => array(NULL => 'null 1', null => 'null 2'),
+      'undefined indexed' => array(@$undefined_var => 'undefined'),
+      'unset  indexed' => array(@$unset_var => 'unset'),
+);
+
+foreach($input_arrays as $key =>$value) {
+      echo "\n--$key--\n";
+      // loop through each element of the array for arr1
+      var_dump( array_diff_key($input_array, $value) );
+      var_dump( array_diff_key($value, $input_array) );
+}
+?>
+--EXPECT--
+*** Testing array_diff_key() : usage variation ***
+
+--null indexed--
+array(1) {
+  [10]=>
+  string(2) "10"
+}
+array(0) {
+}
+
+--undefined indexed--
+array(1) {
+  [10]=>
+  string(2) "10"
+}
+array(0) {
+}
+
+--unset  indexed--
+array(1) {
+  [10]=>
+  string(2) "10"
+}
+array(0) {
+}

tests/std/array/array_diff_key_variation8.phpt

@@ -0,0 +1,47 @@
+--TEST--
+Test array_diff_key() function : usage variation - Passing multi-dimensional array
+--FILE--
+<?php
+echo "*** Testing array_diff_key() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$array1 = array(
+
+      'first' => array('blue' => 1, 'red' => 2),
+
+      'second' => array('yellow' => 7),
+
+      'third' => array(0 => 'zero'),
+);
+
+$array2 = array (
+
+      'first' => array('blue' => 1, 'red' => 2,),
+
+      'second' => array('cyan' => 8),
+
+      'fourth' => array(2 => 'two'),
+);
+
+echo "\n-- Testing array_diff_key() function with multi dimensional array --\n";
+var_dump( array_diff_key($array1, $array2) );
+var_dump( array_diff_key($array2, $array1) );
+?>
+--EXPECT--
+*** Testing array_diff_key() : usage variation ***
+
+-- Testing array_diff_key() function with multi dimensional array --
+array(1) {
+  ["third"]=>
+  array(1) {
+    [0]=>
+    string(4) "zero"
+  }
+}
+array(1) {
+  ["fourth"]=>
+  array(1) {
+    [2]=>
+    string(3) "two"
+  }
+}

tests/std/array/array_diff_single_array.phpt

@@ -0,0 +1,50 @@
+--TEST--
+array_diff() with single array argument
+--FILE--
+<?php
+
+$array = ["a" => 42];
+$cmp = function($a, $b) { return $a <=> $b; };
+var_dump(array_diff($array));
+var_dump(array_diff_key($array));
+var_dump(array_diff_ukey($array, $cmp));
+var_dump(array_diff_assoc($array));
+var_dump(array_diff_uassoc($array, $cmp));
+var_dump(array_udiff($array, $cmp));
+var_dump(array_udiff_assoc($array, $cmp));
+var_dump(array_udiff_uassoc($array, $cmp, $cmp));
+
+?>
+--EXPECT--
+array(1) {
+  ["a"]=>
+  int(42)
+}
+array(1) {
+  ["a"]=>
+  int(42)
+}
+array(1) {
+  ["a"]=>
+  int(42)
+}
+array(1) {
+  ["a"]=>
+  int(42)
+}
+array(1) {
+  ["a"]=>
+  int(42)
+}
+array(1) {
+  ["a"]=>
+  int(42)
+}
+array(1) {
+  ["a"]=>
+  int(42)
+}
+array(1) {
+  ["a"]=>
+  int(42)
+}

tests/std/array/array_diff_uassoc_basic.phpt

@@ -0,0 +1,32 @@
+--TEST--
+array_diff_uassoc(): Basic test
+--FILE--
+<?php
+/*
+* array array_diff_uassoc ( array $array1, array $array2 [, array $..., callback $key_compare_func] )
+* Function is implemented in ext/standard/array.c
+*/
+function key_compare_func($a, $b)
+{
+    if ($a === $b) {
+        return 0;
+    }
+    return $a > $b ? 1 : -1;
+}
+function main()
+{
+    $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
+    $array2 = array("a" => "green", "yellow", "red");
+    $result = array_diff_uassoc($array1, $array2, "key_compare_func");
+    var_dump($result);
+}
+?>
+--EXPECT--
+array(3) {
+  ["b"]=>
+  string(5) "brown"
+  ["c"]=>
+  string(4) "blue"
+  [0]=>
+  string(3) "red"
+}

tests/std/array/array_diff_uassoc_error.phpt

@@ -0,0 +1,50 @@
+--TEST--
+Test array_diff_uassoc() function : error conditions
+--FILE--
+<?php
+function key_compare_func($a, $b)
+{
+    if ($a === $b) {
+        return 0;
+    }
+    return $a > $b ? 1 : -1;
+}
+function main()
+{
+    echo "*** Testing array_diff_uassoc() : error conditions ***\n";
+    //Initialize array
+    $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
+    $array2 = array("a" => "green", "yellow", "red");
+    $array3 = array("a" => "green", "red");
+    $array4 = array();
+    $extra_arg = array(1, 2, 3, 4);
+    //Test array_diff_uassoc with one more than the expected number of arguments
+    echo "\n-- Testing array_diff_uassoc() function with more than expected no. of arguments --\n";
+    try {
+        var_dump(array_diff_uassoc($array1, $array2, "key_compare_func", $extra_arg));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    try {
+        var_dump(array_diff_uassoc($array1, $array2, $array3, $array4, "key_compare_func", $extra_arg));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    // Testing array_diff_uassoc with one less than the expected number of arguments
+    echo "\n-- Testing array_diff_uassoc() function with less than expected no. of arguments --\n";
+    try {
+        var_dump(array_diff_uassoc($array1, $array2));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+}
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : error conditions ***
+
+-- Testing array_diff_uassoc() function with more than expected no. of arguments --
+array_diff_uassoc(): Argument #4 must be a valid callback, array callback must have exactly two members
+array_diff_uassoc(): Argument #6 must be a valid callback, array callback must have exactly two members
+
+-- Testing array_diff_uassoc() function with less than expected no. of arguments --
+array_diff_uassoc(): Argument #2 must be a valid callback, array callback must have exactly two members

tests/std/array/array_diff_uassoc_variation1.phpt

@@ -0,0 +1,174 @@
+--TEST--
+Test array_diff_uassoc() function : usage variation - Passing unexpected values to first argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+function key_compare_func($a, $b)
+{
+    if ($a === $b) {
+        return 0;
+    }
+    return $a > $b ? 1 : -1;
+}
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $array2 = array("a" => "green", "yellow", "red");
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    //resource variable
+    $fp = fopen(__FILE__, "r");
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    // add arrays
+    $index_array = array(1, 2, 3);
+    $assoc_array = array('one' => 1, 'two' => 2);
+    //array of values to iterate over
+    $inputs = array(
+        // int data
+        'int 0' => 0,
+        'int 1' => 1,
+        'int 12345' => 12345,
+        'int -12345' => -2345,
+        // float data
+        'float 10.5' => 10.5,
+        'float -10.5' => -10.5,
+        'float 12.3456789000e10' => 123456789000.0,
+        'float -12.3456789000e10' => -123456789000.0,
+        'float .5' => 0.5,
+        // null data
+        'uppercase NULL' => NULL,
+        'lowercase null' => null,
+        // boolean data
+        'lowercase true' => true,
+        'lowercase false' => false,
+        'uppercase TRUE' => TRUE,
+        'uppercase FALSE' => FALSE,
+        // empty data
+        'empty string DQ' => "",
+        'empty string SQ' => '',
+        // string data
+        'string DQ' => "string",
+        'string SQ' => 'string',
+        'mixed case string' => "sTrInG",
+        'heredoc' => $heredoc,
+        // object data
+        'instance of classWithToString' => new classWithToString(),
+        'instance of classWithoutToString' => new classWithoutToString(),
+        // undefined data
+        'undefined var' => @$undefined_var,
+        // unset data
+        'unset var' => @$unset_var,
+        // resource data
+        'resource' => $fp,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_diff_uassoc($value, $array2, "key_compare_func"));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+--int 0--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--resource--
+array_diff_uassoc(): Argument #1 ($array) must be of type array, resource given

tests/std/array/array_diff_uassoc_variation11.phpt

@@ -0,0 +1,38 @@
+--TEST--
+Test array_diff_uassoc() function : usage variation - Passing boolean indexed array
+--SKIPIF--
+--FILE--
+<?php
+echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$input_array = array(0 => '0', 1 => '1', -10 => '-10', 'true' => 1, 'false' => 0);
+$boolean_indx_array = array(true => 'boolt', false => 'boolf', TRUE => 'boolT', FALSE => 'boolF');
+
+echo "\n-- Testing array_diff_key() function with float indexed array --\n";
+var_dump( array_diff_uassoc($input_array, $boolean_indx_array, "strcasecmp") );
+var_dump( array_diff_uassoc($boolean_indx_array, $input_array, "strcasecmp") );
+
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+-- Testing array_diff_key() function with float indexed array --
+array(5) {
+  [0]=>
+  string(1) "0"
+  [1]=>
+  string(1) "1"
+  [-10]=>
+  string(3) "-10"
+  ["true"]=>
+  int(1)
+  ["false"]=>
+  int(0)
+}
+array(2) {
+  [1]=>
+  string(5) "boolT"
+  [0]=>
+  string(5) "boolF"
+}

tests/std/array/array_diff_uassoc_variation12.phpt

@@ -0,0 +1,57 @@
+--TEST--
+Test array_diff_uassoc() function : usage variation - Passing null,unset and undefined variable indexed array
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$input_array = array(10 => '10', "" => '');
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+$input_arrays = array(
+      'null indexed' => array(NULL => NULL, null => null),
+      'undefined indexed' => array(@$undefined_var => @$undefined_var),
+      'unset indexed' => array(@$unset_var => @$unset_var),
+);
+
+foreach($input_arrays as $key =>$value) {
+      echo "\n--$key--\n";
+      var_dump( array_diff_uassoc($input_array, $value, "strcasecmp") );
+      var_dump( array_diff_uassoc($value, $input_array, "strcasecmp") );
+}
+
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+--null indexed--
+array(1) {
+  [10]=>
+  string(2) "10"
+}
+array(0) {
+}
+
+--undefined indexed--
+array(1) {
+  [10]=>
+  string(2) "10"
+}
+array(0) {
+}
+
+--unset indexed--
+array(1) {
+  [10]=>
+  string(2) "10"
+}
+array(0) {
+}

tests/std/array/array_diff_uassoc_variation13.phpt

@@ -0,0 +1,65 @@
+--TEST--
+Test array_diff_uassoc() function : usage variations - arrays containing referenced variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support cross-type variable reassignment");
+?>
+
+--FILE--
+<?php
+echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+
+//Initialize variables
+$ref_var = 'a';
+$array1 = array('a', $ref_var);
+$array2 = array('a' => 1, &$ref_var);
+
+echo "\n-- Testing array_diff_uassoc() function with referenced variable \$ref_var has value '$ref_var' --\n";
+var_dump( array_diff_uassoc($array1, $array2, "strcasecmp") );
+var_dump( array_diff_uassoc($array2, $array1, "strcasecmp") );
+
+// re-assign reference variable to different value
+$ref_var = 10.00;
+echo "\n-- Testing array_diff_uassoc() function with referenced variable \$ref_var value changed to $ref_var --\n";
+var_dump( array_diff_uassoc($array1, $array2, "strcasecmp") );
+var_dump( array_diff_uassoc($array2, $array1, "strcasecmp") );
+
+//When array are refenced
+$array2 = &$array1;
+echo "\n-- Testing array_diff_uassoc() function when \$array2 is referenced to \$array1 --\n";
+var_dump( array_diff_uassoc($array1, $array2, "strcasecmp") );
+var_dump( array_diff_uassoc($array2, $array1, "strcasecmp") );
+
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+-- Testing array_diff_uassoc() function with referenced variable $ref_var has value 'a' --
+array(1) {
+  [1]=>
+  string(1) "a"
+}
+array(1) {
+  ["a"]=>
+  int(1)
+}
+
+-- Testing array_diff_uassoc() function with referenced variable $ref_var value changed to 10 --
+array(2) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "a"
+}
+array(2) {
+  ["a"]=>
+  int(1)
+  [0]=>
+  &float(10)
+}
+
+-- Testing array_diff_uassoc() function when $array2 is referenced to $array1 --
+array(0) {
+}
+array(0) {
+}

tests/std/array/array_diff_uassoc_variation2.phpt

@@ -0,0 +1,174 @@
+--TEST--
+Test array_diff_uassoc() function : usage variation -Passing unexpected values to second argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+function key_compare_func($a, $b)
+{
+    if ($a === $b) {
+        return 0;
+    }
+    return $a > $b ? 1 : -1;
+}
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    //resource variable
+    $fp = fopen(__FILE__, "r");
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    // add arrays
+    $index_array = array(1, 2, 3);
+    $assoc_array = array('one' => 1, 'two' => 2);
+    //array of values to iterate over
+    $inputs = array(
+        // int data
+        'int 0' => 0,
+        'int 1' => 1,
+        'int 12345' => 12345,
+        'int -12345' => -2345,
+        // float data
+        'float 10.5' => 10.5,
+        'float -10.5' => -10.5,
+        'float 12.3456789000e10' => 123456789000.0,
+        'float -12.3456789000e10' => -123456789000.0,
+        'float .5' => 0.5,
+        // null data
+        'uppercase NULL' => NULL,
+        'lowercase null' => null,
+        // boolean data
+        'lowercase true' => true,
+        'lowercase false' => false,
+        'uppercase TRUE' => TRUE,
+        'uppercase FALSE' => FALSE,
+        // empty data
+        'empty string DQ' => "",
+        'empty string SQ' => '',
+        // string data
+        'string DQ' => "string",
+        'string SQ' => 'string',
+        'mixed case string' => "sTrInG",
+        'heredoc' => $heredoc,
+        // object data
+        'instance of classWithToString' => new classWithToString(),
+        'instance of classWithoutToString' => new classWithoutToString(),
+        // undefined data
+        'undefined var' => @$undefined_var,
+        // unset data
+        'unset var' => @$unset_var,
+        // resource data
+        'resource' => $fp,
+    );
+    // loop through each element of the array for array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_diff_uassoc($array1, $value, "key_compare_func"));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+--int 0--
+array_diff_uassoc(): Argument #2 must be of type array, int given
+
+--int 1--
+array_diff_uassoc(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_diff_uassoc(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_diff_uassoc(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_diff_uassoc(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_diff_uassoc(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_diff_uassoc(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_diff_uassoc(): Argument #2 must be of type array, float given
+
+--float .5--
+array_diff_uassoc(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_diff_uassoc(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_diff_uassoc(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_diff_uassoc(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_diff_uassoc(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_diff_uassoc(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_diff_uassoc(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_diff_uassoc(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_diff_uassoc(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_diff_uassoc(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_diff_uassoc(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_diff_uassoc(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_diff_uassoc(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_diff_uassoc(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_diff_uassoc(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_diff_uassoc(): Argument #2 must be of type array, null given
+
+--unset var--
+array_diff_uassoc(): Argument #2 must be of type array, null given
+
+--resource--
+array_diff_uassoc(): Argument #2 must be of type array, resource given

tests/std/array/array_diff_uassoc_variation5.phpt

@@ -0,0 +1,30 @@
+--TEST--
+Test array_diff_uassoc() function : usage variation - Comparing integers and floating point numbers
+--FILE--
+<?php
+function key_compare_func($key1, $key2)
+{
+    if ($key1 === $key2) {
+        return 0;
+    }
+    return $key1 > $key2 ? 1 : -1;
+}
+function main()
+{
+    echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $arr_default_int = array(1, 2, 3, 4);
+    $arr_float = array(0 => 1.0, 1 => 2.0, 2 => 3.0, 3 => 4.0);
+    echo "\n-- Result of comparing integers and floating point numbers --\n";
+    var_dump(array_diff_uassoc($arr_default_int, $arr_float, "key_compare_func"));
+    var_dump(array_diff_uassoc($arr_float, $arr_default_int, "key_compare_func"));
+}
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+-- Result of comparing integers and floating point numbers --
+array(0) {
+}
+array(0) {
+}

tests/std/array/array_diff_uassoc_variation6.phpt

@@ -0,0 +1,48 @@
+--TEST--
+Test array_diff_uassoc() function : usage variation - Comparing floating points with strings having integers and float
+--FILE--
+<?php
+function key_compare_func($key1, $key2)
+{
+    if ($key1 === $key2) {
+        return 0;
+    }
+    return $key1 > $key2 ? 1 : -1;
+}
+function main()
+{
+    echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $arr_float = array(0 => 1.0, 1 => 2.0);
+    $arr_string_int = array('1', '2');
+    $arr_string_float = array('0' => '1.00', '1.00' => '2.00');
+    echo "\n-- Result of comparing floating points and strings containing integers --\n";
+    var_dump(array_diff_uassoc($arr_float, $arr_string_int, "key_compare_func"));
+    var_dump(array_diff_uassoc($arr_string_int, $arr_float, "key_compare_func"));
+    echo "\n-- Result of comparing floating points and strings containing floating point --\n";
+    var_dump(array_diff_uassoc($arr_float, $arr_string_float, "key_compare_func"));
+    var_dump(array_diff_uassoc($arr_string_float, $arr_float, "key_compare_func"));
+}
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+-- Result of comparing floating points and strings containing integers --
+array(0) {
+}
+array(0) {
+}
+
+-- Result of comparing floating points and strings containing floating point --
+array(2) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(2)
+}
+array(2) {
+  [0]=>
+  string(4) "1.00"
+  ["1.00"]=>
+  string(4) "2.00"
+}

tests/std/array/array_diff_uassoc_variation7.phpt

@@ -0,0 +1,38 @@
+--TEST--
+Test array_diff_uassoc() function : usage variation - Comparing strings containing integers and float
+--FILE--
+<?php
+function key_compare_func($key1, $key2)
+{
+    if ($key1 === $key2) {
+        return 0;
+    }
+    return $key1 > $key2 ? 1 : -1;
+}
+function main()
+{
+    echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $arr_string_int = array('1', '2');
+    $arr_string_float = array('0' => '1.00', '1.00' => '2.00');
+    echo "\n-- Result of comparing strings containing integers and strings containing floating points --\n";
+    var_dump(array_diff_uassoc($arr_string_int, $arr_string_float, "key_compare_func"));
+    var_dump(array_diff_uassoc($arr_string_float, $arr_string_int, "key_compare_func"));
+}
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+-- Result of comparing strings containing integers and strings containing floating points --
+array(2) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  string(1) "2"
+}
+array(2) {
+  [0]=>
+  string(4) "1.00"
+  ["1.00"]=>
+  string(4) "2.00"
+}

tests/std/array/array_diff_uassoc_variation8.phpt

@@ -0,0 +1,52 @@
+--TEST--
+Test array_diff_uassoc() function : usage variation - Comparing integers with strings containing integers and float
+--FILE--
+<?php
+function key_compare_func($key1, $key2)
+{
+    if ($key1 === $key2) {
+        return 0;
+    }
+    return $key1 > $key2 ? 1 : -1;
+}
+function main()
+{
+    echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $arr_default_int = array(1, 2, 3);
+    $arr_string_int = array('1', '2');
+    $arr_string_float = array('0' => '1.00', '1.00' => '2.00');
+    echo "\n-- Result of comparing integers and strings containing an integers --\n";
+    var_dump(array_diff_uassoc($arr_default_int, $arr_string_int, "key_compare_func"));
+    var_dump(array_diff_uassoc($arr_string_int, $arr_default_int, "key_compare_func"));
+    echo "\n-- Result of comparing integers and strings containing floating points --\n";
+    var_dump(array_diff_uassoc($arr_default_int, $arr_string_float, "key_compare_func"));
+    var_dump(array_diff_uassoc($arr_string_float, $arr_default_int, "key_compare_func"));
+}
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+-- Result of comparing integers and strings containing an integers --
+array(1) {
+  [2]=>
+  int(3)
+}
+array(0) {
+}
+
+-- Result of comparing integers and strings containing floating points --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(2) {
+  [0]=>
+  string(4) "1.00"
+  ["1.00"]=>
+  string(4) "2.00"
+}

tests/std/array/array_diff_uassoc_variation9.phpt

@@ -0,0 +1,54 @@
+--TEST--
+Test array_diff_uassoc() function : usage variation - Passing integer indexed array
+--FILE--
+<?php
+echo "*** Testing array_diff_uassoc() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$input_array = array(10 => 10, 12 => 12);
+
+$input_arrays = array(
+      'decimal indexed' => array(10 => 10, -17 => -17),
+      'octal indexed' => array( 012 => 10, -011 => -011,),
+      'hexa  indexed' => array(0xA => 10, -0x7 => -0x7 ),
+);
+
+foreach($input_arrays as $key =>$value) {
+      echo "\n--$key--\n";
+      var_dump( array_diff_uassoc($input_array, $value, "strcasecmp") );
+      var_dump( array_diff_uassoc($value, $input_array, "strcasecmp") );
+}
+
+?>
+--EXPECT--
+*** Testing array_diff_uassoc() : usage variation ***
+
+--decimal indexed--
+array(1) {
+  [12]=>
+  int(12)
+}
+array(1) {
+  [-17]=>
+  int(-17)
+}
+
+--octal indexed--
+array(1) {
+  [12]=>
+  int(12)
+}
+array(1) {
+  [-9]=>
+  int(-9)
+}
+
+--hexa  indexed--
+array(1) {
+  [12]=>
+  int(12)
+}
+array(1) {
+  [-7]=>
+  int(-7)
+}

tests/std/array/array_diff_ukey_basic.phpt

@@ -0,0 +1,31 @@
+--TEST--
+array_diff_ukey() : Basic test.
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+function key_compare_func($key1, $key2)
+{
+    if ($key1 == $key2) {
+        return 0;
+    } else if ($key1 > $key2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+function main()
+{
+    $array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
+    $array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
+    var_dump(array_diff_ukey($array1, $array2, 'key_compare_func'));
+}
+?>
+--EXPECT--
+array(2) {
+  ["red"]=>
+  int(2)
+  ["purple"]=>
+  int(4)
+}

tests/std/array/array_diff_ukey_variation1.phpt

@@ -0,0 +1,203 @@
+--TEST--
+Test array_diff_ukey() function : usage variation - Passing unexpected values to first argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+function key_compare_func($key1, $key2)
+{
+    if ($key1 == $key2) {
+        return 0;
+    }
+    return $key1 > $key2 ? 1 : -1;
+}
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_diff_ukey() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
+    $array3 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    //resource variable
+    $fp = fopen(__FILE__, "r");
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    //array of values to iterate over
+    $inputs = array(
+        // int data
+        'int 0' => 0,
+        'int 1' => 1,
+        'int 12345' => 12345,
+        'int -12345' => -2345,
+        // float data
+        'float 10.5' => 10.5,
+        'float -10.5' => -10.5,
+        'float 12.3456789000e10' => 123456789000.0,
+        'float -12.3456789000e10' => -123456789000.0,
+        'float .5' => 0.5,
+        // null data
+        'uppercase NULL' => NULL,
+        'lowercase null' => null,
+        // boolean data
+        'lowercase true' => true,
+        'lowercase false' => false,
+        'uppercase TRUE' => TRUE,
+        'uppercase FALSE' => FALSE,
+        // empty data
+        'empty string DQ' => "",
+        'empty string SQ' => '',
+        // string data
+        'string DQ' => "string",
+        'string SQ' => 'string',
+        'mixed case string' => "sTrInG",
+        'heredoc' => $heredoc,
+        // object data
+        'instance of classWithToString' => new classWithToString(),
+        'instance of classWithoutToString' => new classWithoutToString(),
+        // undefined data
+        'undefined var' => @$undefined_var,
+        // unset data
+        'unset var' => @$unset_var,
+        // resource data
+        'resource' => $fp,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_diff_ukey($value, $array2, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_diff_ukey($value, $array2, $array3, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_diff_ukey() : usage variation ***
+
+--int 0--
+array_diff_ukey(): Argument #1 ($array) must be of type array, int given
+array_diff_ukey(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_diff_ukey(): Argument #1 ($array) must be of type array, int given
+array_diff_ukey(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_diff_ukey(): Argument #1 ($array) must be of type array, int given
+array_diff_ukey(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_diff_ukey(): Argument #1 ($array) must be of type array, int given
+array_diff_ukey(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+array_diff_ukey(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_diff_ukey(): Argument #1 ($array) must be of type array, null given
+array_diff_ukey(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_diff_ukey(): Argument #1 ($array) must be of type array, null given
+array_diff_ukey(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_diff_ukey(): Argument #1 ($array) must be of type array, true given
+array_diff_ukey(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_diff_ukey(): Argument #1 ($array) must be of type array, false given
+array_diff_ukey(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_diff_ukey(): Argument #1 ($array) must be of type array, true given
+array_diff_ukey(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_diff_ukey(): Argument #1 ($array) must be of type array, false given
+array_diff_ukey(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+array_diff_ukey(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_diff_ukey(): Argument #1 ($array) must be of type array, classWithToString given
+array_diff_ukey(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_diff_ukey(): Argument #1 ($array) must be of type array, classWithoutToString given
+array_diff_ukey(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_diff_ukey(): Argument #1 ($array) must be of type array, null given
+array_diff_ukey(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_diff_ukey(): Argument #1 ($array) must be of type array, null given
+array_diff_ukey(): Argument #1 ($array) must be of type array, null given
+
+--resource--
+array_diff_ukey(): Argument #1 ($array) must be of type array, resource given
+array_diff_ukey(): Argument #1 ($array) must be of type array, resource given

tests/std/array/array_diff_ukey_variation10.phpt

@@ -0,0 +1,29 @@
+--TEST--
+Test array_diff_ukey() function : usage variation - Passing non-existing function name to callback
+--FILE--
+<?php
+echo "*** Testing array_diff_ukey() : usage variation ***\n";
+
+//Initialize variables
+$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
+$array2 = array("a" => "green", "yellow", "red");
+
+//function name within double quotes
+try {
+    var_dump( array_diff_ukey($array1, $array1, "unknown_function") );
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+//function name within single quotes
+try {
+    var_dump( array_diff_ukey($array1, $array1, 'unknown_function') );
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+*** Testing array_diff_ukey() : usage variation ***
+array_diff_ukey(): Argument #3 must be a valid callback, function "unknown_function" not found or invalid function name
+array_diff_ukey(): Argument #3 must be a valid callback, function "unknown_function" not found or invalid function name