diff --git a/CLAUDE.md b/CLAUDE.md
index bf389d0a..f3b46f15 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -8,6 +8,22 @@ Swoole-Compiler is an AOT (Ahead-of-Time) compiler that translates PHP source co
 
 **Prerequisites**: PHP 8.2+, GCC 9+ (C++17), CMake 3.24+. The `swoole/phpx` extension must be compiled (see README.md).
 
+## AOT Language Design Principles
+
+The AOT compiler should not blindly mirror every PHP language behavior. Most PHP syntax and semantics should remain compatible with ZendPHP, but some legal PHP constructs are historical baggage or language-design mistakes that conflict with static compilation, clear semantics, or robust generated C++ code.
+
+When reviewing or changing compiler behavior:
+
+- Prefer PHP compatibility for common, well-defined syntax that does not weaken the AOT static model.
+- Reject PHP historical baggage when the syntax is ambiguous, surprising, or only preserved for legacy compatibility.
+- Diagnose such cases as early as possible during preprocessing/static compilation, instead of deferring to runtime TypeCheck or ZendVM errors.
+- Provide precise errors that include the relevant function/method name, parameter/property name, and type information where applicable.
+- Compare with other statically compiled languages such as C/C++, Java, C#, Go, Rust, Kotlin, and TypeScript before deciding whether AOT should preserve or reject a PHP behavior.
+
+Example: `function test($a = 1, $b, $c) {}` is legal in PHP, but the default value for `$a` is effectively ignored and all parameters become required. This is a PHP historical compatibility artifact. AOT should reject it during preprocessing instead of preserving the behavior.
+
+Example: PHP permits `return $value;` inside `__construct()` and lets callers consume `parent::__construct()` as a value, even though constructors cannot declare a return type. AOT treats constructors consistently with C++/Java-style semantics: constructors initialize objects and must not return values. `return;` is allowed, but `return $value;` or using a constructor call as a value must be rejected during static compilation.
+
 ## Build & Test Commands
 
 ```bash
diff --git a/docs/README.md b/docs/README.md
index e6bd8505..2a6856c8 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -119,6 +119,19 @@
 
 ---
 
+### 9. [核心重构计划](REFACTORING_PLAN.md)
+**必读指数**: ⭐⭐⭐⭐
+
+内容概要：
+- 核心类职责拆分方向
+- TypeSystem、SymbolResolver、PropertyAccessResolver、CallResolver 等模块规划
+- 渐进式重构阶段计划
+- 测试门禁和风险控制要求
+
+**适合人群**: 核心开发者、架构重构参与者
+
+---
+
 ## 🎯 快速导航
 
 ### 按使用场景
diff --git a/docs/REFACTORING_PLAN.md b/docs/REFACTORING_PLAN.md
new file mode 100644
index 00000000..b97deaf9
--- /dev/null
+++ b/docs/REFACTORING_PLAN.md
@@ -0,0 +1,399 @@
+# AOT 编译器核心重构计划
+
+## 背景
+
+当前 AOT 编译器核心类承担了过多职责，尤其是 `CompilerBase`、`Translator` 等类同时包含 AST 分发、类型推导、属性访问解析、调用解析、代码生成、诊断信息、上下文状态维护等逻辑。随着功能持续增加，这种结构会带来以下问题：
+
+- 封装性不足，修改一个语义点时容易影响多个代码路径。
+- 代码复用不足，同类逻辑在普通属性、静态属性、nullsafe、assignment、isset/empty/refval 等路径中重复实现。
+- 编译期检查容易出现绕过路径，例如某些动态 fallback 没有复用静态 resolver。
+- 单个类代码量过大，review、测试定位和长期维护成本持续升高。
+- 设计边界不清晰，类型系统、符号解析、属性访问、调用生成之间耦合过深。
+
+本计划用于指导后续逐步重构，目标是改善架构质量，同时避免一次性大规模重写带来的行为回归风险。
+
+## 核心原则
+
+1. 渐进式重构，禁止一次性重写核心编译流程。
+2. 优先抽离无状态或低状态依赖的纯逻辑，再抽离依赖编译上下文的逻辑。
+3. 每一步重构应尽量保持行为不变，行为变更必须单独说明并补测试。
+4. 新模块应围绕稳定领域建模，而不是简单按 AST 节点机械拆分。
+5. 优先使用小型 service/helper、明确 DTO、resolver、emitter；仅在边界稳定后再引入 Visitor、Strategy 等模式。
+6. 所有错误信息保持 PHP 风格，不暴露实现细节，不使用 “AOT 禁止” 这类表述。
+7. 每个阶段必须有 phpunit 或 phpt 回归验证，尤其是属性、类型、调用、继承、异常等高风险路径。
+
+## 目标架构方向
+
+### CompilerBase
+
+最终应收敛为编译上下文、公共工具、AST 调度入口和跨模块协作层，不再直接承载大量领域逻辑。
+
+保留职责：
+
+- 当前文件、函数、类、方法上下文管理。
+- 临时变量、局部变量、作用域状态维护。
+- AST 顶层分发入口。
+- fatal/warning 的统一入口。
+- 与下层 resolver/emitter 的协作。
+
+逐步移出职责：
+
+- 类型声明解析和类型兼容判断。
+- 属性可见性、属性 offset、typed property 检查。
+- 函数和方法调用解析。
+- 复杂表达式代码生成。
+- union/intersection/nullable runtime typecheck 生成。
+
+### Translator
+
+保留文件级、类级、函数级编译流程控制，逐步减少具体语义检查和表达式生成逻辑。
+
+保留职责：
+
+- 文件扫描和转换入口。
+- 类、函数、方法代码块生成流程。
+- class/function/constant/property metadata 注册。
+- 编译产物组织。
+
+逐步移出职责：
+
+- 继承兼容检查的细节逻辑。
+- trait 属性冲突检查细节。
+- 参数、返回值、属性类型兼容判断。
+
+## 模块拆分计划
+
+### 1. TypeSystem
+
+职责：
+
+- 类型声明解析。
+- PHP 类型到 AOT 内部类型映射。
+- nullable、union、intersection 类型展开。
+- 参数、返回值、属性、常量的类型兼容判断。
+- 静态类型与 runtime typecheck 的边界定义。
+- 类型字符串格式化。
+
+建议子模块：
+
+- `TypeResolver`
+- `TypeCompatibility`
+- `TypeCheckEmitter`
+- `TypeStringFormatter`
+
+设计要求：
+
+- union、intersection、nullable 在静态阶段仍可按 mixed/any 处理，但必须保留 runtime typecheck 信息。
+- `self`、`parent`、`static` 等特殊类型名的解析规则必须集中，避免多个路径实现不一致。
+- 类型错误信息必须包含函数、方法、参数、属性等必要上下文。
+
+### 2. SymbolResolver
+
+职责：
+
+- 命名空间解析。
+- use alias 解析。
+- `self`、`parent`、`static` 解析。
+- 类、接口、trait、函数、常量名称规范化。
+- 动态符号和静态可解析符号的边界判断。
+
+建议接口：
+
+- `resolveClassName(NodeAbstract $node): SymbolResolution`
+- `resolveFunctionName(NodeAbstract $node): SymbolResolution`
+- `resolveMethodScope(NodeAbstract $node): SymbolResolution`
+- `resolveClassConstScope(NodeAbstract $node): SymbolResolution`
+
+设计要求：
+
+- 不同调用路径不能重复实现 `self/parent/static` 规则。
+- 对无法静态确定的符号，应明确返回 dynamic 状态，而不是默默退化为字符串拼接。
+
+### 3. PropertyAccessResolver
+
+职责：
+
+- 对象属性访问解析。
+- 静态属性访问解析。
+- nullsafe 属性访问静态检查。
+- private/protected/public 可见性检查。
+- native property offset 查找。
+- typed property 写入 typecheck 信息生成入口。
+- static-vs-instance 属性误用检查。
+
+建议接口：
+
+- `resolveInstancePropertyAccess(PropertyAccessRequest $request): PropertyAccessResult`
+- `resolveStaticPropertyAccess(StaticPropertyAccessRequest $request): PropertyAccessResult`
+- `assertReadable(PropertyAccessResult $result): void`
+- `assertWritable(PropertyAccessResult $result): void`
+- `emitRead(PropertyAccessResult $result): string`
+- `emitWrite(PropertyAccessResult $result, string $value): string`
+
+需要统一覆盖的路径：
+
+- `$obj->prop`
+- `$obj?->prop`
+- `Class::$prop`
+- `self::$prop`
+- `parent::$prop`
+- `static::$prop`
+- `isset($obj->prop)`
+- `empty($obj->prop)`
+- `refval($obj->prop)`
+- 普通赋值、复合赋值、自增自减、unset。
+
+第一优先级建议从本模块开始，因为近期问题集中在属性访问和可见性绕过，测试边界相对清晰。
+
+### 4. CallResolver
+
+职责：
+
+- 函数调用解析。
+- 对象方法调用解析。
+- 静态方法调用解析。
+- native call 与 dynamic call 选择。
+- named args、unpack、by-ref 参数处理。
+- closure 和动态 callable 退化规则。
+
+建议接口：
+
+- `resolveFunctionCall(CallRequest $request): CallResolution`
+- `resolveMethodCall(MethodCallRequest $request): CallResolution`
+- `resolveStaticCall(StaticCallRequest $request): CallResolution`
+- `emitCall(CallResolution $resolution): string`
+
+设计要求：
+
+- 静态 function 和内置 function 参数信息明确时，可以自动转引用。
+- 动态调用、closure、编译期无法获取参数 by-ref 信息时，必须要求显式 `refval()`。
+- 使用 unpack 并追加尾部 named args 时，应退化为 dynamic call，不能走 native call。
+
+### 5. ExpressionEmitter
+
+职责：
+
+- 表达式级代码生成。
+- 将大型 `parseExpr()` 分发逻辑逐步拆分。
+- 复用 resolver 结果生成 C++ 代码。
+
+建议按领域拆分，而不是一开始拆成大量 AST visitor：
+
+- `AssignmentEmitter`
+- `PropertyEmitter`
+- `CallEmitter`
+- `ArrayEmitter`
+- `ControlExprEmitter`
+- `ObjectEmitter`
+
+设计要求：
+
+- 先保持现有 `parseExpr()` 作为调度入口。
+- 每次只迁移一组表达式，迁移后跑对应测试组。
+- 对表达式副作用、求值顺序、临时变量生成必须保守处理。
+
+### 6. Diagnostic
+
+职责：
+
+- 统一 fatal/warning 构造。
+- 提供上下文增强能力。
+- 保证错误消息风格接近 PHP。
+
+建议能力：
+
+- 当前函数/方法名。
+- 参数名。
+- 属性名和类名。
+- 源码位置。
+- 声明位置与使用位置。
+
+设计要求：
+
+- 错误信息不出现 “AOT” 作为行为主体。
+- 对用户可修复的问题，应包含准确符号名。
+- 编译期能发现的问题优先编译期 fatal，不应依赖运行时 typecheck 异常兜底。
+
+## 阶段计划
+
+### 阶段 1：属性访问解析模块化
+
+目标：
+
+- 抽离 `findNativeProperty()`、`findNativeStaticProperty()`、`canAccessProtectedProperty()` 等属性访问解析逻辑。
+- 保持生成代码基本不变。
+- 建立统一的 `PropertyAccessResult`，承载属性声明、声明类、访问类、是否 native、offset、是否 dynamic 等信息。
+
+范围：
+
+- 普通对象属性读取。
+- 静态属性读取。
+- nullsafe 属性静态检查。
+- 属性可见性检查。
+
+当前进展：
+
+- 已建立 `PropertyAccessResolver` 和 `PropertyAccessResult` 作为属性访问解析的第一层抽象。
+- 实例属性读取已通过 resolver 的 `resolveNativeInstanceProperty()` 显式接口完成 native property 查找、static-vs-instance 检查和可见性检查。
+- `findNativeStaticProperty()` 已通过 resolver 的 `resolveNativeStaticProperty()` 显式接口完成静态属性检查。
+- nullsafe 属性链检查已通过 resolver 的 `resolveNullsafePropertyChain()` 显式接口完成类名推进和可见性检查。
+- 旧的 `CompilerBase::findNativeProperty()` 泛型入口已移除，避免后续继续扩散带 `$static` 布尔参数的访问模式。
+- `CompilerBase::isSameClassName()`、`isSameOrSubclassOf()`、`canAccessProtectedProperty()` 已委托 resolver，避免规则继续扩散。
+- 已添加 `prepare/convert/idle` 编译阶段状态；`PropertyAccessResolver` 只能在 convert 阶段创建和使用，避免预处理阶段误用不完整的类表状态。
+- 当前迁移保持生成代码不变，后续阶段再统一 read/write emitter。
+
+验证：
+
+- `phpunit/src/NativePropertyTest.php`
+- `phpunit/src/InheritanceErrorTest.php`
+- object property 相关 phpt。
+- static property 相关 phpt。
+- nullsafe 相关 phpt。
+
+### 阶段 2：属性写入路径统一
+
+目标：
+
+- 所有属性写入路径先 resolve，再 emit。
+- typed property runtime typecheck 从散落逻辑收敛到属性写入模块。
+- 消除 assignment、compound assignment、inc/dec、unset 各自实现属性访问规则的问题。
+
+范围：
+
+- `$obj->prop = $value`
+- `$obj->prop += $value`
+- `$obj->prop++`
+- `unset($obj->prop)`
+- `Class::$prop = $value`
+- `??=` 相关属性路径。
+
+验证：
+
+- typed property 相关 phpunit/phpt。
+- object property optimization 相关 phpt。
+- nullsafe 写上下文错误测试。
+- private/protected/static 属性错误测试。
+
+### 阶段 3：类型系统模块化
+
+目标：
+
+- 抽离类型声明解析、类型兼容、runtime typecheck 生成。
+- 明确静态类型推导和运行时 typecheck 的职责边界。
+- 减少参数、返回值、属性、常量各自重复处理类型规则。
+
+范围：
+
+- `parseTypeDecl()`。
+- `buildTypeCheckFromNode()`。
+- 参数 typecheck。
+- 返回值 typecheck。
+- 属性 typecheck。
+- 常量类型处理。
+
+验证：
+
+- union、intersection、nullable 类型测试。
+- 参数、返回值、属性 typecheck 测试。
+- namespace constant 测试。
+- constructor、void expression 相关测试。
+
+### 阶段 4：调用解析模块化
+
+目标：
+
+- 统一函数、方法、静态方法调用解析。
+- 明确 native call、dynamic call、closure call 的退化规则。
+- 集中处理 named args、unpack、by-ref 参数。
+
+范围：
+
+- `parseFuncCall()`。
+- `parseMethodCall()`。
+- `parseStaticCall()`。
+- call args 解析。
+- native/internal/user function 调用路径。
+
+验证：
+
+- named args、unpack 相关 phpt。
+- by-ref 参数相关 phpt。
+- closure 相关 phpt。
+- parent/self/static call 相关 phpt。
+
+### 阶段 5：表达式生成器拆分
+
+目标：
+
+- 将 `parseExpr()` 背后的大量表达式生成逻辑迁移到领域 emitter。
+- `CompilerBase` 保持调度和共享上下文能力。
+- 降低单文件和单类代码量。
+
+范围：
+
+- AssignmentEmitter。
+- PropertyEmitter。
+- CallEmitter。
+- ArrayEmitter。
+- ControlExprEmitter。
+
+验证：
+
+- 每迁移一个 emitter，跑对应测试组。
+- 最后跑核心 phpunit 和选定 phpt 回归集。
+
+### 阶段 6：Translator 收敛
+
+目标：
+
+- 将继承兼容、trait 合并、类成员校验等逻辑抽离成专门 checker。
+- `Translator` 聚焦编译流程组织。
+
+建议子模块：
+
+- `InheritanceChecker`
+- `TraitCompositionChecker`
+- `ClassMemberValidator`
+- `FunctionSignatureChecker`
+
+验证：
+
+- 继承错误 phpunit。
+- trait 相关 phpt。
+- interface/abstract/final/readonly 相关 phpt。
+
+## 测试门禁
+
+每个重构 PR 或阶段至少满足：
+
+- 相关 phpunit 必须通过。
+- 相关 phpt 必须通过。
+- 如果修改 C++/phpx，需要补 gtest 并通过对应测试。
+- 如果引入新编译期错误，需要新增固定 fixture 到 `phpunit/code` 或新增 phpt。
+- 不使用 `file_put_contents()` 临时生成源码作为新测试方式。
+
+建议按模块维护最小回归集：
+
+- 属性模块：`NativePropertyTest`、`InheritanceErrorTest`、object property、static property、nullsafe。
+- 类型模块：type_decl、type_hits、typed property、union/intersection/nullable。
+- 调用模块：function call、method call、parent_call、closure、named args、unpack、by-ref。
+- 控制流和表达式：ternary、match、goto、loop、array、coalesce、void expression。
+
+## 风险控制
+
+- 不在同一个变更中同时做大规模文件移动和行为变更。
+- 每次迁移前先补当前行为的测试，尤其是历史 bug 对应路径。
+- 保留旧入口一段时间，通过 adapter 调用新模块，降低切换风险。
+- 对动态 PHP 语义保持保守，无法静态确定时不要过度优化。
+- 对 AOT 明确不兼容 PHP 历史包袱的地方，应在文档和错误信息中表达为语言规则，而不是实现限制。
+
+## 推荐下一步
+
+从 `PropertyAccessResolver` 开始。
+
+理由：
+
+- 最近 bug 多集中在属性访问、可见性、typed property、nullsafe、static-vs-instance 路径。
+- 现有测试较容易扩展。
+- 属性访问是类型系统、优化器、调用生成之外相对独立的领域，适合先建立 resolver/result 模式。
+- 完成后可直接减少 `CompilerBase` 中的复杂分支，并为后续 ExpressionEmitter 拆分打基础。
diff --git a/phpunit/code/abstract_method_signature_mismatch.php b/phpunit/code/abstract_method_signature_mismatch.php
new file mode 100644
index 00000000..c23c370e
--- /dev/null
+++ b/phpunit/code/abstract_method_signature_mismatch.php
@@ -0,0 +1,15 @@
+<?php
+abstract class AbstractSignatureBase
+{
+    abstract public function run(int $id): string;
+}
+
+class AbstractSignatureChild extends AbstractSignatureBase
+{
+    public function run(string $id): string
+    {
+        return $id;
+    }
+}
+
+function main() {}
diff --git a/phpunit/code/abstract_parent_method_missing.php b/phpunit/code/abstract_parent_method_missing.php
new file mode 100644
index 00000000..ec340785
--- /dev/null
+++ b/phpunit/code/abstract_parent_method_missing.php
@@ -0,0 +1,11 @@
+<?php
+abstract class AbstractParentMissing
+{
+    abstract public function run(): void;
+}
+
+class ConcreteParentMissing extends AbstractParentMissing
+{
+}
+
+function main() {}
diff --git a/phpunit/code/accessibility/private-prop-in-parent.php b/phpunit/code/accessibility/private-prop-in-parent.php
new file mode 100644
index 00000000..0a044bfe
--- /dev/null
+++ b/phpunit/code/accessibility/private-prop-in-parent.php
@@ -0,0 +1,18 @@
+<?php
+class Base {
+    private $prop = 999;
+    public function dump()
+    {
+        var_dump($this->prop);
+    }
+}
+class User extends Base {
+    public $prop;
+}
+
+function main() {
+    $u = new User();
+    $u->prop = 12;
+    var_dump($u);
+    $u->dump();
+}
diff --git a/phpunit/code/accessibility/private-prop-in-trait.php b/phpunit/code/accessibility/private-prop-in-trait.php
new file mode 100644
index 00000000..d94013c7
--- /dev/null
+++ b/phpunit/code/accessibility/private-prop-in-trait.php
@@ -0,0 +1,18 @@
+<?php
+
+trait TestTraitProp {
+    private $prop = 999;
+}
+
+class Base {
+    use TestTraitProp;
+}
+class User extends Base {
+    public $prop;
+}
+
+function main() {
+    $u = new User();
+    $u->prop = 12;
+    var_dump($u);
+}
diff --git a/phpunit/code/class-method-override-namespace.php b/phpunit/code/class-method-override-namespace.php
new file mode 100644
index 00000000..4b70736e
--- /dev/null
+++ b/phpunit/code/class-method-override-namespace.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Demo\Dispatch {
+    class ChildOverrideNs extends ParentBaseNs
+    {
+        public function bar(): void
+        {
+            echo "Child\n";
+        }
+    }
+
+    class ParentBaseNs
+    {
+        public function run(): void
+        {
+            $this->bar();
+        }
+
+        public function bar(): void
+        {
+            echo "Parent\n";
+        }
+    }
+}
+
+namespace {
+    function main(): void
+    {
+        $o = new Demo\Dispatch\ChildOverrideNs();
+        $o->run();
+    }
+}
diff --git a/phpunit/code/clone-invalid-return-type.php b/phpunit/code/clone-invalid-return-type.php
new file mode 100644
index 00000000..19392f3f
--- /dev/null
+++ b/phpunit/code/clone-invalid-return-type.php
@@ -0,0 +1,13 @@
+<?php
+
+class CloneInvalidReturnType
+{
+    public function __clone(): int
+    {
+        return 1;
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/closure-ref-param.php b/phpunit/code/closure-ref-param.php
new file mode 100644
index 00000000..a4137eee
--- /dev/null
+++ b/phpunit/code/closure-ref-param.php
@@ -0,0 +1,8 @@
+<?php
+
+function main(): void
+{
+    $fn = function (&$value): void {
+        $value = 1;
+    };
+}
diff --git a/phpunit/code/compiler_api/extension_clean_maps.php b/phpunit/code/compiler_api/extension_clean_maps.php
new file mode 100644
index 00000000..74dd0adb
--- /dev/null
+++ b/phpunit/code/compiler_api/extension_clean_maps.php
@@ -0,0 +1,6 @@
+<?php
+
+function main(): void
+{
+    echo "ok\n";
+}
diff --git a/phpunit/code/compiler_api/hello_world.cc b/phpunit/code/compiler_api/hello_world.cc
new file mode 100644
index 00000000..76e81970
--- /dev/null
+++ b/phpunit/code/compiler_api/hello_world.cc
@@ -0,0 +1 @@
+int main() { return 0; }
diff --git a/phpunit/code/compiler_api/ignored.php b/phpunit/code/compiler_api/ignored.php
new file mode 100644
index 00000000..f95a9e1b
--- /dev/null
+++ b/phpunit/code/compiler_api/ignored.php
@@ -0,0 +1,2 @@
+<?php
+function ignored() {}
diff --git a/phpunit/code/compiler_api/kept.php b/phpunit/code/compiler_api/kept.php
new file mode 100644
index 00000000..39b87bc4
--- /dev/null
+++ b/phpunit/code/compiler_api/kept.php
@@ -0,0 +1,2 @@
+<?php
+function kept() {}
diff --git a/phpunit/code/compiler_api/main.php b/phpunit/code/compiler_api/main.php
new file mode 100644
index 00000000..a3d39521
--- /dev/null
+++ b/phpunit/code/compiler_api/main.php
@@ -0,0 +1,2 @@
+<?php
+function main() {}
diff --git a/phpunit/code/compiler_api/skipped_nested.php b/phpunit/code/compiler_api/skipped_nested.php
new file mode 100644
index 00000000..bf3a017d
--- /dev/null
+++ b/phpunit/code/compiler_api/skipped_nested.php
@@ -0,0 +1,2 @@
+<?php
+function skipped() {}
diff --git a/phpunit/code/constructor-return-type.php b/phpunit/code/constructor-return-type.php
new file mode 100644
index 00000000..57e24bff
--- /dev/null
+++ b/phpunit/code/constructor-return-type.php
@@ -0,0 +1,13 @@
+<?php
+
+class ConstructorReturnType
+{
+    public function __construct(): int
+    {
+        return 1;
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/constructor-return-value.php b/phpunit/code/constructor-return-value.php
new file mode 100644
index 00000000..c373b92b
--- /dev/null
+++ b/phpunit/code/constructor-return-value.php
@@ -0,0 +1,14 @@
+<?php
+
+class ConstructorReturnValue
+{
+    public function __construct()
+    {
+        return 123;
+    }
+}
+
+function main(): void
+{
+    new ConstructorReturnValue();
+}
diff --git a/phpunit/code/destructor-return-type.php b/phpunit/code/destructor-return-type.php
new file mode 100644
index 00000000..49e55e2a
--- /dev/null
+++ b/phpunit/code/destructor-return-type.php
@@ -0,0 +1,12 @@
+<?php
+
+class DestructorReturnType
+{
+    public function __destruct(): void
+    {
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/dynamic-call-positional-after-unpack.php b/phpunit/code/dynamic-call-positional-after-unpack.php
new file mode 100644
index 00000000..6f907784
--- /dev/null
+++ b/phpunit/code/dynamic-call-positional-after-unpack.php
@@ -0,0 +1,11 @@
+<?php
+
+function target(int $a, int $b): void
+{
+}
+
+function main(): void
+{
+    $fn = 'target';
+    $fn(...[1], 2);
+}
diff --git a/phpunit/code/inheritance_const_visibility_widen.php b/phpunit/code/inheritance_const_visibility_widen.php
new file mode 100644
index 00000000..f08d9369
--- /dev/null
+++ b/phpunit/code/inheritance_const_visibility_widen.php
@@ -0,0 +1,11 @@
+<?php
+
+class InheritanceConstVisibilityWidenParent
+{
+    protected const VALUE = 1;
+}
+
+class InheritanceConstVisibilityWidenChild extends InheritanceConstVisibilityWidenParent
+{
+    public const VALUE = 2;
+}
diff --git a/phpunit/code/inheritance_error_final_method.php b/phpunit/code/inheritance_error_final_method.php
new file mode 100644
index 00000000..b2f62163
--- /dev/null
+++ b/phpunit/code/inheritance_error_final_method.php
@@ -0,0 +1,15 @@
+<?php
+
+class InheritanceFinalMethodParent
+{
+    final public function run(): void
+    {
+    }
+}
+
+class InheritanceFinalMethodChild extends InheritanceFinalMethodParent
+{
+    public function run(): void
+    {
+    }
+}
diff --git a/phpunit/code/inheritance_error_param_covariant_class.php b/phpunit/code/inheritance_error_param_covariant_class.php
new file mode 100644
index 00000000..e8a2b12a
--- /dev/null
+++ b/phpunit/code/inheritance_error_param_covariant_class.php
@@ -0,0 +1,23 @@
+<?php
+
+class InheritanceParamCovariantParentType
+{
+}
+
+class InheritanceParamCovariantChildType extends InheritanceParamCovariantParentType
+{
+}
+
+class InheritanceParamCovariantParent
+{
+    public function handle(InheritanceParamCovariantParentType $value): void
+    {
+    }
+}
+
+class InheritanceParamCovariantChild extends InheritanceParamCovariantParent
+{
+    public function handle(InheritanceParamCovariantChildType $value): void
+    {
+    }
+}
diff --git a/phpunit/code/inheritance_error_return_contravariant_class.php b/phpunit/code/inheritance_error_return_contravariant_class.php
new file mode 100644
index 00000000..1a771570
--- /dev/null
+++ b/phpunit/code/inheritance_error_return_contravariant_class.php
@@ -0,0 +1,25 @@
+<?php
+
+class InheritanceReturnContravariantParentType
+{
+}
+
+class InheritanceReturnContravariantChildType extends InheritanceReturnContravariantParentType
+{
+}
+
+class InheritanceReturnContravariantParent
+{
+    public function make(): InheritanceReturnContravariantChildType
+    {
+        return new InheritanceReturnContravariantChildType();
+    }
+}
+
+class InheritanceReturnContravariantChild extends InheritanceReturnContravariantParent
+{
+    public function make(): InheritanceReturnContravariantParentType
+    {
+        return new InheritanceReturnContravariantParentType();
+    }
+}
diff --git a/phpunit/code/inheritance_error_static.php b/phpunit/code/inheritance_error_static.php
new file mode 100644
index 00000000..655844c8
--- /dev/null
+++ b/phpunit/code/inheritance_error_static.php
@@ -0,0 +1,15 @@
+<?php
+
+class InheritanceStaticParent
+{
+    public static function run(): void
+    {
+    }
+}
+
+class InheritanceStaticChild extends InheritanceStaticParent
+{
+    public function run(): void
+    {
+    }
+}
diff --git a/phpunit/code/inheritance_error_visibility_narrow.php b/phpunit/code/inheritance_error_visibility_narrow.php
new file mode 100644
index 00000000..449a1a71
--- /dev/null
+++ b/phpunit/code/inheritance_error_visibility_narrow.php
@@ -0,0 +1,12 @@
+<?php
+class A
+{
+    public function f() {}
+}
+
+class B extends A
+{
+    protected function f() {}
+}
+
+function main() {}
diff --git a/phpunit/code/inheritance_optional_param_allowed.php b/phpunit/code/inheritance_optional_param_allowed.php
new file mode 100644
index 00000000..c42697cc
--- /dev/null
+++ b/phpunit/code/inheritance_optional_param_allowed.php
@@ -0,0 +1,12 @@
+<?php
+class A
+{
+    public function f($x) {}
+}
+
+class B extends A
+{
+    public function f($x, $y = 1) {}
+}
+
+function main() {}
diff --git a/phpunit/code/inheritance_parameter_type_contravariant_class.php b/phpunit/code/inheritance_parameter_type_contravariant_class.php
new file mode 100644
index 00000000..a58af7dc
--- /dev/null
+++ b/phpunit/code/inheritance_parameter_type_contravariant_class.php
@@ -0,0 +1,23 @@
+<?php
+
+class InheritanceParamContravariantParentType
+{
+}
+
+class InheritanceParamContravariantChildType extends InheritanceParamContravariantParentType
+{
+}
+
+class InheritanceParamContravariantParent
+{
+    public function handle(InheritanceParamContravariantChildType $value): void
+    {
+    }
+}
+
+class InheritanceParamContravariantChild extends InheritanceParamContravariantParent
+{
+    public function handle(InheritanceParamContravariantParentType $value): void
+    {
+    }
+}
diff --git a/phpunit/code/inheritance_private_const_redeclare.php b/phpunit/code/inheritance_private_const_redeclare.php
new file mode 100644
index 00000000..985f7619
--- /dev/null
+++ b/phpunit/code/inheritance_private_const_redeclare.php
@@ -0,0 +1,11 @@
+<?php
+
+class InheritancePrivateConstRedeclareParent
+{
+    private const int VALUE = 1;
+}
+
+class InheritancePrivateConstRedeclareChild extends InheritancePrivateConstRedeclareParent
+{
+    public const string VALUE = 'child';
+}
diff --git a/phpunit/code/inheritance_private_prop_redeclare.php b/phpunit/code/inheritance_private_prop_redeclare.php
new file mode 100644
index 00000000..89145665
--- /dev/null
+++ b/phpunit/code/inheritance_private_prop_redeclare.php
@@ -0,0 +1,11 @@
+<?php
+
+class InheritancePrivatePropRedeclareParent
+{
+    private int $value = 1;
+}
+
+class InheritancePrivatePropRedeclareChild extends InheritancePrivatePropRedeclareParent
+{
+    private string $value = 'child';
+}
diff --git a/phpunit/code/inheritance_prop_visibility_widen.php b/phpunit/code/inheritance_prop_visibility_widen.php
new file mode 100644
index 00000000..b1203ec8
--- /dev/null
+++ b/phpunit/code/inheritance_prop_visibility_widen.php
@@ -0,0 +1,11 @@
+<?php
+
+class InheritancePropVisibilityWidenParent
+{
+    protected int $value = 1;
+}
+
+class InheritancePropVisibilityWidenChild extends InheritancePropVisibilityWidenParent
+{
+    public int $value = 2;
+}
diff --git a/phpunit/code/inheritance_protected_child_const_access.php b/phpunit/code/inheritance_protected_child_const_access.php
new file mode 100644
index 00000000..4b8ba577
--- /dev/null
+++ b/phpunit/code/inheritance_protected_child_const_access.php
@@ -0,0 +1,14 @@
+<?php
+
+class InheritanceProtectedChildConstAccessParent
+{
+    public function readChild(): int
+    {
+        return InheritanceProtectedChildConstAccessChild::VALUE;
+    }
+}
+
+class InheritanceProtectedChildConstAccessChild extends InheritanceProtectedChildConstAccessParent
+{
+    protected const VALUE = 1;
+}
diff --git a/phpunit/code/inheritance_protected_child_method_access.php b/phpunit/code/inheritance_protected_child_method_access.php
new file mode 100644
index 00000000..8ccec61d
--- /dev/null
+++ b/phpunit/code/inheritance_protected_child_method_access.php
@@ -0,0 +1,16 @@
+<?php
+
+class InheritanceProtectedChildMethodAccessParent
+{
+    public function callChild(): void
+    {
+        InheritanceProtectedChildMethodAccessChild::run();
+    }
+}
+
+class InheritanceProtectedChildMethodAccessChild extends InheritanceProtectedChildMethodAccessParent
+{
+    protected static function run(): void
+    {
+    }
+}
diff --git a/phpunit/code/inheritance_return_type_covariant_class.php b/phpunit/code/inheritance_return_type_covariant_class.php
new file mode 100644
index 00000000..bc2b9464
--- /dev/null
+++ b/phpunit/code/inheritance_return_type_covariant_class.php
@@ -0,0 +1,25 @@
+<?php
+
+class InheritanceReturnCovariantParentType
+{
+}
+
+class InheritanceReturnCovariantChildType extends InheritanceReturnCovariantParentType
+{
+}
+
+class InheritanceReturnCovariantParent
+{
+    public function make(): InheritanceReturnCovariantParentType
+    {
+        return new InheritanceReturnCovariantParentType();
+    }
+}
+
+class InheritanceReturnCovariantChild extends InheritanceReturnCovariantParent
+{
+    public function make(): InheritanceReturnCovariantChildType
+    {
+        return new InheritanceReturnCovariantChildType();
+    }
+}
diff --git a/phpunit/code/inheritance_return_type_covariant_from_none.php b/phpunit/code/inheritance_return_type_covariant_from_none.php
new file mode 100644
index 00000000..52c955c6
--- /dev/null
+++ b/phpunit/code/inheritance_return_type_covariant_from_none.php
@@ -0,0 +1,17 @@
+<?php
+
+class InheritanceReturnNoneParent
+{
+    public function run()
+    {
+        return 1;
+    }
+}
+
+class InheritanceReturnNoneChild extends InheritanceReturnNoneParent
+{
+    public function run(): int
+    {
+        return 1;
+    }
+}
diff --git a/phpunit/code/interface_abstract_class_missing.php b/phpunit/code/interface_abstract_class_missing.php
new file mode 100644
index 00000000..63db89a9
--- /dev/null
+++ b/phpunit/code/interface_abstract_class_missing.php
@@ -0,0 +1,19 @@
+<?php
+interface ContractAbstractMissing
+{
+    public function run(int $id): string;
+}
+
+abstract class AbstractImplMissing implements ContractAbstractMissing
+{
+}
+
+class ConcreteImplMissing extends AbstractImplMissing
+{
+    public function run(int $id): string
+    {
+        return (string) $id;
+    }
+}
+
+function main() {}
diff --git a/phpunit/code/interface_abstract_method_mismatch.php b/phpunit/code/interface_abstract_method_mismatch.php
new file mode 100644
index 00000000..637ef353
--- /dev/null
+++ b/phpunit/code/interface_abstract_method_mismatch.php
@@ -0,0 +1,12 @@
+<?php
+interface ContractAbstractMismatch
+{
+    public function run(int $id): string;
+}
+
+abstract class AbstractImplMismatch implements ContractAbstractMismatch
+{
+    abstract public function run(string $id): string;
+}
+
+function main() {}
diff --git a/phpunit/code/interface_abstract_method_signature.php b/phpunit/code/interface_abstract_method_signature.php
new file mode 100644
index 00000000..da5b1bf5
--- /dev/null
+++ b/phpunit/code/interface_abstract_method_signature.php
@@ -0,0 +1,20 @@
+<?php
+interface ContractAbstractMethod
+{
+    public function run(int $id): string;
+}
+
+abstract class AbstractImplMethod implements ContractAbstractMethod
+{
+    abstract public function run(int $id): string;
+}
+
+class ConcreteImplMethod extends AbstractImplMethod
+{
+    public function run(int $id): string
+    {
+        return (string) $id;
+    }
+}
+
+function main() {}
diff --git a/phpunit/code/interface_abstract_parent_missing.php b/phpunit/code/interface_abstract_parent_missing.php
new file mode 100644
index 00000000..82e4943b
--- /dev/null
+++ b/phpunit/code/interface_abstract_parent_missing.php
@@ -0,0 +1,15 @@
+<?php
+interface ContractAbstractParentMissing
+{
+    public function run(): void;
+}
+
+abstract class AbstractContractParentMissing implements ContractAbstractParentMissing
+{
+}
+
+class ConcreteContractParentMissing extends AbstractContractParentMissing
+{
+}
+
+function main() {}
diff --git a/phpunit/code/interface_array_constant.php b/phpunit/code/interface_array_constant.php
new file mode 100644
index 00000000..84773773
--- /dev/null
+++ b/phpunit/code/interface_array_constant.php
@@ -0,0 +1,7 @@
+<?php
+interface InterfaceArrayConstant
+{
+    public const ITEMS = [1, 2, 3];
+}
+
+function main() {}
diff --git a/phpunit/code/interface_array_constant_implements.php b/phpunit/code/interface_array_constant_implements.php
new file mode 100644
index 00000000..2cb28fba
--- /dev/null
+++ b/phpunit/code/interface_array_constant_implements.php
@@ -0,0 +1,14 @@
+<?php
+interface InterfaceArrayConstantContract
+{
+    public const ITEMS = [1, 2, 3];
+}
+
+class InterfaceArrayConstantImpl implements InterfaceArrayConstantContract
+{
+}
+
+function main()
+{
+    var_dump(InterfaceArrayConstantImpl::ITEMS);
+}
diff --git a/phpunit/code/interface_method_from_trait.php b/phpunit/code/interface_method_from_trait.php
new file mode 100644
index 00000000..f15289de
--- /dev/null
+++ b/phpunit/code/interface_method_from_trait.php
@@ -0,0 +1,20 @@
+<?php
+interface ContractTrait
+{
+    public function run(int $id): string;
+}
+
+trait ContractTraitImpl
+{
+    public function run(int $id): string
+    {
+        return (string) $id;
+    }
+}
+
+class ImplTrait implements ContractTrait
+{
+    use ContractTraitImpl;
+}
+
+function main() {}
diff --git a/phpunit/code/interface_method_missing.php b/phpunit/code/interface_method_missing.php
new file mode 100644
index 00000000..998cfa36
--- /dev/null
+++ b/phpunit/code/interface_method_missing.php
@@ -0,0 +1,11 @@
+<?php
+interface ContractMissing
+{
+    public function run(int $id): void;
+}
+
+class ImplMissing implements ContractMissing
+{
+}
+
+function main() {}
diff --git a/phpunit/code/interface_method_signature_mismatch.php b/phpunit/code/interface_method_signature_mismatch.php
new file mode 100644
index 00000000..7b8b373b
--- /dev/null
+++ b/phpunit/code/interface_method_signature_mismatch.php
@@ -0,0 +1,15 @@
+<?php
+interface ContractMismatch
+{
+    public function run(int $id): string;
+}
+
+class ImplMismatch implements ContractMismatch
+{
+    public function run(string $id): string
+    {
+        return $id;
+    }
+}
+
+function main() {}
diff --git a/phpunit/code/interface_method_static_mismatch.php b/phpunit/code/interface_method_static_mismatch.php
new file mode 100644
index 00000000..9050cbe3
--- /dev/null
+++ b/phpunit/code/interface_method_static_mismatch.php
@@ -0,0 +1,13 @@
+<?php
+
+interface InterfaceStaticContract
+{
+    public static function run(): void;
+}
+
+class InterfaceStaticImpl implements InterfaceStaticContract
+{
+    public function run(): void
+    {
+    }
+}
diff --git a/phpunit/code/internal-call-missing-required-named-arg.php b/phpunit/code/internal-call-missing-required-named-arg.php
new file mode 100644
index 00000000..750e71ca
--- /dev/null
+++ b/phpunit/code/internal-call-missing-required-named-arg.php
@@ -0,0 +1,6 @@
+<?php
+
+function main(): void
+{
+    str_replace(search: "a", subject: "b");
+}
diff --git a/phpunit/code/internal-call-unknown-named-arg.php b/phpunit/code/internal-call-unknown-named-arg.php
new file mode 100644
index 00000000..2ab6fef5
--- /dev/null
+++ b/phpunit/code/internal-call-unknown-named-arg.php
@@ -0,0 +1,6 @@
+<?php
+
+function main(): void
+{
+    strlen(foo: "abc");
+}
diff --git a/phpunit/code/internal-void-function-assignment.php b/phpunit/code/internal-void-function-assignment.php
new file mode 100644
index 00000000..1339725c
--- /dev/null
+++ b/phpunit/code/internal-void-function-assignment.php
@@ -0,0 +1,6 @@
+<?php
+
+function main(): void
+{
+    $value = var_dump('hello');
+}
diff --git a/phpunit/code/internal-void-function-binary-operand.php b/phpunit/code/internal-void-function-binary-operand.php
new file mode 100644
index 00000000..a123dce7
--- /dev/null
+++ b/phpunit/code/internal-void-function-binary-operand.php
@@ -0,0 +1,6 @@
+<?php
+
+function main(): void
+{
+    $value = var_dump('hello') + 1;
+}
diff --git a/phpunit/code/intersection_type_parent_not_allowed.php b/phpunit/code/intersection_type_parent_not_allowed.php
new file mode 100644
index 00000000..bc1e185b
--- /dev/null
+++ b/phpunit/code/intersection_type_parent_not_allowed.php
@@ -0,0 +1,16 @@
+<?php
+
+interface ITypeParent
+{
+}
+
+class BaseIntersectionParent implements ITypeParent
+{
+}
+
+class DemoParentIntersection extends BaseIntersectionParent
+{
+    public function run(parent&ITypeParent $value): void {}
+}
+
+function main() {}
diff --git a/phpunit/code/intersection_type_self_not_allowed.php b/phpunit/code/intersection_type_self_not_allowed.php
new file mode 100644
index 00000000..f3abe32b
--- /dev/null
+++ b/phpunit/code/intersection_type_self_not_allowed.php
@@ -0,0 +1,12 @@
+<?php
+
+interface ITypeSelf
+{
+}
+
+class DemoSelfIntersection implements ITypeSelf
+{
+    public function run(self&ITypeSelf $value): void {}
+}
+
+function main() {}
diff --git a/phpunit/code/intersection_type_static_not_allowed.php b/phpunit/code/intersection_type_static_not_allowed.php
new file mode 100644
index 00000000..e0718cab
--- /dev/null
+++ b/phpunit/code/intersection_type_static_not_allowed.php
@@ -0,0 +1,15 @@
+<?php
+
+interface ITypeStatic
+{
+}
+
+class DemoStaticIntersection implements ITypeStatic
+{
+    public function run(): static&ITypeStatic
+    {
+        return $this;
+    }
+}
+
+function main() {}
diff --git a/phpunit/code/magic-call-static.php b/phpunit/code/magic-call-static.php
new file mode 100644
index 00000000..6f2a5811
--- /dev/null
+++ b/phpunit/code/magic-call-static.php
@@ -0,0 +1,13 @@
+<?php
+
+class MagicCallStaticInvalid
+{
+    public static function __call(string $name, array $arguments): mixed
+    {
+        return null;
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/magic-callstatic-nonstatic.php b/phpunit/code/magic-callstatic-nonstatic.php
new file mode 100644
index 00000000..bd834753
--- /dev/null
+++ b/phpunit/code/magic-callstatic-nonstatic.php
@@ -0,0 +1,13 @@
+<?php
+
+class MagicCallStaticNonStaticInvalid
+{
+    public function __callStatic(string $name, array $arguments): mixed
+    {
+        return null;
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/magic-destruct-args.php b/phpunit/code/magic-destruct-args.php
new file mode 100644
index 00000000..1175d337
--- /dev/null
+++ b/phpunit/code/magic-destruct-args.php
@@ -0,0 +1,12 @@
+<?php
+
+class MagicDestructArgsInvalid
+{
+    public function __destruct($extra)
+    {
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/magic-get-param-type.php b/phpunit/code/magic-get-param-type.php
new file mode 100644
index 00000000..f2c0f225
--- /dev/null
+++ b/phpunit/code/magic-get-param-type.php
@@ -0,0 +1,13 @@
+<?php
+
+class MagicGetParamTypeInvalid
+{
+    public function __get(int $name): mixed
+    {
+        return null;
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/magic-get-protected.php b/phpunit/code/magic-get-protected.php
new file mode 100644
index 00000000..c52fb04e
--- /dev/null
+++ b/phpunit/code/magic-get-protected.php
@@ -0,0 +1,13 @@
+<?php
+
+class MagicGetProtectedInvalid
+{
+    protected function __get(string $name): mixed
+    {
+        return null;
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/magic-set-state-nonstatic.php b/phpunit/code/magic-set-state-nonstatic.php
new file mode 100644
index 00000000..8e54e1b5
--- /dev/null
+++ b/phpunit/code/magic-set-state-nonstatic.php
@@ -0,0 +1,13 @@
+<?php
+
+class MagicSetStateNonStaticInvalid
+{
+    public function __set_state(array $properties): object
+    {
+        return new self();
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/magic-tostring-args.php b/phpunit/code/magic-tostring-args.php
new file mode 100644
index 00000000..7a576558
--- /dev/null
+++ b/phpunit/code/magic-tostring-args.php
@@ -0,0 +1,13 @@
+<?php
+
+class MagicToStringArgsInvalid
+{
+    public function __toString($extra): string
+    {
+        return '';
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/method-optional-before-required-param.php b/phpunit/code/method-optional-before-required-param.php
new file mode 100644
index 00000000..eb5b7122
--- /dev/null
+++ b/phpunit/code/method-optional-before-required-param.php
@@ -0,0 +1,12 @@
+<?php
+
+class OptionalBeforeRequired
+{
+    public function method($first = 1, $second): void
+    {
+    }
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/native-call-positional-after-unpack.php b/phpunit/code/native-call-positional-after-unpack.php
new file mode 100644
index 00000000..cc93f20e
--- /dev/null
+++ b/phpunit/code/native-call-positional-after-unpack.php
@@ -0,0 +1,10 @@
+<?php
+
+function target(int $a, int $b): void
+{
+}
+
+function main(): void
+{
+    target(...[1], 2);
+}
diff --git a/phpunit/code/new-positional-after-unpack.php b/phpunit/code/new-positional-after-unpack.php
new file mode 100644
index 00000000..560ed14f
--- /dev/null
+++ b/phpunit/code/new-positional-after-unpack.php
@@ -0,0 +1,13 @@
+<?php
+
+class Target
+{
+    public function __construct(int $a, int $b)
+    {
+    }
+}
+
+function main(): void
+{
+    new Target(...[1], 2);
+}
diff --git a/phpunit/code/nullsafe-nested-private-property.php b/phpunit/code/nullsafe-nested-private-property.php
new file mode 100644
index 00000000..ca30b8be
--- /dev/null
+++ b/phpunit/code/nullsafe-nested-private-property.php
@@ -0,0 +1,24 @@
+<?php
+
+use native_types;
+
+class NullsafeNestedOwner
+{
+    public NullsafeNestedChild $child;
+
+    public function __construct()
+    {
+        $this->child = new NullsafeNestedChild();
+    }
+}
+
+class NullsafeNestedChild
+{
+    private int $value = 1;
+}
+
+function main(): void
+{
+    $owner = new NullsafeNestedOwner();
+    var_dump($owner?->child?->value);
+}
diff --git a/phpunit/code/nullsafe-private-property.php b/phpunit/code/nullsafe-private-property.php
new file mode 100644
index 00000000..4ed46c0e
--- /dev/null
+++ b/phpunit/code/nullsafe-private-property.php
@@ -0,0 +1,14 @@
+<?php
+
+use native_types;
+
+class NullsafePrivateOwner
+{
+    private int $value = 1;
+}
+
+function main(): void
+{
+    $owner = new NullsafePrivateOwner();
+    var_dump($owner?->value);
+}
diff --git a/phpunit/code/nullsafe-write-assign-op.php b/phpunit/code/nullsafe-write-assign-op.php
new file mode 100644
index 00000000..81727455
--- /dev/null
+++ b/phpunit/code/nullsafe-write-assign-op.php
@@ -0,0 +1,12 @@
+<?php
+
+class NullsafeWriteAssignOp
+{
+    public int $value = 1;
+}
+
+function main(): void
+{
+    $object = new NullsafeWriteAssignOp();
+    $object?->value += 2;
+}
diff --git a/phpunit/code/nullsafe-write-assign-ref-left.php b/phpunit/code/nullsafe-write-assign-ref-left.php
new file mode 100644
index 00000000..9eeac740
--- /dev/null
+++ b/phpunit/code/nullsafe-write-assign-ref-left.php
@@ -0,0 +1,13 @@
+<?php
+
+class NullsafeWriteAssignRefLeft
+{
+    public int $value = 1;
+}
+
+function main(): void
+{
+    $object = new NullsafeWriteAssignRefLeft();
+    $value = 2;
+    $object?->value =& $value;
+}
diff --git a/phpunit/code/nullsafe-write-assign-ref-right.php b/phpunit/code/nullsafe-write-assign-ref-right.php
new file mode 100644
index 00000000..9e5a3c44
--- /dev/null
+++ b/phpunit/code/nullsafe-write-assign-ref-right.php
@@ -0,0 +1,12 @@
+<?php
+
+class NullsafeWriteAssignRefRight
+{
+    public int $value = 1;
+}
+
+function main(): void
+{
+    $object = new NullsafeWriteAssignRefRight();
+    $value =& $object?->value;
+}
diff --git a/phpunit/code/nullsafe-write-assign.php b/phpunit/code/nullsafe-write-assign.php
new file mode 100644
index 00000000..c6c66f66
--- /dev/null
+++ b/phpunit/code/nullsafe-write-assign.php
@@ -0,0 +1,12 @@
+<?php
+
+class NullsafeWriteAssign
+{
+    public int $value = 1;
+}
+
+function main(): void
+{
+    $object = new NullsafeWriteAssign();
+    $object?->value = 2;
+}
diff --git a/phpunit/code/nullsafe-write-inc.php b/phpunit/code/nullsafe-write-inc.php
new file mode 100644
index 00000000..25725f27
--- /dev/null
+++ b/phpunit/code/nullsafe-write-inc.php
@@ -0,0 +1,12 @@
+<?php
+
+class NullsafeWriteInc
+{
+    public int $value = 1;
+}
+
+function main(): void
+{
+    $object = new NullsafeWriteInc();
+    $object?->value++;
+}
diff --git a/phpunit/code/nullsafe-write-unset.php b/phpunit/code/nullsafe-write-unset.php
new file mode 100644
index 00000000..77ee238c
--- /dev/null
+++ b/phpunit/code/nullsafe-write-unset.php
@@ -0,0 +1,12 @@
+<?php
+
+class NullsafeWriteUnset
+{
+    public int $value = 1;
+}
+
+function main(): void
+{
+    $object = new NullsafeWriteUnset();
+    unset($object?->value);
+}
diff --git a/phpunit/code/optional-before-required-param.php b/phpunit/code/optional-before-required-param.php
new file mode 100644
index 00000000..f093af6f
--- /dev/null
+++ b/phpunit/code/optional-before-required-param.php
@@ -0,0 +1,9 @@
+<?php
+
+function test($a = 1, $b, $c): void
+{
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/parent-constructor-used-as-argument.php b/phpunit/code/parent-constructor-used-as-argument.php
new file mode 100644
index 00000000..562adba0
--- /dev/null
+++ b/phpunit/code/parent-constructor-used-as-argument.php
@@ -0,0 +1,21 @@
+<?php
+
+class ParentConstructorArgument
+{
+    public function __construct()
+    {
+    }
+}
+
+class ChildConstructorArgument extends ParentConstructorArgument
+{
+    public function __construct()
+    {
+        var_dump(parent::__construct());
+    }
+}
+
+function main(): void
+{
+    new ChildConstructorArgument();
+}
diff --git a/phpunit/code/parent-constructor-used-as-value.php b/phpunit/code/parent-constructor-used-as-value.php
new file mode 100644
index 00000000..e513377a
--- /dev/null
+++ b/phpunit/code/parent-constructor-used-as-value.php
@@ -0,0 +1,21 @@
+<?php
+
+class ParentConstructorValue
+{
+    public function __construct()
+    {
+    }
+}
+
+class ChildConstructorValue extends ParentConstructorValue
+{
+    public function __construct()
+    {
+        $ret = parent::__construct();
+    }
+}
+
+function main(): void
+{
+    new ChildConstructorValue();
+}
diff --git a/phpunit/code/preprocessor/abstract_method_signature.php b/phpunit/code/preprocessor/abstract_method_signature.php
new file mode 100644
index 00000000..96b89ec2
--- /dev/null
+++ b/phpunit/code/preprocessor/abstract_method_signature.php
@@ -0,0 +1,4 @@
+<?php
+abstract class PreprocessorAbstractSignature {
+    abstract public function load(int $id, ?string $name = null): self;
+}
diff --git a/phpunit/code/preprocessor/class_constants.php b/phpunit/code/preprocessor/class_constants.php
new file mode 100644
index 00000000..881ac7e3
--- /dev/null
+++ b/phpunit/code/preprocessor/class_constants.php
@@ -0,0 +1,4 @@
+<?php
+class PreprocessorClassConstants {
+    public const TEXT = 'value', ITEMS = [];
+}
diff --git a/phpunit/code/preprocessor/deps_class_implements.php b/phpunit/code/preprocessor/deps_class_implements.php
new file mode 100644
index 00000000..671a3cfc
--- /dev/null
+++ b/phpunit/code/preprocessor/deps_class_implements.php
@@ -0,0 +1,2 @@
+<?php
+class SortDependencyClass implements SortDependencyInterface {}
diff --git a/phpunit/code/preprocessor/deps_class_uses_trait.php b/phpunit/code/preprocessor/deps_class_uses_trait.php
new file mode 100644
index 00000000..37f92976
--- /dev/null
+++ b/phpunit/code/preprocessor/deps_class_uses_trait.php
@@ -0,0 +1,4 @@
+<?php
+class SortDependencyTraitUser {
+    use SortDependencyTrait;
+}
diff --git a/phpunit/code/preprocessor/deps_interface.php b/phpunit/code/preprocessor/deps_interface.php
new file mode 100644
index 00000000..409ff9c0
--- /dev/null
+++ b/phpunit/code/preprocessor/deps_interface.php
@@ -0,0 +1,2 @@
+<?php
+interface SortDependencyInterface {}
diff --git a/phpunit/code/preprocessor/deps_trait.php b/phpunit/code/preprocessor/deps_trait.php
new file mode 100644
index 00000000..4346ba1a
--- /dev/null
+++ b/phpunit/code/preprocessor/deps_trait.php
@@ -0,0 +1,2 @@
+<?php
+trait SortDependencyTrait {}
diff --git a/phpunit/code/preprocessor/duplicate_abstract_method.php b/phpunit/code/preprocessor/duplicate_abstract_method.php
new file mode 100644
index 00000000..fd1f3c97
--- /dev/null
+++ b/phpunit/code/preprocessor/duplicate_abstract_method.php
@@ -0,0 +1,5 @@
+<?php
+abstract class PreprocessorDuplicateAbstractMethod {
+    abstract public function load(): void;
+    abstract public function load(): void;
+}
diff --git a/phpunit/code/preprocessor/duplicate_class_constant.php b/phpunit/code/preprocessor/duplicate_class_constant.php
new file mode 100644
index 00000000..04baa8d1
--- /dev/null
+++ b/phpunit/code/preprocessor/duplicate_class_constant.php
@@ -0,0 +1,5 @@
+<?php
+class PreprocessorDuplicateClassConstant {
+    public const VALUE = 1;
+    public const VALUE = 2;
+}
diff --git a/phpunit/code/preprocessor/duplicate_namespaced_class_interface.php b/phpunit/code/preprocessor/duplicate_namespaced_class_interface.php
new file mode 100644
index 00000000..48daa09d
--- /dev/null
+++ b/phpunit/code/preprocessor/duplicate_namespaced_class_interface.php
@@ -0,0 +1,4 @@
+<?php
+namespace App;
+interface Demo {}
+class Demo {}
diff --git a/phpunit/code/preprocessor/interface_members.php b/phpunit/code/preprocessor/interface_members.php
new file mode 100644
index 00000000..f0faf06e
--- /dev/null
+++ b/phpunit/code/preprocessor/interface_members.php
@@ -0,0 +1,7 @@
+<?php
+interface ParentA {}
+interface ParentB {}
+interface Demo extends ParentA, ParentB {
+    public const VERSION = '1.0';
+    public function run(int $id, ?string $name = null): ParentA|ParentB;
+}
diff --git a/phpunit/code/preprocessor/namespaced_const.php b/phpunit/code/preprocessor/namespaced_const.php
new file mode 100644
index 00000000..ee74f5b0
--- /dev/null
+++ b/phpunit/code/preprocessor/namespaced_const.php
@@ -0,0 +1,3 @@
+<?php
+namespace App;
+const VERSION = 100;
diff --git a/phpunit/code/preprocessor/trait_alias_modifier.php b/phpunit/code/preprocessor/trait_alias_modifier.php
new file mode 100644
index 00000000..9f433da6
--- /dev/null
+++ b/phpunit/code/preprocessor/trait_alias_modifier.php
@@ -0,0 +1,10 @@
+<?php
+trait AliasModifierTrait {
+    public function hello() {}
+}
+
+class AliasModifierUser {
+    use AliasModifierTrait {
+        hello as private;
+    }
+}
diff --git a/phpunit/code/throw-scalar.php b/phpunit/code/throw-scalar.php
new file mode 100644
index 00000000..2ade20a9
--- /dev/null
+++ b/phpunit/code/throw-scalar.php
@@ -0,0 +1,6 @@
+<?php
+
+function test()
+{
+    throw 1;
+}
diff --git a/phpunit/code/trait_constant_conflict.php b/phpunit/code/trait_constant_conflict.php
new file mode 100644
index 00000000..2762737e
--- /dev/null
+++ b/phpunit/code/trait_constant_conflict.php
@@ -0,0 +1,14 @@
+<?php
+trait TraitConstantConflict
+{
+    public const VALUE = 1;
+}
+
+class TraitConstantConflictUser
+{
+    use TraitConstantConflict;
+
+    public const VALUE = 2;
+}
+
+function main() {}
diff --git a/phpunit/code/trait_member_compatible.php b/phpunit/code/trait_member_compatible.php
new file mode 100644
index 00000000..72f1cd4b
--- /dev/null
+++ b/phpunit/code/trait_member_compatible.php
@@ -0,0 +1,16 @@
+<?php
+trait TraitMemberCompatible
+{
+    public const VALUE = 1;
+    public int $count = 1;
+}
+
+class TraitMemberCompatibleUser
+{
+    use TraitMemberCompatible;
+
+    public const VALUE = 1;
+    public int $count = 1;
+}
+
+function main() {}
diff --git a/phpunit/code/trait_property_conflict.php b/phpunit/code/trait_property_conflict.php
new file mode 100644
index 00000000..6b27e726
--- /dev/null
+++ b/phpunit/code/trait_property_conflict.php
@@ -0,0 +1,14 @@
+<?php
+trait TraitPropertyConflict
+{
+    public int $count = 1;
+}
+
+class TraitPropertyConflictUser
+{
+    use TraitPropertyConflict;
+
+    public int $count = 2;
+}
+
+function main() {}
diff --git a/phpunit/code/union_type_parent_allowed.php b/phpunit/code/union_type_parent_allowed.php
new file mode 100644
index 00000000..84ee692d
--- /dev/null
+++ b/phpunit/code/union_type_parent_allowed.php
@@ -0,0 +1,12 @@
+<?php
+
+class BaseParentUnion
+{
+}
+
+class DemoParentUnion extends BaseParentUnion
+{
+    public function run(parent|string $value): void {}
+}
+
+function main() {}
diff --git a/phpunit/code/union_type_self_allowed.php b/phpunit/code/union_type_self_allowed.php
new file mode 100644
index 00000000..ac4b31c5
--- /dev/null
+++ b/phpunit/code/union_type_self_allowed.php
@@ -0,0 +1,8 @@
+<?php
+
+class DemoSelfUnion
+{
+    public function run(self|string $value): void {}
+}
+
+function main() {}
diff --git a/phpunit/code/unpack-after-named-arg.php b/phpunit/code/unpack-after-named-arg.php
new file mode 100644
index 00000000..78e0e22b
--- /dev/null
+++ b/phpunit/code/unpack-after-named-arg.php
@@ -0,0 +1,10 @@
+<?php
+
+function target($a, $b): void
+{
+}
+
+function main(): void
+{
+    target(a: 1, ...[2]);
+}
diff --git a/phpunit/code/variadic-ref-param.php b/phpunit/code/variadic-ref-param.php
new file mode 100644
index 00000000..5a48430d
--- /dev/null
+++ b/phpunit/code/variadic-ref-param.php
@@ -0,0 +1,9 @@
+<?php
+
+function collect(&...$args): void
+{
+}
+
+function main(): void
+{
+}
diff --git a/phpunit/code/void-expression-array-value.php b/phpunit/code/void-expression-array-value.php
new file mode 100644
index 00000000..a91279fd
--- /dev/null
+++ b/phpunit/code/void-expression-array-value.php
@@ -0,0 +1,21 @@
+<?php
+
+class VoidExpressionArrayParent
+{
+    public function __construct()
+    {
+    }
+}
+
+class VoidExpressionArrayChild extends VoidExpressionArrayParent
+{
+    public function __construct()
+    {
+        $value = [parent::__construct()];
+    }
+}
+
+function main(): void
+{
+    new VoidExpressionArrayChild();
+}
diff --git a/phpunit/code/void-expression-binary-operand.php b/phpunit/code/void-expression-binary-operand.php
new file mode 100644
index 00000000..ed9c7e6a
--- /dev/null
+++ b/phpunit/code/void-expression-binary-operand.php
@@ -0,0 +1,21 @@
+<?php
+
+class VoidExpressionBinaryParent
+{
+    public function __construct()
+    {
+    }
+}
+
+class VoidExpressionBinaryChild extends VoidExpressionBinaryParent
+{
+    public function __construct()
+    {
+        $value = parent::__construct() + 1;
+    }
+}
+
+function main(): void
+{
+    new VoidExpressionBinaryChild();
+}
diff --git a/phpunit/code/void-expression-condition.php b/phpunit/code/void-expression-condition.php
new file mode 100644
index 00000000..c09e8b7f
--- /dev/null
+++ b/phpunit/code/void-expression-condition.php
@@ -0,0 +1,23 @@
+<?php
+
+class VoidExpressionConditionParent
+{
+    public function __construct()
+    {
+    }
+}
+
+class VoidExpressionConditionChild extends VoidExpressionConditionParent
+{
+    public function __construct()
+    {
+        if (parent::__construct()) {
+            echo "unreachable\n";
+        }
+    }
+}
+
+function main(): void
+{
+    new VoidExpressionConditionChild();
+}
diff --git a/phpunit/code/void-expression-match-arm.php b/phpunit/code/void-expression-match-arm.php
new file mode 100644
index 00000000..b107621e
--- /dev/null
+++ b/phpunit/code/void-expression-match-arm.php
@@ -0,0 +1,23 @@
+<?php
+
+class VoidExpressionMatchParent
+{
+    public function __construct()
+    {
+    }
+}
+
+class VoidExpressionMatchChild extends VoidExpressionMatchParent
+{
+    public function __construct()
+    {
+        $value = match (1) {
+            1 => parent::__construct(),
+        };
+    }
+}
+
+function main(): void
+{
+    new VoidExpressionMatchChild();
+}
diff --git a/phpunit/code/void-expression-ternary-branch.php b/phpunit/code/void-expression-ternary-branch.php
new file mode 100644
index 00000000..95fa2f09
--- /dev/null
+++ b/phpunit/code/void-expression-ternary-branch.php
@@ -0,0 +1,21 @@
+<?php
+
+class VoidExpressionTernaryParent
+{
+    public function __construct()
+    {
+    }
+}
+
+class VoidExpressionTernaryChild extends VoidExpressionTernaryParent
+{
+    public function __construct()
+    {
+        $value = true ? parent::__construct() : 1;
+    }
+}
+
+function main(): void
+{
+    new VoidExpressionTernaryChild();
+}
diff --git a/phpunit/src/Backend/BackendOptionsTest.php b/phpunit/src/Backend/BackendOptionsTest.php
index e30fff17..91f0eac0 100644
--- a/phpunit/src/Backend/BackendOptionsTest.php
+++ b/phpunit/src/Backend/BackendOptionsTest.php
@@ -121,6 +121,21 @@ class BackendOptionsTest extends TestCase
         $this->assertStringContainsString('/DPPROF_ON=1', $options);
     }
 
+    public function testMsvcCompileOptionsEscapesUnsafeDefines(): void
+    {
+        $platform = new Windows();
+        $compiler = new Msvc($platform);
+
+        $options = $compiler->buildCompileOptions([
+            'enable_profiler' => true,
+            'prof_output' => 'profile output.log',
+            'user_defines' => ['APP_NAME="hello world"'],
+        ]);
+
+        $this->assertStringContainsString('/D' . escapeshellarg('APP_NAME="hello world"'), $options);
+        $this->assertStringContainsString('/D' . escapeshellarg('PROF_OUTPUT_FILE="profile output.log"'), $options);
+    }
+
     /**
      * 测试 MSVC 编译选项 - 自定义标志
      */
@@ -276,6 +291,21 @@ class BackendOptionsTest extends TestCase
         $this->assertStringContainsString('-fPIC', $options);
     }
 
+    public function testGccCompileOptionsEscapesUnsafeDefines(): void
+    {
+        $platform = new Linux();
+        $compiler = new Gcc($platform);
+
+        $options = $compiler->buildCompileOptions([
+            'enable_profiler' => true,
+            'prof_output' => 'profile output.log',
+            'user_defines' => ['APP_NAME="hello world"'],
+        ]);
+
+        $this->assertStringContainsString('-D' . escapeshellarg('APP_NAME="hello world"'), $options);
+        $this->assertStringContainsString('-D' . escapeshellarg('PROF_OUTPUT_FILE="profile output.log"'), $options);
+    }
+
     /**
      * 测试 GCC 链接选项 - 基本配置
      */
diff --git a/phpunit/src/Backend/BackendTest.php b/phpunit/src/Backend/BackendTest.php
index e35f7bdf..8427c6c4 100644
--- a/phpunit/src/Backend/BackendTest.php
+++ b/phpunit/src/Backend/BackendTest.php
@@ -13,6 +13,39 @@ use PhpAot\Php\Backend\CompilerFactory;
 
 class BackendTest extends TestCase
 {
+    private array $temporaryDirectories = [];
+
+    protected function tearDown(): void
+    {
+        parent::tearDown();
+        foreach ($this->temporaryDirectories as $dir) {
+            $this->removeDirectory($dir);
+        }
+        $this->temporaryDirectories = [];
+    }
+
+    private function createTemporaryDirectory(string $prefix): string
+    {
+        $dir = sys_get_temp_dir() . '/' . $prefix . '_' . uniqid();
+        mkdir($dir, 0777, true);
+        $this->temporaryDirectories[] = $dir;
+        return $dir;
+    }
+
+    private function removeDirectory(string $dir): void
+    {
+        if (!is_dir($dir)) {
+            return;
+        }
+
+        $files = array_diff(scandir($dir), ['.', '..']);
+        foreach ($files as $file) {
+            $path = $dir . DIRECTORY_SEPARATOR . $file;
+            is_dir($path) ? $this->removeDirectory($path) : unlink($path);
+        }
+        rmdir($dir);
+    }
+
     /**
      * 测试 MSVC 编译器基本信息
      */
@@ -103,6 +136,31 @@ class BackendTest extends TestCase
         $this->assertStringContainsString('/nologo', $cmd);
     }
 
+    public function testMsvcBuildCCompileCommandKeepsSharedCompilerOptions(): void
+    {
+        $platform = new Windows([], true);
+        $compiler = new Msvc($platform);
+
+        $cmd = $compiler->buildCCompileCommand('misc.c', 'misc.obj', [
+            'sanitize' => 'address',
+            'enable_profiler' => true,
+            'prof_output' => 'app.prof',
+            'user_defines' => ['FEATURE_X=1'],
+            'lto' => true,
+            'is_zts' => true,
+        ]);
+
+        $this->assertStringContainsString('/TC', $cmd);
+        $this->assertStringContainsString('/fsanitize=address', $cmd);
+        $this->assertStringContainsString('/DPPROF_ON=1', $cmd);
+        $this->assertStringContainsString('/D' . escapeshellarg('PROF_OUTPUT_FILE="app.prof"'), $cmd);
+        $this->assertStringContainsString('/DFEATURE_X=1', $cmd);
+        $this->assertStringContainsString('/GL', $cmd);
+        $this->assertStringContainsString('/DZTS', $cmd);
+        $this->assertStringNotContainsString('/EHsc', $cmd);
+        $this->assertStringNotContainsString('/std:', $cmd);
+    }
+
     /**
      * 测试 MSVC 完整链接命令
      */
@@ -250,6 +308,32 @@ class BackendTest extends TestCase
         $this->assertStringContainsString('-fno-rtti', $cmd);
     }
 
+    public function testGccBuildCCompileCommandKeepsSharedCompilerOptions(): void
+    {
+        $platform = new Linux();
+        $compiler = new Gcc($platform);
+
+        $cmd = $compiler->buildCCompileCommand('misc.c', 'misc.o', [
+            'sanitize' => 'address',
+            'enable_profiler' => true,
+            'prof_output' => 'app.prof',
+            'user_defines' => ['FEATURE_X=1'],
+            'lto' => true,
+            'march' => 'native',
+            'target_platform' => 'aarch64-linux-gnu',
+            'build_mode' => 'ext',
+        ]);
+
+        $this->assertStringContainsString('-fsanitize=address', $cmd);
+        $this->assertStringContainsString('-DPPROF_ON=1', $cmd);
+        $this->assertStringContainsString('-D' . escapeshellarg('PROF_OUTPUT_FILE="app.prof"'), $cmd);
+        $this->assertStringContainsString('-DFEATURE_X=1', $cmd);
+        $this->assertStringContainsString('-flto', $cmd);
+        $this->assertStringContainsString('-march=native', $cmd);
+        $this->assertStringContainsString('--target=aarch64-linux-gnu', $cmd);
+        $this->assertStringContainsString('-fPIC', $cmd);
+    }
+
     public function testGccBuildLinkCommandIncludesPlatformPathsOptionsAndLibraries(): void
     {
         $platform = new Linux();
@@ -270,6 +354,27 @@ class BackendTest extends TestCase
         $this->assertStringContainsString('-lphp', $cmd);
     }
 
+    public function testResponseFileArgumentIsEscapedForPathsWithSpaces(): void
+    {
+        $platform = new Linux();
+        $compiler = new Gcc($platform, 'g++');
+        $dir = $this->createTemporaryDirectory('backend link path');
+        $target = $dir . '/my app';
+        $rspFile = $target . '.rsp';
+        $objectWithSpace = $dir . '/object one.o';
+        $objectWithoutSpace = $dir . '/object_two.o';
+
+        $cmd = $compiler->buildLinkCommand([$objectWithSpace, $objectWithoutSpace], $target);
+
+        $this->assertStringContainsString(escapeshellarg('@' . $rspFile), $cmd);
+        $this->assertStringContainsString('-o ' . escapeshellarg($target), $cmd);
+        $this->assertFileExists($rspFile);
+
+        $lines = file($rspFile, FILE_IGNORE_NEW_LINES);
+        $this->assertSame('"' . $objectWithSpace . '"', $lines[0]);
+        $this->assertSame('"' . $objectWithoutSpace . '"', $lines[1]);
+    }
+
     /**
      * 测试 GCC 完整编译选项
      */
diff --git a/phpunit/src/ClassTest.php b/phpunit/src/ClassTest.php
index b74146c2..6d978836 100644
--- a/phpunit/src/ClassTest.php
+++ b/phpunit/src/ClassTest.php
@@ -26,4 +26,133 @@ class ClassTest extends \BaseTest
     {
         $this->exec('Cannot override private method `Base::doWork()`', 'override-private-method.php');
     }
+
+    public function testSelfCanBePartOfUnionType()
+    {
+        global $translator;
+        $compiler = \PhpAot\Php\CompilerTest::create(ROOT_PATH);
+        $translator = $compiler;
+        $testFile = __DIR__ . '/../code/union_type_self_allowed.php';
+        $compiler->addFiles([$testFile]);
+        $compiler->prepareFile($testFile);
+        $compiler->convertFile($testFile);
+        $this->addToAssertionCount(1);
+    }
+
+    public function testParentCanBePartOfUnionType()
+    {
+        global $translator;
+        $compiler = \PhpAot\Php\CompilerTest::create(ROOT_PATH);
+        $translator = $compiler;
+        $testFile = __DIR__ . '/../code/union_type_parent_allowed.php';
+        $compiler->addFiles([$testFile]);
+        $compiler->prepareFile($testFile);
+        $compiler->convertFile($testFile);
+        $this->addToAssertionCount(1);
+    }
+
+    public function testSelfCannotBePartOfIntersectionType()
+    {
+        $this->exec("Type 'self' cannot be part of an intersection type", 'intersection_type_self_not_allowed.php');
+    }
+
+    public function testParentCannotBePartOfIntersectionType()
+    {
+        $this->exec("Type 'parent' cannot be part of an intersection type", 'intersection_type_parent_not_allowed.php');
+    }
+
+    public function testStaticCannotBePartOfIntersectionType()
+    {
+        $this->exec("Type 'static' cannot be part of an intersection type", 'intersection_type_static_not_allowed.php');
+    }
+
+    public function testConstructorCannotDeclareReturnType()
+    {
+        $this->exec('Method `ConstructorReturnType::__construct()` cannot declare a return type', 'constructor-return-type.php');
+    }
+
+    public function testConstructorCannotReturnValue()
+    {
+        $this->exec('Method `ConstructorReturnValue::__construct()` cannot return a value', 'constructor-return-value.php');
+    }
+
+    public function testParentConstructorCannotBeUsedAsValue()
+    {
+        $this->exec('Cannot use void expression as assignment value', 'parent-constructor-used-as-value.php');
+    }
+
+    public function testParentConstructorCannotBeUsedAsArgument()
+    {
+        $this->exec('Cannot use void expression as function argument', 'parent-constructor-used-as-argument.php');
+    }
+
+    public function testVoidExpressionCannotBeUsedAsBinaryOperand()
+    {
+        $this->exec('Cannot use void expression as binary operand', 'void-expression-binary-operand.php');
+    }
+
+    public function testVoidExpressionCannotBeUsedAsCondition()
+    {
+        $this->exec('Cannot use void expression as condition', 'void-expression-condition.php');
+    }
+
+    public function testVoidExpressionCannotBeUsedAsTernaryBranch()
+    {
+        $this->exec('Cannot use void expression as ternary branch', 'void-expression-ternary-branch.php');
+    }
+
+    public function testVoidExpressionCannotBeUsedAsArrayValue()
+    {
+        $this->exec('Cannot use void expression as array value', 'void-expression-array-value.php');
+    }
+
+    public function testVoidExpressionCannotBeUsedAsMatchArm()
+    {
+        $this->exec('Cannot use void expression as match arm', 'void-expression-match-arm.php');
+    }
+
+    public function testDestructorCannotDeclareReturnType()
+    {
+        $this->exec('Method `DestructorReturnType::__destruct()` cannot declare a return type', 'destructor-return-type.php');
+    }
+
+    public function testCloneReturnTypeMustBeVoid()
+    {
+        $this->exec('Method `CloneInvalidReturnType::__clone()` return type must be void when declared', 'clone-invalid-return-type.php');
+    }
+
+    public function testCallMagicMethodCannotBeStatic()
+    {
+        $this->exec('Method MagicCallStaticInvalid::__call() cannot be static', 'magic-call-static.php');
+    }
+
+    public function testCallStaticMagicMethodMustBeStatic()
+    {
+        $this->exec('Method MagicCallStaticNonStaticInvalid::__callStatic() must be static', 'magic-callstatic-nonstatic.php');
+    }
+
+    public function testToStringMagicMethodCannotTakeArguments()
+    {
+        $this->exec('Method MagicToStringArgsInvalid::__toString() must take exactly 0 arguments', 'magic-tostring-args.php');
+    }
+
+    public function testSetStateMagicMethodMustBeStatic()
+    {
+        $this->exec('Method MagicSetStateNonStaticInvalid::__set_state() must be static', 'magic-set-state-nonstatic.php');
+    }
+
+    public function testDestructMagicMethodCannotTakeArguments()
+    {
+        $this->exec('Method MagicDestructArgsInvalid::__destruct() must take exactly 0 arguments', 'magic-destruct-args.php');
+    }
+
+    public function testGetMagicMethodParameterMustBeString()
+    {
+        $this->exec('Method MagicGetParamTypeInvalid::__get() must take string as argument', 'magic-get-param-type.php');
+    }
+
+    public function testMagicMethodMustBePublic()
+    {
+        $this->exec('Method MagicGetProtectedInvalid::__get() must have public visibility', 'magic-get-protected.php');
+    }
 }
diff --git a/phpunit/src/CompilerBaseApiTest.php b/phpunit/src/CompilerBaseApiTest.php
index de2d975a..30b2450b 100644
--- a/phpunit/src/CompilerBaseApiTest.php
+++ b/phpunit/src/CompilerBaseApiTest.php
@@ -11,10 +11,15 @@ class CompilerBaseApiTest extends TestCase
     private string $testDir;
     private CompilerTest $compiler;
     private \ReflectionClass $ref;
+    private array $originalArgv;
+    private string|false $originalPath;
 
     protected function setUp(): void
     {
         parent::setUp();
+        global $argv;
+        $this->originalArgv = $argv ?? [];
+        $this->originalPath = getenv('PATH');
         $this->testDir = sys_get_temp_dir() . '/compiler_api_test_' . uniqid();
         mkdir($this->testDir, 0777, true);
         $this->compiler = CompilerTest::create($this->testDir);
@@ -24,6 +29,13 @@ class CompilerBaseApiTest extends TestCase
     protected function tearDown(): void
     {
         parent::tearDown();
+        global $argv;
+        $argv = $this->originalArgv;
+        if ($this->originalPath === false) {
+            putenv('PATH');
+        } else {
+            putenv('PATH=' . $this->originalPath);
+        }
         // Recursively remove the test directory (compiler creates build/ subdir)
         $this->removeDirectory($this->testDir);
     }
@@ -62,6 +74,34 @@ class CompilerBaseApiTest extends TestCase
         return $m->invoke($this->compiler, ...$args);
     }
 
+    private function fixturePath(string $file): string
+    {
+        return __DIR__ . '/../code/compiler_api/' . $file;
+    }
+
+    private function createProjectFile(string $yaml, string $filename = 'project.yml', string $baseDir = ''): string
+    {
+        $projectDir = $baseDir === '' ? $this->testDir : $this->testDir . '/' . trim($baseDir, '/');
+        if (!is_dir($projectDir)) {
+            mkdir($projectDir, 0777, true);
+        }
+
+        $sourceFile = $projectDir . '/main.php';
+        copy($this->fixturePath('main.php'), $sourceFile);
+
+        $projectFile = $projectDir . '/' . $filename;
+        file_put_contents($projectFile, $yaml);
+
+        return $projectFile;
+    }
+
+    private function createFakeClangFormat(string $binDir, string $logFile): void
+    {
+        mkdir($binDir, 0777, true);
+        file_put_contents($binDir . '/clang-format', "#!/bin/sh\nif [ \"$1\" = \"--version\" ]; then\n  echo 'clang-format version test'\n  exit 0\nfi\npwd > " . escapeshellarg($logFile) . "\nprintf '%s\\n' \"$@\" >> " . escapeshellarg($logFile) . "\n");
+        chmod($binDir . '/clang-format', 0755);
+    }
+
     // ========================================================================
     // getTypeFromZendType
     // ========================================================================
@@ -138,6 +178,11 @@ class CompilerBaseApiTest extends TestCase
         $this->assertStringStartsWith($this->testDir, $buildDir);
     }
 
+    public function testFormatCodeDisabledByDefault(): void
+    {
+        $this->assertFalse($this->getPropertyValue('formatCode'));
+    }
+
     public function testGetIncludeDir(): void
     {
         $includeDir = $this->compiler->getIncludeDir();
@@ -145,6 +190,322 @@ class CompilerBaseApiTest extends TestCase
         $this->assertEquals($buildDir . '/include', $includeDir);
     }
 
+    public function testParseProjectYamlLoadsDocumentedCompilerOptions(): void
+    {
+        $binDir = $this->testDir . '/bin';
+        $formatLog = $this->testDir . '/format.log';
+        $this->createFakeClangFormat($binDir, $formatLog);
+        putenv('PATH=' . $binDir . ':' . ($this->originalPath ?: ''));
+
+        $projectFile = $this->createProjectFile(<<<'YAML'
+sources:
+  - main.php
+optimize: 2
+job: 8
+debug: true
+profile: true
+no-progress: true
+no-console: true
+no-literal-strings: true
+sanitize: address
+target-platform: aarch64-linux-gnu
+build-dir: /tmp/project-build
+include-paths:
+  - /opt/mylib/include
+  - ../shared/headers
+defines:
+  - ENABLE_LOGGING=1
+  - DEBUG_LEVEL=3
+lto: true
+format: true
+link-libs:
+  - curl
+  - ssl
+link-paths:
+  - /usr/local/lib
+  - /opt/custom/lib
+YAML);
+
+        $this->invokeMethod('parseProjectYaml', $projectFile);
+
+        $this->assertSame(2, $this->getPropertyValue('optimizeLevel'));
+        $this->assertSame(8, $this->getPropertyValue('maxJob'));
+        $this->assertTrue($this->getPropertyValue('debug'));
+        $this->assertTrue($this->getPropertyValue('enableProfiler'));
+        $this->assertTrue($this->getPropertyValue('noProgress'));
+        $this->assertTrue($this->getPropertyValue('noConsole'));
+        $this->assertTrue($this->getPropertyValue('noLiteralStrings'));
+        $this->assertSame('address', $this->getPropertyValue('sanitize'));
+        $this->assertSame('aarch64-linux-gnu', $this->getPropertyValue('targetPlatform'));
+        $this->assertSame(['/opt/mylib/include', dirname($projectFile) . '/../shared/headers'], $this->compiler->getUserIncludePaths());
+        $this->assertSame(['ENABLE_LOGGING=1', 'DEBUG_LEVEL=3'], $this->compiler->getUserDefines());
+        $this->assertTrue($this->compiler->isLtoEnabled());
+        $this->assertSame(['curl', 'ssl'], $this->compiler->getLinkLibs());
+        $this->assertSame(['/usr/local/lib', '/opt/custom/lib'], $this->compiler->getLinkPaths());
+        $this->assertSame('/tmp/project-build', $this->compiler->getBuildDir());
+        $this->assertTrue($this->getPropertyValue('formatCode'));
+    }
+
+    public function testParseProjectYamlSupportsCustomFilenameAndRelativeBuildDir(): void
+    {
+        $projectFile = $this->createProjectFile(<<<'YAML'
+sources:
+  - main.php
+build-dir: build/output
+YAML, 'myproject.yml', 'nested/config');
+
+        $this->invokeMethod('parseProjectYaml', $projectFile);
+
+        $this->assertSame(
+            realpath($this->testDir . '/nested/config/build/output'),
+            $this->compiler->getBuildDir()
+        );
+    }
+
+    public function testParseProjectYamlSupportsCliStyleModeAndOutputAliases(): void
+    {
+        $projectFile = $this->createProjectFile(<<<'YAML'
+sources:
+  - main.php
+mode: ext
+output: out/custom-ext
+dry: true
+YAML, 'custom-name.yml', 'yaml-alias');
+
+        $this->invokeMethod('parseProjectYaml', $projectFile);
+
+        $this->assertSame(CompilerBase::BUILD_MODE_EXT, $this->getPropertyValue('buildMode'));
+        $this->assertTrue($this->getPropertyValue('dryRun'));
+        $this->assertSame('custom_ext', $this->getPropertyValue('targetName'));
+        $this->assertSame(dirname($projectFile) . '/out', $this->getPropertyValue('outputDir'));
+    }
+
+    public function testParseProjectYamlResolvesRelativePathOptionsAgainstYamlDirectory(): void
+    {
+        $projectFile = $this->createProjectFile(<<<'YAML'
+sources:
+  - main.php
+include-paths:
+  - includes
+link-paths:
+  - libs
+output: bin/my-app
+YAML, 'myproject.yml', 'nested/config');
+
+        $this->invokeMethod('parseProjectYaml', $projectFile);
+
+        $projectDir = dirname($projectFile);
+        $this->assertSame([$projectDir . '/includes'], $this->compiler->getUserIncludePaths());
+        $this->assertSame([$projectDir . '/libs'], $this->compiler->getLinkPaths());
+        $this->assertSame($projectDir . '/bin', $this->getPropertyValue('outputDir'));
+        $this->assertSame('my_app', $this->getPropertyValue('targetName'));
+    }
+
+    public function testCliOutputOverridesYamlOutputOnlyWhenCommandLineArgumentsAreApplied(): void
+    {
+        global $argv;
+        $argv = ['compiler.php', '--output', 'cli/out-file'];
+        $compiler = CompilerTest::create($this->testDir);
+        $ref = new \ReflectionClass($compiler);
+        $parseMethod = $ref->getMethod('parseProjectYaml');
+        $parseMethod->setAccessible(true);
+        $applyMethod = $ref->getMethod('applyCommandLineArguments');
+        $applyMethod->setAccessible(true);
+        $targetProp = $ref->getProperty('targetName');
+        $targetProp->setAccessible(true);
+        $outputProp = $ref->getProperty('outputDir');
+        $outputProp->setAccessible(true);
+
+        $projectFile = $this->createProjectFile(<<<'YAML'
+sources:
+  - main.php
+output: yaml/out-file
+YAML, 'myproject.yml', 'cli-output');
+
+        $parseMethod->invoke($compiler, $projectFile);
+        $this->assertSame(dirname($projectFile) . '/yaml', $outputProp->getValue($compiler));
+        $this->assertSame('out_file', $targetProp->getValue($compiler));
+
+        $applyMethod->invoke($compiler);
+        $this->assertSame('cli', $outputProp->getValue($compiler));
+        $this->assertSame('out_file', $targetProp->getValue($compiler));
+    }
+
+    public function testApplyCommandLineArgumentsDoesNotClearYamlRepeatableOptionsWhenCliAbsent(): void
+    {
+        $projectFile = $this->createProjectFile(<<<'YAML'
+sources:
+  - main.php
+include-paths:
+  - /yaml/include
+defines:
+  - YAML_DEFINE=1
+lto: true
+link-libs:
+  - yamlssl
+link-paths:
+  - /yaml/lib
+YAML);
+
+        $this->invokeMethod('parseProjectYaml', $projectFile);
+        $this->invokeMethod('applyCommandLineArguments');
+
+        $this->assertSame(['/yaml/include'], $this->compiler->getUserIncludePaths());
+        $this->assertSame(['YAML_DEFINE=1'], $this->compiler->getUserDefines());
+        $this->assertTrue($this->compiler->isLtoEnabled());
+        $this->assertSame(['yamlssl'], $this->compiler->getLinkLibs());
+        $this->assertSame(['/yaml/lib'], $this->compiler->getLinkPaths());
+    }
+
+    public function testParseProjectYamlFiltersIgnoredFilesFromReturnedSources(): void
+    {
+        $projectFile = $this->createProjectFile(<<<'YAML'
+sources:
+  - .
+ignore:
+  - ignored.php
+  - skipped
+YAML);
+        $projectDir = dirname($projectFile);
+        mkdir($projectDir . '/skipped', 0777, true);
+        copy($this->fixturePath('ignored.php'), $projectDir . '/ignored.php');
+        copy($this->fixturePath('skipped_nested.php'), $projectDir . '/skipped/nested.php');
+        copy($this->fixturePath('kept.php'), $projectDir . '/kept.php');
+
+        $files = $this->invokeMethod('parseProjectYaml', $projectFile);
+
+        $this->assertContains(realpath($projectDir . '/main.php'), $files);
+        $this->assertContains(realpath($projectDir . '/kept.php'), $files);
+        $this->assertNotContains(realpath($projectDir . '/ignored.php'), $files);
+        $this->assertNotContains(realpath($projectDir . '/skipped/nested.php'), $files);
+    }
+
+    public function testCCompileCommandOptionsKeepCommonUserConfiguration(): void
+    {
+        $this->setPropertyValue('userIncludePaths', ['/user/include']);
+        $this->setPropertyValue('userDefines', ['FEATURE_X=1']);
+        $this->setPropertyValue('buildMode', CompilerBase::BUILD_MODE_EXT);
+        $this->setPropertyValue('enableProfiler', true);
+        $this->setPropertyValue('enableLto', true);
+        $this->setPropertyValue('sanitize', 'address');
+        $this->setPropertyValue('targetPlatform', 'aarch64-linux-gnu');
+        $this->setPropertyValue('march', 'native');
+
+        $options = $this->invokeMethod('getCCompileCommandOptions');
+
+        $this->assertContains('/user/include', $options['include_paths']);
+        $this->assertSame(['FEATURE_X=1'], $options['user_defines']);
+        $this->assertSame(CompilerBase::BUILD_MODE_EXT, $options['build_mode']);
+        $this->assertTrue($options['enable_profiler']);
+        $this->assertTrue($options['lto']);
+        $this->assertSame('address', $options['sanitize']);
+        $this->assertSame('aarch64-linux-gnu', $options['target_platform']);
+        $this->assertSame('native', $options['march']);
+    }
+
+    public function testNativeCompileCommandOptionsKeepCommonUserConfiguration(): void
+    {
+        $this->setPropertyValue('userIncludePaths', ['/native/include']);
+        $this->setPropertyValue('userDefines', ['NATIVE_FEATURE=1']);
+        $this->setPropertyValue('buildMode', CompilerBase::BUILD_MODE_EXT);
+        $this->setPropertyValue('enableProfiler', true);
+        $this->setPropertyValue('enableLto', true);
+
+        $options = $this->invokeMethod('getNativeCompileCommandOptions', 'objective-c');
+
+        $this->assertContains('/native/include', $options['include_paths']);
+        $this->assertSame(['NATIVE_FEATURE=1'], $options['user_defines']);
+        $this->assertSame(CompilerBase::BUILD_MODE_EXT, $options['build_mode']);
+        $this->assertTrue($options['enable_profiler']);
+        $this->assertTrue($options['lto']);
+        $this->assertArrayNotHasKey('cpp_std', $options);
+        $this->assertArrayNotHasKey('cxxflags', $options);
+    }
+
+    public function testExtensionCleanClearsRuntimeMapsWithValidCpp(): void
+    {
+        global $translator;
+        $compiler = CompilerTest::create(ROOT_PATH);
+        $translator = $compiler;
+        $ref = new \ReflectionClass($compiler);
+        $buildMode = $ref->getProperty('buildMode');
+        $buildMode->setAccessible(true);
+        $buildMode->setValue($compiler, CompilerBase::BUILD_MODE_EXT);
+
+        $testFile = ROOT_PATH . '/phpunit/code/compiler_api/extension_clean_maps.php';
+        $compiler->addFiles([$testFile]);
+        $compiler->prepareFile($testFile);
+        $compiler->convertFile($testFile);
+        $extensionFile = $compiler->genExtension();
+        $code = file_get_contents($extensionFile);
+
+        $this->assertStringContainsString('#include <cstring>', $code);
+        $this->assertStringContainsString('std::memset(php_func_map, 0, sizeof(php_func_map));', $code);
+        $this->assertStringContainsString('std::memset(php_class_map, 0, sizeof(php_class_map));', $code);
+        $this->assertStringContainsString('std::memset(php_property_map, 0, sizeof(php_property_map));', $code);
+        $this->assertStringNotContainsString('func_map = {}', $code);
+        $this->assertStringNotContainsString('class_map = {}', $code);
+        $this->assertStringNotContainsString('property_map = {}', $code);
+    }
+
+    public function testObjectiveCppCompileCommandOptionsKeepCppOptions(): void
+    {
+        $this->setPropertyValue('cxxStd', 'c++20');
+        $this->setPropertyValue('cxxFlags', '-fobjc-arc');
+
+        $options = $this->invokeMethod('getNativeCompileCommandOptions', 'objective-c++');
+
+        $this->assertSame('c++20', $options['cpp_std']);
+        $this->assertSame('-fobjc-arc', $options['cxxflags']);
+    }
+
+    public function testLinkCommandOptionsPassUserLibrariesThroughBackendFields(): void
+    {
+        $this->setPropertyValue('linkLibs', ['curl', 'ssl']);
+        $this->setPropertyValue('linkPaths', ['/user/lib']);
+        $this->setPropertyValue('enableProfiler', true);
+        $this->setPropertyValue('ldflags', '-Wl,--as-needed');
+
+        $options = $this->invokeMethod('getLinkCommandOptions');
+
+        $this->assertContains('/user/lib', $options['library_paths']);
+        $this->assertContains('profiler', $options['libraries']);
+        $this->assertContains('curl', $options['libraries']);
+        $this->assertContains('ssl', $options['libraries']);
+        $this->assertSame('-Wl,--as-needed', $options['ldflags']);
+    }
+
+    public function testFormatCppCodeEscapesPathsWithSpaces(): void
+    {
+        $spaceDir = sys_get_temp_dir() . '/compiler api format ' . uniqid();
+        mkdir($spaceDir, 0777, true);
+        $binDir = $spaceDir . '/bin';
+        $logFile = $spaceDir . '/format.log';
+        $sourceFile = $spaceDir . '/hello world.cc';
+
+        copy($this->fixturePath('hello_world.cc'), $sourceFile);
+        $this->createFakeClangFormat($binDir, $logFile);
+        putenv('PATH=' . $binDir . ':' . ($this->originalPath ?: ''));
+
+        $compiler = CompilerTest::create($spaceDir);
+        $ref = new \ReflectionClass($compiler);
+        $formatProp = $ref->getProperty('formatCode');
+        $formatProp->setAccessible(true);
+        $formatProp->setValue($compiler, true);
+
+        $method = $ref->getMethod('formatCppCode');
+        $method->setAccessible(true);
+        $method->invoke($compiler, $sourceFile);
+
+        $this->assertFileExists($logFile);
+        $lines = file($logFile, FILE_IGNORE_NEW_LINES);
+        $this->assertSame($spaceDir, $lines[0]);
+        $this->assertSame('-i', $lines[1]);
+        $this->assertSame($sourceFile, $lines[2]);
+
+        $this->removeDirectory($spaceDir);
+    }
+
     // ========================================================================
     // isWindows / isLinux / isMacos
     // ========================================================================
diff --git a/phpunit/src/CompilerPhaseTest.php b/phpunit/src/CompilerPhaseTest.php
new file mode 100644
index 00000000..b767aa61
--- /dev/null
+++ b/phpunit/src/CompilerPhaseTest.php
@@ -0,0 +1,61 @@
+<?php
+
+use PhpAot\Php\CompilerTest;
+use PhpAot\Php\Exception\TestError;
+
+class CompilerPhaseProbe extends CompilerTest
+{
+    public static function createProbe(string $rootPath): self
+    {
+        $compiler = new self($rootPath);
+        $compiler->forTest = true;
+        return $compiler;
+    }
+
+    public function enterPreparePhase(): void
+    {
+        $this->enterCompilerPhase(self::PHASE_PREPARE);
+    }
+
+    public function enterConvertPhase(): void
+    {
+        $this->enterCompilerPhase(self::PHASE_CONVERT);
+    }
+
+    public function probePropertyAccessResolver(): bool
+    {
+        return $this->canAccessProtectedProperty('ProbeClass', 'ProbeClass');
+    }
+}
+
+class CompilerPhaseTest extends \PHPUnit\Framework\TestCase
+{
+    public function testPropertyAccessResolverCannotBeUsedOutsideConvertPhase(): void
+    {
+        $compiler = CompilerPhaseProbe::createProbe(ROOT_PATH);
+
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('PropertyAccessResolver can only be used during convert phase');
+
+        $compiler->probePropertyAccessResolver();
+    }
+
+    public function testPropertyAccessResolverCannotBeUsedDuringPreparePhase(): void
+    {
+        $compiler = CompilerPhaseProbe::createProbe(ROOT_PATH);
+        $compiler->enterPreparePhase();
+
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('PropertyAccessResolver can only be used during convert phase');
+
+        $compiler->probePropertyAccessResolver();
+    }
+
+    public function testPropertyAccessResolverCanBeUsedDuringConvertPhase(): void
+    {
+        $compiler = CompilerPhaseProbe::createProbe(ROOT_PATH);
+        $compiler->enterConvertPhase();
+
+        $this->assertTrue($compiler->probePropertyAccessResolver());
+    }
+}
diff --git a/phpunit/src/Entity/InterfaceDefTest.php b/phpunit/src/Entity/InterfaceDefTest.php
index 645847ff..b769aacc 100644
--- a/phpunit/src/Entity/InterfaceDefTest.php
+++ b/phpunit/src/Entity/InterfaceDefTest.php
@@ -4,6 +4,7 @@ namespace PhpAot\Tests\Entity;
 
 use PHPUnit\Framework\TestCase;
 use PhpAot\Php\Entity\InterfaceDef;
+use PhpAot\Php\Entity\MethodDef;
 
 class InterfaceDefTest extends TestCase
 {
@@ -39,4 +40,22 @@ class InterfaceDefTest extends TestCase
 
         $this->assertEquals('Parent', $iface->extends);
     }
+
+    public function testTracksMethodsCaseInsensitively(): void
+    {
+        $iface = new InterfaceDef('Runnable');
+        $iface->addMethod(new MethodDef(0, 'run'));
+
+        $this->assertTrue($iface->hasMethod('run'));
+        $this->assertTrue($iface->hasMethod('RUN'));
+        $this->assertArrayHasKey('run', $iface->methods);
+    }
+
+    public function testTracksMultipleParentInterfaces(): void
+    {
+        $iface = new InterfaceDef('Child');
+        $iface->extendsList = ['ParentA', 'ParentB'];
+
+        $this->assertSame(['ParentA', 'ParentB'], $iface->extendsList);
+    }
 }
diff --git a/phpunit/src/FunctionTest.php b/phpunit/src/FunctionTest.php
index d04e7e4b..e547d5cb 100644
--- a/phpunit/src/FunctionTest.php
+++ b/phpunit/src/FunctionTest.php
@@ -27,4 +27,64 @@ class FunctionTest extends \BaseTest
         $this->exec('Named argument `value` overwrites previous argument', 'native-call-named-overwrites-positional.php');
     }
 
+    public function testInternalCallUnknownNamedArgument()
+    {
+        $this->exec('Unknown named argument `foo`', 'internal-call-unknown-named-arg.php');
+    }
+
+    public function testInternalCallMissingRequiredNamedArgument()
+    {
+        $this->exec('Named argument `replace` is missing default value', 'internal-call-missing-required-named-arg.php');
+    }
+
+    public function testUnpackAfterNamedArgument()
+    {
+        $this->exec('Cannot use argument unpacking after named arguments', 'unpack-after-named-arg.php');
+    }
+
+    public function testNativeCallPositionalAfterUnpack()
+    {
+        $this->exec('Cannot use positional argument after argument unpacking', 'native-call-positional-after-unpack.php');
+    }
+
+    public function testDynamicCallPositionalAfterUnpack()
+    {
+        $this->exec('Cannot use positional argument after argument unpacking', 'dynamic-call-positional-after-unpack.php');
+    }
+
+    public function testNewPositionalAfterUnpack()
+    {
+        $this->exec('Cannot use positional argument after argument unpacking', 'new-positional-after-unpack.php');
+    }
+
+    public function testClosureReferenceParameter()
+    {
+        $this->exec('Closure cannot use reference parameter', 'closure-ref-param.php');
+    }
+
+    public function testVariadicReferenceParameter()
+    {
+        $this->exec('Variadic parameters cannot be passed by reference', 'variadic-ref-param.php');
+    }
+
+    public function testOptionalParameterBeforeRequiredParameter()
+    {
+        $this->exec('test(): optional parameter `$a` cannot be declared before required parameter `$c`', 'optional-before-required-param.php');
+    }
+
+    public function testMethodOptionalParameterBeforeRequiredParameter()
+    {
+        $this->exec('OptionalBeforeRequired::method(): optional parameter `$first` cannot be declared before required parameter `$second`', 'method-optional-before-required-param.php');
+    }
+
+    public function testInternalVoidFunctionCannotBeAssigned()
+    {
+        $this->exec('Cannot use void expression as assignment value', 'internal-void-function-assignment.php');
+    }
+
+    public function testInternalVoidFunctionCannotBeUsedAsBinaryOperand()
+    {
+        $this->exec('Cannot use void expression as binary operand', 'internal-void-function-binary-operand.php');
+    }
+
 }
diff --git a/phpunit/src/InheritanceErrorTest.php b/phpunit/src/InheritanceErrorTest.php
index 1139ab14..8731232a 100644
--- a/phpunit/src/InheritanceErrorTest.php
+++ b/phpunit/src/InheritanceErrorTest.php
@@ -21,6 +21,18 @@ class InheritanceErrorTest extends TestCase
         $this->fail('Expected TestError exception was not thrown');
     }
 
+    private function assertCompiles(string $file): void
+    {
+        global $translator;
+        $compiler = CompilerTest::create(ROOT_PATH);
+        $translator = $compiler;
+        $testFile = __DIR__ . '/../code/' . $file;
+        $compiler->addFiles([$testFile]);
+        $compiler->prepareFile($testFile);
+        $compiler->convertFile($testFile);
+        $this->addToAssertionCount(1);
+    }
+
     public function testParameterCountMismatch()
     {
         $this->exec('must be compatible', 'inheritance_error.php');
@@ -36,6 +48,16 @@ class InheritanceErrorTest extends TestCase
         $this->exec('must be compatible', 'inheritance_error_return.php');
     }
 
+    public function testReturnTypeCannotBeContravariant()
+    {
+        $this->exec('must be compatible', 'inheritance_error_return_contravariant_class.php');
+    }
+
+    public function testParameterTypeCannotBeCovariant()
+    {
+        $this->exec('must be compatible', 'inheritance_error_param_covariant_class.php');
+    }
+
     public function testByRefMismatch()
     {
         $this->exec('must be compatible', 'inheritance_error_byref.php');
@@ -48,7 +70,57 @@ class InheritanceErrorTest extends TestCase
 
     public function testMethodVisibilityMismatch()
     {
-        $this->exec('must be compatible', 'inheritance_error_visibility.php');
+        $this->exec('must be compatible', 'inheritance_error_visibility_narrow.php');
+    }
+
+    public function testMethodVisibilityWideningIsAllowed()
+    {
+        $this->assertCompiles('inheritance_error_visibility.php');
+    }
+
+    public function testParentScopeMayAccessChildProtectedMethod()
+    {
+        $this->assertCompiles('inheritance_protected_child_method_access.php');
+    }
+
+    public function testParentScopeMayAccessChildProtectedConstant()
+    {
+        $this->assertCompiles('inheritance_protected_child_const_access.php');
+    }
+
+    public function testMethodStaticMismatch()
+    {
+        $this->exec('must be compatible', 'inheritance_error_static.php');
+    }
+
+    public function testCannotOverrideFinalMethod()
+    {
+        $this->exec('Cannot override final method', 'inheritance_error_final_method.php');
+    }
+
+    public function testInterfaceMethodStaticMismatch()
+    {
+        $this->exec('must be compatible', 'interface_method_static_mismatch.php');
+    }
+
+    public function testChildMayAddOptionalTrailingParameter()
+    {
+        $this->assertCompiles('inheritance_optional_param_allowed.php');
+    }
+
+    public function testChildMayDeclareReturnTypeWhenParentHasNone()
+    {
+        $this->assertCompiles('inheritance_return_type_covariant_from_none.php');
+    }
+
+    public function testChildReturnTypeMayBeCovariant()
+    {
+        $this->assertCompiles('inheritance_return_type_covariant_class.php');
+    }
+
+    public function testChildParameterTypeMayBeContravariant()
+    {
+        $this->assertCompiles('inheritance_parameter_type_contravariant_class.php');
     }
 
     public function testPropertyTypeMismatch()
@@ -61,6 +133,26 @@ class InheritanceErrorTest extends TestCase
         $this->exec('must be compatible', 'inheritance_error_prop_visibility.php');
     }
 
+    public function testPropertyVisibilityMayBeWidened()
+    {
+        $this->assertCompiles('inheritance_prop_visibility_widen.php');
+    }
+
+    public function testPrivateParentPropertyCannotBeRedeclared()
+    {
+        $this->exec('property shadowing across inheritance is not allowed', 'inheritance_private_prop_redeclare.php');
+    }
+
+    public function testPrivateParentPropertyCannotBeShadowedByPublicProperty()
+    {
+        $this->exec('property shadowing across inheritance is not allowed', 'accessibility/private-prop-in-parent.php');
+    }
+
+    public function testPrivateTraitPropertyCannotBeShadowedByPublicProperty()
+    {
+        $this->exec('property shadowing across inheritance is not allowed', 'accessibility/private-prop-in-trait.php');
+    }
+
     public function testConstantTypeMismatch()
     {
         $this->exec('must be compatible', 'inheritance_error_const_type.php');
@@ -71,8 +163,107 @@ class InheritanceErrorTest extends TestCase
         $this->exec('must be compatible', 'inheritance_error_const_visibility.php');
     }
 
+    public function testConstantVisibilityMayBeWidened()
+    {
+        $this->assertCompiles('inheritance_const_visibility_widen.php');
+    }
+
+    public function testPrivateParentConstantMayBeRedeclared()
+    {
+        $this->assertCompiles('inheritance_private_const_redeclare.php');
+    }
+
     public function testPropertyReadonlyMismatch()
     {
         $this->exec('must be compatible', 'inheritance_error_prop_readonly.php');
     }
+
+    public function testInterfaceMethodMissing()
+    {
+        $this->exec('must implement method', 'interface_method_missing.php');
+    }
+
+    public function testInterfaceMethodSignatureMismatch()
+    {
+        $this->exec('must be compatible', 'interface_method_signature_mismatch.php');
+    }
+
+    public function testInterfaceMethodProvidedByTrait()
+    {
+        $this->assertCompiles('interface_method_from_trait.php');
+    }
+
+    public function testAbstractClassMayDeferInterfaceMethodImplementation()
+    {
+        $this->assertCompiles('interface_abstract_class_missing.php');
+    }
+
+    public function testAbstractMethodMayImplementInterfaceContract()
+    {
+        $this->assertCompiles('interface_abstract_method_signature.php');
+    }
+
+    public function testAbstractInterfaceMethodSignatureMismatch()
+    {
+        $this->exec('must be compatible', 'interface_abstract_method_mismatch.php');
+    }
+
+    public function testInterfaceArrayConstantInitializesRuntimeValue()
+    {
+        global $translator;
+        $compiler = CompilerTest::create(ROOT_PATH);
+        $translator = $compiler;
+        $testFile = __DIR__ . '/../code/interface_array_constant.php';
+        $compiler->addFiles([$testFile]);
+        $compiler->prepareFile($testFile);
+        $compiler->convertFile($testFile);
+        $extensionFile = $compiler->genExtension();
+
+        $this->assertStringContainsString('php::updateConstant("InterfaceArrayConstant", "ITEMS"', file_get_contents($extensionFile));
+    }
+
+    public function testInterfaceArrayConstantPropagatesToImplementingClass()
+    {
+        global $translator;
+        $compiler = CompilerTest::create(ROOT_PATH);
+        $translator = $compiler;
+        $testFile = __DIR__ . '/../code/interface_array_constant_implements.php';
+        $compiler->addFiles([$testFile]);
+        $compiler->prepareFile($testFile);
+        $cppFile = $compiler->convertFile($testFile);
+        $extensionFile = $compiler->genExtension();
+
+        $this->assertStringContainsString('php_interfacearrayconstantcontract__items', file_get_contents($cppFile));
+        $this->assertStringContainsString('php::updateConstant("InterfaceArrayConstantImpl", "ITEMS"', file_get_contents($extensionFile));
+    }
+
+    public function testConcreteClassMustImplementInheritedAbstractMethod()
+    {
+        $this->exec('must implement abstract method', 'abstract_parent_method_missing.php');
+    }
+
+    public function testConcreteClassMustImplementInheritedInterfaceMethod()
+    {
+        $this->exec('must implement method', 'interface_abstract_parent_missing.php');
+    }
+
+    public function testCompatibleTraitMemberDuplicatesCompile()
+    {
+        $this->assertCompiles('trait_member_compatible.php');
+    }
+
+    public function testTraitConstantConflict()
+    {
+        $this->exec('constant `VALUE` conflicts', 'trait_constant_conflict.php');
+    }
+
+    public function testTraitPropertyConflict()
+    {
+        $this->exec('property `count` conflicts', 'trait_property_conflict.php');
+    }
+
+    public function testAbstractMethodSignatureMismatch()
+    {
+        $this->exec('must be compatible', 'abstract_method_signature_mismatch.php');
+    }
 }
diff --git a/phpunit/src/NativePropertyTest.php b/phpunit/src/NativePropertyTest.php
index b01b6b80..11c31544 100644
--- a/phpunit/src/NativePropertyTest.php
+++ b/phpunit/src/NativePropertyTest.php
@@ -51,4 +51,44 @@ class NativePropertyTest extends \BaseTest
     {
         $this->exec('Cannot access protected property `value` of class `NativeProtectedOwner`', 'native-property-protected-unrelated-class.php');
     }
+
+    public function testCannotAccessPrivateNativePropertyThroughNullsafe(): void
+    {
+        $this->exec('Cannot access private property `value` of class `NullsafePrivateOwner`', 'nullsafe-private-property.php');
+    }
+
+    public function testCannotAccessNestedPrivateNativePropertyThroughNullsafe(): void
+    {
+        $this->exec('Cannot access private property `value` of class `NullsafeNestedChild`', 'nullsafe-nested-private-property.php');
+    }
+
+    public function testCannotAssignThroughNullsafeProperty(): void
+    {
+        $this->exec("Can't use nullsafe operator in write context", 'nullsafe-write-assign.php');
+    }
+
+    public function testCannotUseCompoundAssignThroughNullsafeProperty(): void
+    {
+        $this->exec("Can't use nullsafe operator in write context", 'nullsafe-write-assign-op.php');
+    }
+
+    public function testCannotIncrementThroughNullsafeProperty(): void
+    {
+        $this->exec("Can't use nullsafe operator in write context", 'nullsafe-write-inc.php');
+    }
+
+    public function testCannotUnsetThroughNullsafeProperty(): void
+    {
+        $this->exec("Can't use nullsafe operator in write context", 'nullsafe-write-unset.php');
+    }
+
+    public function testCannotAssignReferenceToNullsafeProperty(): void
+    {
+        $this->exec("Can't use nullsafe operator in write context", 'nullsafe-write-assign-ref-left.php');
+    }
+
+    public function testCannotTakeReferenceOfNullsafeProperty(): void
+    {
+        $this->exec('Cannot take reference of a nullsafe chain', 'nullsafe-write-assign-ref-right.php');
+    }
 }
diff --git a/phpunit/src/Platform/PlatformTest.php b/phpunit/src/Platform/PlatformTest.php
index 35e0ec27..589ad117 100644
--- a/phpunit/src/Platform/PlatformTest.php
+++ b/phpunit/src/Platform/PlatformTest.php
@@ -110,6 +110,15 @@ class PlatformTest extends TestCase
         $this->assertSame('src/app.php', $linux->removeCommonPrefix('/project', '/project/src/app.php'));
     }
 
+    public function testPlatformPathPrefixRemovalUsesPathSegments(): void
+    {
+        $windows = new Windows();
+        $linux = new Linux();
+
+        $this->assertSame('project2\src\app.php', $windows->removeCommonPrefix('C:\project', 'C:/project2/src/app.php'));
+        $this->assertSame('project2/src/app.php', $linux->removeCommonPrefix('/tmp/project', '/tmp/project2/src/app.php'));
+    }
+
     /**
      * 测试 Windows 子系统选项
      */
diff --git a/phpunit/src/PreprocessorTest.php b/phpunit/src/PreprocessorTest.php
index ff3ddb0d..39888c4d 100644
--- a/phpunit/src/PreprocessorTest.php
+++ b/phpunit/src/PreprocessorTest.php
@@ -5,7 +5,11 @@ namespace PhpAot\Tests;
 use PHPUnit\Framework\TestCase;
 use PhpAot\Php\CompilerTest;
 use PhpAot\Php\ArgInfo;
+use PhpAot\Php\Exception\TestError;
 use PhpParser\Node;
+use PhpParser\Node\Stmt\Function_;
+use PhpParser\Modifiers;
+use PhpParser\ParserFactory;
 
 class PreprocessorTest extends TestCase
 {
@@ -57,6 +61,26 @@ class PreprocessorTest extends TestCase
         $prop->setValue($this->compiler, $value);
     }
 
+    private function getProperty(string $name): mixed
+    {
+        $prop = $this->ref->getProperty($name);
+        $prop->setAccessible(true);
+        return $prop->getValue($this->compiler);
+    }
+
+    private function parseFunctionNode(string $code): Function_
+    {
+        $parser = (new ParserFactory())->createForHostVersion();
+        $stmts = $parser->parse($code);
+        $this->assertNotNull($stmts);
+        foreach ($stmts as $stmt) {
+            if ($stmt instanceof Function_) {
+                return $stmt;
+            }
+        }
+        $this->fail('No function node found');
+    }
+
     // ========================================================================
     // genArgumentDeclaration
     // ========================================================================
@@ -120,6 +144,15 @@ class PreprocessorTest extends TestCase
         $this->assertStringStartsWith($this->compiler->getBuildDir(), $result);
     }
 
+    public function testGetCppFileDoesNotTrimSiblingDirectoryByCharacterPrefix(): void
+    {
+        $this->setProperty('buildDir', '/tmp/project/build');
+
+        $result = $this->compiler->getCppFile('/tmp/project2/src/app.php');
+
+        $this->assertSame('/tmp/project/build/project2/src/app.cc', $result);
+    }
+
     public function testGetCppFileDotPhpReplaced(): void
     {
         $phpFile = '/tmp/test_file.php';
@@ -210,4 +243,175 @@ class PreprocessorTest extends TestCase
         // Empty array stays empty or nearly empty
         $this->assertIsArray($files);
     }
+
+    public function testPrepareFileParsesInterfaceMembersAndTypeChecks(): void
+    {
+        $file = __DIR__ . '/../code/preprocessor/interface_members.php';
+
+        $this->compiler->prepareFile($file);
+
+        $interfaces = $this->getProperty('interfaces');
+        $this->assertArrayHasKey('demo', $interfaces);
+
+        $iface = $interfaces['demo'];
+        $this->assertSame(['ParentA', 'ParentB'], $iface->extendsList);
+        $this->assertSame('ParentA', $iface->extends);
+        $this->assertArrayHasKey('VERSION', $iface->constants);
+        $this->assertTrue($iface->hasMethod('run'));
+
+        $functionDef = $iface->methods['run']->functionDef;
+        $this->assertTrue($functionDef->method);
+        $this->assertSame('php::Int', $functionDef->argInfoList[0]->type);
+        $this->assertNull($functionDef->argInfoList[0]->typeCheck);
+        $this->assertSame('php::Var', $functionDef->argInfoList[1]->type);
+        $this->assertNotEmpty($functionDef->argInfoList[1]->typeCheck);
+        $this->assertSame('php::Var', $functionDef->returnType);
+        $this->assertNotEmpty($functionDef->returnTypeCheck);
+    }
+
+    public function testPrepareFileParsesInterfaceArrayConstantInitExpr(): void
+    {
+        $file = __DIR__ . '/../code/interface_array_constant.php';
+
+        $this->compiler->prepareFile($file);
+
+        $interfaces = $this->getProperty('interfaces');
+        $this->assertArrayHasKey('interfacearrayconstant', $interfaces);
+        $constant = $interfaces['interfacearrayconstant']->constants['ITEMS'];
+
+        $this->assertSame('php::Array', $constant->type);
+        $this->assertStringContainsString('php::Array', $constant->value);
+    }
+
+    public function testPrepareFileRejectsNamespacedDuplicateClassAndInterface(): void
+    {
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('Duplicate class `App\\Demo`');
+
+        $file = __DIR__ . '/../code/preprocessor/duplicate_namespaced_class_interface.php';
+        $this->compiler->prepareFile($file);
+    }
+
+    public function testPrepareFileParsesNamespacedConstants(): void
+    {
+        $file = __DIR__ . '/../code/preprocessor/namespaced_const.php';
+
+        $this->compiler->prepareFile($file);
+
+        $constants = $this->getProperty('constants');
+        $this->assertArrayHasKey('_const_var_App__VERSION', $constants);
+        $this->assertSame('App\\VERSION', $constants['_const_var_App__VERSION']->name);
+    }
+
+    public function testSortFilesUsesImplementsAndTraitDependencies(): void
+    {
+        $classFile = realpath(__DIR__ . '/../code/preprocessor/deps_class_implements.php');
+        $interfaceFile = realpath(__DIR__ . '/../code/preprocessor/deps_interface.php');
+        $traitUserFile = realpath(__DIR__ . '/../code/preprocessor/deps_class_uses_trait.php');
+        $traitFile = realpath(__DIR__ . '/../code/preprocessor/deps_trait.php');
+
+        $this->compiler->prepareFile($classFile);
+        $this->compiler->prepareFile($interfaceFile);
+        $this->compiler->prepareFile($traitUserFile);
+        $this->compiler->prepareFile($traitFile);
+
+        $files = [$classFile, $interfaceFile, $traitUserFile, $traitFile];
+        $this->compiler->sortFiles($files);
+
+        $this->assertLessThan(array_search($classFile, $files, true), array_search($interfaceFile, $files, true));
+        $this->assertLessThan(array_search($traitUserFile, $files, true), array_search($traitFile, $files, true));
+    }
+
+    public function testPrepareFileParsesTraitAliasModifierWithoutNewName(): void
+    {
+        $file = __DIR__ . '/../code/preprocessor/trait_alias_modifier.php';
+
+        $this->compiler->prepareFile($file);
+
+        $classes = $this->getProperty('classes');
+        $this->assertArrayHasKey('aliasmodifieruser', $classes);
+        $aliases = $classes['aliasmodifieruser']->traitAliases;
+        $this->assertArrayHasKey('aliasmodifiertrait::hello', $aliases);
+        $this->assertSame('hello', $aliases['aliasmodifiertrait::hello'][0]['newName']);
+        $this->assertSame(Modifiers::PRIVATE, $aliases['aliasmodifiertrait::hello'][0]['newModifier']);
+    }
+
+    public function testPrepareFileInfersEachClassConstantTypeIndependently(): void
+    {
+        $file = __DIR__ . '/../code/preprocessor/class_constants.php';
+
+        $this->compiler->prepareFile($file);
+
+        $classes = $this->getProperty('classes');
+        $this->assertArrayHasKey('preprocessorclassconstants', $classes);
+        $constants = $classes['preprocessorclassconstants']->constants;
+        $this->assertSame('php::Str', $constants['TEXT']->type);
+        $this->assertSame('php::Array', $constants['ITEMS']->type);
+    }
+
+    public function testPrepareFileRejectsDuplicateClassConstants(): void
+    {
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('Duplicate constant `VALUE`');
+
+        $file = __DIR__ . '/../code/preprocessor/duplicate_class_constant.php';
+        $this->compiler->prepareFile($file);
+    }
+
+    public function testPrepareFileParsesAbstractMethodSignatures(): void
+    {
+        $file = __DIR__ . '/../code/preprocessor/abstract_method_signature.php';
+
+        $this->compiler->prepareFile($file);
+
+        $classes = $this->getProperty('classes');
+        $this->assertArrayHasKey('preprocessorabstractsignature', $classes);
+        $methodDef = $classes['preprocessorabstractsignature']->abstractMethodDefs['load'];
+        $functionDef = $methodDef->functionDef;
+        $this->assertTrue($functionDef->method);
+        $this->assertSame('php::Int', $functionDef->argInfoList[0]->type);
+        $this->assertSame('php::Var', $functionDef->argInfoList[1]->type);
+        $this->assertNotEmpty($functionDef->argInfoList[1]->typeCheck);
+        $this->assertSame('php::Object', $functionDef->returnType);
+        $this->assertSame('PreprocessorAbstractSignature', $functionDef->returnClass);
+    }
+
+    public function testPrepareFileRejectsDuplicateAbstractMethods(): void
+    {
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('Duplicate method `load`');
+
+        $file = __DIR__ . '/../code/preprocessor/duplicate_abstract_method.php';
+        $this->compiler->prepareFile($file);
+    }
+
+    public function testIntersectionParamDeclFallsBackToVarWithRuntimeCheck(): void
+    {
+        $fn = $this->parseFunctionNode('<?php interface A {} interface B {} function demo(A&B $value): void {}');
+        $functionDef = $this->invokeMethod('parseFunctionDecl', $fn);
+
+        $this->assertSame('php::Var', $functionDef->argInfoList[0]->type);
+        $this->assertNotEmpty($functionDef->argInfoList[0]->typeCheck);
+        $this->assertSame('A&B', $functionDef->argInfoList[0]->typeStr);
+    }
+
+    public function testIntersectionReturnDeclFallsBackToVarWithRuntimeCheck(): void
+    {
+        $fn = $this->parseFunctionNode('<?php interface A {} interface B {} function demo(): A&B { throw new \Exception(); }');
+        $functionDef = $this->invokeMethod('parseFunctionDecl', $fn);
+
+        $this->assertSame('php::Var', $functionDef->returnType);
+        $this->assertNotEmpty($functionDef->returnTypeCheck);
+        $this->assertSame('A&B', $functionDef->returnTypeStr);
+    }
+
+    public function testNullableReturnDeclFallsBackToVarWithRuntimeCheck(): void
+    {
+        $fn = $this->parseFunctionNode('<?php function demo(): ?int { return null; }');
+        $functionDef = $this->invokeMethod('parseFunctionDecl', $fn);
+
+        $this->assertSame('php::Var', $functionDef->returnType);
+        $this->assertNotEmpty($functionDef->returnTypeCheck);
+        $this->assertSame('?int', $functionDef->returnTypeStr);
+    }
 }
diff --git a/phpunit/src/ReflectionTest.php b/phpunit/src/ReflectionTest.php
index 1158c2cf..effac68c 100644
--- a/phpunit/src/ReflectionTest.php
+++ b/phpunit/src/ReflectionTest.php
@@ -7,6 +7,25 @@ use PhpAot\Php\Reflection;
 
 class ReflectionTest extends TestCase
 {
+    public function testGetFunctionReturnTypeUnionReturnsNull(): void
+    {
+        eval('function php_aot_reflection_union_return(): int|string { return 1; }');
+        $this->assertNull(Reflection::getFunctionReturnType('php_aot_reflection_union_return'));
+    }
+
+    public function testGetFunctionReturnTypeIntersectionReturnsNull(): void
+    {
+        eval('
+            interface PhpAotReflectionI1 {}
+            interface PhpAotReflectionI2 {}
+            final class PhpAotReflectionBoth implements PhpAotReflectionI1, PhpAotReflectionI2 {}
+            function php_aot_reflection_intersection_return(): PhpAotReflectionI1&PhpAotReflectionI2 {
+                return new PhpAotReflectionBoth();
+            }
+        ');
+        $this->assertNull(Reflection::getFunctionReturnType('php_aot_reflection_intersection_return'));
+    }
+
     public function testIsInternalClass(): void
     {
         // Standard PHP internal classes
@@ -125,6 +144,33 @@ class ReflectionTest extends TestCase
         $this->assertEquals('string', $type);
     }
 
+    public function testGetMethodReturnTypeUnionReturnsNull(): void
+    {
+        eval('
+            class PhpAotReflectionUnionMethodReturn {
+                public function value(): int|string {
+                    return 1;
+                }
+            }
+        ');
+        $this->assertNull(Reflection::getMethodReturnType('PhpAotReflectionUnionMethodReturn', 'value'));
+    }
+
+    public function testGetMethodReturnTypeIntersectionReturnsNull(): void
+    {
+        eval('
+            interface PhpAotReflectionMethodI1 {}
+            interface PhpAotReflectionMethodI2 {}
+            final class PhpAotReflectionMethodBoth implements PhpAotReflectionMethodI1, PhpAotReflectionMethodI2 {}
+            class PhpAotReflectionIntersectionMethodReturn {
+                public function value(): PhpAotReflectionMethodI1&PhpAotReflectionMethodI2 {
+                    return new PhpAotReflectionMethodBoth();
+                }
+            }
+        ');
+        $this->assertNull(Reflection::getMethodReturnType('PhpAotReflectionIntersectionMethodReturn', 'value'));
+    }
+
     public function testGetMethodReturnTypeNonexistent(): void
     {
         $type = Reflection::getMethodReturnType('NonExistent_' . uniqid(), 'test');
diff --git a/phpunit/src/ThrowTest.php b/phpunit/src/ThrowTest.php
new file mode 100644
index 00000000..b6cdd99d
--- /dev/null
+++ b/phpunit/src/ThrowTest.php
@@ -0,0 +1,9 @@
+<?php
+
+class ThrowTest extends \BaseTest
+{
+    public function testThrowScalarStaticError()
+    {
+        $this->exec('Can only throw objects', 'throw-scalar.php');
+    }
+}
diff --git a/phpunit/src/TypeCheckGeneratorTest.php b/phpunit/src/TypeCheckGeneratorTest.php
new file mode 100644
index 00000000..6934bf57
--- /dev/null
+++ b/phpunit/src/TypeCheckGeneratorTest.php
@@ -0,0 +1,70 @@
+<?php
+
+use PhpAot\Php\ArgInfo;
+use PhpAot\Php\CompilerTest;
+use PhpAot\Php\Entity\ClassDef;
+use PhpAot\Php\Entity\FunctionDef;
+
+class TypeCheckGeneratorTest extends \PHPUnit\Framework\TestCase
+{
+    private function setProtectedProperty(object $object, string $property, mixed $value): void
+    {
+        $ref = new ReflectionProperty($object, $property);
+        $ref->setAccessible(true);
+        $ref->setValue($object, $value);
+    }
+
+    private function invokeMethod(object $object, string $method, array $args = []): mixed
+    {
+        $ref = new ReflectionMethod($object, $method);
+        $ref->setAccessible(true);
+        return $ref->invokeArgs($object, $args);
+    }
+
+    public function testMethodTypeCheckErrorUsesClassQualifiedCallableName(): void
+    {
+        $compiler = CompilerTest::create(ROOT_PATH);
+        $classDef = new ClassDef('Demo', 0, 'Foo\\Bar');
+        $functionDef = new FunctionDef('run', 'php::Var', 'Foo\\Bar');
+        $argInfo = new ArgInfo();
+        $argInfo->name = 'value';
+        $argInfo->typeStr = 'int|string';
+
+        $functionDef->returnTypeCheck = [['kind' => 'isInt'], ['kind' => 'isString']];
+        $functionDef->returnTypeStr = 'int|string';
+
+        $this->setProtectedProperty($compiler, 'classDef', $classDef);
+        $this->setProtectedProperty($compiler, 'functionDef', $functionDef);
+
+        $callableName = $this->invokeMethod($compiler, 'getTypeCheckCallableName');
+        $paramExpr = $this->invokeMethod($compiler, 'genUnionParamTypeErrorExpr', [$argInfo, 'value', '1']);
+        $returnCode = $this->invokeMethod($compiler, 'genUnionReturnCheck', ['retval']);
+
+        $this->assertSame('Foo\\Bar\\Demo::run', $callableName);
+        $this->assertStringContainsString('Foo\\\\Bar\\\\Demo::run(): Argument #', $paramExpr);
+        $this->assertStringContainsString('Foo\\\\Bar\\\\Demo::run', $returnCode);
+    }
+
+    public function testFunctionTypeCheckErrorUsesFunctionQualifiedCallableName(): void
+    {
+        $compiler = CompilerTest::create(ROOT_PATH);
+        $functionDef = new FunctionDef('run', 'php::Var', 'Foo\\Bar');
+        $argInfo = new ArgInfo();
+        $argInfo->name = 'value';
+        $argInfo->typeStr = 'int|string';
+
+        $functionDef->returnTypeCheck = [['kind' => 'isInt'], ['kind' => 'isString']];
+        $functionDef->returnTypeStr = 'int|string';
+
+        $this->setProtectedProperty($compiler, 'classDef', null);
+        $this->setProtectedProperty($compiler, 'functionDef', $functionDef);
+
+        $callableName = $this->invokeMethod($compiler, 'getTypeCheckCallableName');
+        $paramExpr = $this->invokeMethod($compiler, 'genUnionParamTypeErrorExpr', [$argInfo, 'value', '1']);
+        $returnCode = $this->invokeMethod($compiler, 'genUnionReturnCheck', ['retval']);
+
+        $this->assertSame('Foo\\Bar\\run', $callableName);
+        $this->assertStringContainsString('Foo\\\\Bar\\\\run(): Argument #', $paramExpr);
+        $this->assertStringContainsString('Foo\\\\Bar\\\\run', $returnCode);
+    }
+}
diff --git a/samples/c1.php b/samples/c1.php
new file mode 100644
index 00000000..5e29ce44
--- /dev/null
+++ b/samples/c1.php
@@ -0,0 +1,14 @@
+<?php
+function add(int $a, int $b): int {
+    return $a + $b;
+}
+
+function main()
+{
+    $a = 1000;
+    $b = 999;
+    var_dump(add($a, $b));
+
+    $func = 'add';
+    var_dump($func($a, $b));
+}
diff --git a/samples/c2.php b/samples/c2.php
new file mode 100644
index 00000000..3622c623
--- /dev/null
+++ b/samples/c2.php
@@ -0,0 +1,20 @@
+<?php
+class Foo {
+    static public function func1(string $name)
+    {
+        var_dump('hello ' . $name . '!');
+    }
+
+    public function func2(string $name)
+    {
+        var_dump('hello ' . $name . '!');
+    }
+}
+
+function main()
+{
+    Foo::func1('world');
+
+    $obj = new Foo();
+    $obj->func2('php');
+}
diff --git a/samples/c3.php b/samples/c3.php
new file mode 100644
index 00000000..897b6422
--- /dev/null
+++ b/samples/c3.php
@@ -0,0 +1,6 @@
+<?php
+function main()
+{
+    require __DIR__ . '/script.php';
+    php_os();
+}
diff --git a/samples/c4.php b/samples/c4.php
new file mode 100644
index 00000000..8817f0d9
--- /dev/null
+++ b/samples/c4.php
@@ -0,0 +1,34 @@
+<?php
+class Base {
+    function bar()
+    {
+        var_dump(__METHOD__);
+    }
+
+    public function run()
+    {
+        $this->bar();
+    }
+}
+
+class Child extends Base
+{
+    function bar()
+    {
+        var_dump(__METHOD__);
+    }
+}
+
+function my_uname_func()
+{
+    var_dump(php_uname());
+}
+
+function main()
+{
+    $obj1 = new Child();
+    $obj1->run();
+
+    $obj2 = new Base();
+    $obj2->run();
+}
diff --git a/samples/script.php b/samples/script.php
new file mode 100644
index 00000000..fd125df1
--- /dev/null
+++ b/samples/script.php
@@ -0,0 +1,5 @@
+<?php
+function php_os()
+{
+    var_dump(PHP_OS);
+}
\ No newline at end of file
diff --git a/src/Php/Analysis/SsaBuilder.php b/src/Php/Analysis/SsaBuilder.php
index abf5bb23..46ea8a1c 100644
--- a/src/Php/Analysis/SsaBuilder.php
+++ b/src/Php/Analysis/SsaBuilder.php
@@ -206,8 +206,9 @@ class SsaBuilder
         private array $argInfoList = []
     ) {
         foreach ($this->argInfoList as $argInfo) {
-            $this->params[] = $argInfo->name;
-            $this->paramByRef[$argInfo->name] = $argInfo->byRef ?? false;
+            $paramName = $argInfo->phpName ?: $argInfo->name;
+            $this->params[] = $paramName;
+            $this->paramByRef[$paramName] = $argInfo->byRef ?? false;
         }
     }
 
diff --git a/src/Php/ArgInfo.php b/src/Php/ArgInfo.php
index 70902959..93843742 100644
--- a/src/Php/ArgInfo.php
+++ b/src/Php/ArgInfo.php
@@ -15,6 +15,7 @@ use PhpParser\NodeAbstract;
 class ArgInfo
 {
     public string $name;
+    public string $phpName = '';
     public string $type;
     public string $default = '';
     public ?ArrayInitPlan $arrayInitPlan = null;
diff --git a/src/Php/Backend/CompilerBackend.php b/src/Php/Backend/CompilerBackend.php
index 23bcb466..a206749c 100644
--- a/src/Php/Backend/CompilerBackend.php
+++ b/src/Php/Backend/CompilerBackend.php
@@ -158,6 +158,15 @@ abstract class CompilerBackend
         return $this->platform->getLibraryFlags($libraries);
     }
 
+    protected function formatDefineFlag(string $define, string $prefix): string
+    {
+        if (preg_match('/^[A-Za-z_][A-Za-z0-9_]*(=(?:[A-Za-z0-9_.,:+\/@%-]+))?$/', $define) === 1) {
+            return $prefix . $define;
+        }
+
+        return $prefix . escapeshellarg($define);
+    }
+
     /**
      * 将目标文件列表写入 Response File，避免命令行参数过长超出 OS 限制（Windows 8191 字符）
      *
@@ -178,7 +187,7 @@ abstract class CompilerBackend
             $lines[] = $file;
         }
         file_put_contents($rspFile, implode("\n", $lines));
-        return '@' . $rspFile;
+        return escapeshellarg('@' . $rspFile);
     }
 
     /**
diff --git a/src/Php/Backend/GccLikeBackend.php b/src/Php/Backend/GccLikeBackend.php
index c31cf242..790d7e74 100644
--- a/src/Php/Backend/GccLikeBackend.php
+++ b/src/Php/Backend/GccLikeBackend.php
@@ -59,6 +59,63 @@ abstract class GccLikeBackend extends CompilerBackend
         return '';
     }
 
+    /** 构建 GCC/Clang 共享编译选项，C 和 C++ 编译路径都复用这里 */
+    protected function buildSharedCompileFlags(array $config, bool $includeCppStd = false): string
+    {
+        $cmd = '';
+
+        if (!empty($config['sanitize'])) {
+            $cmd .= ' ' . $this->formatSanitizerFlag($config['sanitize']);
+        }
+
+        if (!empty($config['debug'])) {
+            $cmd .= ' -O0 -g';
+        } else {
+            $optimizeLevel = $config['optimize'] ?? 2;
+            $cmd .= ' -O' . $optimizeLevel;
+        }
+
+        $cmd .= ' -Wall';
+
+        if ($includeCppStd && !empty($config['cpp_std'])) {
+            $cmd .= ' -std=' . $config['cpp_std'];
+        }
+
+        if (!empty($config['march'])) {
+            $cmd .= ' -march=' . $config['march'];
+        }
+
+        if (!empty($config['target_platform'])) {
+            $cmd .= ' --target=' . $config['target_platform'];
+        }
+
+        $cmd .= $this->getPICFlag($config);
+
+        if (!empty($config['enable_profiler'])) {
+            $cmd .= ' ' . $this->formatDefineFlag('PPROF_ON=1', '-D');
+            if (!empty($config['prof_output'])) {
+                $profOutput = addcslashes($config['prof_output'], "\\\"");
+                $cmd .= ' ' . $this->formatDefineFlag('PROF_OUTPUT_FILE="' . $profOutput . '"', '-D');
+            }
+        }
+
+        if ($includeCppStd && !empty($config['cxxflags'])) {
+            $cmd .= ' ' . $config['cxxflags'];
+        }
+
+        if (!empty($config['user_defines'])) {
+            foreach ($config['user_defines'] as $define) {
+                $cmd .= ' ' . $this->formatDefineFlag($define, '-D');
+            }
+        }
+
+        if (!empty($config['lto'])) {
+            $cmd .= ' -flto';
+        }
+
+        return $cmd;
+    }
+
     /** 获取平台特定的链接选项 */
     protected function getPlatformLinkFlags(array $config): string
     {
@@ -116,7 +173,7 @@ abstract class GccLikeBackend extends CompilerBackend
         }
 
         foreach ($defines as $define) {
-            $cmd .= ' -D' . $define;
+            $cmd .= ' ' . $this->formatDefineFlag($define, '-D');
         }
 
         if (!empty($flags)) {
@@ -181,15 +238,7 @@ abstract class GccLikeBackend extends CompilerBackend
         if (!empty($options['include_paths'])) {
             $cmd .= ' ' . $this->formatIncludePaths($options['include_paths']);
         }
-
-        $optimizeLevel = $options['optimize'] ?? 0;
-        if (!empty($options['debug'])) {
-            $cmd .= ' -O0 -g';
-        } else {
-            $cmd .= ' -O' . $optimizeLevel;
-        }
-
-        $cmd .= ' -Wall';
+        $cmd .= $this->buildSharedCompileFlags($options, false);
 
         return $cmd;
     }
@@ -239,58 +288,8 @@ abstract class GccLikeBackend extends CompilerBackend
 
     public function buildCompileOptions(array $config = []): string
     {
-        $cmd = '';
-
-        $cmd .= $this->getCompilerPrefixFlags();
-
-        if (!empty($config['sanitize'])) {
-            $cmd .= ' ' . $this->formatSanitizerFlag($config['sanitize']);
-        }
-
-        if (!empty($config['debug'])) {
-            $cmd .= ' -O0 -g';
-        } else {
-            $optimizeLevel = $config['optimize'] ?? 2;
-            $cmd .= ' -O' . $optimizeLevel;
-        }
-
-        $cmd .= ' -Wall';
-
-        if (!empty($config['cpp_std'])) {
-            $cmd .= ' -std=' . $config['cpp_std'];
-        }
-
-        if (!empty($config['march'])) {
-            $cmd .= ' -march=' . $config['march'];
-        }
-
-        if (!empty($config['target_platform'])) {
-            $cmd .= ' --target=' . $config['target_platform'];
-        }
-
-        $cmd .= $this->getPICFlag($config);
-
-        if (!empty($config['enable_profiler'])) {
-            $cmd .= ' -DPPROF_ON=1';
-            if (!empty($config['prof_output'])) {
-                $cmd .= ' -DPROF_OUTPUT_FILE=\'"' . $config['prof_output'] . '"\'';
-            }
-        }
-
-        if (!empty($config['cxxflags'])) {
-            $cmd .= ' ' . $config['cxxflags'];
-        }
-
-        if (!empty($config['user_defines'])) {
-            foreach ($config['user_defines'] as $define) {
-                $cmd .= ' -D' . $define;
-            }
-        }
-
-        if (!empty($config['lto'])) {
-            $cmd .= ' -flto';
-        }
-
+        $cmd = $this->getCompilerPrefixFlags();
+        $cmd .= $this->buildSharedCompileFlags($config, true);
         return $cmd;
     }
 
@@ -317,35 +316,8 @@ abstract class GccLikeBackend extends CompilerBackend
 
     public function buildFullCompileOptions(array $options = []): string
     {
-        $cmd = '';
-
-        $cmd .= $this->getCompilerPrefixFlags();
-
-        if (!empty($options['debug'])) {
-            $cmd .= ' -O0 -g';
-        } else {
-            $optimizeLevel = $options['optimize'] ?? 2;
-            $cmd .= ' -O' . $optimizeLevel;
-        }
-
-        $cmd .= ' -Wall';
-
-        if (!empty($options['cpp_std'])) {
-            $cmd .= ' -std=' . $options['cpp_std'];
-        }
-
-        if (!empty($options['march'])) {
-            $cmd .= ' -march=' . $options['march'];
-        }
-
-        if (!empty($options['sanitize'])) {
-            $cmd .= ' ' . $this->formatSanitizerFlag($options['sanitize']);
-        }
-
-        if (!empty($options['pic'])) {
-            $cmd .= ' -fPIC';
-        }
-
+        $cmd = $this->getCompilerPrefixFlags();
+        $cmd .= $this->buildSharedCompileFlags($options, true);
         return $cmd;
     }
 
diff --git a/src/Php/Backend/Msvc.php b/src/Php/Backend/Msvc.php
index 817632a5..9256d68e 100644
--- a/src/Php/Backend/Msvc.php
+++ b/src/Php/Backend/Msvc.php
@@ -34,6 +34,75 @@ class Msvc extends CompilerBackend
         return $this->linkerCommand;
     }
 
+    private function buildCommonCompileFlags(array $config, bool $includeCppOptions = true): string
+    {
+        $cmd = '';
+
+        $cmd .= ' /DZEND_WIN32 /DPHP_WIN32 /DZEND_DEBUG=0';
+
+        if (!empty($config['is_zts'])) {
+            $cmd .= ' /DZTS';
+        }
+
+        if (!empty($config['sanitize'])) {
+            if ($config['sanitize'] === 'address' || $config['sanitize'] === 'addr') {
+                $cmd .= ' /fsanitize=address';
+            }
+        }
+
+        if (!empty($config['debug'])) {
+            $cmd .= ' /Od /Zi';
+        } else {
+            $optimizeLevel = $config['optimize'] ?? 2;
+            $optMap = [0 => '/Od', 1 => '/O1', 2 => '/O2', 3 => '/Ox'];
+            $cmd .= ' ' . ($optMap[$optimizeLevel] ?? '/O2');
+        }
+
+        $cmd .= ' /W3';
+
+        if (!empty($config['suppressed_warnings'])) {
+            foreach ($config['suppressed_warnings'] as $code => $description) {
+                $code = is_int($code) && $code < 100 ? $description : $code;
+                $cmd .= " /wd{$code}";
+            }
+        }
+
+        if (!empty($config['enable_profiler'])) {
+            $cmd .= ' ' . $this->formatDefineFlag('PPROF_ON=1', '/D');
+            if (!empty($config['prof_output'])) {
+                $profOutput = addcslashes($config['prof_output'], "\\\"");
+                $cmd .= ' ' . $this->formatDefineFlag('PROF_OUTPUT_FILE="' . $profOutput . '"', '/D');
+            }
+        }
+
+        if (!empty($config['user_defines'])) {
+            foreach ($config['user_defines'] as $define) {
+                $cmd .= ' ' . $this->formatDefineFlag($define, '/D');
+            }
+        }
+
+        if (!empty($config['lto'])) {
+            $cmd .= ' /GL';
+        }
+
+        if ($includeCppOptions) {
+            $cmd .= ' /EHsc';
+            if (!empty($config['cpp_std'])) {
+                $cmd .= ' /std:' . $config['cpp_std'];
+            }
+
+            $cmd .= ' /MD';
+
+            if (!empty($config['cxxflags'])) {
+                $cmd .= ' ' . $config['cxxflags'];
+            }
+        }
+
+        $cmd .= ' /nologo';
+
+        return $cmd;
+    }
+
     public function compileFile(
         string $sourceFile,
         string $outputFile,
@@ -52,7 +121,7 @@ class Msvc extends CompilerBackend
         
         // 添加宏定义
         foreach ($defines as $define) {
-            $cmd .= ' /D' . $define;
+            $cmd .= ' ' . $this->formatDefineFlag($define, '/D');
         }
         
         // 添加额外标志
@@ -129,29 +198,7 @@ class Msvc extends CompilerBackend
         }
 
         // 平台宏定义
-        $cmd .= ' /DZEND_WIN32 /DPHP_WIN32 /DZEND_DEBUG=0';
-
-        // ZTS 支持
-        if ($this->platform instanceof Windows && $this->platform->isZts()) {
-            $cmd .= ' /DZTS';
-        }
-
-        // 优化级别（C 文件通常使用较低的优化）
-        $optimizeLevel = $options['optimize'] ?? 0;
-        $optMap = [0 => '/Od', 1 => '/O1', 2 => '/O2', 3 => '/Ox'];
-        $cmd .= ' ' . ($optMap[$optimizeLevel] ?? '/O2');
-
-        // 警告级别
-        $cmd .= ' /W3';
-
-        // 禁用常见警告
-        $suppressedWarnings = $options['suppressed_warnings'] ?? ['4244', '4146'];
-        foreach ($suppressedWarnings as $code) {
-            $cmd .= " /wd{$code}";
-        }
-
-        // nologo
-        $cmd .= ' /nologo';
+        $cmd .= $this->buildCommonCompileFlags($options, false);
 
         // 注意：C 文件不使用 /EHsc, /std:c++17, /MD 等 C++ 特定选项
 
@@ -220,7 +267,7 @@ class Msvc extends CompilerBackend
         
         // 宏定义
         foreach ($defines as $define) {
-            $cmd .= ' /D' . $define;
+            $cmd .= ' ' . $this->formatDefineFlag($define, '/D');
         }
         
         // 编译选项
@@ -322,86 +369,7 @@ class Msvc extends CompilerBackend
      */
     public function buildCompileOptions(array $config = []): string
     {
-        $cmd = '';
-        
-        // 平台宏定义
-        $cmd .= ' /DZEND_WIN32 /DPHP_WIN32 /DZEND_DEBUG=0';
-        
-        // ZTS
-        if (!empty($config['is_zts'])) {
-            $cmd .= ' /DZTS';
-        }
-        
-        // Sanitizer
-        if (!empty($config['sanitize'])) {
-            if ($config['sanitize'] === 'address' || $config['sanitize'] === 'addr') {
-                $cmd .= ' /fsanitize=address';
-            }
-        }
-        
-        // 优化和调试
-        if (!empty($config['debug'])) {
-            $cmd .= ' /Od /Zi';
-        } else {
-            $optimizeLevel = $config['optimize'] ?? 2;
-            $optMap = [0 => '/Od', 1 => '/O1', 2 => '/O2', 3 => '/Ox'];
-            $cmd .= ' ' . ($optMap[$optimizeLevel] ?? '/O2');
-        }
-        
-        // 警告
-        $cmd .= ' /W3';
-        
-        // 禁用常见警告（只使用键，即警告代码）
-        if (!empty($config['suppressed_warnings'])) {
-            foreach ($config['suppressed_warnings'] as $code => $description) {
-                $code = is_int($code) && $code < 100 ? $description : $code;
-                $cmd .= " /wd{$code}";
-            }
-        }
-        
-        // C++ 选项
-        $cmd .= ' /EHsc';
-        if (!empty($config['cpp_std'])) {
-            $cmd .= ' /std:' . $config['cpp_std'];
-        }
-        
-        // 扩展模块选项
-        if (!empty($config['build_mode']) && $config['build_mode'] === 'ext') {
-            // MSVC 不需要 -fPIC，默认就是位置无关代码
-        }
-        
-        // CRT
-        $cmd .= ' /MD';
-        
-        // nologo
-        $cmd .= ' /nologo';
-        
-        // 性能分析宏
-        if (!empty($config['enable_profiler'])) {
-            $cmd .= ' /DPPROF_ON=1';
-            if (!empty($config['prof_output'])) {
-                $cmd .= ' /DPROF_OUTPUT_FILE=\'"' . $config['prof_output'] . '"\'';
-            }
-        }
-        
-        // 用户自定义编译标志
-        if (!empty($config['cxxflags'])) {
-            $cmd .= ' ' . $config['cxxflags'];
-        }
-        
-        // 用户自定义预处理器宏
-        if (!empty($config['user_defines'])) {
-            foreach ($config['user_defines'] as $define) {
-                $cmd .= ' /D' . $define;
-            }
-        }
-    
-        // LTO（全程序优化 /GL + 链接时代码生成 /LTCG）
-        if (!empty($config['lto'])) {
-            $cmd .= ' /GL';
-        }
-    
-        return $cmd;
+        return $this->buildCommonCompileFlags($config, true);
     }
     
     /**
diff --git a/src/Php/CompilerBase.php b/src/Php/CompilerBase.php
index bf3af3f6..036ce139 100644
--- a/src/Php/CompilerBase.php
+++ b/src/Php/CompilerBase.php
@@ -43,6 +43,8 @@ use PhpAot\Php\Platform\Macos;
 use PhpAot\Php\Platform\PlatformBase;
 use PhpAot\Php\Platform\PlatformFactory;
 use PhpAot\Php\Platform\Windows;
+use PhpAot\Php\Resolver\PropertyAccessResult;
+use PhpAot\Php\Resolver\PropertyAccessResolver;
 use PhpParser\Modifiers;
 use PhpParser\Node;
 use PhpParser\Node\ArrayItem;
@@ -50,6 +52,7 @@ use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\CallLike;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\FunctionLike;
+use PhpParser\Node\IntersectionType;
 use PhpParser\Node\NullableType;
 use PhpParser\Node\Scalar\MagicConst;
 use PhpParser\Node\Stmt\Foreach_;
@@ -162,8 +165,12 @@ class CompilerBase extends \PhpAot\Core\Translator
     public const string BUILD_MODE_EXT = 'ext';
     public const string ENTRY_FUNCTION = 'main';
     public const string PHPX_VENDOR_DIR = '/vendor/swoole/phpx';
+    protected const string PHASE_IDLE = 'idle';
+    protected const string PHASE_PREPARE = 'prepare';
+    protected const string PHASE_CONVERT = 'convert';
 
     protected string $lang = 'PHP';
+    protected string $compilerPhase = self::PHASE_IDLE;
     protected string $cppCompiler = '';
     protected array $literalStrings = [];
     protected int $literalStringIndex = 0;
@@ -250,7 +257,7 @@ class CompilerBase extends \PhpAot\Core\Translator
     protected array $linkPaths = [];   // --link-path / -L: user-specified library search paths
     protected int $floatPrecision = 17;
     protected bool $debug = false;
-    protected bool $formatCode = true;   // --format: enable clang-format (disabled by default)
+    protected bool $formatCode = false;   // --format: enable clang-format (disabled by default)
     protected bool $printBacktraceOnError = true;
     protected bool $noLiteralStrings = false;
     protected bool $noConsole = false;  // Windows: hide console window
@@ -844,6 +851,25 @@ class CompilerBase extends \PhpAot\Core\Translator
         $this->methodDef = null;
     }
 
+    protected function enterCompilerPhase(string $phase): string
+    {
+        $previous = $this->compilerPhase;
+        $this->compilerPhase = $phase;
+        return $previous;
+    }
+
+    protected function restoreCompilerPhase(string $phase): void
+    {
+        $this->compilerPhase = $phase;
+    }
+
+    protected function assertCompilerPhase(string $expected, string $feature): void
+    {
+        if ($this->compilerPhase !== $expected) {
+            $this->error("Internal compiler error: {$feature} can only be used during {$expected} phase, current phase is {$this->compilerPhase}");
+        }
+    }
+
     protected function resetClass(): void
     {
         $this->class     = '';
@@ -886,6 +912,30 @@ class CompilerBase extends \PhpAot\Core\Translator
         return strtolower($fullClassName . '::' . $method);
     }
 
+    protected function isCurrentConstructor(): bool
+    {
+        return $this->method === '__construct';
+    }
+
+    protected function getCurrentMethodDisplayName(): string
+    {
+        return $this->getFullClassName() . '::' . $this->method;
+    }
+
+    protected function assertExprCanBeUsedAsValue(NodeAbstract $expr, string $context = 'value'): void
+    {
+        if ($this->detectTypeOfExpr($expr) === self::TYPE_VOID) {
+            $this->fatalError($expr, 'Cannot use void expression as ' . $context);
+        }
+    }
+
+    protected function assertExprCanBeUsedAsCondition(NodeAbstract $expr, string $context = 'condition'): void
+    {
+        if ($this->detectTypeOfExpr($expr) === self::TYPE_VOID) {
+            $this->fatalError($expr, 'Cannot use void expression as ' . $context);
+        }
+    }
+
     public function getNamespacedClassName(string $class, string $currentNamespace = ''): string
     {
         if ($class === '') {
@@ -957,6 +1007,12 @@ class CompilerBase extends \PhpAot\Core\Translator
             }
             return $type;
         }
+        if ($type instanceof Node\IntersectionType) {
+            foreach ($type->types as $i => $subType) {
+                $type->types[$i] = $this->upgradeToFullyQualifiedName($subType);
+            }
+            return $type;
+        }
         if ($type instanceof Node\Name\FullyQualified) {
             return $type;
         }
@@ -1095,8 +1151,8 @@ class CompilerBase extends \PhpAot\Core\Translator
         if ($type === null) {
             return self::TYPE_VAR;
         }
-        if ($type instanceof UnionType or $type instanceof NullableType) {
-            // 联合类型暂时不支持，使用 var 类型代替
+        if ($type instanceof UnionType || $type instanceof NullableType || $type instanceof IntersectionType) {
+            // 复杂类型静态阶段统一按 mixed/var 处理，运行时再由 typeCheck 兜底。
             return self::TYPE_VAR;
         } else {
             $typeName = $this->parseIdentifier($type);
@@ -1217,7 +1273,11 @@ class CompilerBase extends \PhpAot\Core\Translator
     {
         $list = [];
         foreach ($implements as $implement) {
-            $list[] = $this->getNamespacedClassName($implement);
+            $interfaceName = $this->getNamespacedClassName($this->parseIdentifier($implement));
+            $list[] = $interfaceName;
+            if (!$this->isInternalInterface($interfaceName)) {
+                $this->symbolCallInFile[$this->file][] = strtolower($interfaceName);
+            }
         }
         return $list;
     }
@@ -1339,6 +1399,45 @@ class CompilerBase extends \PhpAot\Core\Translator
         return '';
     }
 
+    protected function parseExprWithCapturedStmts(NodeAbstract $expr): array
+    {
+        $beforeStmtCount = count($this->context->beforeStmtLines);
+        $afterStmtCount = count($this->context->afterStmtLines);
+        $value = $this->parseExpr($expr);
+        $beforeStmts = array_slice($this->context->beforeStmtLines, $beforeStmtCount);
+        $afterStmts = array_slice($this->context->afterStmtLines, $afterStmtCount);
+        $this->context->beforeStmtLines = array_slice($this->context->beforeStmtLines, 0, $beforeStmtCount);
+        $this->context->afterStmtLines = array_slice($this->context->afterStmtLines, 0, $afterStmtCount);
+        return [$value, $beforeStmts, $afterStmts];
+    }
+
+    protected function appendCapturedStmtLines(string &$code, array $stmts): void
+    {
+        if ($stmts) {
+            $code .= $this->getIndent() . implode(PHP_EOL . $this->getIndent(), $stmts) . PHP_EOL;
+        }
+    }
+
+    protected function genConditionWithCapturedStmts(NodeAbstract $cond, string $openPrefix): string
+    {
+        $this->assertExprCanBeUsedAsCondition($cond);
+        [$condExpr, $beforeStmts, $afterStmts] = $this->parseExprWithCapturedStmts($cond);
+        $code = '';
+        $this->appendCapturedStmtLines($code, $beforeStmts);
+        if ($afterStmts) {
+            $tmpVar = $this->addTmpVar(self::TYPE_VAR);
+            $code .= $this->getIndent() . $tmpVar . ' = ' . $condExpr . ';' . PHP_EOL;
+            $this->appendCapturedStmtLines($code, $afterStmts);
+            $condExpr = $tmpVar;
+        }
+
+        if ($cond instanceof Expr\Assign) {
+            $condExpr = '(' . $condExpr . ')';
+        }
+        $code .= $openPrefix . '(' . $condExpr . ') {' . PHP_EOL;
+        return $code;
+    }
+
     protected function parseBlockStmts(array $stmts): string
     {
         $this->indentLevel++;
@@ -1621,6 +1720,13 @@ class CompilerBase extends \PhpAot\Core\Translator
         if ($v->expr === null) {
             if ($this->functionDef->returnType === self::TYPE_VOID and !$this->context->inClosure) {
                 return 'return;';
+            } elseif ($this->context->inClosure && $this->context->closureReturnTypeCheck) {
+                $tmpVar = $this->genTmpVarName();
+                $this->addLocalVar($tmpVar, self::TYPE_VAR);
+                $code = $tmpVar . ' = ' . self::VALUE_NULL . ';' . PHP_EOL;
+                $code .= $this->genClosureReturnCheck($tmpVar);
+                $code .= $this->getIndent() . 'return ' . $tmpVar . ';';
+                return $code;
             } elseif ($this->functionDef->returnTypeCheck && !$this->context->inClosure) {
                 $tmpVar = $this->genTmpVarName();
                 $this->addLocalVar($tmpVar, self::TYPE_VAR);
@@ -1634,6 +1740,12 @@ class CompilerBase extends \PhpAot\Core\Translator
         }
         // 实际函数的返回值
         $type = $this->detectTypeOfExpr($v->expr);
+        if ($this->isCurrentConstructor() && !$this->context->inClosure) {
+            $this->fatalError($v, 'Method `' . $this->getCurrentMethodDisplayName() . '()` cannot return a value');
+        }
+        if ($type === self::TYPE_VOID) {
+            $this->fatalError($v, 'Cannot return void expression');
+        }
         $expr = $this->parseExpr($v->expr);
         $returnType = $this->getReturnType();
 
@@ -1668,7 +1780,13 @@ class CompilerBase extends \PhpAot\Core\Translator
 
         $exprCode = $this->convertExprType($expr, $returnType, $type);
         // Union/nullable return type: always use tmpVar for runtime check
-        if ($this->functionDef->returnTypeCheck && !$this->context->inClosure) {
+        if ($this->context->inClosure && $this->context->closureReturnTypeCheck) {
+            $tmpVar = $this->genTmpVarName();
+            $this->addLocalVar($tmpVar, self::TYPE_VAR);
+            $code = $tmpVar . ' = ' . $exprCode . ';' . PHP_EOL;
+            $code .= $this->genClosureReturnCheck($tmpVar);
+            $this->context->afterStmtLines[] = $this->getIndent() . 'return ' . $tmpVar . ';';
+        } elseif ($this->functionDef->returnTypeCheck && !$this->context->inClosure) {
             $tmpVar = $this->genTmpVarName();
             $this->addLocalVar($tmpVar, self::TYPE_VAR);
             $code = $tmpVar . ' = ' . $exprCode . ';' . PHP_EOL;
@@ -1815,6 +1933,11 @@ class CompilerBase extends \PhpAot\Core\Translator
         return array_key_exists($this->escapeClass($name), $this->interfaces);
     }
 
+    protected function getInterface(string $name): InterfaceDef
+    {
+        return $this->interfaces[$this->escapeClass($name)];
+    }
+
     protected function checkFunction(string $name): void
     {
         // 在预处理阶段检测到函数声明，但是未定义，说明在当前文件，但是顺序错误
@@ -1831,6 +1954,10 @@ class CompilerBase extends \PhpAot\Core\Translator
     {
         $this->validateNativeNamedCallArgs($funcDef, $args);
 
+        if ($this->hasUnpackCallArg($args)) {
+            return;
+        }
+
         $argc = count($args);
         $type = str_contains($name, '::') ? 'Method' : 'Function';
         if ($argc < $funcDef->argCountRequired) {
@@ -1844,7 +1971,7 @@ class CompilerBase extends \PhpAot\Core\Translator
     {
         $argNameIndex = [];
         foreach ($functionDef->argInfoList as $k => $argInfo) {
-            $argNameIndex[$argInfo->name] = $k;
+            $argNameIndex[$argInfo->phpName ?: $this->unescapeVarName($argInfo->name)] = $k;
         }
         return $argNameIndex;
     }
@@ -1861,6 +1988,7 @@ class CompilerBase extends \PhpAot\Core\Translator
     protected function validateNativeNamedCallArgs(FunctionDef $functionDef, array $callArgs): void
     {
         $hasNamedArg = false;
+        $hasUnpack = false;
         $seenNamedArgs = [];
         $providedArgIndexes = [];
         $argNameIndex = $this->getFunctionArgNameIndex($functionDef);
@@ -1870,7 +1998,18 @@ class CompilerBase extends \PhpAot\Core\Translator
             if ($this->isPlaceholderExpr($arg)) {
                 continue;
             }
+            if ($arg instanceof Node\Arg && $arg->unpack) {
+                if ($hasNamedArg) {
+                    $this->fatalError($arg, 'Cannot use argument unpacking after named arguments');
+                }
+                $hasUnpack = true;
+                $providedArgIndexes[$i] = true;
+                continue;
+            }
             if ($arg->name === null) {
+                if ($hasUnpack) {
+                    $this->fatalError($arg, 'Cannot use positional argument after argument unpacking');
+                }
                 if ($hasNamedArg) {
                     $this->fatalError($arg, 'Cannot use positional argument after named argument');
                 }
@@ -1963,15 +2102,16 @@ class CompilerBase extends \PhpAot\Core\Translator
         }
 
         $classDef = $this->getClass($class);
+        $originClassDef = $classDef;
         $constDef = null;
         // 递归查找，若子类中未定义方法，则尝试查找父类是否存在此方法
         while (true) {
             if (!$classDef->hasConstant($const)) {
                 if (!$classDef->extends) {
-                    return false;
+                    break;
                 }
                 if (!$this->hasClass($classDef->extends)) {
-                    return false;
+                    break;
                 }
                 $classDef = $this->getClass($classDef->extends);
             } else {
@@ -1979,7 +2119,24 @@ class CompilerBase extends \PhpAot\Core\Translator
                 break;
             }
         }
-        if (!$this->checkAccessible($classDef, $constDef->flags)) {
+        if ($constDef === null) {
+            foreach ($this->getClassImplementedInterfaces($originClassDef) as $interfaceName) {
+                if (!$this->hasInterface($interfaceName)) {
+                    continue;
+                }
+                $interfaceDef = $this->getInterface($interfaceName);
+                if (!$interfaceDef->hasConstant($const)) {
+                    continue;
+                }
+                $classDef = $interfaceDef;
+                $constDef = $interfaceDef->constants[$const];
+                break;
+            }
+        }
+        if ($constDef === null) {
+            return false;
+        }
+        if ($classDef instanceof ClassDef && !$this->checkAccessible($classDef, $constDef->flags)) {
             $this->fatalError($expr, 'Constant `' . $classDef->getNamespacedName() . '::' . $const . '` is not accessible');
         }
         if ($constDef->type === self::TYPE_ARRAY) {
@@ -1990,6 +2147,44 @@ class CompilerBase extends \PhpAot\Core\Translator
         }
     }
 
+    /**
+     * @return array<string>
+     */
+    protected function getClassImplementedInterfaces(ClassDef $classDef): array
+    {
+        $interfaces = [];
+        $current = $classDef;
+        while (true) {
+            foreach ($current->implements as $interfaceName) {
+                $this->collectInterfaceAndParents($interfaceName, $interfaces);
+            }
+            if (!$current->extends || !$this->hasClass($current->extends)) {
+                break;
+            }
+            $current = $this->getClass($current->extends);
+        }
+
+        return array_values($interfaces);
+    }
+
+    /**
+     * @param array<string, string> $interfaces
+     */
+    private function collectInterfaceAndParents(string $interfaceName, array &$interfaces): void
+    {
+        if (isset($interfaces[$interfaceName])) {
+            return;
+        }
+        $interfaces[$interfaceName] = $interfaceName;
+        if (!$this->hasInterface($interfaceName)) {
+            return;
+        }
+        $interfaceDef = $this->getInterface($interfaceName);
+        foreach ($interfaceDef->extendsList ?: ($interfaceDef->extends ? [$interfaceDef->extends] : []) as $parentInterface) {
+            $this->collectInterfaceAndParents($parentInterface, $interfaces);
+        }
+    }
+
     protected function resetReturnType(Node\Stmt\Return_ $node, string $type): void
     {
         $oriType = $this->functionDef->returnType;
@@ -2305,8 +2500,10 @@ class CompilerBase extends \PhpAot\Core\Translator
         $list = [];
         $this->indentLevel++;
         foreach ($items as $item) {
+            $this->assertExprCanBeUsedAsValue($item->value, 'array value');
             $value = $this->parseIdentifier($item->value);
             if ($item->key) {
+                $this->assertExprCanBeUsedAsValue($item->key, 'array key');
                 $key = $this->parseArrayKey($item->key);
                 $list[] = $this->getIndent() . '{ ' . $key . ', ' . self::TYPE_VAR . '(' . $value . ') }';
             } else {
@@ -2500,24 +2697,66 @@ class CompilerBase extends \PhpAot\Core\Translator
 
         $list_expr = [];
         foreach ($init as $expr) {
-            $list_expr[] = $this->parseExpr($expr);
+            [$initExpr, $beforeStmts, $afterStmts] = $this->parseExprWithCapturedStmts($expr);
+            $this->appendCapturedStmtLines($code, $beforeStmts);
+            $list_expr[] = $initExpr;
+            if ($afterStmts) {
+                $list_expr[] = implode(";\n" . $this->getIndent(), $afterStmts);
+            }
         }
         $list_expr[] = '';
         $code .= implode(";\n" . $this->getIndent(), $list_expr);
 
         $list_cond = [];
+        $hasCondStmts = false;
         foreach ($cond as $expr) {
-            $list_cond[] = $this->parseExpr($expr);
+            $this->assertExprCanBeUsedAsCondition($expr, 'for condition');
+            [$condExpr, $beforeStmts, $afterStmts] = $this->parseExprWithCapturedStmts($expr);
+            $hasCondStmts = $hasCondStmts || $beforeStmts || $afterStmts;
+            $list_cond[] = [$condExpr, $beforeStmts, $afterStmts];
         }
 
         $code .= $this->parseBeforeStmtLines() . PHP_EOL;
         $code .= 'for (;';
-        $code .= implode(', ', $list_cond);
+        if ($hasCondStmts) {
+            $condCode = '[&]() -> bool {';
+            if (empty($list_cond)) {
+                $condCode .= $this->getIndent() . 'return true;';
+            } else {
+                $condResult = $this->genTmpVarName();
+                $condCode .= $this->getIndent() . 'bool ' . $condResult . ' = true;' . PHP_EOL;
+                foreach ($list_cond as [$condExpr, $beforeStmts, $afterStmts]) {
+                    $this->appendCapturedStmtLines($condCode, $beforeStmts);
+                    if ($afterStmts) {
+                        $tmpVar = $this->addTmpVar(self::TYPE_VAR);
+                        $condCode .= $this->getIndent() . $tmpVar . ' = ' . $condExpr . ';' . PHP_EOL;
+                        $this->appendCapturedStmtLines($condCode, $afterStmts);
+                        $condExpr = $tmpVar;
+                    }
+                    $condCode .= $this->getIndent() . $condResult . ' = ' . $this->convertBoolExpr($condExpr) . ';' . PHP_EOL;
+                }
+                $condCode .= $this->getIndent() . 'return ' . $condResult . ';';
+            }
+            $condCode .= $this->getIndent() . '}()';
+            $code .= $condCode;
+        } else {
+            $code .= implode(', ', array_map(static fn($item) => $item[0], $list_cond));
+        }
         $code .= '; ';
 
         $list_loop = [];
         foreach ($loop as $expr) {
-            $list_loop[] = $this->parseExpr($expr);
+            [$loopExpr, $beforeStmts, $afterStmts] = $this->parseExprWithCapturedStmts($expr);
+            if ($beforeStmts || $afterStmts) {
+                $loopCode = '[&]() {';
+                $this->appendCapturedStmtLines($loopCode, $beforeStmts);
+                $loopCode .= $this->getIndent() . $loopExpr . ';' . PHP_EOL;
+                $this->appendCapturedStmtLines($loopCode, $afterStmts);
+                $loopCode .= $this->getIndent() . '}()';
+                $list_loop[] = $loopCode;
+            } else {
+                $list_loop[] = $loopExpr;
+            }
         }
         $code .= implode(', ', $list_loop);
         $code .= ') {' . PHP_EOL;
@@ -2537,7 +2776,7 @@ class CompilerBase extends \PhpAot\Core\Translator
      */
     protected function genDynamicPropIncDec($var, string $op, bool $isPre): ?string
     {
-        if (!$this->isPropertyFetch($var) || $var->getAttribute('nativeProperty')) {
+        if (!$this->isPropertyFetch($var) || $this->isNativePropertyAccess($var)) {
             return null;
         }
 
@@ -2558,6 +2797,7 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parsePreInc(Expr\PreInc $expr): string
     {
+        $this->assertNotNullsafeWriteContext($expr->var);
         $oriInAssignExpr = $this->context->inAssignExpr;
         $this->context->inAssignExpr = true;
 
@@ -2756,6 +2996,10 @@ class CompilerBase extends \PhpAot\Core\Translator
         if (!$ref) {
             return;
         }
+        $this->validateInternalNamedCallArgs($ref, $expr->args);
+        if ($this->hasUnpackCallArg($expr->args)) {
+            return;
+        }
         $minArgs = $ref->getNumberOfRequiredParameters();
         $maxArgs = $ref->getNumberOfParameters();
         $actualArgCount = count($expr->args);
@@ -2767,6 +3011,158 @@ class CompilerBase extends \PhpAot\Core\Translator
         }
     }
 
+    protected function hasNamedCallArg(array $args): bool
+    {
+        foreach ($args as $arg) {
+            if ($arg instanceof Node\Arg && $arg->name !== null) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected function hasUnpackBeforeNamedArg(array $args): bool
+    {
+        $hasUnpack = false;
+        foreach ($args as $arg) {
+            if (!$arg instanceof Node\Arg) {
+                continue;
+            }
+            if ($arg->unpack) {
+                $hasUnpack = true;
+            } elseif ($hasUnpack && $arg->name !== null) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected function hasUnpackCallArg(array $args): bool
+    {
+        foreach ($args as $arg) {
+            if ($arg instanceof Node\Arg && $arg->unpack) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected function shouldUseDynamicCallForNativeArgs(string $nativeFunc, array $args): bool
+    {
+        if (!$this->hasUnpackCallArg($args)) {
+            return false;
+        }
+        if ($this->hasUnpackBeforeNamedArg($args)) {
+            return true;
+        }
+
+        $variadicArgIndex = $this->getVariadicArgIndex($this->getFunction($nativeFunc));
+        foreach ($args as $i => $arg) {
+            if (!$arg instanceof Node\Arg || !$arg->unpack) {
+                continue;
+            }
+            if ($variadicArgIndex === null || $i < $variadicArgIndex) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected function genCallUserFuncArray(string $callback, array $args, string $funcName = '', string $className = ''): string
+    {
+        return 'php::call(' . $this->getFuncPtr('call_user_func_array') . ', '
+            . Symbol::argList() . '{' . $callback . ', ' . $this->parseCallArgs($args, $funcName, $className, false, true) . '})';
+    }
+
+    protected function getFunctionCallbackExpr(string $nativeFn): string
+    {
+        $functionDef = $this->getFunction($nativeFn);
+        return $this->getLiteralString($functionDef->getNamespacedName());
+    }
+
+    protected function validateInternalNamedCallArgs(\ReflectionFunctionAbstract $ref, array $callArgs): void
+    {
+        $hasNamedArg = false;
+        $hasUnpack = false;
+        $seenNamedArgs = [];
+        $providedArgIndexes = [];
+        $argNameIndex = [];
+        $requiredArgIndexes = [];
+        $variadicArgIndex = null;
+
+        foreach ($ref->getParameters() as $i => $param) {
+            $argNameIndex[$param->getName()] = $i;
+            if (!$param->isOptional() && !$param->isVariadic()) {
+                $requiredArgIndexes[$i] = $param->getName();
+            }
+            if ($param->isVariadic()) {
+                $variadicArgIndex = $i;
+            }
+        }
+
+        foreach ($callArgs as $i => $arg) {
+            if ($this->isPlaceholderExpr($arg)) {
+                continue;
+            }
+            if ($arg instanceof Node\Arg && $arg->unpack) {
+                if ($hasNamedArg) {
+                    $this->fatalError($arg, 'Cannot use argument unpacking after named arguments');
+                }
+                $hasUnpack = true;
+                $providedArgIndexes[$i] = true;
+                continue;
+            }
+            if ($arg->name === null) {
+                if ($hasUnpack) {
+                    $this->fatalError($arg, 'Cannot use positional argument after argument unpacking');
+                }
+                if ($hasNamedArg) {
+                    $this->fatalError($arg, 'Cannot use positional argument after named argument');
+                }
+                $providedArgIndexes[$i] = true;
+                continue;
+            }
+            if (!$this->isIdExpr($arg->name)) {
+                $this->fatalError($arg, 'Named argument must be a string');
+            }
+
+            $argName = $arg->name->name;
+            if (isset($seenNamedArgs[$argName])) {
+                $this->fatalError($arg, "Duplicate named argument `{$argName}`");
+            }
+            if (!array_key_exists($argName, $argNameIndex)) {
+                if ($variadicArgIndex === null) {
+                    $this->fatalError($arg, "Unknown named argument `{$argName}`");
+                }
+                $seenNamedArgs[$argName] = true;
+                $hasNamedArg = true;
+                continue;
+            }
+
+            $argIndex = $argNameIndex[$argName];
+            if ($variadicArgIndex !== null && $argIndex === $variadicArgIndex) {
+                $seenNamedArgs[$argName] = true;
+                $hasNamedArg = true;
+                continue;
+            }
+            if (isset($providedArgIndexes[$argIndex])) {
+                $this->fatalError($arg, "Named argument `{$argName}` overwrites previous argument");
+            }
+
+            $seenNamedArgs[$argName] = true;
+            $providedArgIndexes[$argIndex] = true;
+            $hasNamedArg = true;
+        }
+
+        if ($hasNamedArg && !$hasUnpack) {
+            foreach ($requiredArgIndexes as $index => $name) {
+                if (!isset($providedArgIndexes[$index])) {
+                    $this->fatalError($callArgs[array_key_last($callArgs)] ?? null, "Named argument `{$name}` is missing default value");
+                }
+            }
+        }
+    }
+
     protected function parseFuncCall(Expr\FuncCall $expr): string
     {
         if ($this->isVarExpr($expr->name)) {
@@ -2789,6 +3185,9 @@ class CompilerBase extends \PhpAot\Core\Translator
                     return $this->genPlaceHolder($this->identifierToStr($expr->name));
                 }
                 $this->checkNativeCallArgs($expr, $this->getFunction($nativeFn), $expr->args, $name);
+                if ($this->shouldUseDynamicCallForNativeArgs($nativeFn, $expr->args)) {
+                    return $this->genCallUserFuncArray($this->getFunctionCallbackExpr($nativeFn), $expr->args, $name);
+                }
                 try {
                     return self::PREFIX . $nativeFn . '(' . $this->parseNativeCallArgs($expr->args, $nativeFn) . ')';
                 } catch (PlaceHolder) {
@@ -2814,8 +3213,12 @@ class CompilerBase extends \PhpAot\Core\Translator
         if (empty($expr->args)) {
             return 'php::call(' . $fn . ')';
         }
+        if ($this->hasNamedCallArg($expr->args)) {
+            $callback = $name !== '' ? $this->getLiteralString($name) : $fn;
+            return $this->genCallUserFuncArray($callback, $expr->args, $name);
+        }
         try {
-            return 'php::call(' . $fn . ', ' . $this->parseCallArgs($expr->args, $name) . ')';
+            return 'php::call(' . $fn . ', ' . $this->parseCallArgs($expr->args, $name, '', $name !== '') . ')';
         } catch (PlaceHolder) {
             return $this->genPlaceHolder($placeHolder);
         }
@@ -2869,7 +3272,8 @@ class CompilerBase extends \PhpAot\Core\Translator
                                 break;
                             }
                         }
-                        $this->fatalError($errorNode ?? reset($callArgs), 'Named argument `' . $argInfo->name . '` is missing default value');
+                        $argName = $argInfo->phpName ?: $this->unescapeVarName($argInfo->name);
+                        $this->fatalError($errorNode ?? reset($callArgs), 'Named argument `' . $argName . '` is missing default value');
                     }
                     $args[$k] = new Node\Arg($argInfo->defaultValue);
                 }
@@ -2958,6 +3362,11 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function isReferenceArgument($funcName, $className, $argIndex): bool
     {
+        $argInfo = $this->getAotCallArgInfo($funcName, $className, $argIndex);
+        if ($argInfo !== null) {
+            return $argInfo->byRef;
+        }
+
         if ($className) {
             // 动态调用类方法，无法判断参数是否为引用
             if ($className === self::DYNAMIC_CALLED_CLASS) {
@@ -2968,31 +3377,219 @@ class CompilerBase extends \PhpAot\Core\Translator
             $param = Reflection::getFunctionParameter($funcName, $argIndex);
         }
 
-        if ($param) {
-            return $param->isPassedByReference();
+        if ($param) {
+            return $param->isPassedByReference();
+        }
+
+        // 参数索引超出声明范围，检查最后一个参数是否为变长引用参数（如 &...$rest）
+        $variadicParam = Reflection::getVariadicParameter($funcName, $className);
+        return $variadicParam !== null && $variadicParam->isPassedByReference();
+    }
+
+    protected function getAotCallArgInfo(string $funcName, string $className, int $argIndex): ?ArgInfo
+    {
+        if ($className !== '') {
+            if ($className === self::DYNAMIC_CALLED_CLASS || !$this->hasClass($className)) {
+                return null;
+            }
+            $classDef = $this->getClass($className);
+            while (true) {
+                if ($classDef->hasMethod($funcName)) {
+                    return $this->getArgInfoByIndex($classDef->getMethod($funcName)->functionDef, $argIndex);
+                }
+                if (!$classDef->extends || !$this->hasClass($classDef->extends)) {
+                    return null;
+                }
+                $classDef = $this->getClass($classDef->extends);
+            }
+        }
+
+        if (!$this->hasFunction($funcName)) {
+            return null;
+        }
+        return $this->getArgInfoByIndex($this->getFunction($funcName), $argIndex);
+    }
+
+    protected function getAotCallArgInfoByName(string $funcName, string $className, string $argName): ?ArgInfo
+    {
+        $functionDef = null;
+        if ($className !== '') {
+            if ($className === self::DYNAMIC_CALLED_CLASS || !$this->hasClass($className)) {
+                return null;
+            }
+            $classDef = $this->getClass($className);
+            while (true) {
+                if ($classDef->hasMethod($funcName)) {
+                    $functionDef = $classDef->getMethod($funcName)->functionDef;
+                    break;
+                }
+                if (!$classDef->extends || !$this->hasClass($classDef->extends)) {
+                    return null;
+                }
+                $classDef = $this->getClass($classDef->extends);
+            }
+        } elseif ($this->hasFunction($funcName)) {
+            $functionDef = $this->getFunction($funcName);
+        }
+
+        if ($functionDef === null) {
+            return null;
+        }
+
+        $variadicArgInfo = null;
+        foreach ($functionDef->argInfoList as $argInfo) {
+            if ($argInfo->variadic) {
+                $variadicArgInfo = $argInfo;
+            }
+            if (($argInfo->phpName ?: $this->unescapeVarName($argInfo->name)) === $argName) {
+                return $argInfo;
+            }
+        }
+        return $variadicArgInfo;
+    }
+
+    protected function getArgInfoByIndex(FunctionDef $functionDef, int $argIndex): ?ArgInfo
+    {
+        if (array_key_exists($argIndex, $functionDef->argInfoList)) {
+            return $functionDef->argInfoList[$argIndex];
+        }
+        if ($functionDef->hasVariadicArg()) {
+            return $functionDef->argInfoList[array_key_last($functionDef->argInfoList)];
+        }
+        return null;
+    }
+
+    protected function isReferenceNamedArgument(string $funcName, string $className, string $argName): bool
+    {
+        $argInfo = $this->getAotCallArgInfoByName($funcName, $className, $argName);
+        if ($argInfo !== null) {
+            return $argInfo->byRef;
+        }
+
+        if ($className) {
+            if ($className === self::DYNAMIC_CALLED_CLASS) {
+                return false;
+            }
+            $ref = Reflection::getClass($className);
+            if (!$ref) {
+                return false;
+            }
+            try {
+                $params = $ref->getMethod($funcName)->getParameters();
+            } catch (\ReflectionException) {
+                return false;
+            }
+        } else {
+            $ref = Reflection::getFunction($funcName);
+            if (!$ref) {
+                return false;
+            }
+            $params = $ref->getParameters();
+        }
+
+        $variadicParam = null;
+        foreach ($params as $param) {
+            if ($param->isVariadic()) {
+                $variadicParam = $param;
+            }
+            if ($param->getName() === $argName) {
+                return $param->isPassedByReference();
+            }
+        }
+        return $variadicParam !== null && $variadicParam->isPassedByReference();
+    }
+
+    protected function parseCallArgs(
+        array $args,
+        string $funcName = '',
+        string $className = '',
+        bool $separateNamedArgs = true,
+        bool $forceArrayArgs = false
+    ): string
+    {
+        $list_args = [];
+        $arrayArgsVar = null;
+        $namedArgsVar = null;
+        $namedArgs = [];
+        $hasNamedArg = false;
+        $hasUnpack = false;
+
+        $ensureArrayArgs = function () use (&$arrayArgsVar, &$list_args): string {
+            if ($arrayArgsVar === null) {
+                $arrayArgsVar = $this->genTmpVarName();
+                $this->context->beforeStmtLines[] = self::TYPE_ARRAY . ' ' . $arrayArgsVar . '{' . implode(', ', $list_args) . '};';
+                $list_args = [];
+            }
+            return $arrayArgsVar;
+        };
+
+        $ensureNamedArgs = function () use (&$namedArgsVar): string {
+            if ($namedArgsVar === null) {
+                $namedArgsVar = $this->genTmpVarName();
+                $this->context->beforeStmtLines[] = self::TYPE_ARRAY . ' ' . $namedArgsVar . ';';
+                $this->context->afterStmtLines[] = $namedArgsVar . '.unset();';
+            }
+            return $namedArgsVar;
+        };
+
+        $addPositionalArg = function (string $value) use (&$arrayArgsVar, &$list_args): void {
+            if ($arrayArgsVar !== null) {
+                $this->context->beforeStmtLines[] = $arrayArgsVar . '.append(' . $value . ');';
+            } else {
+                $list_args[] = $value;
+            }
+        };
+
+        if ($forceArrayArgs) {
+            $ensureArrayArgs();
         }
 
-        // 参数索引超出声明范围，检查最后一个参数是否为变长引用参数（如 &...$rest）
-        $variadicParam = Reflection::getVariadicParameter($funcName, $className);
-        return $variadicParam !== null && $variadicParam->isPassedByReference();
-    }
-
-    protected function parseCallArgs(array $args, string $funcName = '', string $className = ''): string
-    {
-        $list_args = [];
-        $last = array_key_last($args);
         foreach ($args as $i => $arg) {
             if ($this->isPlaceholderExpr($arg)) {
                 throw new PlaceHolder();
             }
+            if ($arg->unpack) {
+                if ($hasNamedArg) {
+                    $this->fatalError($arg, 'Cannot use argument unpacking after named arguments');
+                }
+                $hasUnpack = true;
+                $arrayArgs = $ensureArrayArgs();
+                $this->context->beforeStmtLines[] = $arrayArgs . '.merge(' . $this->parseArrayArg($arg) . ');';
+                continue;
+            }
             if ($arg->name !== null) {
-                return $this->parseNamedCallArgs($args, $i, $list_args);
+                $hasNamedArg = true;
+                if (!$this->isIdExpr($arg->name)) {
+                    $this->fatalError($arg, 'Named argument must be a string');
+                }
+                if (array_key_exists($arg->name->name, $namedArgs)) {
+                    $this->fatalError($arg, "Duplicate named argument `{$arg->name->name}`");
+                }
+                $namedArgs[$arg->name->name] = true;
+                $byRef = $funcName && $this->isReferenceNamedArgument($funcName, $className, $arg->name->name);
+                $value = ($byRef || $this->isRefvalCall($arg->value))
+                    ? $this->parseReferenceCallArgValue($arg)
+                    : $this->parseCallArgValue($arg);
+                if ($separateNamedArgs) {
+                    $namedArgsArray = $ensureNamedArgs();
+                    $this->context->beforeStmtLines[] = $namedArgsArray . '.set(' . $this->getLiteralString($arg->name->name) . ', ' . $value . ');';
+                } else {
+                    $arrayArgs = $ensureArrayArgs();
+                    $this->context->beforeStmtLines[] = $arrayArgs . '.set(' . $this->getLiteralString($arg->name->name) . ', ' . $value . ');';
+                }
+                continue;
+            }
+            if ($hasNamedArg) {
+                $this->fatalError($arg, 'Cannot use positional argument after named argument');
+            }
+            if ($hasUnpack) {
+                $this->fatalError($arg, 'Cannot use positional argument after argument unpacking');
             }
             $byRef = $funcName && $this->isReferenceArgument($funcName, $className, $i);
             if ($this->isVarExpr($arg->value)) {
                 $name = $this->parseIdentifier($arg->value);
                 if ($byRef) {
-                    $list_args[] = $this->parseArgRefVar($arg, $name);
+                    $addPositionalArg($this->parseArgRefVar($arg, $name));
                     continue;
                 }
                 if (!$this->hasVar($name)) {
@@ -3004,7 +3601,7 @@ class CompilerBase extends \PhpAot\Core\Translator
                     $this->fatalError($arg, 'Undefined variable `$' . $obj . '`');
                 }
                 if ($byRef) {
-                    $list_args[] = $obj . '.attrRef(' . $this->identifierToStr($arg->value->name) . ')';
+                    $addPositionalArg($obj . '.attrRef(' . $this->identifierToStr($arg->value->name) . ')');
                     continue;
                 }
             } elseif ($this->isArrayDimFetch($arg->value) and $this->isVarExpr($arg->value->var)) {
@@ -3015,9 +3612,9 @@ class CompilerBase extends \PhpAot\Core\Translator
                     if ($byRef) {
                         $ref = $this->addTmpVar(self::TYPE_REF);
                         $this->context->beforeStmtLines[] = $ref . ' = ' . $globalVar . '.toReference();';
-                        $list_args[] = '&' . $ref;
+                        $addPositionalArg('&' . $ref);
                     } else {
-                        $list_args[] = $globalVar;
+                        $addPositionalArg($globalVar);
                     }
                     continue;
                 }
@@ -3028,7 +3625,7 @@ class CompilerBase extends \PhpAot\Core\Translator
                     if ($arg->value->dim === null) {
                         $this->fatalError($arg, 'Array dimension must be a constant expression');
                     }
-                    $list_args[] = $array . '.itemRef(' . $this->identifierToStr($arg->value->dim) . ')';
+                    $addPositionalArg($array . '.itemRef(' . $this->identifierToStr($arg->value->dim) . ')');
                     continue;
                 }
             } elseif ($this->isFuncCallExpr($arg->value)) {
@@ -3041,12 +3638,12 @@ class CompilerBase extends \PhpAot\Core\Translator
                         $name = $this->parseVariable($inner);
                         // 消除 refval() 函数调用，直接使用变量
                         $arg->value = $inner;
-                        $list_args[] = $this->parseArgRefVar($arg, $name);
+                        $addPositionalArg($this->parseArgRefVar($arg, $name));
                         continue;
                     }
                     $expr = $this->expandRefvalExpr($inner, $arg);
                     if ($expr !== null) {
-                        $list_args[] = $expr;
+                        $addPositionalArg($expr);
                         continue;
                     }
                     $this->fatalError($arg, 'The refval function only accepts a variable, array element, or object property');
@@ -3059,34 +3656,24 @@ class CompilerBase extends \PhpAot\Core\Translator
                     $tmpRef = $this->genTmpVarName();
                     $this->addLocalVar($tmpRef, self::TYPE_REF);
                     $this->context->beforeStmtLines[] = $tmpRef . ' = ' . $this->parseChainedExpr($arg->value, self::OP_REFVAL) . ';';
-                    $list_args[] = '&' . $tmpRef;
+                    $addPositionalArg('&' . $tmpRef);
                     continue;
                 }
             }
-            // 变长参数展开的语法，例如：array_merge(...$arr)
-            if ($arg->unpack) {
-                if ($i !== $last) {
-                    $this->fatalError($arg, 'The unpack expression for variadic arguments must be the last');
-                }
-                // 如果第一个参数是数组变量，数组展开语法直接传递该变量，没必要创建临时变量
-                // 例如：function (array $args) { var_dump(...$args); }
-                if ($i === 0 and $this->isVarExpr($arg->value) and $this->getVarType($arg->value->name) === self::TYPE_ARRAY) {
-                    return $this->parseIdentifier($arg->value);
-                } else {
-                    $tmpVar = $this->genTmpVarName();
-                    $this->context->beforeStmtLines[] = self::TYPE_ARRAY . ' ' . $tmpVar . '{' . implode(', ', $list_args) . '};';
-                    $this->context->beforeStmtLines[] = $tmpVar . '.merge(' . $this->parseArrayArg($arg) . ');';
-                    return $tmpVar;
-                }
-            }
-            $list_args[] = $this->parseCallArgValue($arg);
+            $value = $this->parseCallArgValue($arg);
+            $addPositionalArg($value);
         }
 
-        return Symbol::argList() . '{' . implode(', ', $list_args) . '}';
+        if ($arrayArgsVar !== null) {
+            return $namedArgsVar !== null ? $arrayArgsVar . ', ' . $namedArgsVar . '.array()' : $arrayArgsVar;
+        }
+        $callArgs = Symbol::argList() . '{' . implode(', ', $list_args) . '}';
+        return $namedArgsVar !== null ? $callArgs . ', ' . $namedArgsVar . '.array()' : $callArgs;
     }
 
     protected function parseCallArgValue(Node\Arg $arg): string
     {
+        $this->assertExprCanBeUsedAsValue($arg->value, 'function argument');
         return $this->materializeCallArgValue($arg->value, $this->parseArg($arg));
     }
 
@@ -3107,6 +3694,54 @@ class CompilerBase extends \PhpAot\Core\Translator
         return $value instanceof Expr\PropertyFetch;
     }
 
+    protected function parseReferenceCallArgValue(Node\Arg $arg): string
+    {
+        if ($this->isRefvalCall($arg->value)) {
+            if (count($arg->value->args) !== 1) {
+                $this->fatalError($arg, 'The refval function only accepts one parameter');
+            }
+            $arg->value = $arg->value->args[0]->value;
+        }
+
+        if ($this->isVarExpr($arg->value)) {
+            return $this->parseArgRefVar($arg, $this->parseIdentifier($arg->value));
+        }
+
+        if ($this->isPropertyFetch($arg->value) and $this->isVarExpr($arg->value->var)) {
+            $obj = $this->parseIdentifier($arg->value->var);
+            if (!$this->hasVar($obj)) {
+                $this->fatalError($arg, 'Undefined variable `$' . $obj . '`');
+            }
+            return $obj . '.attrRef(' . $this->identifierToStr($arg->value->name) . ')';
+        }
+
+        if ($this->isArrayDimFetch($arg->value) and $this->isVarExpr($arg->value->var)) {
+            $array = $this->parseIdentifier($arg->value->var);
+            if ($array === 'GLOBALS') {
+                $globalVar = $this->parseGlobalsArrayDimFetch($arg->value);
+                $ref = $this->addTmpVar(self::TYPE_REF);
+                $this->context->beforeStmtLines[] = $ref . ' = ' . $globalVar . '.toReference();';
+                return '&' . $ref;
+            }
+            if (!$this->hasVar($array)) {
+                $this->fatalError($arg, 'Undefined variable `$' . $array . '`');
+            }
+            if ($arg->value->dim === null) {
+                $this->fatalError($arg, 'Array dimension must be a constant expression');
+            }
+            return $array . '.itemRef(' . $this->identifierToStr($arg->value->dim) . ')';
+        }
+
+        if ($this->isScalar($arg->value)) {
+            $this->fatalError($arg, 'The constants cannot be used as an argument for a reference-type parameter');
+        }
+
+        $tmpRef = $this->genTmpVarName();
+        $this->addLocalVar($tmpRef, self::TYPE_REF);
+        $this->context->beforeStmtLines[] = $tmpRef . ' = ' . $this->parseChainedExpr($arg->value, self::OP_REFVAL) . ';';
+        return '&' . $tmpRef;
+    }
+
     /**
      * 展开 refval() 调用中的数组元素或对象属性，返回对应的 C++ 引用表达式。
      * 若为普通变量则返回 null，由调用方自行处理。
@@ -3189,6 +3824,20 @@ class CompilerBase extends \PhpAot\Core\Translator
         return $expr;
     }
 
+    protected function parseOrderedArg(Node\Arg $arg): string
+    {
+        if ($this->isArrayDimFetch($arg->value) and $this->isStdContainerExpr($arg->value)) {
+            return $this->parseArg($arg);
+        }
+        if ($this->isVarExpr($arg->value) and $arg->value->name === 'GLOBALS') {
+            return 'php_globals_array()';
+        }
+        if ($this->isVarExpr($arg->value) and $this->isStdContainer($arg->value->name)) {
+            return $this->convertArrayExpr($this->parseIdentifier($arg->value) . '_ref');
+        }
+        return $this->parseOrderedOperand($arg->value, false);
+    }
+
     protected function parseArrayArg(Node\Arg $expr): string
     {
         $value = $expr->value;
@@ -3206,6 +3855,7 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parsePostOp(Expr\PostDec|Expr\PostInc $expr, string $op): string
     {
+        $this->assertNotNullsafeWriteContext($expr->var);
         $result = $this->genDynamicPropIncDec($expr->var, $op, false);
         if ($result !== null) {
             return $result;
@@ -3259,18 +3909,71 @@ class CompilerBase extends \PhpAot\Core\Translator
         if ($expr->if === null) {
             return $this->parseValueSelection($expr, $expr->cond, $expr->else, self::OP_NOT_EMPTY);
         }
-        $cond = $this->parseExpr($expr->cond);
+        $this->assertExprCanBeUsedAsCondition($expr->cond, 'ternary condition');
+        $this->assertExprCanBeUsedAsValue($expr->if, 'ternary branch');
+        $this->assertExprCanBeUsedAsValue($expr->else, 'ternary branch');
+        [$cond, $condBeforeStmts, $condAfterStmts] = $this->parseExprWithCapturedStmts($expr->cond);
+        $ifBeforeStmtCount = count($this->context->beforeStmtLines);
+        $ifAfterStmtCount = count($this->context->afterStmtLines);
         $if = $this->parseExpr($expr->if);
+        $ifBeforeStmts = array_slice($this->context->beforeStmtLines, $ifBeforeStmtCount);
+        $ifAfterStmts = array_slice($this->context->afterStmtLines, $ifAfterStmtCount);
+        $this->context->beforeStmtLines = array_slice($this->context->beforeStmtLines, 0, $ifBeforeStmtCount);
+        $this->context->afterStmtLines = array_slice($this->context->afterStmtLines, 0, $ifAfterStmtCount);
+
+        $elseBeforeStmtCount = count($this->context->beforeStmtLines);
+        $elseAfterStmtCount = count($this->context->afterStmtLines);
         $else = $this->parseExpr($expr->else);
-        if ($this->detectTypeOfExpr($expr->if) !== $this->detectTypeOfExpr($expr->else)) {
+        $elseBeforeStmts = array_slice($this->context->beforeStmtLines, $elseBeforeStmtCount);
+        $elseAfterStmts = array_slice($this->context->afterStmtLines, $elseAfterStmtCount);
+        $this->context->beforeStmtLines = array_slice($this->context->beforeStmtLines, 0, $elseBeforeStmtCount);
+        $this->context->afterStmtLines = array_slice($this->context->afterStmtLines, 0, $elseAfterStmtCount);
+
+        $hasBranchStmts = $condBeforeStmts || $condAfterStmts || $ifBeforeStmts || $ifAfterStmts || $elseBeforeStmts || $elseAfterStmts;
+        $typeChanged = $this->detectTypeOfExpr($expr->if) !== $this->detectTypeOfExpr($expr->else);
+        if (!$hasBranchStmts && $typeChanged) {
             $if = 'php::Var(' . $if . ')';
             $else = 'php::Var(' . $else . ')';
         }
+        if ($hasBranchStmts) {
+            $appendStmtLines = function (string &$code, array $stmts): void {
+                if ($stmts) {
+                    $code .= $this->getIndent() . implode(PHP_EOL . $this->getIndent(), $stmts) . PHP_EOL;
+                }
+            };
+            $appendReturn = function (string &$code, string $value, array $beforeStmts, array $afterStmts) use ($appendStmtLines): void {
+                $appendStmtLines($code, $beforeStmts);
+                if ($afterStmts) {
+                    $tmpVar = $this->addTmpVar(self::TYPE_VAR);
+                    $code .= $this->getIndent() . "{$tmpVar} = {$value};";
+                    $appendStmtLines($code, $afterStmts);
+                    $code .= $this->getIndent() . 'return ' . $tmpVar . ';';
+                } else {
+                    $code .= $this->getIndent() . 'return php::Var(' . $value . ');';
+                }
+            };
+            $code = '[&]() -> ' . self::TYPE_VAR . '{';
+            $appendStmtLines($code, $condBeforeStmts);
+            if ($condAfterStmts) {
+                $condTmpVar = $this->addTmpVar(self::TYPE_VAR);
+                $code .= $this->getIndent() . "{$condTmpVar} = {$cond};";
+                $appendStmtLines($code, $condAfterStmts);
+                $cond = $condTmpVar;
+            }
+            $code .= $this->getIndent() . 'if (' . $cond . ') {';
+            $appendReturn($code, $if, $ifBeforeStmts, $ifAfterStmts);
+            $code .= $this->getIndent() . '} else {';
+            $appendReturn($code, $else, $elseBeforeStmts, $elseAfterStmts);
+            $code .= $this->getIndent() . '}';
+            $code .= $this->getIndent() . '}()';
+            return $code;
+        }
         return '(' . $cond . ') ? (' . $if . ') : (' . $else . ')';
     }
 
     protected function parseMatch(Expr\Match_ $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->cond, 'match condition');
         $var = $this->parseIdentifier($expr->cond);
         if ($this->isVarExpr($expr->cond)) {
             if (!$this->hasVar($var)) {
@@ -3282,31 +3985,74 @@ class CompilerBase extends \PhpAot\Core\Translator
             $var = $tmpVar;
         }
 
+        $parseExprWithStmts = function (NodeAbstract $node): array {
+            $beforeStmtCount = count($this->context->beforeStmtLines);
+            $afterStmtCount = count($this->context->afterStmtLines);
+            $value = $this->parseExpr($node);
+            $beforeStmts = array_slice($this->context->beforeStmtLines, $beforeStmtCount);
+            $afterStmts = array_slice($this->context->afterStmtLines, $afterStmtCount);
+            $this->context->beforeStmtLines = array_slice($this->context->beforeStmtLines, 0, $beforeStmtCount);
+            $this->context->afterStmtLines = array_slice($this->context->afterStmtLines, 0, $afterStmtCount);
+            return [$value, $beforeStmts, $afterStmts];
+        };
+
+        $appendStmtLines = function (string &$code, array $stmts): void {
+            if ($stmts) {
+                $code .= $this->getIndent() . implode(PHP_EOL . $this->getIndent(), $stmts) . PHP_EOL;
+            }
+        };
+
+        $appendMatchReturn = function (string &$code, NodeAbstract $body) use ($parseExprWithStmts, $appendStmtLines): void {
+            $this->assertExprCanBeUsedAsValue($body, 'match arm');
+            [$value, $beforeStmts, $afterStmts] = $parseExprWithStmts($body);
+            $appendStmtLines($code, $beforeStmts);
+            if ($afterStmts) {
+                $tmpVar = $this->addTmpVar(self::TYPE_VAR);
+                $code .= $this->getIndent() . "{$tmpVar} = {$value};";
+                $appendStmtLines($code, $afterStmts);
+                $code .= $this->getIndent() . 'return ' . $tmpVar . ';';
+            } else {
+                $code .= $this->getIndent() . 'return ' . $value . ';';
+            }
+        };
+
         $code = '[&]() -> ' . self::TYPE_VAR . '{';
         $default = null;
-        foreach ($expr->arms as $i => $arm) {
+        foreach ($expr->arms as $arm) {
             if ($arm->conds === null) {
                 $default = $arm->body;
                 continue;
             }
-            $prefix = $i === 0 ? 'if' : 'else if';
-            $condList = [];
+            $matched = $this->genTmpVarName();
+            $code .= $this->getIndent() . 'bool ' . $matched . ' = false;';
             foreach ($arm->conds as $cond) {
                 if ($this->isMatchExpr($cond)) {
                     $this->fatalError($arm, 'Match expression cannot be used as a condition');
                 }
-                $condList[] = 'php::same(' . $var . ', ' . $this->parseExpr($cond) . ')';
+                $this->assertExprCanBeUsedAsValue($cond, 'match arm condition');
+                [$condValue, $beforeStmts, $afterStmts] = $parseExprWithStmts($cond);
+                $code .= $this->getIndent() . 'if (!' . $matched . ') {';
+                $appendStmtLines($code, $beforeStmts);
+                if ($afterStmts) {
+                    $condTmpVar = $this->addTmpVar(self::TYPE_VAR);
+                    $code .= $this->getIndent() . "{$condTmpVar} = {$condValue};";
+                    $appendStmtLines($code, $afterStmts);
+                    $condValue = $condTmpVar;
+                }
+                $code .= $this->getIndent() . $matched . ' = php::same(' . $var . ', ' . $condValue . ');';
+                $code .= $this->getIndent() . '}';
             }
-            $code .= $prefix . '(' . implode(' || ', $condList) . ') {';
-            $code .= 'return ' . $this->parseExpr($arm->body) . ';';
-            $code .= '}';
+            $code .= $this->getIndent() . 'if (' . $matched . ') {';
+            $appendMatchReturn($code, $arm->body);
+            $code .= $this->getIndent() . '}';
         }
 
-        $else = count($expr->arms) === 0 ? '' : 'else ';
         if ($default) {
-            $code .= $else . ' { return ' . $this->parseExpr($default) . '; }';
+            $code .= $this->getIndent() . '{';
+            $appendMatchReturn($code, $default);
+            $code .= $this->getIndent() . '}';
         } else {
-            $code .= $else . ' { return php::throwException("UnhandledMatchError", "Unhandled match case"); }';
+            $code .= $this->getIndent() . '{ return php::throwException("UnhandledMatchError", "Unhandled match case"); }';
         }
         $code .= '}()';
 
@@ -3315,6 +4061,7 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parsePreDec(Expr\PreDec $expr): string
     {
+        $this->assertNotNullsafeWriteContext($expr->var);
         $oriInAssignExpr = $this->context->inAssignExpr;
         $this->context->inAssignExpr = true;
 
@@ -3336,6 +4083,7 @@ class CompilerBase extends \PhpAot\Core\Translator
     protected function parseBitwiseNot(Expr\BitwiseNot $expr): string
     {
         $type = $this->detectTypeOfExpr($expr->expr);
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'bitwise operand');
         if ($type === self::TYPE_BIGINT) {
             return 'php::BigInt::bitNot(' . $this->parseExpr($expr->expr) . ')';
         }
@@ -3345,30 +4093,32 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parseIf(Node\Stmt\If_ $v): string
     {
-        $cond = $this->parseExpr($v->cond);
-        $cond = $this->parseConditionAssign($v->cond, $cond);
-
-        $code = $this->parseBeforeStmtLines() . PHP_EOL;
-        $code .= 'if (' . $cond . ') {' . PHP_EOL;
-        $code .= $this->parseBlockStmts($v->stmts);
-        $code .= $this->getIndent() . '}';
+        $arms = [[$v->cond, $v->stmts]];
+        foreach ($v->elseifs as $elseif) {
+            $arms[] = [$elseif->cond, $elseif->stmts];
+        }
 
-        if ($v->elseifs) {
-            foreach ($v->elseifs as $elseif) {
-                $elseifCond = $this->parseExpr($elseif->cond);
-                $code .= ' else if (' . $elseifCond . ') {' . PHP_EOL;
-                $code .= $this->parseBlockStmts($elseif->stmts);
-                $code .= $this->getIndent() . '}';
+        $emitIfChain = function (int $index) use (&$emitIfChain, $arms, $v): string {
+            if (!isset($arms[$index])) {
+                if (!$v->else) {
+                    return '';
+                }
+                return $this->parseBlockStmts($v->else->stmts);
             }
-        }
 
-        if ($v->else) {
-            $code .= ' else {' . PHP_EOL;
-            $code .= $this->parseBlockStmts($v->else->stmts);
+            [$cond, $stmts] = $arms[$index];
+            $code = $this->genConditionWithCapturedStmts($cond, 'if ');
+            $code .= $this->parseBlockStmts($stmts);
+            $tail = $emitIfChain($index + 1);
+            if ($tail !== '') {
+                $code .= $this->getIndent() . '} else {' . PHP_EOL;
+                $code .= $tail;
+            }
             $code .= $this->getIndent() . '}';
-        }
+            return $code;
+        };
 
-        return $code . PHP_EOL;
+        return $this->parseBeforeStmtLines() . PHP_EOL . $emitIfChain(0) . PHP_EOL;
     }
 
     /**
@@ -3376,17 +4126,30 @@ class CompilerBase extends \PhpAot\Core\Translator
      */
     protected function parseBooleanNot(Expr\BooleanNot $expr): string
     {
+        $this->assertExprCanBeUsedAsCondition($expr->expr, 'boolean operand');
         return '!(' . $this->parseExpr($expr->expr) . ')';
     }
 
     protected function parseWhile(Node\Stmt\While_ $v): string
     {
-        $cond  = $this->parseExpr($v->cond);
-        $cond  = $this->parseConditionAssign($v->cond, $cond);
         $stmts = $v->stmts;
+        $this->assertExprCanBeUsedAsCondition($v->cond, 'while condition');
+        [$cond, $beforeStmts, $afterStmts] = $this->parseExprWithCapturedStmts($v->cond);
 
         $code = $this->parseBeforeStmtLines() . PHP_EOL;
-        $code .= 'while (' . $cond . ') {' . PHP_EOL;
+        if ($beforeStmts || $afterStmts) {
+            $code .= 'while (true) {' . PHP_EOL;
+            $this->appendCapturedStmtLines($code, $beforeStmts);
+            if ($afterStmts) {
+                $tmpVar = $this->addTmpVar(self::TYPE_VAR);
+                $code .= $this->getIndent() . $tmpVar . ' = ' . $cond . ';' . PHP_EOL;
+                $this->appendCapturedStmtLines($code, $afterStmts);
+                $cond = $tmpVar;
+            }
+            $code .= $this->getIndent() . 'if (!(' . $cond . ')) { break; }' . PHP_EOL;
+        } else {
+            $code .= 'while (' . $cond . ') {' . PHP_EOL;
+        }
         $code .= $this->parseBlockStmts($stmts);
         $code .= $this->genLoopEndFlagCheck();
         $code .= $this->getIndent() . '}' . PHP_EOL;
@@ -3396,14 +4159,28 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parsePrint(Expr\Print_ $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'print operand');
         return 'php::print(' . $this->parseExpr($expr->expr) . ')';
     }
 
     protected function parseDo(Node\Stmt\Do_ $v): string
     {
         $stmts = $v->stmts;
-        $cond  = $this->parseExpr($v->cond);
-        $cond  = $this->parseConditionAssign($v->cond, $cond);
+        $this->assertExprCanBeUsedAsCondition($v->cond, 'do-while condition');
+        [$cond, $beforeStmts, $afterStmts] = $this->parseExprWithCapturedStmts($v->cond);
+        if ($beforeStmts || $afterStmts) {
+            $condCode = '[&]() -> bool {';
+            $this->appendCapturedStmtLines($condCode, $beforeStmts);
+            if ($afterStmts) {
+                $tmpVar = $this->addTmpVar(self::TYPE_VAR);
+                $condCode .= $this->getIndent() . $tmpVar . ' = ' . $cond . ';' . PHP_EOL;
+                $this->appendCapturedStmtLines($condCode, $afterStmts);
+                $cond = $tmpVar;
+            }
+            $condCode .= $this->getIndent() . 'return ' . $this->convertBoolExpr($cond) . ';';
+            $condCode .= $this->getIndent() . '}()';
+            $cond = $condCode;
+        }
         $code  = $this->parseBeforeStmtLines() . PHP_EOL;
         $code .= 'do {' . PHP_EOL;
         $code .= $this->parseBlockStmts($stmts);
@@ -3418,6 +4195,8 @@ class CompilerBase extends \PhpAot\Core\Translator
      */
     protected function parseValueSelection(NodeAbstract $expr, Expr $left, Expr $right, string $op): string
     {
+        $this->assertExprCanBeUsedAsValue($left, 'selection value');
+        $this->assertExprCanBeUsedAsValue($right, 'selection value');
         $leftExpr = $this->parseIdentifier($left);
         if ($this->isVarExpr($left)) {
             $this->checkVarMustExist($left, $leftExpr);
@@ -3429,26 +4208,43 @@ class CompilerBase extends \PhpAot\Core\Translator
             $leftExpr = $chainOpResult;
         }
 
+        $rightBeforeStmtCount = count($this->context->beforeStmtLines);
+        $rightAfterStmtCount = count($this->context->afterStmtLines);
         $rightExpr = $this->parseIdentifier($right);
+        $rightBeforeStmts = array_slice($this->context->beforeStmtLines, $rightBeforeStmtCount);
+        $rightAfterStmts = array_slice($this->context->afterStmtLines, $rightAfterStmtCount);
+        $this->context->beforeStmtLines = array_slice($this->context->beforeStmtLines, 0, $rightBeforeStmtCount);
+        $this->context->afterStmtLines = array_slice($this->context->afterStmtLines, 0, $rightAfterStmtCount);
         $this->checkVarMustExist($right, $rightExpr);
 
         $tmpVar = $this->addTmpVar(self::TYPE_VAR);
-        $this->context->beforeStmtLines[] = '// Expr: ' . $this->printer->prettyPrintExpr($expr) . PHP_EOL .
-            $tmpVar . ' = ' . $condExpr . ' ? ' . $leftExpr . ' : ' . $rightExpr . ';';
+        if ($rightBeforeStmts || $rightAfterStmts) {
+            $code = '// Expr: ' . $this->printer->prettyPrintExpr($expr) . PHP_EOL .
+                'if (' . $condExpr . ') {' . PHP_EOL .
+                $this->getIndent() . $tmpVar . ' = ' . $leftExpr . ';' . PHP_EOL .
+                '} else {' . PHP_EOL;
+            if ($rightBeforeStmts) {
+                $code .= $this->getIndent() . implode(PHP_EOL . $this->getIndent(), $rightBeforeStmts) . PHP_EOL;
+            }
+            if ($rightAfterStmts) {
+                $rightTmpVar = $this->addTmpVar(self::TYPE_VAR);
+                $code .= $this->getIndent() . $rightTmpVar . ' = ' . $rightExpr . ';' . PHP_EOL;
+                $code .= $this->getIndent() . implode(PHP_EOL . $this->getIndent(), $rightAfterStmts) . PHP_EOL;
+                $code .= $this->getIndent() . $tmpVar . ' = ' . $rightTmpVar . ';' . PHP_EOL;
+            } else {
+                $code .= $this->getIndent() . $tmpVar . ' = ' . $rightExpr . ';' . PHP_EOL;
+            }
+            $code .= '}';
+            $this->context->beforeStmtLines[] = $code;
+        } else {
+            $this->context->beforeStmtLines[] = '// Expr: ' . $this->printer->prettyPrintExpr($expr) . PHP_EOL .
+                $tmpVar . ' = ' . $condExpr . ' ? ' . $leftExpr . ' : ' . $rightExpr . ';';
+        }
         $expr->setAttribute('replace', $tmpVar);
 
         return $tmpVar;
     }
 
-    /**
-     * while, do while 判断中赋值，在C++编译中会提示
-     * suggest parentheses around assignment used as truth value
-     */
-    protected function parseConditionAssign(NodeAbstract $cond, string $code): string
-    {
-        return $cond instanceof Expr\Assign ? '(' . $code . ')' : $code;
-    }
-
     protected function packData(string $bytes): string
     {
         $out = '';
@@ -3469,6 +4265,7 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parseNew(Expr\New_ $expr): string
     {
+        $ctorClassName = '';
         // 匿名类
         if ($expr->class instanceof Node\Stmt\Class_) {
             if ($expr->class->name === null) {
@@ -3495,6 +4292,7 @@ class CompilerBase extends \PhpAot\Core\Translator
                     . $className . '_defined = true; php::eval((const char *)' . $className . '_code);}';
                 $className = '\\' . $className;
                 $cePtr     = $this->getClassEntryPtr($className);
+                $ctorClassName = $className;
             } else {
                 $this->fatalError($expr, 'must be anonymous class');
             }
@@ -3514,6 +4312,7 @@ class CompilerBase extends \PhpAot\Core\Translator
                     } else {
                         $className = $this->getNamespacedClassName($className);
                     }
+                    $ctorClassName = $className;
                     if ($this->hasClass($className)) {
                         $classDef = $this->getClass($className);
                         if ($classDef->flags & Modifiers::ABSTRACT) {
@@ -3531,16 +4330,18 @@ class CompilerBase extends \PhpAot\Core\Translator
         if (empty($args)) {
             return 'php::newObject(' . $cePtr . ')';
         }
-        return 'php::newObject(' . $cePtr . ', ' . $this->parseCallArgs($args) . ')';
+        return 'php::newObject(' . $cePtr . ', ' . $this->parseCallArgs($args, '__construct', $ctorClassName) . ')';
     }
 
     protected function parseClone(Expr\Clone_ $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'clone operand');
         return 'php::clone(' . $this->parseExpr($expr->expr) . ')';
     }
 
     protected function parseInstanceof(Expr\Instanceof_ $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'instanceof operand');
         if ($this->isNameExpr($expr->class)) {
             $className = $this->getNamespacedClassName($this->parseIdentifier($expr->class));
             $className = $this->getClassEntryPtr($className);
@@ -3552,11 +4353,13 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parseCastInt(Expr\Cast\Int_ $node): string
     {
+        $this->assertExprCanBeUsedAsValue($node->expr, 'cast operand');
         return $this->convertIntExpr($this->parseExpr($node->expr));
     }
 
     protected function parseCastString(Expr\Cast\String_ $node): string
     {
+        $this->assertExprCanBeUsedAsValue($node->expr, 'cast operand');
         return $this->convertExprToStringByType(
             $this->parseExpr($node->expr),
             $this->detectTypeOfExpr($node->expr)
@@ -3565,11 +4368,13 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parseCastBool(Expr\Cast\Bool_ $node): string
     {
+        $this->assertExprCanBeUsedAsValue($node->expr, 'cast operand');
         return $this->convertBoolExpr($this->parseExpr($node->expr));
     }
 
     protected function parseCastObject(Expr\Cast\Object_ $node): string
     {
+        $this->assertExprCanBeUsedAsValue($node->expr, 'cast operand');
         return $this->convertObjectExpr($this->parseExpr($node->expr));
     }
 
@@ -3583,7 +4388,7 @@ class CompilerBase extends \PhpAot\Core\Translator
         if ($this->isNameExpr($expr->name) and $this->hasConstant($name)) {
             return $this->getConstant($name);
         }
-        if ($this->namespace and $this->isNameExpr($expr->name) and !str_contains($name, '\\')) {
+        if ($this->namespace and $this->isNameExpr($expr->name) and !$expr->name instanceof Node\Name\FullyQualified) {
             $nsName = $this->namespace . '\\' . $name;
             if ($this->hasConstant($nsName)) {
                 return $this->getConstant($nsName);
@@ -3638,6 +4443,7 @@ class CompilerBase extends \PhpAot\Core\Translator
     protected function parseUnaryMinus(Expr\UnaryMinus $expr): string
     {
         $type = $this->detectTypeOfExpr($expr->expr);
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'unary operand');
         if ($type === self::TYPE_BIGFLOAT) {
                         return 'php::BigFloat::neg(' . $this->parseExpr($expr->expr) . ')';
         }
@@ -3652,8 +4458,9 @@ class CompilerBase extends \PhpAot\Core\Translator
         return '-' . $code;
     }
 
-    protected function parseUnaryPlus(Expr\UnaryPlus $expr)
+    protected function parseUnaryPlus(Expr\UnaryPlus $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'unary operand');
         return $this->parseExpr($expr->expr);
     }
 
@@ -3662,6 +4469,9 @@ class CompilerBase extends \PhpAot\Core\Translator
         $parts = $expr->parts;
         $list  = [];
         foreach ($parts as $part) {
+            if (!$part instanceof Node\InterpolatedStringPart) {
+                $this->assertExprCanBeUsedAsValue($part, 'string interpolation value');
+            }
             $list[] = $this->parseExpr($part);
         }
 
@@ -3730,12 +4540,19 @@ class CompilerBase extends \PhpAot\Core\Translator
                 }
                 // Check transitive interface inheritance (e.g., Iterator extends Traversable)
                 foreach ($classDef->implements as $iface) {
-                    $check = $iface;
-                    while ($check && $this->hasInterface($check)) {
+                    $stack = [$iface];
+                    while ($stack) {
+                        $check = array_pop($stack);
                         if (strcasecmp($check, $expected) === 0) {
                             return true;
                         }
-                        $check = $this->getInterface($check)->extends;
+                        if (!$this->hasInterface($check)) {
+                            continue;
+                        }
+                        $interfaceDef = $this->getInterface($check);
+                        foreach ($interfaceDef->extendsList ?: ($interfaceDef->extends ? [$interfaceDef->extends] : []) as $parentIface) {
+                            $stack[] = $parentIface;
+                        }
                     }
                     if (is_subclass_of($iface, $expected)) {
                         return true;
@@ -3764,8 +4581,8 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function getTypeConvertedArg(Node\Arg $arg, ArgInfo $argInfo): string
     {
-        $expr = $this->parseArg($arg);
         $type = $this->detectTypeOfExpr($arg->value);
+        $this->assertExprCanBeUsedAsValue($arg->value, 'function argument');
 
         if ($argInfo->byRef) {
             if ($this->isRefvalCall($arg->value)) {
@@ -3794,6 +4611,7 @@ class CompilerBase extends \PhpAot\Core\Translator
             return $this->convertToRef($arg->value);
         }
 
+        $expr = $this->parseOrderedArg($arg);
         $expr = $this->materializeCallArgValue($arg->value, $expr);
 
         $this->checkVarAssignExpr($arg, $argInfo->type, $type);
@@ -3811,7 +4629,8 @@ class CompilerBase extends \PhpAot\Core\Translator
                 if ($this->isTypedObject($object)) {
                     $class = $this->getObjectType($object);
                     if ($class and $argInfo->class and !$this->isInheritedFrom($class, $argInfo->class)) {
-                        $this->fatalError($arg, "Argument `{$argInfo->name}` must be an instance of `{$argInfo->class}`, `{$class}` given");
+                        $argName = $argInfo->phpName ?: $this->unescapeVarName($argInfo->name);
+                        $this->fatalError($arg, "Argument `{$argName}` must be an instance of `{$argInfo->class}`, `{$class}` given");
                     }
                 }
             }
@@ -3911,11 +4730,99 @@ class CompilerBase extends \PhpAot\Core\Translator
         }
     }
 
+    protected function wrapObjectPropertyAssignTypeCheck(NodeAbstract $left, Expr $right, string $rightExpr): string
+    {
+        if (!$left->hasAttribute('nativePropertyDef')) {
+            return $rightExpr;
+        }
+
+        /** @var PropertyDef $def */
+        $def = $left->getAttribute('nativePropertyDef');
+        $typeCheck = $this->getObjectPropertyAssignTypeCheck($def);
+        if (empty($typeCheck)) {
+            return $rightExpr;
+        }
+
+        $rightClass = $this->detectClassOfExpr($right);
+        if ($rightClass !== '') {
+            return $rightExpr;
+        }
+
+        $tmpVar = $this->addTmpVar(self::TYPE_VAR);
+        $conditions = [];
+        foreach ($typeCheck as $entry) {
+            $cond = $this->genSingleTypeCondition($tmpVar, $entry);
+            if ($cond !== '') {
+                $conditions[] = $cond;
+            }
+        }
+        if (empty($conditions)) {
+            return $rightExpr;
+        }
+
+        $propDisplay = $this->getObjectPropertyTypeCheckDisplayName($left);
+        $typeStr = $this->getObjectPropertyTypeCheckTypeString($def);
+        $msgExpr = 'php::concat(php::concat(php::Str(' . $this->genCharPtr($propDisplay, true) . ' " must be of type " '
+            . $this->genCharPtr($typeStr, true) . ' ", "), ' . $tmpVar . '.typeStr()), php::Str(" given"))';
+
+        return '([&]() -> ' . self::TYPE_VAR . ' { '
+            . $tmpVar . ' = ' . $rightExpr . '; '
+            . 'if (UNEXPECTED(!(' . implode(' || ', $conditions) . '))) { '
+            . 'php::throwException(zend_ce_type_error, (' . $msgExpr . ').toCString()); '
+            . '} '
+            . 'return ' . $tmpVar . '; '
+            . '}())';
+    }
+
+    private function getObjectPropertyAssignTypeCheck(PropertyDef $def): array
+    {
+        if (!empty($def->typeCheck)) {
+            return $def->typeCheck;
+        }
+        if ($def->type !== self::TYPE_OBJECT || $def->class === '') {
+            return [];
+        }
+
+        $check = [];
+        if ($def->nullable) {
+            $check[] = ['kind' => 'isNull'];
+        }
+        $check[] = ['kind' => 'instanceof', 'class' => $def->class];
+        return $check;
+    }
+
+    private function getObjectPropertyTypeCheckDisplayName(NodeAbstract $left): string
+    {
+        $propName = $this->parseIdentifier($left->name);
+        if ($left->hasAttribute('nativeClassDef')) {
+            $class = $left->getAttribute('nativeClassDef')->getNamespacedName(false);
+            return $class . '::$' . $propName;
+        }
+
+        if ($left instanceof Expr\StaticPropertyFetch) {
+            return $this->identifierToStr($left->class, literal: true) . '::$' . $propName;
+        }
+
+        return '$' . $propName;
+    }
+
+    private function getObjectPropertyTypeCheckTypeString(PropertyDef $def): string
+    {
+        if ($def->typeStr !== '') {
+            return $def->typeStr;
+        }
+        if ($def->class !== '') {
+            return ($def->nullable ? '?' : '') . $def->class;
+        }
+        return $def->type;
+    }
+
     protected function parseUnset(Node\Stmt\Unset_ $node): string
     {
         $vars = $node->vars;
         $lines = [];
         foreach ($vars as $var) {
+            $this->assertNotNullsafeWriteContext($var);
             if ($this->isArrayDimFetch($var)) {
                 if ($var->dim === null) {
                     $this->fatalError($var, 'Cannot use [] for array unset');
@@ -3989,13 +4896,14 @@ class CompilerBase extends \PhpAot\Core\Translator
                 if ($this->classDef->trait) {
                     goto _dynamic_attr;
                 }
-                $nativeProperty = $this->findNativeProperty($expr, $propertyName, $this->getFullClassName());
+                $result = $this->resolveNativeInstanceProperty($expr, $propertyName, $this->getFullClassName());
+                $nativeProperty = $result ? $this->applyNativePropertyAccessResult($expr, $result) : null;
             } elseif ($this->isTypedObject($objectName)) {
                 $className = $this->getObjectType($objectName);
-                $nativeProperty = $this->findNativeProperty($expr, $propertyName, $className);
+                $result = $this->resolveNativeInstanceProperty($expr, $propertyName, $className);
+                $nativeProperty = $result ? $this->applyNativePropertyAccessResult($expr, $result) : null;
             }
             if ($nativeProperty) {
-                $expr->setAttribute('nativeProperty', $nativeProperty);
                 return $nativeProperty;
             }
         }
@@ -4217,10 +5125,15 @@ class CompilerBase extends \PhpAot\Core\Translator
         $cond    = $v->cond;
         $tmp_var = $this->genTmpVarName();
         $type    = $this->detectTypeOfExpr($cond);
+        $this->assertExprCanBeUsedAsValue($cond, 'switch condition');
         if ($this->isVarExpr($cond)) {
             $this->requireVar($v, $this->parseIdentifier($cond));
         }
-        $var_def = $type . ' ' . $tmp_var . ' = ' . $this->parseExpr($cond) . ';' . PHP_EOL;
+        [$condExpr, $condBeforeStmts, $condAfterStmts] = $this->parseExprWithCapturedStmts($cond);
+        $var_def = '';
+        $this->appendCapturedStmtLines($var_def, $condBeforeStmts);
+        $var_def .= $type . ' ' . $tmp_var . ' = ' . $condExpr . ';' . PHP_EOL;
+        $this->appendCapturedStmtLines($var_def, $condAfterStmts);
 
         // 保存作用域，switch 可能会解析失败，在这个过程中会增加变量，需重置
         $localVars = $this->context->localVars;
@@ -4257,33 +5170,23 @@ class CompilerBase extends \PhpAot\Core\Translator
 
         _fail:
 
-        if (count($v->cases) == 1) {
-            if (!empty($v->cases[0]->cond)) {
-                $code = 'if (' . $tmp_var . '==' . $this->parseIdentifier($v->cases[0]->cond) . ') {' . PHP_EOL;
-            } else {
-                $code = 'if (1) {' . PHP_EOL;
-            }
-            $code .= $this->parseStmts($v->cases[0]->stmts);
-            $code .= $this->getIndent() . '}';
-            return $var_def . $code;
-        }
-
         $code = 'do {' . PHP_EOL;
         $this->indentLevel++;
-        $condList = [];
-        $defaultCase = false;
-        $defaultOnly = true;
+        $switchMatched = $this->genTmpVarName();
+        $code .= $this->getIndent() . 'bool ' . $switchMatched . ' = false;' . PHP_EOL;
+        $caseConds = [];
         foreach ($v->cases as $case) {
             if (empty($case->cond)) {
-                $defaultCase = true;
+                $isDefault = true;
             } else {
-                $condList[] = $tmp_var . '==' . $this->parseIdentifier($case->cond);
+                $isDefault = false;
+                $caseConds[] = $case->cond;
             }
-            $this->indentLevel++;
             $stmts = $case->stmts;
             if (empty($stmts)) {
                 continue;
             }
+            $this->indentLevel++;
             if (count($stmts) === 1 and $stmts[0] instanceof Node\Stmt\Block) {
                 $stmts = $stmts[0]->stmts;
             }
@@ -4296,13 +5199,35 @@ class CompilerBase extends \PhpAot\Core\Translator
                 $this->fatalError($case, 'switch case must end with return/break/exit/throw, ' . $lastExpr->getType() . ' given');
             }
 
-            if ($defaultCase) {
-                $else = $defaultOnly ? '' : 'else';
-                $code .= $this->getIndent() . $else . ' {' . PHP_EOL;
+            if ($isDefault) {
+                $code .= $this->getIndent() . 'if (!' . $switchMatched . ') {' . PHP_EOL;
             } else {
-                $code .= $this->getIndent() . 'if (' . implode(' || ', $condList) . ') {' . PHP_EOL;
-                $defaultOnly = false;
-                $condList = [];
+                $groupMatched = $this->genTmpVarName();
+                $code .= $this->getIndent() . 'bool ' . $groupMatched . ' = false;' . PHP_EOL;
+                foreach ($caseConds as $caseCond) {
+                    $this->assertExprCanBeUsedAsValue($caseCond, 'switch case condition');
+                    $caseBeforeStmtCount = count($this->context->beforeStmtLines);
+                    $caseAfterStmtCount = count($this->context->afterStmtLines);
+                    $caseCondExpr = $this->parseIdentifier($caseCond);
+                    $caseBeforeStmts = array_slice($this->context->beforeStmtLines, $caseBeforeStmtCount);
+                    $caseAfterStmts = array_slice($this->context->afterStmtLines, $caseAfterStmtCount);
+                    $this->context->beforeStmtLines = array_slice($this->context->beforeStmtLines, 0, $caseBeforeStmtCount);
+                    $this->context->afterStmtLines = array_slice($this->context->afterStmtLines, 0, $caseAfterStmtCount);
+
+                    $code .= $this->getIndent() . 'if (!' . $switchMatched . ' && !' . $groupMatched . ') {' . PHP_EOL;
+                    $this->appendCapturedStmtLines($code, $caseBeforeStmts);
+                    if ($caseAfterStmts) {
+                        $caseTmpVar = $this->addTmpVar(self::TYPE_VAR);
+                        $code .= $this->getIndent() . $caseTmpVar . ' = ' . $caseCondExpr . ';' . PHP_EOL;
+                        $this->appendCapturedStmtLines($code, $caseAfterStmts);
+                        $caseCondExpr = $caseTmpVar;
+                    }
+                    $code .= $this->getIndent() . $groupMatched . ' = php::equals(' . $tmp_var . ', ' . $caseCondExpr . ');' . PHP_EOL;
+                    $code .= $this->getIndent() . '}' . PHP_EOL;
+                }
+                $code .= $this->getIndent() . 'if (' . $groupMatched . ') {' . PHP_EOL;
+                $code .= $this->getIndent() . $switchMatched . ' = true;' . PHP_EOL;
+                $caseConds = [];
             }
 
             $code .= $this->parseStmts($stmts);
@@ -4322,6 +5247,9 @@ class CompilerBase extends \PhpAot\Core\Translator
         foreach ($v->vars as $var) {
             $varName = $this->escapeVarName($var->var->name);
             $type = $var->default ? $this->detectTypeOfExpr($var->default) : self::TYPE_VAR;
+            if ($var->default) {
+                $this->assertExprCanBeUsedAsValue($var->default, 'static variable default value');
+            }
             $globalVar = $this->addStaticVar($var->var, $varName, $type);
 
             $list[] = self::TYPE_VAR . ' &' . $varName . ' = ' . $this->escapeGlobalVar($globalVar) . ';';
@@ -4350,6 +5278,7 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parseEval(Expr\Eval_ $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'eval operand');
         // 对 eval() 指令的 PHP 代码段禁止字面量优化
         $expr->expr->setAttribute('noLiteralString', true);
         return 'php::eval(' . $this->identifierToStr($expr->expr) . ')';
@@ -4357,6 +5286,7 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parseInclude(Expr\Include_ $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'include operand');
         switch ($expr->type) {
             case Expr\Include_::TYPE_INCLUDE:
                 $type = 'php::INCLUDE';
@@ -4467,11 +5397,19 @@ class CompilerBase extends \PhpAot\Core\Translator
      */
     protected function checkLeftValue(NodeAbstract $expr): void
     {
+        $this->assertNotNullsafeWriteContext($expr);
         if (!$this->isVarExpr($expr) && !$this->isArrayDimFetch($expr) && !$this->isPropertyFetch($expr) && !$this->isStaticPropertyFetch($expr)) {
             $this->fatalError($expr, 'The left value of assignment operation can only be variable, array item, object property, class static property');
         }
     }
 
+    protected function assertNotNullsafeWriteContext(NodeAbstract $expr): void
+    {
+        if ($expr instanceof Expr\NullsafePropertyFetch) {
+            $this->fatalError($expr, "Can't use nullsafe operator in write context");
+        }
+    }
+
     protected function getChainedFunc(string $op): string
     {
         return match ($op) {
@@ -4493,7 +5431,7 @@ class CompilerBase extends \PhpAot\Core\Translator
         // 单属性读取（非链式）
         if ($this->isPropertyFetch($expr) and $this->isVarExpr($expr->var) and $this->isIdExpr($expr->name)) {
             $prop = $this->parsePropertyFetch($expr);
-            if ($expr->hasAttribute('nativeProperty')) {
+            if ($this->isNativePropertyAccess($expr)) {
                 if ($op === self::OP_REFVAL) {
                     return $prop . '.toReference()';
                 }
@@ -4502,7 +5440,7 @@ class CompilerBase extends \PhpAot\Core\Translator
         }
         if ($this->isStaticPropertyFetch($expr) and $this->isNameExpr($expr->class) and $this->isIdExpr($expr->name)) {
             $prop = $this->parseStaticPropertyFetch($expr);
-            if ($expr->hasAttribute('nativeProperty')) {
+            if ($this->isNativePropertyAccess($expr)) {
                 if ($op === self::OP_REFVAL) {
                     return $prop . '.toReference()';
                 }
@@ -4550,6 +5488,7 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parseCastArray(Expr\Cast\Array_ $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'cast operand');
         return $this->convertArrayExpr($this->parseExpr($expr->expr));
     }
 
@@ -4570,6 +5509,7 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function parseCastDouble(mixed $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->expr, 'cast operand');
         return $this->convertFloatExpr($this->parseIdentifier($expr->expr));
     }
 
@@ -4577,9 +5517,7 @@ class CompilerBase extends \PhpAot\Core\Translator
     {
         if ($this->isInternalFunction($name)) {
             $returnType = Reflection::getFunctionReturnType($name);
-            // void 类型将被忽略，类型推测仅用于赋值操作的右值，即使返回值为 void , 赋值操作也应该继续运行，右值会被当做 null
-            // 例如 $a = var_dump('hello'); 虽然 var_dump 返回值为 void ，但是 $a 的类型是 mixed，值为 null
-            if ($returnType and $returnType !== 'void') {
+            if ($returnType) {
                 return $this->getTypeFromZendType($returnType);
             }
         }
@@ -4589,7 +5527,7 @@ class CompilerBase extends \PhpAot\Core\Translator
     protected function detectMethodCallReturnType(string $class, string $method): string
     {
         $returnType = Reflection::getMethodReturnType($class, $method);
-        if ($returnType and $returnType !== 'void') {
+        if ($returnType) {
             return $this->getTypeFromZendType($returnType);
         }
         return self::TYPE_VAR;
@@ -4672,6 +5610,9 @@ class CompilerBase extends \PhpAot\Core\Translator
                 if ($nativeFunc) {
                     $expr->setAttribute('nativeCall', $nativeFunc);
                     try {
+                        if ($this->shouldUseDynamicCallForNativeArgs($nativeFunc, $expr->args)) {
+                            return $this->genCallUserFuncArray($this->genArray([$object, $method]), $expr->args, $methodName, $class);
+                        }
                         return $this->parseNativeMethodCall($object, $nativeFunc, $expr->args);
                     } catch (PlaceHolder) {
                         return $this->genPlaceHolder($this->genArray([$object, $method]));
@@ -4725,9 +5666,12 @@ class CompilerBase extends \PhpAot\Core\Translator
         if (empty($expr->args)) {
             return $object . '.call(' . $methodPtr . ')';
         }
+        if ($this->hasNamedCallArg($expr->args)) {
+            return $this->genCallUserFuncArray($this->genArray([$object, $method]), $expr->args, $funcName, $class);
+        }
         try {
             $class = empty($class) ? self::DYNAMIC_CALLED_CLASS : $class;
-            return $object . '.call(' . $methodPtr . ', ' . $this->parseCallArgs($expr->args, $funcName, $class) . ')';
+            return $object . '.call(' . $methodPtr . ', ' . $this->parseCallArgs($expr->args, $funcName, $class, false) . ')';
         } catch (PlaceHolder) {
             return $this->genPlaceHolder($this->genArray([$object, $method]));
         }
@@ -4815,6 +5759,9 @@ class CompilerBase extends \PhpAot\Core\Translator
 
                 if ($nativeFunc) {
                     try {
+                        if ($this->shouldUseDynamicCallForNativeArgs($nativeFunc, $expr->args)) {
+                            return $this->genCallUserFuncArray($this->genArray($callScope), $expr->args, $method, $class);
+                        }
                         $args = $this->parseNativeCallArgs($expr->args, $nativeFunc);
                         $expr->setAttribute('nativeCall', $nativeFunc);
                     } catch (PlaceHolder) {
@@ -4850,6 +5797,9 @@ class CompilerBase extends \PhpAot\Core\Translator
         if (empty($expr->args)) {
             return $call . '(' . $fn . ')';
         }
+        if ($this->hasNamedCallArg($expr->args)) {
+            return $this->genCallUserFuncArray($placeHolder, $expr->args);
+        }
         try {
             $callArgs = $this->parseCallArgs($expr->args);
             return $call . '(' . $fn . ', ' . $callArgs . ')';
@@ -4879,93 +5829,63 @@ class CompilerBase extends \PhpAot\Core\Translator
             } else {
                 $class = $this->getNamespacedClassName($class);
             }
-            $nativeProperty = $this->findNativeProperty($expr, $propertyName, $class, true);
-            if ($nativeProperty) {
-                $expr->setAttribute('nativeProperty', $nativeProperty);
-                return $nativeProperty;
+            $result = $this->resolveNativeStaticProperty($expr, $propertyName, $class);
+            if ($result !== null) {
+                return $this->applyNativePropertyAccessResult($expr, $result);
             }
         }
         return null;
     }
 
+    private function createPropertyAccessResolver(): PropertyAccessResolver
+    {
+        $this->assertCompilerPhase(self::PHASE_CONVERT, 'PropertyAccessResolver');
+        return new PropertyAccessResolver(
+            fn(string $class): ?ClassDef => $this->classes[$this->escapeClass($class)] ?? null,
+            fn(string $class): string => $this->classExtends[strtolower(ltrim($class, '\\'))] ?? '',
+            fn(NodeAbstract $expr, string $message) => $this->fatalError($expr, $message),
+        );
+    }
+
     protected function isSameClassName(string $classA, string $classB): bool
     {
-        return strcasecmp(ltrim($classA, '\\'), ltrim($classB, '\\')) === 0;
+        return $this->createPropertyAccessResolver()->isSameClassName($classA, $classB);
     }
 
     protected function isSameOrSubclassOf(string $class, string $parent): bool
     {
-        $class = strtolower(ltrim($class, '\\'));
-        $parent = strtolower(ltrim($parent, '\\'));
-        while ($class !== '') {
-            if ($class === $parent) {
-                return true;
-            }
-            $class = $this->classExtends[$class] ?? '';
-        }
-        return false;
+        return $this->createPropertyAccessResolver()->isSameOrSubclassOf($class, $parent);
     }
 
     protected function canAccessProtectedProperty(string $scope, string $declaringClass): bool
     {
-        if ($scope === '') {
-            return false;
-        }
-        return $this->isSameOrSubclassOf($scope, $declaringClass)
-            || $this->isSameOrSubclassOf($declaringClass, $scope);
+        return $this->createPropertyAccessResolver()->canAccessProtectedProperty($scope, $declaringClass);
     }
 
-    /**
-     * @param NodeAbstract $expr 仅用于输出错误日志
-     * @param string $class 必须传入带有完整命名空间的类名
-     */
-    protected function findNativeProperty(NodeAbstract $expr, string $property, string $class, bool $static = false): ?string
+    private function resolveNativeInstanceProperty(NodeAbstract $expr, string $property, string $class): ?PropertyAccessResult
     {
-        $class = ltrim($class, '\\');
-        $findClass = $class;
         $scope = $this->class ? $this->getFullClassName() : '';
-        $propertyDef = null;
-        $classDef = null;
-        while (true) {
-            if ($this->hasClass($findClass)) {
-                $classDef = $this->getClass($findClass);
-                if ($classDef->hasProperty($property)) {
-                    $propertyDef = $classDef->getProperty($property);
-                    if (!$static and $propertyDef->isStatic()) {
-                        $this->fatalError($expr, "Cannot access static property `{$class}::\${$property}` as non-static instance property.");
-                    }
-                    if ($static and !$propertyDef->isStatic()) {
-                        $this->fatalError($expr, "Cannot access non-static property `{$class}::\${$property}` as static property.");
-                    }
-                    if ($propertyDef->isPublic()) {
-                        break;
-                    }
-                    if ($propertyDef->isProtected()) {
-                        if ($this->canAccessProtectedProperty($scope, $findClass)) {
-                            break;
-                        }
-                        $displayClass = ltrim($class, '\\');
-                        $this->fatalError($expr, "Cannot access protected property `{$property}` of class `{$displayClass}`");
-                    } else {
-                        if ($this->isSameClassName($scope, $findClass)) {
-                            break;
-                        }
-                        $displayClass = ltrim($class, '\\');
-                        $this->fatalError($expr, "Cannot access private property `{$property}` of class `{$displayClass}`");
-                    }
-                } elseif ($classDef->extends) {
-                    $findClass = $classDef->extends;
-                    continue;
-                }
-            }
-            break;
-        }
-        if ($propertyDef and $classDef) {
-            $expr->setAttribute('nativePropertyDef', $propertyDef);
-            $expr->setAttribute('nativeClassDef', $classDef);
-            return $this->getPropertyOffset($classDef->getNamespacedName(false), $property);
-        }
-        return null;
+        return $this->createPropertyAccessResolver()->resolveNativeInstanceProperty($expr, $property, $class, $scope);
+    }
+
+    private function resolveNativeStaticProperty(NodeAbstract $expr, string $property, string $class): ?PropertyAccessResult
+    {
+        $scope = $this->class ? $this->getFullClassName() : '';
+        return $this->createPropertyAccessResolver()->resolveNativeStaticProperty($expr, $property, $class, $scope);
+    }
+
+    private function applyNativePropertyAccessResult(NodeAbstract $expr, PropertyAccessResult $result): string
+    {
+        $offset = $this->getPropertyOffset($result->classDef->getNamespacedName(false), $result->property);
+        $expr->setAttribute('nativePropertyDef', $result->propertyDef);
+        $expr->setAttribute('nativeClassDef', $result->classDef);
+        $expr->setAttribute('nativeProperty', $offset);
+        return $offset;
+    }
+
+    protected function isNativePropertyAccess(NodeAbstract $expr): bool
+    {
+        return $expr->hasAttribute('nativeProperty');
     }
 
     protected function parseNativeStaticPropertyFetch(Expr\StaticPropertyFetch $expr): string|bool
@@ -5006,7 +5926,7 @@ class CompilerBase extends \PhpAot\Core\Translator
                 return $refVar;
             }
 
-            if ($expr->hasAttribute('nativeProperty')) {
+            if ($this->isNativePropertyAccess($expr)) {
                 $classPtr = $this->getClassEntryPtr($class);
                 return Symbol::getStaticProperty() . '(' . $classPtr . ', ' . $nativeProp . ')';
             } else {
@@ -5080,19 +6000,24 @@ class CompilerBase extends \PhpAot\Core\Translator
         if ($this->method === '__destruct') {
             $this->warning($expr, "Throwing exception in {$this->getFullClassName()}::__destruct() may cause memory leak");
         }
+        $type = $this->detectTypeOfExpr($expr->expr);
         if ($this->isNewExpr($expr->expr)) {
             $ex = $this->parseExpr($expr->expr);
+            return 'php::throwException(' . $ex . ')';
         } elseif ($this->isVarExpr($expr->expr)) {
             $ex = $this->parseIdentifier($expr->expr);
-            if ($this->getVarType($ex) != self::TYPE_OBJECT) {
-                goto _to_object;
+            if ($type == self::TYPE_OBJECT) {
+                return 'php::throwException(' . $ex . ')';
             }
         } else {
-            $ex = $this->parseIdentifier($expr->expr);
-            _to_object:
-            $ex = $this->convertObjectExpr($ex);
+            $ex = $this->parseExpr($expr->expr);
         }
-        return 'php::throwException(' . $ex . ')';
+        if ($type != self::TYPE_VAR) {
+            $this->fatalError($expr, 'Can only throw objects');
+        }
+        $tmp = $this->genTmpVarName();
+        $this->addLocalVar($tmp, self::TYPE_VAR);
+        return '([&]() -> php::Var { ' . $tmp . ' = ' . $ex . '; if (!' . $tmp . '.isObject()) { php::throwError("Can only throw objects"); } return php::throwException(php::Object(' . $tmp . ')); })()';
     }
 
     protected function parseTryCatch(mixed $v): string
@@ -5143,16 +6068,18 @@ class CompilerBase extends \PhpAot\Core\Translator
         $code .= $this->parseBeforeStmtLines() . PHP_EOL;
 
         $code .= $this->getIndent() . 'if (' . $var . ' && ';
+        $conditions = [];
         foreach ($types as $type) {
             if ($this->isNameExpr($type) or $this->isFullNameExpr($type)) {
                 $class = $this->getNamespacedClassName($this->parseIdentifier($type));
                 $ce = $this->getClassEntryPtr($class);
-                $code .= Symbol::instanceOf() . '(' . $var . ', ' . $ce . ')';
+                $conditions[] = Symbol::instanceOf() . '(' . $var . ', ' . $ce . ')';
             } else {
                 $this->fatalError($type, 'Unsupported catch type');
             }
         }
 
+        $code .= implode(' || ', $conditions);
         $code .= ') {' . PHP_EOL;
         $this->indentLevel++;
         $code .= $this->parseStmts($catch->stmts);
@@ -5416,7 +6343,10 @@ class CompilerBase extends \PhpAot\Core\Translator
             if (!$this->classDef) {
                 return false;
             }
-            return $this->isInheritedFrom($this->classDef->getNamespacedName(false), $classDef->getNamespacedName(false));
+            return $this->canAccessProtectedProperty(
+                $this->classDef->getNamespacedName(false),
+                $classDef->getNamespacedName(false)
+            );
         }
         // 类外部调用，只允许调用 public 方法
         return true;
@@ -5775,6 +6705,14 @@ class CompilerBase extends \PhpAot\Core\Translator
 
     protected function genReturnCode(): string
     {
+        if ($this->context->inClosure && $this->context->closureReturnTypeCheck) {
+            $tmpVar = $this->genTmpVarName();
+            $this->addLocalVar($tmpVar, self::TYPE_VAR);
+            $code = $tmpVar . ' = ' . self::VALUE_NULL . ';' . PHP_EOL;
+            $code .= $this->genClosureReturnCheck($tmpVar);
+            $code .= $this->getIndent() . 'return ' . $tmpVar . ';';
+            return $code;
+        }
         if ($this->functionDef->returnType === self::TYPE_VOID) {
             return '';
         }
@@ -5833,9 +6771,36 @@ class CompilerBase extends \PhpAot\Core\Translator
             if ($this->isCallExpr($expr->expr)) {
                 $nativeCall = $expr->expr->getAttribute('nativeCall');
                 if ($nativeCall and $this->getFunction($nativeCall)->returnType === self::TYPE_VOID) {
+                    if ($this->context->closureReturnTypeCheck) {
+                        $tmpVar = $this->genTmpVarName();
+                        $this->addLocalVar($tmpVar, self::TYPE_VAR);
+                        return $beforeCode . PHP_EOL . $code . ';' . PHP_EOL
+                            . $tmpVar . ' = ' . self::VALUE_NULL . ';' . PHP_EOL
+                            . $this->genClosureReturnCheck($tmpVar)
+                            . $this->getIndent() . 'return ' . $tmpVar . ';';
+                    }
                     return $beforeCode . PHP_EOL . $code . ';' . PHP_EOL . 'return ' . self::VALUE_NULL . ';';
                 }
             }
+            if ($this->detectTypeOfExpr($expr->expr) === self::TYPE_VOID) {
+                if ($this->context->closureReturnTypeCheck) {
+                    $tmpVar = $this->genTmpVarName();
+                    $this->addLocalVar($tmpVar, self::TYPE_VAR);
+                    return $beforeCode . PHP_EOL . $code . ';' . PHP_EOL
+                        . $tmpVar . ' = ' . self::VALUE_NULL . ';' . PHP_EOL
+                        . $this->genClosureReturnCheck($tmpVar)
+                        . $this->getIndent() . 'return ' . $tmpVar . ';';
+                }
+                return $beforeCode . PHP_EOL . $code . ';' . PHP_EOL . 'return ' . self::VALUE_NULL . ';';
+            }
+            if ($this->context->closureReturnTypeCheck) {
+                $tmpVar = $this->genTmpVarName();
+                $this->addLocalVar($tmpVar, self::TYPE_VAR);
+                return $beforeCode . PHP_EOL
+                    . $tmpVar . ' = ' . $code . ';' . PHP_EOL
+                    . $this->genClosureReturnCheck($tmpVar)
+                    . $this->getIndent() . 'return ' . $tmpVar . ';';
+            }
             return $beforeCode . PHP_EOL . 'return ' . $code . ';';
         };
 
@@ -5847,7 +6812,11 @@ class CompilerBase extends \PhpAot\Core\Translator
         $cb = function () use ($expr) {
             $fnCode = $this->parseStmts($expr->stmts);
             if (!$this->isReturnStmtInLastLine($expr->stmts)) {
-                $fnCode .= 'return ' . self::VALUE_NULL . ';' . PHP_EOL;
+                if ($this->context->closureReturnTypeCheck) {
+                    $fnCode .= $this->genReturnCode() . PHP_EOL;
+                } else {
+                    $fnCode .= 'return ' . self::VALUE_NULL . ';' . PHP_EOL;
+                }
             }
             return $fnCode;
         };
@@ -5879,7 +6848,7 @@ class CompilerBase extends \PhpAot\Core\Translator
 
         while (1) {
             if ($expr instanceof Expr\NullsafePropertyFetch) {
-                $list[] = ['property', $this->identifierToStr($expr->name, literal: true)];
+                $list[] = ['property', $this->identifierToStr($expr->name, literal: true), $expr];
                 $expr = $expr->var;
             } elseif ($expr instanceof Expr\NullsafeMethodCall) {
                 $list[] = ['method', $this->identifierToStr($expr->name, literal: true), $expr->args];
@@ -5902,6 +6871,7 @@ class CompilerBase extends \PhpAot\Core\Translator
         }
 
         $list = array_reverse($list);
+        $this->checkNullsafePropertyAccesses($expr, $list);
         $last = array_key_last($list);
         $tmpFn = $this->genTmpVarName();
 
@@ -5914,8 +6884,20 @@ class CompilerBase extends \PhpAot\Core\Translator
             if ($item[0] == 'property') {
                 $code .= $this->getIndent() . "{$tmpVar} = {$object}.attr({$item[1]}, {$update});";
             } else {
+                $beforeStmtCount = count($this->context->beforeStmtLines);
+                $afterStmtCount = count($this->context->afterStmtLines);
                 $args = $this->parseCallArgs($item[2]);
+                $argBeforeStmts = array_slice($this->context->beforeStmtLines, $beforeStmtCount);
+                $argAfterStmts = array_slice($this->context->afterStmtLines, $afterStmtCount);
+                $this->context->beforeStmtLines = array_slice($this->context->beforeStmtLines, 0, $beforeStmtCount);
+                $this->context->afterStmtLines = array_slice($this->context->afterStmtLines, 0, $afterStmtCount);
+                if ($argBeforeStmts) {
+                    $code .= $this->getIndent() . implode(PHP_EOL . $this->getIndent(), $argBeforeStmts) . PHP_EOL;
+                }
                 $code .= $this->getIndent() . "{$tmpVar} = {$object}.call({$item[1]}, {$args});";
+                if ($argAfterStmts) {
+                    $code .= $this->getIndent() . implode(PHP_EOL . $this->getIndent(), $argAfterStmts) . PHP_EOL;
+                }
             }
             $object = $tmpVar;
         }
@@ -5924,6 +6906,42 @@ class CompilerBase extends \PhpAot\Core\Translator
         return "{$tmpFn}()";
     }
 
+    private function checkNullsafePropertyAccesses(NodeAbstract $baseExpr, array $list): void
+    {
+        $properties = [];
+        foreach ($list as $item) {
+            if ($item[0] !== 'property') {
+                break;
+            }
+
+            /** @var Expr\NullsafePropertyFetch $node */
+            $node = $item[2];
+            if (!$this->isIdExpr($node->name)) {
+                break;
+            }
+
+            $properties[] = [
+                'node' => $node,
+                'property' => $this->parseIdentifier($node->name),
+            ];
+        }
+
+        if (!$properties) {
+            return;
+        }
+
+        $scope = $this->class ? $this->getFullClassName() : '';
+        $results = $this->createPropertyAccessResolver()->resolveNullsafePropertyChain(
+            $this->detectClassOfExpr($baseExpr),
+            $properties,
+            $scope,
+            self::TYPE_OBJECT,
+        );
+        foreach ($results as $index => $result) {
+            $this->applyNativePropertyAccessResult($properties[$index]['node'], $result);
+        }
+    }
+
     protected function parseFullyQualifiedName(Node\Name\FullyQualified $expr): string
     {
         return $expr->name;
@@ -5941,10 +6959,12 @@ class CompilerBase extends \PhpAot\Core\Translator
 
         $items = $node->items;
         foreach ($items as $item) {
+            $this->assertExprCanBeUsedAsValue($item->value, $item->unpack ? 'array unpack value' : 'array value');
             $value = $this->parseIdentifier($item->value);
             if ($item->unpack) {
                 $this->context->beforeStmtLines[] = $this->getIndent() . $tmpVar . '.merge(' . $value . ');';
             } elseif ($item->key) {
+                $this->assertExprCanBeUsedAsValue($item->key, 'array key');
                 $key = $this->parseArrayKey($item->key);
                 $this->context->beforeStmtLines[] = $this->getIndent() . $tmpVar . '.set(' . $key . ', ' . $value . ');';
             } else {
diff --git a/src/Php/Constants.php b/src/Php/Constants.php
index 5609f319..770a214e 100644
--- a/src/Php/Constants.php
+++ b/src/Php/Constants.php
@@ -11,53 +11,103 @@ namespace PhpAot\Php;
 class Constants
 {
     public const array CPP_RESERVED_NAMES = [
+        'alignas',
+        'alignof',
+        'and',
+        'and_eq',
+        'asm',
         'auto',
+        'bitand',
+        'bitor',
+        'bool',
         'break',
         'case',
         'catch',
+        'char',
+        'char8_t',
+        'char16_t',
+        'char32_t',
         'class',
-        'struct',
+        'compl',
         'const',
+        'consteval',
+        'constexpr',
+        'constinit',
+        'const_cast',
         'continue',
+        'decltype',
         'default',
+        'delete',
         'do',
+        'double',
+        'dynamic_cast',
         'else',
         'elseif',
         'enum',
+        'explicit',
+        'export',
         'extends',
+        'extern',
+        'false',
         'final',
         'finally',
+        'float',
         'for',
+        'friend',
         'function',
         'global',
+        'goto',
         'if',
-        'bool',
+        'inline',
         'int',
-        'short',
         'long',
-        'unsigned',
-        'void',
-        'signed',
-        'double',
-        'float',
-        'false',
-        'for',
-        'if',
-        'int',
+        'mutable',
+        'namespace',
         'new',
+        'noexcept',
+        'not',
+        'not_eq',
+        'nullptr',
         'null',
-        'var',
-        'char',
         'or',
-        'and',
+        'or_eq',
+        'operator',
         'private',
         'protected',
         'public',
+        'register',
+        'reinterpret_cast',
+        'requires',
         'return',
+        'short',
+        'signed',
+        'sizeof',
         'static',
-        'pipe',
+        'static_assert',
+        'static_cast',
+        'struct',
+        'switch',
         'template',
-        'namespace',
+        'this',
+        'thread_local',
+        'throw',
+        'true',
+        'try',
+        'typedef',
+        'typeid',
+        'typename',
+        'union',
+        'unsigned',
+        'using',
+        'var',
+        'virtual',
+        'void',
+        'volatile',
+        'wchar_t',
+        'while',
+        'xor',
+        'xor_eq',
+        'pipe',
         'errno', // Linux error code
         'this_', // phpx keywords
     ];
diff --git a/src/Php/Context/FunctionContext.php b/src/Php/Context/FunctionContext.php
index e344d411..6f3c145b 100644
--- a/src/Php/Context/FunctionContext.php
+++ b/src/Php/Context/FunctionContext.php
@@ -50,6 +50,8 @@ class FunctionContext
     public array $arguments = [];
     public bool $inLoop = false;
     public bool $inClosure = false;
+    public ?array $closureReturnTypeCheck = null;
+    public string $closureReturnTypeStr = '';
 
     /** True if any break N (N > 1) appears in this function. */
     public bool $hasMultiLevelBreak = false;
@@ -92,6 +94,8 @@ class FunctionContext
         $this->scopeLevel = 0;
         $this->inLoop = false;
         $this->inClosure = false;
+        $this->closureReturnTypeCheck = null;
+        $this->closureReturnTypeStr = '';
         $this->inAssignExpr = false;
     }
 
diff --git a/src/Php/Entity/ClassDef.php b/src/Php/Entity/ClassDef.php
index 96a13f5b..ae3703c5 100644
--- a/src/Php/Entity/ClassDef.php
+++ b/src/Php/Entity/ClassDef.php
@@ -48,11 +48,17 @@ class ClassDef extends ClassLikeDef
      * @var array<string, int>
      */
     public array $abstractMethods = [];
+
+    /**
+     * Abstract method name (lowercase) => method definition
+     * @var array<string, MethodDef>
+     */
+    public array $abstractMethodDefs = [];
     public ?Trait_ $trait = null;
 
     /**
-     * FullMethodName -> NewMethodName
-     * @var array<string, array>
+     * FullMethodName -> alias list
+     * @var array<string, array<int, array{newName: string, newModifier: int}>>
      */
     public array $traitAliases = [];
 
@@ -79,9 +85,13 @@ class ClassDef extends ClassLikeDef
         $this->methods[strtolower($method->name)] = $method;
     }
 
-    public function addAbstractMethod(string $name, int $flags): void
+    public function addAbstractMethod(string $name, int $flags, ?MethodDef $methodDef = null): void
     {
-        $this->abstractMethods[strtolower($name)] = $flags;
+        $lower = strtolower($name);
+        $this->abstractMethods[$lower] = $flags;
+        if ($methodDef !== null) {
+            $this->abstractMethodDefs[$lower] = $methodDef;
+        }
     }
 
     public function hasMethod(string $method): bool
@@ -126,6 +136,11 @@ class ClassDef extends ClassLikeDef
         return $this->methods[strtolower($method)];
     }
 
+    public function getAbstractMethod($method): MethodDef
+    {
+        return $this->abstractMethodDefs[strtolower($method)];
+    }
+
     public function getConstant($name): ConstantDef
     {
         return $this->constants[$name];
diff --git a/src/Php/Entity/InterfaceDef.php b/src/Php/Entity/InterfaceDef.php
index 019b4e9f..a5fef3f2 100644
--- a/src/Php/Entity/InterfaceDef.php
+++ b/src/Php/Entity/InterfaceDef.php
@@ -10,8 +10,38 @@ namespace PhpAot\Php\Entity;
 
 class InterfaceDef extends ClassLikeDef
 {
+    /**
+     * @var array<string, MethodDef>
+     */
+    public array $methods = [];
+
+    /**
+     * @var array<string, ConstantDef>
+     */
+    public array $constants = [];
+
+    /**
+     * @var string[]
+     */
+    public array $extendsList = [];
+
     public function __construct(string $name, string $namespace = '')
     {
         parent::__construct($name, $namespace);
     }
+
+    public function addMethod(MethodDef $method): void
+    {
+        $this->methods[strtolower($method->name)] = $method;
+    }
+
+    public function hasMethod(string $method): bool
+    {
+        return isset($this->methods[strtolower($method)]);
+    }
+
+    public function hasConstant(string $name): bool
+    {
+        return isset($this->constants[$name]);
+    }
 }
diff --git a/src/Php/Entity/PropertyDef.php b/src/Php/Entity/PropertyDef.php
index 7448d4f6..69c569b6 100644
--- a/src/Php/Entity/PropertyDef.php
+++ b/src/Php/Entity/PropertyDef.php
@@ -19,6 +19,8 @@ class PropertyDef
     public ?ArrayInitPlan $arrayInitPlan = null;
     public bool $nullable = false;
     public string $class = '';
+    public array $typeCheck = [];
+    public string $typeStr = '';
 
     public function __construct(string $name, int $flags, string $type, ?string $default = null, bool $nullable = false)
     {
diff --git a/src/Php/Generator/ClosureGenerator.php b/src/Php/Generator/ClosureGenerator.php
index 06193d73..60c4cc3f 100644
--- a/src/Php/Generator/ClosureGenerator.php
+++ b/src/Php/Generator/ClosureGenerator.php
@@ -8,7 +8,12 @@
 
 namespace PhpAot\Php\Generator;
 
+use PhpAot\Php\ArgInfo;
 use PhpAot\Php\Context\FunctionContext;
+use PhpParser\Node;
+use PhpParser\Node\IntersectionType;
+use PhpParser\Node\NullableType;
+use PhpParser\Node\UnionType;
 use PhpParser\NodeAbstract;
 
 trait ClosureGenerator
@@ -36,15 +41,59 @@ trait ClosureGenerator
         $this->context = new FunctionContext();
 
         $this->context->inClosure = true;
+        if ($expr->returnType instanceof NullableType || $expr->returnType instanceof UnionType || $expr->returnType instanceof IntersectionType) {
+            $returnTypeInfo = $this->buildTypeCheckFromNode($expr->returnType);
+            if (!empty($returnTypeInfo['check'])) {
+                $this->context->closureReturnTypeCheck = $returnTypeInfo['check'];
+                $this->context->closureReturnTypeStr = $returnTypeInfo['typeStr'];
+            }
+        }
         $this->indentLevel++;
 
+        $requiredArgCount = 0;
+        foreach ($params as $param) {
+            if ($param->variadic || $param->default !== null) {
+                break;
+            }
+            $requiredArgCount++;
+        }
+        if ($requiredArgCount > 0) {
+            $expected = $requiredArgCount === count($params) ? 'exactly' : 'at least';
+            $message = 'php::concat({'
+                . 'php::Str(' . $this->genCharPtr('Too few arguments to function {closure}(), ', true) . '), '
+                . 'php::toString(php::getCallArgNum()), '
+                . 'php::Str(' . $this->genCharPtr(' passed and ' . $expected . ' ' . $requiredArgCount . ' expected', true) . ')'
+                . '})';
+            $code .= $this->getIndent() . 'if (UNEXPECTED(php::getCallArgNum() < ' . $requiredArgCount . ')) {' . PHP_EOL;
+            $this->indentLevel++;
+            $code .= $this->getIndent() . 'return php::throwException(zend_ce_argument_count_error, (' . $message . ').toCString());' . PHP_EOL;
+            $this->indentLevel--;
+            $code .= $this->getIndent() . '}' . PHP_EOL;
+        }
+
         foreach ($params as $i => $param) {
             if ($param->byRef) {
                 $this->fatalError($expr, 'Closure cannot use reference parameter');
             }
             $var = $this->parseIdentifier($param->var);
-            $code .= 'auto ' . $var . ' = php::getCallArg(' . $i . ');' . PHP_EOL;
+            $phpName = is_string($param->var->name) ? $param->var->name : $this->unescapeVarName($var);
+            if ($param->variadic) {
+                $code .= $this->getIndent() . self::TYPE_ARRAY . ' ' . $var . ';' . PHP_EOL;
+                $code .= $this->getIndent() . 'for (uint32_t i = ' . $i . '; i < php::getCallArgNum(); i++) {' . PHP_EOL;
+                $this->indentLevel++;
+                $code .= $this->getIndent() . $var . '.append(php::getCallArg(i));' . PHP_EOL;
+                $this->indentLevel--;
+                $code .= $this->getIndent() . '}' . PHP_EOL;
+                $this->addArgument($var, self::TYPE_ARRAY);
+                $code .= $this->genClosureParamTypeCheck($param, $var, $phpName, $i, true);
+                continue;
+            }
+            $argExpr = $param->default === null
+                ? 'php::getCallArg(' . $i . ')'
+                : 'php::getCallArg(' . $i . ', ' . $this->parseParamDefaultValue($param->default) . ')';
+            $code .= $this->getIndent() . 'auto ' . $var . ' = ' . $argExpr . ';' . PHP_EOL;
             $this->addArgument($var, self::TYPE_VAR);
+            $code .= $this->genClosureParamTypeCheck($param, $var, $phpName, $i, false);
         }
 
         foreach ($uses as $i => $useItem) {
@@ -116,4 +165,27 @@ trait ClosureGenerator
 
         return $code;
     }
+
+    private function genClosureParamTypeCheck(Node\Param $param, string $var, string $phpName, int $index, bool $variadic): string
+    {
+        if (!$param->type instanceof NullableType && !$param->type instanceof UnionType && !$param->type instanceof IntersectionType) {
+            return '';
+        }
+
+        $typeInfo = $this->buildTypeCheckFromNode($param->type);
+        if (empty($typeInfo['check'])) {
+            return '';
+        }
+
+        $argInfo = new ArgInfo();
+        $argInfo->name = $var;
+        $argInfo->phpName = $phpName;
+        $argInfo->type = self::TYPE_VAR;
+        $argInfo->variadic = $variadic;
+        $argInfo->typeCheck = $typeInfo['check'];
+        $argInfo->typeStr = $typeInfo['typeStr'];
+        $argInfo->typeNode = $param->type;
+
+        return $this->genClosureParamCheck($argInfo, $index);
+    }
 }
diff --git a/src/Php/Generator/PropertyPromotion.php b/src/Php/Generator/PropertyPromotion.php
index 1ef954de..edea815e 100644
--- a/src/Php/Generator/PropertyPromotion.php
+++ b/src/Php/Generator/PropertyPromotion.php
@@ -15,7 +15,8 @@ trait PropertyPromotion
     protected function genPropertyPromotion(ArgInfo $argInfo): string
     {
         $code = '';
-        $code .= 'this_.setProperty(' . $this->genCharPtr($argInfo->name) . ', ' . $argInfo->name . ')';
+        $propertyName = $argInfo->phpName ?: $this->unescapeVarName($argInfo->name);
+        $code .= 'this_.setProperty(' . $this->genCharPtr($propertyName) . ', ' . $argInfo->name . ')';
         $code .= ";\n";
         return $code;
     }
diff --git a/src/Php/Generator/TypeCheckGenerator.php b/src/Php/Generator/TypeCheckGenerator.php
index ce7ac739..c0ee0699 100644
--- a/src/Php/Generator/TypeCheckGenerator.php
+++ b/src/Php/Generator/TypeCheckGenerator.php
@@ -10,6 +10,7 @@ namespace PhpAot\Php\Generator;
 
 use PhpAot\Php\ArgInfo;
 use PhpParser\Node;
+use PhpParser\Node\IntersectionType;
 use PhpParser\Node\NullableType;
 use PhpParser\Node\UnionType;
 use PhpParser\NodeAbstract;
@@ -19,81 +20,127 @@ trait TypeCheckGenerator
     protected function buildTypeCheckFromNode(NodeAbstract $typeNode): array
     {
         $check = [];
-        $names = [];
+        $typeStr = $this->typeCheckNodeToString($typeNode);
 
         if ($typeNode instanceof NullableType) {
-            $subTypes = [$typeNode->type];
-            $isNullable = true;
+            $check[] = ['kind' => 'isNull'];
+            $innerClause = $this->buildTypeCheckClause($typeNode->type);
+            if (!empty($innerClause)) {
+                $check[] = count($innerClause) === 1 ? $innerClause[0] : ['kind' => 'allOf', 'types' => $innerClause];
+            }
         } elseif ($typeNode instanceof UnionType) {
-            $subTypes = $typeNode->types;
-            $isNullable = false;
+            foreach ($typeNode->types as $subType) {
+                $clause = $this->buildTypeCheckClause($subType);
+                if (empty($clause)) {
+                    continue;
+                }
+                $check[] = count($clause) === 1 ? $clause[0] : ['kind' => 'allOf', 'types' => $clause];
+            }
+        } elseif ($typeNode instanceof IntersectionType) {
+            foreach ($typeNode->types as $subType) {
+                $nameLower = strtolower($this->parseIdentifier($subType));
+                if ($nameLower === 'self' || $nameLower === 'parent' || $nameLower === 'static') {
+                    $this->fatalError($subType, "Type '{$nameLower}' cannot be part of an intersection type");
+                }
+            }
+            $clause = $this->buildTypeCheckClause($typeNode);
+            if (!empty($clause)) {
+                $check[] = count($clause) === 1 ? $clause[0] : ['kind' => 'allOf', 'types' => $clause];
+            }
         } else {
             return ['check' => [], 'typeStr' => ''];
         }
 
-        foreach ($subTypes as $subType) {
-            $name = $this->parseIdentifier($subType);
-            $nameLower = strtolower($name);
-
-            if ($nameLower === 'void' or $nameLower === 'never') {
-                $this->fatalError($subType, "Type '{$nameLower}' cannot be part of a union type");
-            }
+        if (empty($check)) {
+            return ['check' => [], 'typeStr' => $typeStr];
+        }
 
-            if ($nameLower === 'mixed') {
-                // mixed accepts everything — don't add any check
-                $names[] = $name;
-                continue;
-            }
+        return ['check' => $check, 'typeStr' => $typeStr];
+    }
 
-            $entry = match ($nameLower) {
-                'int' => ['kind' => 'isInt'],
-                'float', 'double' => ['kind' => 'isFloat'],
-                'bool' => ['kind' => 'isBool'],
-                'string' => ['kind' => 'isString'],
-                'array' => ['kind' => 'isArray'],
-                'object' => ['kind' => 'isObject'],
-                'null' => ['kind' => 'isNull'],
-                'true' => ['kind' => 'isTrue'],
-                'false' => ['kind' => 'isFalse'],
-                'resource' => ['kind' => 'isResource'],
-                'callable' => ['kind' => 'callable'],
-                'iterable' => ['kind' => 'iterable'],
-                default => null,
-            };
-
-            if ($entry !== null) {
-                $check[] = $entry;
-            } else {
-                // Class/interface type
-                if ($name === 'self') {
-                    $class = $this->getFullClassName();
-                } elseif ($name === 'parent') {
-                    $class = $this->classDef->extends ?? '';
-                } elseif ($name === 'static') {
-                    $class = 'static';
-                } else {
-                    $class = $this->getNamespacedClassName($name);
-                }
-                if ($class) {
-                    $check[] = ['kind' => 'instanceof', 'class' => $class];
+    private function buildTypeCheckClause(NodeAbstract $typeNode): array
+    {
+        if ($typeNode instanceof IntersectionType) {
+            $clause = [];
+            foreach ($typeNode->types as $subType) {
+                foreach ($this->buildTypeCheckClause($subType) as $entry) {
+                    $clause[] = $entry;
                 }
             }
-            $names[] = $name;
+            return $clause;
         }
 
-        if ($isNullable) {
-            // NullableType: prepend null to both check array and typeStr
-            array_unshift($check, ['kind' => 'isNull']);
-            $typeStr = '?' . implode('|', $names);
+        $name = $this->parseIdentifier($typeNode);
+        $nameLower = strtolower($name);
+
+        if ($nameLower === 'void' || $nameLower === 'never') {
+            $this->fatalError($typeNode, "Type '{$nameLower}' cannot be part of a composite type");
+        }
+
+        if ($nameLower === 'mixed') {
+            return [];
+        }
+
+        $entry = match ($nameLower) {
+            'int' => ['kind' => 'isInt'],
+            'float', 'double' => ['kind' => 'isFloat'],
+            'bool' => ['kind' => 'isBool'],
+            'string' => ['kind' => 'isString'],
+            'array' => ['kind' => 'isArray'],
+            'object' => ['kind' => 'isObject'],
+            'null' => ['kind' => 'isNull'],
+            'true' => ['kind' => 'isTrue'],
+            'false' => ['kind' => 'isFalse'],
+            'resource' => ['kind' => 'isResource'],
+            'callable' => ['kind' => 'callable'],
+            'iterable' => ['kind' => 'iterable'],
+            default => null,
+        };
+
+        if ($entry !== null) {
+            return [$entry];
+        }
+
+        if ($name === 'self') {
+            $class = $this->getFullClassName();
+        } elseif ($name === 'parent') {
+            $class = $this->classDef->extends ?? '';
+        } elseif ($name === 'static') {
+            $class = 'static';
         } else {
-            $typeStr = implode('|', $names);
+            $class = $this->getNamespacedClassName($name);
         }
 
-        if (empty($check)) {
-            return ['check' => [], 'typeStr' => $typeStr];
+        return $class ? [['kind' => 'instanceof', 'class' => $class]] : [];
+    }
+
+    private function typeCheckNodeToString(NodeAbstract $typeNode): string
+    {
+        if ($typeNode instanceof Node\Identifier) {
+            return $typeNode->name;
+        }
+        if ($typeNode instanceof Node\Name) {
+            return $typeNode->toString();
+        }
+        if ($typeNode instanceof NullableType) {
+            return '?' . $this->typeCheckNodeToString($typeNode->type);
+        }
+        if ($typeNode instanceof UnionType) {
+            $parts = [];
+            foreach ($typeNode->types as $type) {
+                $parts[] = $this->typeCheckNodeToString($type);
+            }
+            return implode('|', $parts);
+        }
+        if ($typeNode instanceof IntersectionType) {
+            $parts = [];
+            foreach ($typeNode->types as $type) {
+                $parts[] = $this->typeCheckNodeToString($type);
+            }
+            return implode('&', $parts);
         }
 
-        return ['check' => $check, 'typeStr' => $typeStr];
+        return $this->printer->prettyPrint([$typeNode]);
     }
 
     protected function genSingleTypeCondition(string $varName, array $entry): string
@@ -112,6 +159,7 @@ trait TypeCheckGenerator
             'isResource' => $v . '.isResource()',
             'callable' => $v . '.isCallable()',
             'iterable' => '(' . $v . '.isArray() || (' . $v . '.isObject() && php::instanceOf(' . $v . ', zend_ce_traversable)))',
+            'allOf' => $this->genAllOfTypeCondition($varName, $entry['types']),
             'instanceof' => $entry['class'] === 'static'
                 ? '(' . $v . '.isObject() && php::instanceOf(' . $v . ', php_get_called_ce(this_)))'
                 : '(' . $v . '.isObject() && php::instanceOf(' . $v . ', ' . $this->getClassEntryPtr($entry['class']) . '))',
@@ -119,6 +167,32 @@ trait TypeCheckGenerator
         };
     }
 
+    private function genAllOfTypeCondition(string $varName, array $types): string
+    {
+        $conditions = [];
+        foreach ($types as $type) {
+            $cond = $this->genSingleTypeCondition($varName, $type);
+            if ($cond !== '') {
+                $conditions[] = $cond;
+            }
+        }
+
+        if (empty($conditions)) {
+            return '';
+        }
+
+        return '(' . implode(' && ', $conditions) . ')';
+    }
+
+    protected function getTypeCheckCallableName(): string
+    {
+        if ($this->classDef) {
+            return $this->classDef->getNamespacedName(false) . '::' . $this->functionDef->name;
+        }
+
+        return $this->functionDef->getNamespacedName();
+    }
+
     protected function genUnionParamCheck(ArgInfo $argInfo, int $argIndex): string
     {
         if (empty($argInfo->typeCheck)) {
@@ -190,11 +264,12 @@ trait TypeCheckGenerator
 
     protected function genUnionParamTypeErrorExpr(ArgInfo $argInfo, string $valueExpr, string $argNoExpr): string
     {
-        $fnName = $this->functionDef->getNamespacedName();
+        $fnName = $this->getTypeCheckCallableName();
+        $paramName = $argInfo->phpName ?: $this->unescapeVarName($argInfo->name);
         return 'php::concat({'
             . 'php::Str(' . $this->genCharPtr($fnName . '(): Argument #', true) . '), '
             . 'php::toString(' . $argNoExpr . '), '
-            . 'php::Str(' . $this->genCharPtr(' ($' . $argInfo->name . ') must be of type ', true) . '), '
+            . 'php::Str(' . $this->genCharPtr(' ($' . $paramName . ') must be of type ', true) . '), '
             . 'php::Str(' . $this->genCharPtr($argInfo->typeStr, true) . '), '
             . 'php::Str(", "), '
             . $valueExpr . '.typeStr(), '
@@ -221,7 +296,7 @@ trait TypeCheckGenerator
         }
 
         $orExpr = implode(' || ', $conditions);
-        $fnName = $this->functionDef->getNamespacedName();
+        $fnName = $this->getTypeCheckCallableName();
         $typeStr = $this->functionDef->returnTypeStr;
 
         $msgExpr = 'php::concat(php::concat(php::Str(' . $this->genCharPtr($fnName, true) . ' "(): Return value must be of type " '
@@ -236,4 +311,118 @@ trait TypeCheckGenerator
         return $code;
     }
 
+    protected function genClosureParamCheck(ArgInfo $argInfo, int $argIndex): string
+    {
+        if (empty($argInfo->typeCheck)) {
+            return '';
+        }
+
+        if ($argInfo->variadic) {
+            return $this->genClosureVariadicParamCheck($argInfo, $argIndex);
+        }
+
+        $conditions = [];
+        foreach ($argInfo->typeCheck as $entry) {
+            $cond = $this->genSingleTypeCondition($argInfo->name, $entry);
+            if ($cond !== '') {
+                $conditions[] = $cond;
+            }
+        }
+        if (empty($conditions)) {
+            return '';
+        }
+
+        $orExpr = implode(' || ', $conditions);
+        $msgExpr = $this->genClosureParamTypeErrorExpr($argInfo, $argInfo->name, (string) ($argIndex + 1));
+
+        $code = $this->getIndent() . 'if (UNEXPECTED(!(' . $orExpr . '))) {' . PHP_EOL;
+        $this->indentLevel++;
+        $code .= $this->getIndent() . 'return php::throwException(zend_ce_type_error, (' . $msgExpr . ').toCString());' . PHP_EOL;
+        $this->indentLevel--;
+        $code .= $this->getIndent() . '}' . PHP_EOL;
+
+        return $code;
+    }
+
+    protected function genClosureVariadicParamCheck(ArgInfo $argInfo, int $argIndex): string
+    {
+        $valueVar = $this->genTmpVarName();
+        $iterVar = $this->genTmpVarName();
+        $argNoVar = $this->genTmpVarName();
+
+        $conditions = [];
+        foreach ($argInfo->typeCheck as $entry) {
+            $cond = $this->genSingleTypeCondition($valueVar, $entry);
+            if ($cond !== '') {
+                $conditions[] = $cond;
+            }
+        }
+        if (empty($conditions)) {
+            return '';
+        }
+
+        $orExpr = implode(' || ', $conditions);
+        $msgExpr = $this->genClosureParamTypeErrorExpr($argInfo, $valueVar, $argNoVar);
+
+        $code = $this->getIndent() . 'for (auto ' . $iterVar . ' = ' . $argInfo->name . '.begin(); ' . $iterVar . ' != ' . $argInfo->name . '.end(); ++' . $iterVar . ') {' . PHP_EOL;
+        $this->indentLevel++;
+        $code .= $this->getIndent() . self::TYPE_VAR . ' ' . $valueVar . ' = ' . $iterVar . '.value();' . PHP_EOL;
+        $code .= $this->getIndent() . self::TYPE_INT . ' ' . $argNoVar . ' = ' . ($argIndex + 1) . ' + ' . $iterVar . '.index();' . PHP_EOL;
+        $code .= $this->getIndent() . 'if (UNEXPECTED(!(' . $orExpr . '))) {' . PHP_EOL;
+        $this->indentLevel++;
+        $code .= $this->getIndent() . 'return php::throwException(zend_ce_type_error, (' . $msgExpr . ').toCString());' . PHP_EOL;
+        $this->indentLevel--;
+        $code .= $this->getIndent() . '}' . PHP_EOL;
+        $this->indentLevel--;
+        $code .= $this->getIndent() . '}' . PHP_EOL;
+
+        return $code;
+    }
+
+    protected function genClosureParamTypeErrorExpr(ArgInfo $argInfo, string $valueExpr, string $argNoExpr): string
+    {
+        $paramName = $argInfo->phpName ?: $this->unescapeVarName($argInfo->name);
+        return 'php::concat({'
+            . 'php::Str(' . $this->genCharPtr('{closure}(): Argument #', true) . '), '
+            . 'php::toString(' . $argNoExpr . '), '
+            . 'php::Str(' . $this->genCharPtr(' ($' . $paramName . ') must be of type ', true) . '), '
+            . 'php::Str(' . $this->genCharPtr($argInfo->typeStr, true) . '), '
+            . 'php::Str(", "), '
+            . $valueExpr . '.typeStr(), '
+            . 'php::Str(" given")'
+            . '})';
+    }
+
+    protected function genClosureReturnCheck(string $varName): string
+    {
+        $typeCheck = $this->context->closureReturnTypeCheck;
+        if (empty($typeCheck)) {
+            return '';
+        }
+
+        $conditions = [];
+        foreach ($typeCheck as $entry) {
+            $cond = $this->genSingleTypeCondition($varName, $entry);
+            if ($cond !== '') {
+                $conditions[] = $cond;
+            }
+        }
+        if (empty($conditions)) {
+            return '';
+        }
+
+        $orExpr = implode(' || ', $conditions);
+        $typeStr = $this->context->closureReturnTypeStr;
+        $msgExpr = 'php::concat(php::concat(php::Str(' . $this->genCharPtr('{closure}', true) . ' "(): Return value must be of type " '
+                 . $this->genCharPtr($typeStr, true) . ' ", "), ' . $varName . '.typeStr()), php::Str(" given"))';
+
+        $code = $this->getIndent() . 'if (UNEXPECTED(!(' . $orExpr . '))) {' . PHP_EOL;
+        $this->indentLevel++;
+        $code .= $this->getIndent() . 'return php::throwException(zend_ce_type_error, (' . $msgExpr . ').toCString());' . PHP_EOL;
+        $this->indentLevel--;
+        $code .= $this->getIndent() . '}' . PHP_EOL;
+
+        return $code;
+    }
+
 }
diff --git a/src/Php/Generator/Utils.php b/src/Php/Generator/Utils.php
index 284bcf8f..85fd3fa7 100644
--- a/src/Php/Generator/Utils.php
+++ b/src/Php/Generator/Utils.php
@@ -62,12 +62,12 @@ trait Utils
 
     protected function escapeVarName(string $name): string
     {
-        if (in_array($name, Constants::CPP_RESERVED_NAMES)) {
-            return '_php__var__' . $name;
-        }
         if ($name === 'this') {
             return 'this_';
         }
+        if (in_array($name, Constants::CPP_RESERVED_NAMES, true)) {
+            return '_php__var__' . $name;
+        }
         return $name;
     }
 
diff --git a/src/Php/MagicMethodDetector.php b/src/Php/MagicMethodDetector.php
index f7f8b2d6..469fc69a 100644
--- a/src/Php/MagicMethodDetector.php
+++ b/src/Php/MagicMethodDetector.php
@@ -20,130 +20,182 @@ trait MagicMethodDetector
         $returnTypeUndeclared = $fnDef->returnTypeUndeclared;
 
         $nameLower = strtolower($name);
+        $methodName = $this->class . "::{$name}";
+        $isStatic = (bool) ($methodDef->flags & \PhpParser\Modifiers::STATIC);
+
+        $mustBeStatic = ['__callstatic' => true, '__set_state' => true];
+        $mustNotBeStatic = [
+            '__construct' => true,
+            '__destruct' => true,
+            '__clone' => true,
+            '__call' => true,
+            '__get' => true,
+            '__set' => true,
+            '__isset' => true,
+            '__unset' => true,
+            '__sleep' => true,
+            '__wakeup' => true,
+            '__serialize' => true,
+            '__unserialize' => true,
+            '__debuginfo' => true,
+            '__tostring' => true,
+            '__invoke' => true,
+        ];
+        if (isset($mustBeStatic[$nameLower]) && !$isStatic) {
+            $this->fatalError($v, 'Method ' . $methodName . '() must be static');
+        }
+        if (isset($mustNotBeStatic[$nameLower]) && $isStatic) {
+            $this->fatalError($v, 'Method ' . $methodName . '() cannot be static');
+        }
+
+        $mustBePublic = [
+            '__call' => true,
+            '__callstatic' => true,
+            '__get' => true,
+            '__set' => true,
+            '__isset' => true,
+            '__unset' => true,
+            '__sleep' => true,
+            '__wakeup' => true,
+            '__serialize' => true,
+            '__unserialize' => true,
+            '__debuginfo' => true,
+            '__tostring' => true,
+            '__invoke' => true,
+            '__set_state' => true,
+        ];
+        if (isset($mustBePublic[$nameLower]) && !($methodDef->flags & \PhpParser\Modifiers::PUBLIC)) {
+            $this->fatalError($v, 'Method ' . $methodName . '() must have public visibility');
+        }
+
+        $exactArgCount = [
+            '__destruct' => 0,
+            '__clone' => 0,
+            '__tostring' => 0,
+            '__sleep' => 0,
+            '__wakeup' => 0,
+            '__serialize' => 0,
+            '__debuginfo' => 0,
+            '__call' => 2,
+            '__callstatic' => 2,
+            '__set' => 2,
+            '__get' => 1,
+            '__isset' => 1,
+            '__unset' => 1,
+            '__set_state' => 1,
+            '__unserialize' => 1,
+        ];
+        if (array_key_exists($nameLower, $exactArgCount) && count($argInfoList) !== $exactArgCount[$nameLower]) {
+            $this->fatalError($v, 'Method ' . $methodName . '() must take exactly ' . $exactArgCount[$nameLower] . ' arguments');
+        }
 
         if ($nameLower == '__call' or $nameLower == '__callstatic') {
-            if (count($argInfoList) != 2) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take exactly 2 arguments");
-            }
             if ($argInfoList[0]->undeclared) {
                 $argInfoList[0]->type = self::TYPE_STR;
             } elseif ($argInfoList[0]->type !== self::TYPE_STR) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take string as first argument");
+                $this->fatalError($v, 'Method ' . $methodName . '() must take string as first argument');
             }
             if ($argInfoList[1]->undeclared) {
                 $argInfoList[1]->type = self::TYPE_ARRAY;
             } elseif ($argInfoList[1]->type !== self::TYPE_ARRAY) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take array as second argument");
+                $this->fatalError($v, 'Method ' . $methodName . '() must take array as second argument');
             }
         } elseif ($nameLower == '__set') {
-            if (count($argInfoList) != 2) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take exactly 2 arguments");
-            }
             if ($argInfoList[0]->undeclared) {
                 $argInfoList[0]->type = self::TYPE_STR;
             } elseif ($argInfoList[0]->type !== self::TYPE_STR) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take string as first argument");
+                $this->fatalError($v, 'Method ' . $methodName . '() must take string as first argument');
             }
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_VOID;
             } elseif ($fnDef->returnType !== self::TYPE_VOID) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return void");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return void');
             }
         } elseif ($nameLower == '__get') {
-            if (count($argInfoList) != 1) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take exactly 1 argument");
+            if ($argInfoList[0]->undeclared) {
+                $argInfoList[0]->type = self::TYPE_STR;
+            } elseif ($argInfoList[0]->type !== self::TYPE_STR) {
+                $this->fatalError($v, 'Method ' . $methodName . '() must take string as argument');
             }
         } elseif ($nameLower == '__tostring') {
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_STR;
             } elseif ($fnDef->returnType !== self::TYPE_STR) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return string");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return string');
             }
         } elseif ($nameLower == '__serialize') {
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_ARRAY;
             } elseif ($fnDef->returnType !== self::TYPE_ARRAY) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return array");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return array');
             }
         } elseif ($nameLower == '__unserialize') {
-            if (count($argInfoList) != 1) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take exactly 1 argument");
-            }
             if ($argInfoList[0]->undeclared) {
                 $argInfoList[0]->type = self::TYPE_ARRAY;
             } elseif ($argInfoList[0]->type !== self::TYPE_ARRAY) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take array as argument");
+                $this->fatalError($v, 'Method ' . $methodName . '() must take array as argument');
             }
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_VOID;
             } elseif ($fnDef->returnType !== self::TYPE_VOID) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return void");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return void');
             }
         } elseif ($nameLower == '__isset') {
-            if (count($argInfoList) != 1) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take exactly 1 argument");
-            }
             if ($argInfoList[0]->undeclared) {
                 $argInfoList[0]->type = self::TYPE_STR;
             } elseif ($argInfoList[0]->type !== self::TYPE_STR) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take string as argument");
+                $this->fatalError($v, 'Method ' . $methodName . '() must take string as argument');
             }
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_BOOL;
             } elseif ($fnDef->returnType !== self::TYPE_BOOL) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return bool");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return bool');
             }
         } elseif ($nameLower == '__unset') {
-            if (count($argInfoList) != 1) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take exactly 1 argument");
-            }
             if ($argInfoList[0]->undeclared) {
                 $argInfoList[0]->type = self::TYPE_STR;
             } elseif ($argInfoList[0]->type !== self::TYPE_STR) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take string as argument");
+                $this->fatalError($v, 'Method ' . $methodName . '() must take string as argument');
             }
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_VOID;
             } elseif ($fnDef->returnType !== self::TYPE_VOID) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return void");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return void');
             }
         } elseif ($nameLower == '__set_state') {
-            if (count($argInfoList) != 1) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take exactly 1 argument");
-            }
             if ($argInfoList[0]->undeclared) {
                 $argInfoList[0]->type = self::TYPE_ARRAY;
             } elseif ($argInfoList[0]->type !== self::TYPE_ARRAY) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must take array as argument");
+                $this->fatalError($v, 'Method ' . $methodName . '() must take array as argument');
             }
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_OBJECT;
             } elseif ($fnDef->returnType !== self::TYPE_OBJECT) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return object");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return object');
             }
         } elseif ($nameLower == '__debuginfo') {
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_ARRAY;
             } elseif ($fnDef->returnType !== self::TYPE_ARRAY) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return array");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return array');
             }
         } elseif ($nameLower == '__sleep') {
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_ARRAY;
             } elseif ($fnDef->returnType !== self::TYPE_ARRAY) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return array");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return array');
             }
         } elseif ($nameLower == '__wakeup') {
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_VOID;
             } elseif ($fnDef->returnType !== self::TYPE_VOID) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return void");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return void');
             }
         } elseif ($nameLower == '__clone') {
             if ($returnTypeUndeclared) {
                 $fnDef->returnType = self::TYPE_VOID;
             } elseif ($fnDef->returnType !== self::TYPE_VOID) {
-                $this->fatalError($v, 'Method ' . $this->class . "::{$name}() must return void");
+                $this->fatalError($v, 'Method ' . $methodName . '() must return void');
             }
         }
 
diff --git a/src/Php/Optimizer/FuncCallOptimizer.php b/src/Php/Optimizer/FuncCallOptimizer.php
index f0b9a08d..6c5bd757 100644
--- a/src/Php/Optimizer/FuncCallOptimizer.php
+++ b/src/Php/Optimizer/FuncCallOptimizer.php
@@ -195,6 +195,12 @@ trait FuncCallOptimizer
 
     protected function parseFuncCallWithOptimizer(string $name, Node\Expr\FuncCall $expr): string|false
     {
+        foreach ($expr->args as $arg) {
+            if ($arg instanceof Node\Arg && $arg->name !== null) {
+                return false;
+            }
+        }
+
         $config = $this->getFuncCallConfig()[$name] ?? null;
         if ($config === null) {
             return false;
@@ -340,7 +346,7 @@ trait FuncCallOptimizer
         if ($this->isVarExpr($arg) and $arg->name === 'GLOBALS') {
             return 'php_globals_array()';
         }
-        return $this->parseIdentifier($arg);
+        return $this->parseOrderedOperand($arg, false);
     }
 
     protected function getRefArg(Node\Expr\FuncCall $expr, int $i): string
@@ -441,7 +447,7 @@ trait FuncCallOptimizer
         $base = ($variadicType !== '' && ($variadicType[0] ?? '') === self::ARG_OPTIONAL) ? substr($variadicType, 1) : $variadicType;
         $args = [];
         foreach ($expr->args as $index => $arg) {
-            $raw = $this->parseExpr($arg->value);
+            $raw = $this->parseOrderedOperand($arg->value, false);
             $args[] = match ($base) {
                 self::ARG_TYPE_STR => $this->convertStringExpr($raw),
                 self::ARG_TYPE_INT => $this->convertIntExpr($raw),
@@ -485,9 +491,9 @@ trait FuncCallOptimizer
             return false;
         }
 
-        $args = [$this->parseExpr($expr->args[0]->value)];
+        $args = [$this->parseOrderedOperand($expr->args[0]->value, false)];
         if (count($expr->args) >= 2) {
-            $args[] = $this->parseExpr($expr->args[1]->value);
+            $args[] = $this->parseOrderedOperand($expr->args[1]->value, false);
         }
 
         return $target . '(' . implode(', ', $args) . ')';
diff --git a/src/Php/Parser/AssignOpTrait.php b/src/Php/Parser/AssignOpTrait.php
index e07de024..abdaedf3 100644
--- a/src/Php/Parser/AssignOpTrait.php
+++ b/src/Php/Parser/AssignOpTrait.php
@@ -49,6 +49,7 @@ trait AssignOpTrait
         $array = $this->parseIdentifier($left->var);
         $propName = $this->identifierToStr($left->name, literal: true);
         $rightExpr = $this->trimBrackets($this->parseExpr($right));
+        $rightExpr = $this->wrapObjectPropertyAssignTypeCheck($left, $right, $rightExpr);
 
         $tmp = $this->genTmpVarName();
         $this->addLocalVar($tmp, self::TYPE_VAR);
@@ -142,6 +143,7 @@ trait AssignOpTrait
 
     protected function parseAssignFinally(Expr $left, Expr $right): string
     {
+        $this->assertNotNullsafeWriteContext($left);
         if ($left instanceof Expr\List_) {
             return $this->parseAssignToList($left, $right);
         }
@@ -154,6 +156,9 @@ trait AssignOpTrait
             $this->fatalError($left, 'Cannot re-assign $this');
         }
         $finalVarType = $type = $this->detectTypeOfExpr($right);
+        if ($type === self::TYPE_VOID) {
+            $this->fatalError($right, 'Cannot use void expression as assignment value');
+        }
 
         if ($this->isVarExpr($left)) {
             if ($this->isStdContainer($var)) {
@@ -255,7 +260,7 @@ trait AssignOpTrait
                     $this->checkVarAssignExpr($left, $finalVarType, $type);
                 }
             }
-        } elseif ($this->isPropertyFetch($left) and !$left->getAttribute('nativeProperty')) {
+        } elseif ($this->isPropertyFetch($left) and !$this->isNativePropertyAccess($left)) {
             return $this->parseAssignPropertyFetch($left, $right);
         } elseif ($this->isArrayDimFetch($left) and $this->isVarExpr($left->var)) {
             $tmp = $this->parseIdentifier($left->var);
@@ -275,6 +280,9 @@ trait AssignOpTrait
         }
 
         $rightExpr = $this->parseAssignRightExpr($right);
+        if ($this->isPropertyFetch($left) || $this->isStaticPropertyFetch($left)) {
+            $rightExpr = $this->wrapObjectPropertyAssignTypeCheck($left, $right, $rightExpr);
+        }
         $leftExprType = $this->detectTypeOfExpr($left);
         $rightExprType = $this->detectTypeOfExpr($right);
         if ($finalVarType === self::TYPE_VAR) {
@@ -318,6 +326,7 @@ trait AssignOpTrait
 
     protected function parseAssignOp(Expr\AssignOp $node, string $op): string
     {
+        $this->assertNotNullsafeWriteContext($node->var);
         $oriInAssignExpr = $this->context->inAssignExpr;
         $this->context->inAssignExpr = true;
         $var          = $this->parseIdentifier($node->var);
@@ -388,7 +397,7 @@ trait AssignOpTrait
             return $this->parseArrayDimStore($node->var->var, $dim, $tmpVar);
         }
 
-        if ($this->isPropertyFetch($node->var) and !$node->var->getAttribute('nativeProperty')) {
+        if ($this->isPropertyFetch($node->var) and !$this->isNativePropertyAccess($node->var)) {
             $obj = $this->parseIdentifier($node->var->var);
             $propName = $this->identifierToStr($node->var->name, literal: true);
             $binaryOp = $this->removeAssignOp($op);
@@ -514,6 +523,11 @@ trait AssignOpTrait
 
     protected function parseAssignRef(Expr\AssignRef $expr): string
     {
+        $this->assertNotNullsafeWriteContext($expr->var);
+        if ($expr->expr instanceof Expr\NullsafePropertyFetch) {
+            $this->fatalError($expr->expr, 'Cannot take reference of a nullsafe chain');
+        }
+
         $this->context->inAssignExpr = true;
         $left = $this->parseIdentifier($expr->var);
         $this->context->inAssignExpr = false;
@@ -582,7 +596,16 @@ trait AssignOpTrait
         $var = $this->parseIdentifier($expr->var);
         $this->context->inAssignExpr = $inAssignExpr;
 
+        if ($this->isPropertyFetch($expr->var)) {
+            $this->assertCanAssignObjectProp($expr->var, $expr->expr);
+        } elseif ($this->isStaticPropertyFetch($expr->var)) {
+            $this->assertCanAssignStaticProp($expr->var, $expr->expr);
+        }
+
         $right = $this->parseExpr($expr->expr);
+        if ($this->isPropertyFetch($expr->var) || $this->isStaticPropertyFetch($expr->var)) {
+            $right = $this->wrapObjectPropertyAssignTypeCheck($expr->var, $expr->expr, $right);
+        }
         if ($this->isVarExpr($expr->expr) and !$this->hasVar($right)) {
             $this->errorUndefinedVariable($expr->expr);
         }
diff --git a/src/Php/Parser/BinaryOpTrait.php b/src/Php/Parser/BinaryOpTrait.php
index f752e65d..66112bd0 100644
--- a/src/Php/Parser/BinaryOpTrait.php
+++ b/src/Php/Parser/BinaryOpTrait.php
@@ -18,9 +18,12 @@ trait BinaryOpTrait
 {
     protected function parseBinaryOp(NodeAbstract $left, NodeAbstract $right, string $op): string
     {
+        $this->assertExprCanBeUsedAsValue($left, 'binary operand');
+        $this->assertExprCanBeUsedAsValue($right, 'binary operand');
+
         // 运算逻辑，优先转为数字
-        $leftExpr  = $this->parseNumericIdentifier($left);
-        $rightExpr = $this->parseNumericIdentifier($right);
+        $leftExpr  = $this->parseOrderedBinaryOperand($left);
+        $rightExpr = $this->parseOrderedBinaryOperand($right);
 
         $this->checkVarMustExist($left, $leftExpr);
         $this->checkVarMustExist($right, $rightExpr);
@@ -130,6 +133,111 @@ trait BinaryOpTrait
         return '((' . $leftExpr . ') ' . $op . ' (' . $rightExpr . '))';
     }
 
+    protected function shouldMaterializeOrderedOperand(NodeAbstract $expr): bool
+    {
+        if ($expr instanceof Expr\BinaryOp) {
+            return $this->shouldMaterializeOrderedOperand($expr->left)
+                || $this->shouldMaterializeOrderedOperand($expr->right);
+        }
+
+        return $expr instanceof Expr\FuncCall
+            || $expr instanceof Expr\MethodCall
+            || $expr instanceof Expr\StaticCall
+            || $expr instanceof Expr\New_
+            || $expr instanceof Expr\Assign
+            || $expr instanceof Expr\AssignRef
+            || $expr instanceof Expr\AssignOp
+            || $expr instanceof Expr\PostInc
+            || $expr instanceof Expr\PostDec
+            || $expr instanceof Expr\PreInc
+            || $expr instanceof Expr\PreDec
+            || $expr instanceof Expr\Print_
+            || $expr instanceof Expr\Array_
+            || $expr instanceof Expr\ArrayDimFetch
+            || $expr instanceof Expr\PropertyFetch
+            || $expr instanceof Expr\StaticPropertyFetch
+            || $expr instanceof Expr\Ternary
+            || $expr instanceof Expr\Match_
+            || $expr instanceof Expr\NullsafeMethodCall
+            || $expr instanceof Expr\NullsafePropertyFetch
+            || $expr instanceof Expr\Clone_
+            || $expr instanceof Expr\Include_
+            || $expr instanceof Expr\Eval_;
+    }
+
+    protected function parseOrderedBinaryOperand(NodeAbstract $expr): float|int|string
+    {
+        return $this->parseOrderedOperand($expr, true);
+    }
+
+    protected function parseOrderedOperand(NodeAbstract $expr, bool $numeric): float|int|string
+    {
+        $this->assertExprCanBeUsedAsValue($expr, 'operand');
+        if (!$this->shouldMaterializeOrderedOperand($expr)) {
+            return $numeric ? $this->parseNumericIdentifier($expr) : $this->parseIdentifier($expr);
+        }
+
+        [$value, $beforeStmts, $afterStmts] = $this->parseExprWithCapturedStmts($expr);
+        $this->appendCapturedStmtLinesToContext($beforeStmts);
+
+        $type = $this->getOrderedOperandTmpType($expr, (string) $value);
+        $tmpVar = $this->addTmpVar($type);
+        $this->context->beforeStmtLines[] = $tmpVar . ' = ' . $value . ';';
+        $this->appendCapturedStmtLinesToContext($afterStmts);
+        return $tmpVar;
+    }
+
+    protected function getOrderedOperandTmpType(NodeAbstract $expr, string $value): string
+    {
+        if ($expr instanceof Expr\BinaryOp) {
+            $type = $this->detectTypeOfExpr($expr);
+            return in_array($type, [self::TYPE_BIGINT, self::TYPE_DECIMAL, self::TYPE_BIGFLOAT], true) ? $type : self::TYPE_VAR;
+        }
+
+        if (
+            $expr instanceof Expr\FuncCall
+            || $expr instanceof Expr\MethodCall
+            || $expr instanceof Expr\StaticCall
+        ) {
+            $type = $this->detectTypeOfExpr($expr);
+            return in_array($type, [self::TYPE_BIGINT, self::TYPE_DECIMAL, self::TYPE_BIGFLOAT], true) ? $type : self::TYPE_VAR;
+        }
+
+        if ($expr instanceof Expr\PropertyFetch) {
+            $nativePropertyVar = $expr->getAttribute('nativePropertyVar');
+            if (is_string($nativePropertyVar) && $nativePropertyVar === $value) {
+                if (isset($this->context->objectProps[$nativePropertyVar])) {
+                    return $this->context->objectProps[$nativePropertyVar]['type'];
+                }
+                if (!str_contains($nativePropertyVar, '.attr(') && $expr->hasAttribute('nativePropertyDef')) {
+                    return $expr->getAttribute('nativePropertyDef')->type;
+                }
+            }
+            return self::TYPE_VAR;
+        }
+
+        if ($expr instanceof Expr\StaticPropertyFetch) {
+            if ($expr->hasAttribute('nativePropertyDef') && !str_contains($value, 'getStaticProperty')) {
+                return $expr->getAttribute('nativePropertyDef')->type;
+            }
+            return self::TYPE_VAR;
+        }
+
+        if ($expr instanceof Expr\ArrayDimFetch) {
+            return self::TYPE_VAR;
+        }
+
+        $type = $this->detectTypeOfExpr($expr);
+        return $type;
+    }
+
+    protected function appendCapturedStmtLinesToContext(array $stmts): void
+    {
+        foreach ($stmts as $stmt) {
+            $this->context->beforeStmtLines[] = $stmt;
+        }
+    }
+
     protected function parseBinaryOpPlus(Expr\BinaryOp\Plus $expr): string
     {
         return $this->parseBinaryOp($expr->left, $expr->right, '+');
@@ -194,18 +302,20 @@ trait BinaryOpTrait
 
     protected function parseBinaryOpPow(Expr\BinaryOp\Pow $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr->left, 'binary operand');
+        $this->assertExprCanBeUsedAsValue($expr->right, 'binary operand');
         $leftType = $this->detectTypeOfExpr($expr->left);
         if ($leftType === self::TYPE_BIGINT) {
-                        $leftExpr = $this->parseExpr($expr->left);
-            $rightExpr = $this->parseExpr($expr->right);
+            $leftExpr = $this->parseOrderedOperand($expr->left, false);
+            $rightExpr = $this->parseOrderedOperand($expr->right, false);
             $rightType = $this->detectTypeOfExpr($expr->right);
             if ($rightType !== self::TYPE_BIGINT) {
                 $rightExpr = $this->convertBigIntExpr($rightExpr, $rightType);
             }
             return 'php::BigInt::pow(' . $leftExpr . ', ' . $rightExpr . ')';
         }
-        $left  = $this->parseIdentifier($expr->left);
-        $right = $this->parseIdentifier($expr->right);
+        $left  = $this->parseOrderedOperand($expr->left, false);
+        $right = $this->parseOrderedOperand($expr->right, false);
         return 'php::fn::pow(' . $left . ', ' . $right . ')';
     }
 
@@ -226,11 +336,12 @@ trait BinaryOpTrait
 
     protected function parseCompareExpr(NodeAbstract $expr): string
     {
+        $this->assertExprCanBeUsedAsValue($expr, 'comparison operand');
         // PHPX 与 bool 值比较会出现重载错误，所以需要转换成 bool 值
         if ($this->isScalarBool($expr)) {
             return $this->getBoolValue($expr);
         }
-        return $this->parseIdentifier($expr);
+        return $this->parseOrderedOperand($expr, false);
     }
 
     protected function parseBinaryOpEqual(Expr\BinaryOp\Equal $expr): string
@@ -283,12 +394,59 @@ trait BinaryOpTrait
 
     protected function parseBinaryOpLogicalAnd(Expr\BinaryOp\LogicalAnd|Expr\BinaryOp\BooleanAnd $expr): string
     {
-        return $this->convertBoolExpr($this->parseBinaryOp($expr->left, $expr->right, '&&'));
+        return $this->parseShortCircuitLogicalOp($expr->left, $expr->right, '&&');
     }
 
     protected function parseBinaryOpLogicalOr(Expr\BinaryOp\LogicalOr|Expr\BinaryOp\BooleanOr $expr): string
     {
-        return $this->convertBoolExpr($this->parseBinaryOp($expr->left, $expr->right, '||'));
+        return $this->parseShortCircuitLogicalOp($expr->left, $expr->right, '||');
+    }
+
+    protected function parseShortCircuitLogicalOp(NodeAbstract $left, NodeAbstract $right, string $op): string
+    {
+        $this->assertExprCanBeUsedAsCondition($left, 'logical operand');
+        $this->assertExprCanBeUsedAsCondition($right, 'logical operand');
+
+        $leftExpr = $this->parseNumericIdentifier($left);
+        $this->checkVarMustExist($left, $leftExpr);
+
+        $rightBeforeStmtCount = count($this->context->beforeStmtLines);
+        $rightAfterStmtCount = count($this->context->afterStmtLines);
+        $rightExpr = $this->parseNumericIdentifier($right);
+        $rightBeforeStmts = array_slice($this->context->beforeStmtLines, $rightBeforeStmtCount);
+        $rightAfterStmts = array_slice($this->context->afterStmtLines, $rightAfterStmtCount);
+        $this->context->beforeStmtLines = array_slice($this->context->beforeStmtLines, 0, $rightBeforeStmtCount);
+        $this->context->afterStmtLines = array_slice($this->context->afterStmtLines, 0, $rightAfterStmtCount);
+        $this->checkVarMustExist($right, $rightExpr);
+
+        $leftBool = $this->convertBoolExpr((string) $leftExpr);
+        if (!$rightBeforeStmts && !$rightAfterStmts) {
+            return '(' . $leftBool . ' ' . $op . ' ' . $this->convertBoolExpr((string) $rightExpr) . ')';
+        }
+
+        $appendStmtLines = function (string &$code, array $stmts): void {
+            if ($stmts) {
+                $code .= $this->getIndent() . implode(PHP_EOL . $this->getIndent(), $stmts) . PHP_EOL;
+            }
+        };
+        $shortCircuitValue = $op === '&&' ? 'false' : 'true';
+        $rightCondition = $op === '&&' ? $leftBool : '!(' . $leftBool . ')';
+
+        $code = '[&]() -> bool {';
+        $code .= $this->getIndent() . 'if (' . $rightCondition . ') {';
+        $appendStmtLines($code, $rightBeforeStmts);
+        if ($rightAfterStmts) {
+            $rightTmpVar = $this->addTmpVar(self::TYPE_VAR);
+            $code .= $this->getIndent() . $rightTmpVar . ' = ' . $rightExpr . ';';
+            $appendStmtLines($code, $rightAfterStmts);
+            $rightExpr = $rightTmpVar;
+        }
+        $code .= $this->getIndent() . 'return ' . $this->convertBoolExpr((string) $rightExpr) . ';';
+        $code .= $this->getIndent() . '}';
+        $code .= $this->getIndent() . 'return ' . $shortCircuitValue . ';';
+        $code .= $this->getIndent() . '}()';
+
+        return $code;
     }
 
     protected function parseBinaryOpLogicalXor(Expr\BinaryOp\LogicalXor $expr): string
@@ -309,7 +467,7 @@ trait BinaryOpTrait
     protected function parseBinaryOpSpaceship(Expr\BinaryOp\Spaceship $expr): string
     {
         return $this->genBigNumericCmp($expr)
-            ?? 'php::compare(' . $this->parseIdentifier($expr->left) . ', ' . $this->parseIdentifier($expr->right) . ')';
+            ?? 'php::compare(' . $this->parseOrderedOperand($expr->left, false) . ', ' . $this->parseOrderedOperand($expr->right, false) . ')';
     }
 
     protected function genBigNumericCmp(Expr\BinaryOp $expr, string $suffix = ''): ?string
@@ -318,8 +476,8 @@ trait BinaryOpTrait
         $rightType = $this->detectTypeOfExpr($expr->right);
 
         if ($leftType === self::TYPE_BIGFLOAT || $rightType === self::TYPE_BIGFLOAT) {
-            $leftExpr = $this->parseExpr($expr->left);
-            $rightExpr = $this->parseExpr($expr->right);
+            $leftExpr = $this->parseOrderedOperand($expr->left, false);
+            $rightExpr = $this->parseOrderedOperand($expr->right, false);
             if ($leftType !== self::TYPE_BIGFLOAT) {
                 $leftExpr = $this->convertBigFloatExpr($leftExpr, $leftType);
             }
@@ -329,8 +487,8 @@ trait BinaryOpTrait
             return 'php::BigFloat::cmp(' . $leftExpr . ', ' . $rightExpr . ')' . $suffix;
         }
         if ($leftType === self::TYPE_BIGINT || $rightType === self::TYPE_BIGINT) {
-            $leftExpr = $this->parseExpr($expr->left);
-            $rightExpr = $this->parseExpr($expr->right);
+            $leftExpr = $this->parseOrderedOperand($expr->left, false);
+            $rightExpr = $this->parseOrderedOperand($expr->right, false);
             if ($leftType !== self::TYPE_BIGINT) {
                 $leftExpr = $this->convertBigIntExpr($leftExpr, $leftType);
             }
@@ -340,8 +498,8 @@ trait BinaryOpTrait
             return 'php::BigInt::cmp(' . $leftExpr . ', ' . $rightExpr . ')' . $suffix;
         }
         if ($leftType === self::TYPE_DECIMAL || $rightType === self::TYPE_DECIMAL) {
-            $leftExpr = $this->parseExpr($expr->left);
-            $rightExpr = $this->parseExpr($expr->right);
+            $leftExpr = $this->parseOrderedOperand($expr->left, false);
+            $rightExpr = $this->parseOrderedOperand($expr->right, false);
             if ($leftType !== self::TYPE_DECIMAL) {
                 $leftExpr = $this->convertDecimalExpr($leftExpr, $leftType, $expr->left);
             }
diff --git a/src/Php/Platform/PlatformBase.php b/src/Php/Platform/PlatformBase.php
index 272ca47d..fc4e2da6 100644
--- a/src/Php/Platform/PlatformBase.php
+++ b/src/Php/Platform/PlatformBase.php
@@ -154,18 +154,22 @@ abstract class PlatformBase
             $long = str_replace('/', '\\', $long);
         }
 
-        $len = min(strlen($short), strlen($long));
+        $short = rtrim($short, $separator);
+        $long = rtrim($long, $separator);
+        $shortParts = explode($separator, $short);
+        $longParts = explode($separator, $long);
         $prefixLen = 0;
+        $len = min(count($shortParts), count($longParts));
 
         for ($i = 0; $i < $len; $i++) {
-            if ($short[$i] === $long[$i]) {
+            if ($shortParts[$i] === $longParts[$i]) {
                 $prefixLen++;
             } else {
                 break;
             }
         }
 
-        return ltrim(substr($long, $prefixLen), $separator);
+        return implode($separator, array_slice($longParts, $prefixLen));
     }
 
     /**
diff --git a/src/Php/Preprocessor.php b/src/Php/Preprocessor.php
index 8120abae..9422772a 100644
--- a/src/Php/Preprocessor.php
+++ b/src/Php/Preprocessor.php
@@ -19,6 +19,7 @@ use PhpAot\Php\Entity\PropertyDef;
 use PhpAot\Php\Exception\SyntaxError;
 use PhpParser\Modifiers;
 use PhpParser\Node;
+use PhpParser\Node\IntersectionType;
 use PhpParser\Node\NullableType;
 use PhpParser\Node\UnionType;
 use PhpParser\NodeAbstract;
@@ -92,62 +93,67 @@ class Preprocessor extends CompilerBase
 
     public function prepareFile(string $file): void
     {
-        $phpCode = $this->loadFile($file);
-        $this->symbolCallInFile[$this->file] = [];
-        $this->resetFile();
-        $this->resetFunction();
-        $this->resetMethod();
-        $this->resetClass();
-        $this->resetNamespace();
-
-        $this->climate->info('prepare: ' . $this->getRelativePath($this->file));
+        $previousPhase = $this->enterCompilerPhase(self::PHASE_PREPARE);
         try {
-            $ast = $this->parser->parse($phpCode);
-        } catch (\PhpParser\Error $e) {
-            $this->climate->red("Fatal error: {$e->getMessage()} in {$this->file}");
-            throw new SyntaxError($e->getMessage(), $e->getCode());
-        }
-
-        $traverser = new NodeTraverser();
-        $traverser->addVisitor(new Visitor());
-        $stmts = $traverser->traverse($ast);
-
-        foreach ($stmts as $v) {
-            $type = $v->getType();
-            switch ($type) {
-                case 'Stmt_Namespace':
-                    $this->prepareNamespace($v);
-                    break;
-                case 'Stmt_Enum':
-                case 'Stmt_Class':
-                case 'Stmt_Trait':
-                    $this->prepareClass($v);
-                    break;
-                case 'Stmt_Interface':
-                    $this->parseInterface($v);
-                    break;
-                case 'Stmt_Function':
-                    $this->prepareFunction($v);
-                    break;
-                case 'Stmt_Use':
-                    $this->parseUse($v);
-                    break;
-                case 'Stmt_GroupUse':
-                    $this->parseGroupUse($v);
-                    break;
-                case 'Stmt_Declare':
-                case 'Stmt_Nop':
-                    break;
-                case 'Stmt_Const':
-                    $this->parseConstDef($v);
-                    break;
-                case 'Stmt_Expression':
-                    $this->foundStrayCode($v);
-                    break;
-                default:
-                    $this->fatalError($v, 'Unsupported statement: ' . $type);
-                    break;
+            $phpCode = $this->loadFile($file);
+            $this->symbolCallInFile[$this->file] = [];
+            $this->resetFile();
+            $this->resetFunction();
+            $this->resetMethod();
+            $this->resetClass();
+            $this->resetNamespace();
+
+            $this->climate->info('prepare: ' . $this->getRelativePath($this->file));
+            try {
+                $ast = $this->parser->parse($phpCode);
+            } catch (\PhpParser\Error $e) {
+                $this->climate->red("Fatal error: {$e->getMessage()} in {$this->file}");
+                throw new SyntaxError($e->getMessage(), $e->getCode());
+            }
+
+            $traverser = new NodeTraverser();
+            $traverser->addVisitor(new Visitor());
+            $stmts = $traverser->traverse($ast);
+
+            foreach ($stmts as $v) {
+                $type = $v->getType();
+                switch ($type) {
+                    case 'Stmt_Namespace':
+                        $this->prepareNamespace($v);
+                        break;
+                    case 'Stmt_Enum':
+                    case 'Stmt_Class':
+                    case 'Stmt_Trait':
+                        $this->prepareClass($v);
+                        break;
+                    case 'Stmt_Interface':
+                        $this->parseInterface($v);
+                        break;
+                    case 'Stmt_Function':
+                        $this->prepareFunction($v);
+                        break;
+                    case 'Stmt_Use':
+                        $this->parseUse($v);
+                        break;
+                    case 'Stmt_GroupUse':
+                        $this->parseGroupUse($v);
+                        break;
+                    case 'Stmt_Declare':
+                    case 'Stmt_Nop':
+                        break;
+                    case 'Stmt_Const':
+                        $this->parseConstDef($v);
+                        break;
+                    case 'Stmt_Expression':
+                        $this->foundStrayCode($v);
+                        break;
+                    default:
+                        $this->fatalError($v, 'Unsupported statement: ' . $type);
+                        break;
+                }
             }
+        } finally {
+            $this->restoreCompilerPhase($previousPhase);
         }
     }
 
@@ -211,6 +217,7 @@ class Preprocessor extends CompilerBase
                     $this->parseGroupUse($v2);
                     break;
                 case 'Stmt_Const':
+                    $this->parseConstDef($v2);
                     break;
                 case 'Stmt_Interface':
                     $this->parseInterface($v2);
@@ -243,25 +250,38 @@ class Preprocessor extends CompilerBase
     {
         $list                          = [];
         $functionDef->argCountRequired = count($params);
-        $defaultValueCount = 0;
+        $lastRequiredIndex = -1;
+        $lastRequiredName = '';
         $last = array_key_last($params);
+        foreach ($params as $i => $param) {
+            if (!$param->default && !$param->variadic) {
+                $lastRequiredIndex = $i;
+                if (is_string($param->var->name)) {
+                    $lastRequiredName = $param->var->name;
+                }
+            }
+        }
 
         foreach ($params as $i => $param) {
+            if (!is_string($param->var->name)) {
+                $this->fatalError($param, 'Parameter name must be a string');
+            }
+            $phpName = $param->var->name;
+            $name = $this->escapeVarName($phpName);
             // .stub 存根定义 C++ Native 函数，必须设置函数的参数类型
             if ($this->stubFile and !$param->type) {
-                throw new \RuntimeException('No type for ' . $this->parseIdentifier($param->var));
+                throw new \RuntimeException('No type for ' . $phpName);
             }
             // 构造方法属性定义语法（Constructor Property Promotion）
             if ($param->isPromoted()) {
                 if (!$this->classDef or !$this->methodDef or $this->methodDef->name !== '__construct') {
                     $this->fatalError($param, 'Promoted properties are not supported');
                 }
-                $name = $this->parseIdentifier($param->var);
                 $nullable = $param->type instanceof NullableType;
                 // Promoted property defaults belong to the constructor parameter,
                 // not to the property default table. The property itself must stay
                 // uninitialized until __construct assigns it.
-                $this->addClassProperty($name, $param->flags, $param->type, null, $nullable, $param);
+                $this->addClassProperty($phpName, $param->flags, $param->type, null, $nullable, $param);
             }
             if ($param->variadic) {
                 if ($i !== $last) {
@@ -270,13 +290,21 @@ class Preprocessor extends CompilerBase
                     $this->fatalError($param, 'Variadic parameters cannot be passed by reference');
                 }
             }
-            $name = $this->parseIdentifier($param->var);
+            if ($param->default && $i < $lastRequiredIndex) {
+                $this->fatalError(
+                    $param,
+                    $this->getFunctionDisplayName($functionDef)
+                    . '(): optional parameter `$' . $phpName . '` cannot be declared before required parameter `$'
+                    . $lastRequiredName . '`'
+                );
+            }
             if ($this->method and $name === 'this_') {
                 $this->fatalError($param, 'Cannot use `$this` as parameter of class method');
             }
             $argInfo = new ArgInfo();
             $type = $this->parseParameterType($param, $argInfo, $name);
             $argInfo->name = $name;
+            $argInfo->phpName = $phpName;
             $argInfo->type = $type;
             $argInfo->byRef = $param->byRef;
             $argInfo->variadic = $param->variadic;
@@ -284,7 +312,7 @@ class Preprocessor extends CompilerBase
             if ($param->type === null || $param->type instanceof NullableType) {
                 $argInfo->nullable = true;
             }
-            if ($param->type instanceof NullableType or $param->type instanceof UnionType) {
+            if ($param->type instanceof NullableType || $param->type instanceof UnionType || $param->type instanceof IntersectionType) {
                 $typeInfo = $this->buildTypeCheckFromNode($param->type);
                 if (!empty($typeInfo['check'])) {
                     $argInfo->typeCheck = $typeInfo['check'];
@@ -319,17 +347,23 @@ class Preprocessor extends CompilerBase
                     $argInfo->arrayInitPlan = $arrayInitPlan;
                     $argInfo->defaultValue = $param->default;
                 }
-                $defaultValueCount++;
             } elseif ($param->variadic) {
                 // 变长参数可以视为空数组默认值
-                $defaultValueCount++;
                 $argInfo->default = '{}';
                 $argInfo->defaultValue = new Node\Expr\Array_();
             }
             $functionDef->argInfoList[] = $argInfo;
         }
         $functionDef->params = implode(', ', $list);
-        $functionDef->argCountRequired -= $defaultValueCount;
+        $functionDef->argCountRequired = $lastRequiredIndex + 1;
+    }
+
+    protected function getFunctionDisplayName(FunctionDef $functionDef): string
+    {
+        if ($this->class) {
+            return $this->class . '::' . $functionDef->name;
+        }
+        return $functionDef->getNamespacedName();
     }
 
     protected function parseFunctionDecl(Node\Stmt\Function_|Node\Stmt\ClassMethod $v): FunctionDef
@@ -346,6 +380,16 @@ class Preprocessor extends CompilerBase
         if ($v->byRef) {
             $this->fatalError($v, 'The return type of the function `' . $v->name . '` cannot be a reference type');
         }
+        if ($this->method and $v->returnType !== null) {
+            $methodName = $this->class . '::' . $this->method;
+            if (in_array($this->method, ['__construct', '__destruct'], true)) {
+                $this->fatalError($v, 'Method `' . $methodName . '()` cannot declare a return type');
+            }
+            if ($this->method === '__clone'
+                and (!$v->returnType instanceof Node\Identifier or strtolower($v->returnType->name) !== 'void')) {
+                $this->fatalError($v, 'Method `' . $methodName . '()` return type must be void when declared');
+            }
+        }
 
         $fnName = $this->parseIdentifier($v->name);
         $class = '';
@@ -360,7 +404,7 @@ class Preprocessor extends CompilerBase
         $functionDef->stub = $this->stubFile;
         $functionDef->returnTypeUndeclared = $v->returnType === null;
 
-        if ($v->returnType instanceof NullableType or $v->returnType instanceof UnionType) {
+        if ($v->returnType instanceof NullableType || $v->returnType instanceof UnionType || $v->returnType instanceof IntersectionType) {
             $typeInfo = $this->buildTypeCheckFromNode($v->returnType);
             if (!empty($typeInfo['check'])) {
                 $functionDef->returnTypeCheck = $typeInfo['check'];
@@ -429,6 +473,9 @@ class Preprocessor extends CompilerBase
         } else {
             $flags = Modifiers::PUBLIC;
         }
+        if (isset($this->symbolDeclInFile[$fullClassNameLower])) {
+            $this->fatalError($class, "Duplicate class `{$fullClassName}`");
+        }
 
         $this->classDef = new ClassDef($this->class, $flags, $this->namespace);
         $this->addClass($fullClassName, $this->classDef);
@@ -460,10 +507,6 @@ class Preprocessor extends CompilerBase
         } else {
             $this->classDef->trait = $class;
         }
-        if (isset($this->symbolDeclInFile[$fullClassNameLower])) {
-            $this->fatalError($class, "Duplicate class `{$fullClassName}`");
-        }
-
         $this->symbolDeclInFile[$fullClassNameLower] = $this->file;
 
         $code = '';
@@ -553,13 +596,10 @@ class Preprocessor extends CompilerBase
         $flags = $this->parseModifiers($v->flags);
         $class = '';
 
-        if ($v->type) {
-            $type = $this->parseTypeDecl($v->type, self::DECL_TYPE_OF_CONST, $class);
-        } else {
-            $type = null;
-        }
+        $declaredType = $v->type ? $this->parseTypeDecl($v->type, self::DECL_TYPE_OF_CONST, $class) : null;
 
         foreach ($v->consts as $const) {
+            $type = $declaredType;
             if ($type === null) {
                 $type = match ($const->value->getType()) {
                     'Expr_Array' => self::TYPE_ARRAY,
@@ -568,24 +608,35 @@ class Preprocessor extends CompilerBase
                 };
             }
             $constName = $this->parseIdentifier($const->name);
-            $constValue = $this->parseIdentifier($const->value);
-
-            $constInfo = new ConstantDef($constName, $flags, $type, $constValue);
-            $constInfo->valueExpr = $const->value;
-
-            if ($this->context->beforeStmtLines) {
-                $arrayExpr = '';
-                if ($this->context->localVars) {
-                    $arrayExpr .= $this->genScopeVarDecl();
-                }
-                $arrayExpr .= $this->parseBeforeStmtLines();
-                $constInfo->arrayExpr = $arrayExpr;
+            if ($this->classDef->hasConstant($constName)) {
+                $this->fatalError($v, "Duplicate constant `{$constName}`");
             }
+            $constInfo = $this->parseClassLikeConstant($const, $flags, $type, $class);
             $constInfo->class = $class;
             $this->classDef->constants[$constInfo->name] = $constInfo;
         }
     }
 
+    private function parseClassLikeConstant(Node\Const_ $const, int $flags, string $type, string $class = ''): ConstantDef
+    {
+        $constName = $this->parseIdentifier($const->name);
+        $constValue = $this->parseIdentifier($const->value);
+
+        $constInfo = new ConstantDef($constName, $flags, $type, $constValue);
+        $constInfo->valueExpr = $const->value;
+
+        if ($this->context->beforeStmtLines) {
+            $arrayExpr = '';
+            if ($this->context->localVars) {
+                $arrayExpr .= $this->genScopeVarDecl();
+            }
+            $arrayExpr .= $this->parseBeforeStmtLines();
+            $constInfo->arrayExpr = $arrayExpr;
+        }
+        $constInfo->class = $class;
+        return $constInfo;
+    }
+
     /**
      * Create and register a class property with type normalization, shared by
      * regular property declarations and constructor property promotion.
@@ -615,6 +666,11 @@ class Preprocessor extends CompilerBase
         $propDef = new PropertyDef($name, $flags, $type, $default, $nullable);
         $propDef->class = $class;
         $propDef->arrayInitPlan = $arrayInitPlan;
+        if ($typeNode instanceof NullableType || $typeNode instanceof UnionType || $typeNode instanceof IntersectionType) {
+            $typeInfo = $this->buildTypeCheckFromNode($typeNode);
+            $propDef->typeCheck = $typeInfo['check'];
+            $propDef->typeStr = $typeInfo['typeStr'];
+        }
         $this->classDef->properties[$name] = $propDef;
         return $propDef;
     }
@@ -653,9 +709,16 @@ class Preprocessor extends CompilerBase
             $this->checkRequiredArgNum($name, $this->methodDef, $v);
             $this->classDef->addMethod($this->methodDef);
         } else {
+            if ($this->classDef->hasMethod($name) || $this->classDef->hasAbstractMethod($name)) {
+                $this->fatalError($v, "Duplicate method `{$this->method}`");
+            }
             if (!$class instanceof Node\Stmt\Trait_ && isset($class->flags) && !($class->flags & Modifiers::ABSTRACT)) {
                 $this->fatalError($v, "Non-abstract class {$this->class} contains abstract method {$v->name}");
             }
+            $this->methodDef = new MethodDef($flags, $name);
+            $this->methodDef->functionDef = $this->parseFunctionDecl($v);
+            $this->methodDef->functionDef->method = true;
+            $this->checkRequiredArgNum($name, $this->methodDef, $v);
             if ($this->method === '__construct') {
                 foreach ($v->params as $param) {
                     if ($param->isPromoted()) {
@@ -663,7 +726,7 @@ class Preprocessor extends CompilerBase
                     }
                 }
             }
-            $this->classDef->addAbstractMethod($name, $flags);
+            $this->classDef->addAbstractMethod($name, $flags, $this->methodDef);
         }
 
         $fullClassName = $this->getFullClassName();
@@ -715,12 +778,79 @@ class Preprocessor extends CompilerBase
 
     protected function parseInterface(Node\Stmt\Interface_ $v): void
     {
+        $this->resetClass();
+        $this->resetMethod();
+        $this->resetFunction();
         $name = $this->parseIdentifier($v->name);
         $this->interface = $name;
         $this->interfaceDef = new InterfaceDef($name, $this->namespace);
-        $interfaceName = $this->interfaceDef->getNamespacedName();
+        $interfaceName = $this->interfaceDef->getNamespacedName(false);
+        $interfaceNameLower = strtolower($interfaceName);
+
+        foreach ($v->extends as $parent) {
+            $parentName = $this->getNamespacedClassName($this->parseIdentifier($parent));
+            $this->interfaceDef->extendsList[] = $parentName;
+            if ($this->interfaceDef->extends === '') {
+                $this->interfaceDef->extends = $parentName;
+            }
+            if (!$this->isInternalInterface($parentName)) {
+                $this->symbolCallInFile[$this->file][] = strtolower($parentName);
+            }
+        }
+
+        if (isset($this->symbolDeclInFile[$interfaceNameLower])) {
+            $this->fatalError($v, "Duplicate interface `{$interfaceName}`");
+        }
+
+        $this->symbolDeclInFile[$interfaceNameLower] = $this->file;
         $this->interfaces[$this->escapeClass($interfaceName)] = $this->interfaceDef;
         $this->interfacesDefineInFile[$interfaceName] = $this->interfaceDef;
+
+        foreach ($v->stmts as $stmt) {
+            if ($stmt instanceof Node\Stmt\ClassConst) {
+                foreach ($stmt->consts as $const) {
+                    $constName = $this->parseIdentifier($const->name);
+                    if ($this->interfaceDef->hasConstant($constName)) {
+                        $this->fatalError($stmt, "Duplicate constant `{$constName}`");
+                    }
+                    $class = '';
+                    $type = $stmt->type
+                        ? $this->parseTypeDecl($stmt->type, self::DECL_TYPE_OF_CONST, $class)
+                        : match ($const->value->getType()) {
+                            'Expr_Array' => self::TYPE_ARRAY,
+                            'Scalar_String' => self::TYPE_STR,
+                            default => self::TYPE_VAR,
+                        };
+                    $constInfo = $this->parseClassLikeConstant($const, $this->parseModifiers($stmt->flags), $type, $class);
+                    $this->interfaceDef->constants[$constName] = $constInfo;
+                }
+                continue;
+            }
+
+            if ($stmt instanceof Node\Stmt\ClassMethod) {
+                $methodName = $this->getMethodName($stmt);
+                if ($this->interfaceDef->hasMethod($methodName)) {
+                    $this->fatalError($stmt, "Duplicate method `{$methodName}`");
+                }
+                $this->method = $methodName;
+                $methodDef = new MethodDef($this->parseModifiers($stmt->flags), $methodName);
+                $methodDef->functionDef = $this->parseFunctionDecl($stmt);
+                $methodDef->functionDef->method = true;
+                $this->interfaceDef->addMethod($methodDef);
+                $this->resetMethod();
+                $this->resetFunction();
+                continue;
+            }
+
+            if (!$stmt instanceof Node\Stmt\Nop) {
+                $this->fatalError($stmt, 'Unsupported interface statement: ' . $stmt->getType());
+            }
+        }
+
+        $this->resetMethod();
+        $this->resetFunction();
+        $this->interface = '';
+        $this->interfaceDef = null;
     }
 
     protected function parseTraitUseOptions(Node\Stmt\TraitUse $traitUse, array &$aliases, array &$ignored): void
@@ -738,15 +868,15 @@ class Preprocessor extends CompilerBase
                     $traits[] = $adaptation->trait;
                 }
                 foreach ($traits as $trait) {
-                    $traitName = $this->getNamespacedClassName($trait);
+                    $traitName = $this->getNamespacedClassName($this->parseIdentifier($trait));
                     $methodName = $adaptation->method->toString();
                     /*
                      * 例如：
                      * use TraitA { TraitA::method as newMethod}
                      * 这表示 TraitA::method() 会被重命名为 TraitA::newMethod()
                      */
-                    $aliases[$this->getFullMethodName($traitName, $methodName)] = [
-                        'newName' => $adaptation->newName->toString(),
+                    $aliases[$this->getFullMethodName($traitName, $methodName)][] = [
+                        'newName' => $adaptation->newName ? $adaptation->newName->toString() : $methodName,
                         'newModifier' => $adaptation->newModifier ?: 0,
                     ];
                 }
@@ -762,7 +892,8 @@ class Preprocessor extends CompilerBase
                  * 这表示 TraitB::method() 将会被忽略，真正执行的是 TraitA::method()
                  */
                 foreach ($adaptation->insteadof as $trait2) {
-                    $ignored[$this->getFullMethodName($trait2, $methodName)] = true;
+                    $traitName = $this->getNamespacedClassName($this->parseIdentifier($trait2));
+                    $ignored[$this->getFullMethodName($traitName, $methodName)] = true;
                 }
             }
         }
@@ -775,7 +906,17 @@ class Preprocessor extends CompilerBase
         if ($v->adaptations) {
             $this->parseTraitUseOptions($v, $aliases, $ignored);
         }
-        $this->classDef->traitAliases = array_merge($this->classDef->traitAliases, $aliases);
+        foreach ($v->traits as $trait) {
+            $traitName = $this->getNamespacedClassName($this->parseIdentifier($trait));
+            if (!$this->isInternalClass($traitName)) {
+                $this->symbolCallInFile[$this->file][] = strtolower($traitName);
+            }
+        }
+        foreach ($aliases as $fullMethodName => $aliasList) {
+            foreach ($aliasList as $alias) {
+                $this->classDef->traitAliases[$fullMethodName][] = $alias;
+            }
+        }
         $this->classDef->traitIgnored = array_merge($this->classDef->traitIgnored, $ignored);
     }
 }
diff --git a/src/Php/Reflection.php b/src/Php/Reflection.php
index 9dc89764..5c380d3f 100644
--- a/src/Php/Reflection.php
+++ b/src/Php/Reflection.php
@@ -93,15 +93,7 @@ class Reflection
         if (!$func) {
             return null;
         }
-        $returnType = $func->getReturnType();
-        if (!$returnType) {
-            return null;
-        }
-        if ($returnType instanceof \ReflectionUnionType) {
-            return null;
-        }
-
-        return $returnType->getName();
+        return self::extractNamedReturnType($func->getReturnType());
     }
 
     public static function getFunctionParameter(string $fn, int $index): ?\ReflectionParameter
@@ -172,7 +164,7 @@ class Reflection
             return null;
         }
         $methodDef = $classRef->getMethod($method);
-        return $methodDef->getReturnType() ? $methodDef->getReturnType()->getName() : null;
+        return self::extractNamedReturnType($methodDef->getReturnType());
     }
 
     public static function isAbstractClass(string $name): bool
@@ -215,4 +207,13 @@ class Reflection
         $lastParam = end($params);
         return $lastParam->isVariadic() ? $lastParam : null;
     }
+
+    private static function extractNamedReturnType(?\ReflectionType $returnType): ?string
+    {
+        if (!$returnType instanceof \ReflectionNamedType) {
+            return null;
+        }
+
+        return $returnType->getName();
+    }
 }
diff --git a/src/Php/Resolver/PropertyAccessResolver.php b/src/Php/Resolver/PropertyAccessResolver.php
new file mode 100644
index 00000000..9fe2a1ca
--- /dev/null
+++ b/src/Php/Resolver/PropertyAccessResolver.php
@@ -0,0 +1,160 @@
+<?php
+/**
+ * This file is part of Swoole-Compiler(AOT).
+ *
+ * @link     https://www.swoole.com/
+ * @contact  service@swoole.com
+ */
+
+namespace PhpAot\Php\Resolver;
+
+use Closure;
+use PhpAot\Php\Entity\ClassDef;
+use PhpParser\NodeAbstract;
+
+final class PropertyAccessResolver
+{
+    /**
+     * @param Closure(string): ?ClassDef $getClassDef
+     * @param Closure(string): string $getParentClass
+     */
+    public function __construct(
+        private readonly Closure $getClassDef,
+        private readonly Closure $getParentClass,
+        private readonly Closure $fatalError,
+    ) {
+    }
+
+    public function isSameClassName(string $classA, string $classB): bool
+    {
+        return strcasecmp(ltrim($classA, '\\'), ltrim($classB, '\\')) === 0;
+    }
+
+    public function isSameOrSubclassOf(string $class, string $parent): bool
+    {
+        $class = strtolower(ltrim($class, '\\'));
+        $parent = strtolower(ltrim($parent, '\\'));
+        while ($class !== '') {
+            if ($class === $parent) {
+                return true;
+            }
+            $class = ($this->getParentClass)($class);
+        }
+        return false;
+    }
+
+    public function canAccessProtectedProperty(string $scope, string $declaringClass): bool
+    {
+        if ($scope === '') {
+            return false;
+        }
+        return $this->isSameOrSubclassOf($scope, $declaringClass)
+            || $this->isSameOrSubclassOf($declaringClass, $scope);
+    }
+
+    public function resolveNativeProperty(
+        NodeAbstract $expr,
+        string $property,
+        string $class,
+        string $scope,
+        bool $static = false,
+    ): ?PropertyAccessResult {
+        $class = ltrim($class, '\\');
+        $findClass = $class;
+
+        while (true) {
+            $classDef = ($this->getClassDef)($findClass);
+            if ($classDef === null) {
+                break;
+            }
+
+            if ($classDef->hasProperty($property)) {
+                $propertyDef = $classDef->getProperty($property);
+                if (!$static && $propertyDef->isStatic()) {
+                    $this->fatal($expr, "Cannot access static property `{$class}::\${$property}` as non-static instance property.");
+                }
+                if ($static && !$propertyDef->isStatic()) {
+                    $this->fatal($expr, "Cannot access non-static property `{$class}::\${$property}` as static property.");
+                }
+                if ($propertyDef->isPublic()) {
+                    return new PropertyAccessResult($class, $findClass, $property, $classDef, $propertyDef);
+                }
+                if ($propertyDef->isProtected()) {
+                    if ($this->canAccessProtectedProperty($scope, $findClass)) {
+                        return new PropertyAccessResult($class, $findClass, $property, $classDef, $propertyDef);
+                    }
+                    $displayClass = ltrim($class, '\\');
+                    $this->fatal($expr, "Cannot access protected property `{$property}` of class `{$displayClass}`");
+                }
+                if ($this->isSameClassName($scope, $findClass)) {
+                    return new PropertyAccessResult($class, $findClass, $property, $classDef, $propertyDef);
+                }
+                $displayClass = ltrim($class, '\\');
+                $this->fatal($expr, "Cannot access private property `{$property}` of class `{$displayClass}`");
+            }
+
+            if (!$classDef->extends) {
+                break;
+            }
+            $findClass = $classDef->extends;
+        }
+
+        return null;
+    }
+
+    public function resolveNativeInstanceProperty(
+        NodeAbstract $expr,
+        string $property,
+        string $class,
+        string $scope,
+    ): ?PropertyAccessResult {
+        return $this->resolveNativeProperty($expr, $property, $class, $scope);
+    }
+
+    public function resolveNativeStaticProperty(
+        NodeAbstract $expr,
+        string $property,
+        string $class,
+        string $scope,
+    ): ?PropertyAccessResult {
+        return $this->resolveNativeProperty($expr, $property, $class, $scope, true);
+    }
+
+    /**
+     * @param array<int, array{node: NodeAbstract, property: string}> $properties
+     * @return array<int, PropertyAccessResult>
+     */
+    public function resolveNullsafePropertyChain(
+        string $baseClass,
+        array $properties,
+        string $scope,
+        string $objectType,
+    ): array {
+        if ($baseClass === '') {
+            return [];
+        }
+
+        $className = $baseClass;
+        $resolved = [];
+        foreach ($properties as $index => $property) {
+            $result = $this->resolveNativeProperty($property['node'], $property['property'], $className, $scope);
+            if ($result === null) {
+                break;
+            }
+
+            $resolved[$index] = $result;
+            $def = $result->propertyDef;
+            if ($def->type !== $objectType || $def->class === '') {
+                break;
+            }
+            $className = $def->class;
+        }
+
+        return $resolved;
+    }
+
+    private function fatal(NodeAbstract $expr, string $message): never
+    {
+        ($this->fatalError)($expr, $message);
+    }
+}
diff --git a/src/Php/Resolver/PropertyAccessResult.php b/src/Php/Resolver/PropertyAccessResult.php
new file mode 100644
index 00000000..18c0fc8f
--- /dev/null
+++ b/src/Php/Resolver/PropertyAccessResult.php
@@ -0,0 +1,24 @@
+<?php
+/**
+ * This file is part of Swoole-Compiler(AOT).
+ *
+ * @link     https://www.swoole.com/
+ * @contact  service@swoole.com
+ */
+
+namespace PhpAot\Php\Resolver;
+
+use PhpAot\Php\Entity\ClassDef;
+use PhpAot\Php\Entity\PropertyDef;
+
+final readonly class PropertyAccessResult
+{
+    public function __construct(
+        public string $requestedClass,
+        public string $declaringClass,
+        public string $property,
+        public ClassDef $classDef,
+        public PropertyDef $propertyDef,
+    ) {
+    }
+}
diff --git a/src/Php/Translator.php b/src/Php/Translator.php
index 3577e509..0d8134e7 100644
--- a/src/Php/Translator.php
+++ b/src/Php/Translator.php
@@ -206,11 +206,11 @@ class Translator extends Preprocessor
         $cmd = $argv[0];
 
         $climate->bold('USAGE:');
-        $climate->tab()->out($cmd . ' <file/dir/project.yml> [options]');
+        $climate->tab()->out($cmd . ' <file/dir/config.yml> [options]');
         $climate->br();
 
         $climate->bold('ARGUMENTS:');
-        $climate->tab()->out('<file>    Input PHP file/directory/project.yml to compile');
+        $climate->tab()->out('<file>    Input PHP file/directory/YAML config to compile');
         $climate->br();
 
         $climate->bold('EXAMPLES:');
@@ -325,6 +325,11 @@ class Translator extends Preprocessor
             $this->targetPlatform = $this->climate->arguments->get('target-platform');
         }
 
+        // 输出文件名/路径
+        if ($this->climate->arguments->defined('output')) {
+            $this->setTargetName($this->climate->arguments->get('output'));
+        }
+
         // 构建目录
         if ($this->climate->arguments->defined('build-dir')) {
             $buildDir = $this->climate->arguments->get('build-dir');
@@ -339,9 +344,13 @@ class Translator extends Preprocessor
         }
 
         // 用户自定义 C++ include 路径（直接从 argv 解析以支持多值）
-        $this->userIncludePaths = $this->parseRepeatableArgv(['-I', '--include-path']);
+        if ($this->hasRepeatableArgvFlag(['-I', '--include-path'])) {
+            $this->userIncludePaths = $this->parseRepeatableArgv(['-I', '--include-path']);
+        }
         // 用户自定义预处理器宏（直接从 argv 解析以支持多值）
-        $this->userDefines = $this->parseRepeatableArgv(['-D', '--define']);
+        if ($this->hasRepeatableArgvFlag(['-D', '--define'])) {
+            $this->userDefines = $this->parseRepeatableArgv(['-D', '--define']);
+        }
 
         // 链接时优化
         if ($this->climate->arguments->defined('lto')) {
@@ -350,18 +359,17 @@ class Translator extends Preprocessor
 
         // clang-format 代码格式化（默认关闭，需显式 --format 开启）
         if ($this->climate->arguments->defined('format')) {
-            $clangFormatVersion = shell_exec('clang-format --version');
-            if (!empty($clangFormatVersion)) {
-                $this->formatCode = true;
-            } else {
-                $this->climate->warning('--format requested but clang-format not found, skipping formatting');
-            }
+            $this->enableCodeFormattingIfAvailable('--format');
         }
 
         // 用户自定义链接库（直接从 argv 解析以支持多值）
-        $this->linkLibs = $this->parseRepeatableArgv(['-l', '--link-lib']);
+        if ($this->hasRepeatableArgvFlag(['-l', '--link-lib'])) {
+            $this->linkLibs = $this->parseRepeatableArgv(['-l', '--link-lib']);
+        }
         // 用户自定义库搜索路径（直接从 argv 解析以支持多值）
-        $this->linkPaths = $this->parseRepeatableArgv(['-L', '--link-path']);
+        if ($this->hasRepeatableArgvFlag(['-L', '--link-path'])) {
+            $this->linkPaths = $this->parseRepeatableArgv(['-L', '--link-path']);
+        }
     }
 
     /**
@@ -397,6 +405,32 @@ class Translator extends Preprocessor
         return $values;
     }
 
+    protected function hasRepeatableArgvFlag(array $flags): bool
+    {
+        global $argv;
+
+        for ($i = 1; $i < count($argv); $i++) {
+            $arg = $argv[$i];
+            if (in_array($arg, $flags, true)) {
+                return true;
+            }
+
+            foreach ($flags as $flag) {
+                if (str_starts_with($arg, $flag . '=')) {
+                    return true;
+                }
+                if (strlen($flag) === 2 && $flag[0] === '-') {
+                    $short = substr($flag, 1);
+                    if (preg_match('/^-' . preg_quote($short, '/') . '(.+)$/', $arg)) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
     /**
      * 处理 --flag=value 格式的长标志
      */
@@ -416,13 +450,24 @@ class Translator extends Preprocessor
         $this->climate->bold()->out(self::APP_NAME . ' v' . self::VERSION);
     }
 
+    private function enableCodeFormattingIfAvailable(string $source): void
+    {
+        $clangFormatVersion = shell_exec('clang-format --version');
+        if (!empty($clangFormatVersion)) {
+            $this->formatCode = true;
+            return;
+        }
+
+        $this->climate->warning($source . ' requested but clang-format not found, skipping formatting');
+    }
+
     protected function formatCppCode(string $file): void
     {
         if (!$this->formatCode) {
             return;
         }
 
-        $cmd = 'cd ' . $this->rootPath . ' && clang-format -i ' . $file;
+        $cmd = 'cd ' . escapeshellarg($this->rootPath) . ' && clang-format -i ' . escapeshellarg($file);
         $this->climate->info('format: ' . $this->getRelativePath($file));
         $this->climate->comment($cmd);
         shell_exec($cmd);
@@ -436,21 +481,26 @@ class Translator extends Preprocessor
 
     public function convertFile(string $file): string
     {
-        $file = realpath($file);
-        $phpCode = $this->loadFile($file);
-        $this->localHeaders = [];
-        while (true) {
-            try {
-                $cppCode = $this->doConvert($phpCode);
-                $cppFile = $this->getCppFile($file);
-                $this->save($cppCode, $cppFile);
-                $this->phpSrcFiles[] = $file;
-                // 生成 stub 文件，依赖 convert 阶段的 use 等信息
-                $this->genStubFile($this->file);
-                return $cppFile;
-            } catch (Redo $e) {
-                continue;
+        $previousPhase = $this->enterCompilerPhase(self::PHASE_CONVERT);
+        try {
+            $file = realpath($file);
+            $phpCode = $this->loadFile($file);
+            $this->localHeaders = [];
+            while (true) {
+                try {
+                    $cppCode = $this->doConvert($phpCode);
+                    $cppFile = $this->getCppFile($file);
+                    $this->save($cppCode, $cppFile);
+                    $this->phpSrcFiles[] = $file;
+                    // 生成 stub 文件，依赖 convert 阶段的 use 等信息
+                    $this->genStubFile($this->file);
+                    return $cppFile;
+                } catch (Redo $e) {
+                    continue;
+                }
             }
+        } finally {
+            $this->restoreCompilerPhase($previousPhase);
         }
     }
 
@@ -506,9 +556,6 @@ class Translator extends Preprocessor
 
     public function setTargetName(string $name): void
     {
-        if ($this->climate->arguments->defined('output')) {
-            $name = $this->climate->arguments->get('output');
-        }
         // 如果指定了路径（包含目录分隔符），提取目录和文件名
         if (str_contains($name, '/') || str_contains($name, '\\')) {
             $this->outputDir = dirname($name);
@@ -519,10 +566,6 @@ class Translator extends Preprocessor
             $this->climate->red('The target name `' . $name . '` must be a valid identifier');
             exit(1);
         }
-        if (in_array($name, Constants::CPP_RESERVED_NAMES)) {
-            $this->climate->red('The target name `' . $name . '` must not be a reserved keyword');
-            exit(1);
-        }
         $realTargetPath = $this->rootPath . '/' . $name;
         if (is_dir($realTargetPath)) {
             $this->climate->red('The target name `' . $name . '` must not be a directory');
@@ -569,7 +612,7 @@ class Translator extends Preprocessor
         // 在所有配置加载完成后，应用命令行参数（确保优先级最高）
         $this->applyCommandLineArguments();
 
-        return $list;
+        return $this->filterIgnoredFiles($list);
     }
 
     public function prepare(string $path): array
@@ -587,20 +630,7 @@ class Translator extends Preprocessor
         }
 
         $files = $this->getFiles($path);
-        // 应用 ignorePaths 过滤
-        if (!empty($this->ignorePaths)) {
-            $files = array_filter($files, function ($file) {
-                foreach ($this->ignorePaths as $ignorePath) {
-                    if ($file === $ignorePath) {
-                        return false;
-                    }
-                    if (is_dir($ignorePath) && str_starts_with($file, $ignorePath . DIRECTORY_SEPARATOR)) {
-                        return false;
-                    }
-                }
-                return true;
-            });
-        }
+        $files = $this->filterIgnoredFiles($files);
         // 分析 PHP 文件，预处理
         foreach ($files as $k => $file) {
             if (FileScanner::isPhpFile($file)) {
@@ -619,6 +649,29 @@ class Translator extends Preprocessor
         return $files;
     }
 
+    protected function shouldIgnoreFile(string $file): bool
+    {
+        foreach ($this->ignorePaths as $ignorePath) {
+            if ($file === $ignorePath) {
+                return true;
+            }
+            if (is_dir($ignorePath) && str_starts_with($file, rtrim($ignorePath, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    protected function filterIgnoredFiles(array $files): array
+    {
+        if (empty($this->ignorePaths)) {
+            return $files;
+        }
+
+        return array_values(array_filter($files, fn(string $file): bool => !$this->shouldIgnoreFile($file)));
+    }
+
     public function convert(array $files): array
     {
         $sourceFiles = [];
@@ -700,7 +753,7 @@ class Translator extends Preprocessor
         $propCount = max(1, count($this->propMap));
         $lines[] = 'extern THREAD_LOCAL uint32_t ' . self::PREFIX . self::PROP_MAP . '[' . $propCount . '];' . PHP_EOL;
 
-        foreach ($this->classes as $classDef) {
+        foreach ($this->getClassLikesWithConstants() as $classDef) {
             foreach ($classDef->constants as $constant) {
                 if ($constant->type === self::TYPE_ARRAY) {
                     $constName = self::PREFIX . $this->getNativeName($constant->name, $classDef->namespace, $classDef->name);
@@ -726,7 +779,8 @@ class Translator extends Preprocessor
         $this->genClassCeList();
         $this->indentLevel++;
 
-        $code = $this->genIncludeHeaderFiles();
+        $code = '#include <cstring>' . PHP_EOL;
+        $code .= $this->genIncludeHeaderFiles();
 
         if ($this->isBuildModeBin()) {
             $cliHeaders = [
@@ -809,8 +863,8 @@ CODE;
         }
 
         $code .= "// class \n";
-        foreach ($this->classes as $classDef) {
-            if ($classDef->requireCtor) {
+        foreach ($this->getClassLikesWithConstants() as $classDef) {
+            if ($classDef instanceof ClassDef && $classDef->requireCtor) {
                 $code .= 'static zend_object* (*create_object_' . $classDef->getNamespacedName() . ")(zend_class_entry *class_type);\n";
             }
             foreach ($classDef->constants as $constant) {
@@ -912,7 +966,7 @@ CODE;
         }
 
         $code .= '// class array constants' . PHP_EOL;
-        foreach ($this->classes as $classDef) {
+        foreach ($this->getClassLikesWithConstants() as $classDef) {
             foreach ($classDef->constants as $constant) {
                 if ($constant->type === self::TYPE_ARRAY) {
                     $constName = self::PREFIX . $this->getNativeName($constant->name, $classDef->namespace, $classDef->name);
@@ -947,13 +1001,28 @@ CODE;
                 }
                 $parentName = $this->escapeClass($parentDef->extends);
             }
+
+            foreach ($this->getClassImplementedInterfaces($classDef) as $interfaceName) {
+                if (!$this->hasInterface($interfaceName)) {
+                    continue;
+                }
+                $interfaceDef = $this->getInterface($interfaceName);
+                foreach ($interfaceDef->constants as $constant) {
+                    if ($constant->type === self::TYPE_ARRAY && !isset($ownConstNames[$constant->name])) {
+                        $ownConstNames[$constant->name] = true;
+                        $classNameStr = $this->genCharPtr($classDef->getNamespacedName(false), true);
+                        $classConstStr = $this->genCharPtr($constant->name);
+                        $code .= "php::updateConstant($classNameStr, $classConstStr, php::null);\n";
+                    }
+                }
+            }
         }
 
         // 扩展模式，需要在 RSHUTDOWN 阶段中清理函数、类、属性表
         if ($this->isBuildModeExt()) {
-            $code .= self::FUNC_MAP." = {}\n";
-            $code .= self::CLASS_MAP." = {}\n";
-            $code .= self::PROP_MAP." = {}\n";
+            $code .= 'std::memset(' . self::PREFIX . self::FUNC_MAP . ', 0, sizeof(' . self::PREFIX . self::FUNC_MAP . '));' . PHP_EOL;
+            $code .= 'std::memset(' . self::PREFIX . self::CLASS_MAP . ', 0, sizeof(' . self::PREFIX . self::CLASS_MAP . '));' . PHP_EOL;
+            $code .= 'std::memset(' . self::PREFIX . self::PROP_MAP . ', 0, sizeof(' . self::PREFIX . self::PROP_MAP . '));' . PHP_EOL;
         }
 
         $code .= '}' . PHP_EOL . PHP_EOL;
@@ -1446,7 +1515,7 @@ CODE;
         }
     }
 
-    protected function getCompileCommandOptions(): array
+    protected function getCommonCompileCommandOptions(): array
     {
         // 包含路径：系统路径 + 用户自定义路径
         $includePaths = $this->getIncludePaths();
@@ -1459,29 +1528,31 @@ CODE;
             'optimize' => $this->optimizeLevel,
             'debug' => $this->debug,
             'sanitize' => $this->sanitize,
-            'cpp_std' => $this->cxxStd,
             'march' => $this->march,
             'target_platform' => $this->targetPlatform,
             'is_zts' => $this->isPhpZts,
             'build_mode' => $this->buildMode,
             'enable_profiler' => $this->enableProfiler,
             'prof_output' => $this->targetName . '.prof',
-            'suppressed_warnings' => Constants::MSVC_SUPPRESSED_WARNINGS ?? [],
-            'cxxflags' => $this->cxxFlags,
             'user_defines' => $this->userDefines,
             'lto' => $this->enableLto,
         ];
     }
 
+    protected function getCompileCommandOptions(): array
+    {
+        $options = $this->getCommonCompileCommandOptions();
+        $options['cpp_std'] = $this->cxxStd;
+        $options['cxxflags'] = $this->cxxFlags;
+        $options['suppressed_warnings'] = Constants::MSVC_SUPPRESSED_WARNINGS ?? [];
+        return $options;
+    }
+
     protected function getCCompileCommandOptions(): array
     {
-        return [
-            'include_paths' => $this->getIncludePaths(),
-            'optimize' => 0,
-            'debug' => $this->debug,
-            'is_zts' => $this->isPhpZts,
-            'suppressed_warnings' => ['4244', '4146'],
-        ];
+        $options = $this->getCommonCompileCommandOptions();
+        $options['suppressed_warnings'] = ['4244', '4146'];
+        return $options;
     }
 
     /**
@@ -1491,41 +1562,30 @@ CODE;
      */
     protected function getNativeCompileCommandOptions(string $language = ''): array
     {
-        return [
-            'include_paths' => $this->getIncludePaths(),
-            'optimize' => $this->optimizeLevel,
-            'debug' => $this->debug,
-            'sanitize' => $this->sanitize,
-            'is_zts' => $this->isPhpZts,
-            'build_mode' => $this->buildMode,
-            'enable_profiler' => $this->enableProfiler,
-            'suppressed_warnings' => Constants::MSVC_SUPPRESSED_WARNINGS ?? [],
-            'march' => $this->march,
-            'target_platform' => $this->targetPlatform,
-        ];
+        $options = $this->getCommonCompileCommandOptions();
+        $options['suppressed_warnings'] = Constants::MSVC_SUPPRESSED_WARNINGS ?? [];
+
+        if ($language === 'objective-c++') {
+            $options['cpp_std'] = $this->cxxStd;
+            $options['cxxflags'] = $this->cxxFlags;
+        }
+
+        return $options;
     }
 
     protected function getLinkCommandOptions(): array
     {
         $ldflags = $this->ldflags;
-
+        $libraryPaths = array_merge($this->getLibraryPaths(), $this->linkPaths);
+        $libraries = $this->getLibraries();
         if ($this->enableProfiler) {
-            $ldflags .= ' -lprofiler';
-        }
-
-        // 用户通过 --link-lib / -l 指定的链接库
-        foreach ($this->linkLibs as $lib) {
-            $ldflags .= ' -l' . $lib;
-        }
-
-        // 用户通过 --link-path / -L 指定的库搜索路径
-        foreach ($this->linkPaths as $path) {
-            $ldflags .= ' -L' . escapeshellarg($path);
+            $libraries[] = 'profiler';
         }
+        $libraries = array_merge($libraries, $this->linkLibs);
 
         $options = [
-            'library_paths' => $this->getLibraryPaths(),
-            'libraries' => $this->getLibraries(),
+            'library_paths' => $libraryPaths,
+            'libraries' => $libraries,
             'ldflags' => $ldflags,
             'debug' => $this->debug,
             'no_console' => $this->noConsole,
@@ -1735,6 +1795,7 @@ CODE;
                     if (!$property->isStatic() && $property->arrayInitPlan && $property->default) {
                         $body = "auto value = {$property->arrayInitPlan->expr};\n";
                         $body .= 'zend_update_property(obj->ce, obj, ' . $this->genZendStrl($property->name) . ", value.ptr());\n";
+                        $body .= "php::throwErrorIfOccurred();\n";
                         $code .= $this->wrapArrayInitPlan($property->arrayInitPlan, $body);
                     }
                 }
@@ -1821,14 +1882,17 @@ CODE;
     protected function getRegisterClassFunctionCeList(ClassDef|InterfaceDef $classDef): array
     {
         $list = [];
+        if ($classDef instanceof InterfaceDef) {
+            foreach ($classDef->extendsList ?: ($classDef->extends ? [$classDef->extends] : []) as $parentInterface) {
+                $list[] = self::PREFIX . 'class_entry_' . $this->escapeCeName($parentInterface);
+            }
+            return $list;
+        }
+
         $parentCe = $this->getParentClassCe($classDef);
         if ($parentCe !== '') {
             $list = [$parentCe];
         }
-        //  interface 没有 implements
-        if ($classDef instanceof InterfaceDef) {
-            return $list;
-        }
         $implements = $this->getImplementCe($classDef);
 
         return array_merge($list, $implements);
@@ -1839,6 +1903,14 @@ CODE;
         return self::PREFIX . 'class_entry_' . $this->escapeCeName($classDef->getNamespacedName());
     }
 
+    /**
+     * @return array<ClassDef|InterfaceDef>
+     */
+    private function getClassLikesWithConstants(): array
+    {
+        return array_merge($this->classes, $this->interfaces);
+    }
+
     protected function getFilesFromDir(string $path): array
     {
         $scanner = new FileScanner($path);
@@ -1849,7 +1921,7 @@ CODE;
     protected function genClassArrayConstants(): string
     {
         $code = '';
-        foreach ($this->classes as $classDef) {
+        foreach ($this->getClassLikesWithConstants() as $classDef) {
             foreach ($classDef->constants as $constant) {
                 if ($constant->type === self::TYPE_ARRAY) {
                     $constName = self::PREFIX . $this->getNativeName($constant->name, $classDef->namespace, $classDef->name);
@@ -1887,23 +1959,55 @@ CODE;
                 }
                 $parentName = $this->escapeClass($parentDef->extends);
             }
+
+            foreach ($this->getClassImplementedInterfaces($classDef) as $interfaceName) {
+                if (!$this->hasInterface($interfaceName)) {
+                    continue;
+                }
+                $interfaceDef = $this->getInterface($interfaceName);
+                foreach ($interfaceDef->constants as $constant) {
+                    if ($constant->type === self::TYPE_ARRAY && !isset($ownConstNames[$constant->name])) {
+                        $ownConstNames[$constant->name] = true;
+                        $constName = self::PREFIX . $this->getNativeName($constant->name, $interfaceDef->namespace, $interfaceDef->name);
+                        $classNameStr = $this->genCharPtr($classDef->getNamespacedName(false), true);
+                        $classConstStr = $this->genCharPtr($constant->name);
+                        $code .= "php::updateConstant($classNameStr, $classConstStr, {$constName});\n";
+                    }
+                }
+            }
         }
 
         return $code;
     }
 
     protected function getAbsolutePath(string $path, string $projectDir): string
+    {
+        $absPath = $this->resolvePath($path, $projectDir, 'Source path');
+        return realpath($absPath);
+    }
+
+    protected function resolvePath(string $path, string $baseDir, string $label = 'Path'): string
     {
         $path = trim($path);
         if ($path === '') {
-            $this->error('Source path must not be empty');
+            $this->error($label . ' must not be empty');
         }
-        if ($path[0] !== '/') {
-            $absPath = $projectDir . '/' . $path;
-        } else {
-            $absPath = $path;
+
+        if ($this->isAbsolutePath($path)) {
+            return $path;
         }
-        return realpath($absPath);
+
+        return $baseDir . '/' . $path;
+    }
+
+    protected function isAbsolutePath(string $path): bool
+    {
+        return $path !== ''
+            && (
+                $path[0] === '/'
+                || $path[0] === '\\'
+                || preg_match('/^[A-Za-z]:[\\\\\\/]/', $path) === 1
+            );
     }
 
     protected function parseProjectYaml(string $path): array
@@ -1935,6 +2039,43 @@ CODE;
             $list = $this->getFilesFromDir($projectDir);
         }
 
+        if (array_key_exists('optimize', $cfg)) {
+            $this->optimizeLevel = (int) $cfg['optimize'];
+        }
+
+        if (array_key_exists('job', $cfg)) {
+            $this->maxJob = (int) $cfg['job'];
+        }
+
+        if (!empty($cfg['debug'])) {
+            $this->debug = true;
+        }
+
+        if (!empty($cfg['no-literal-strings'])) {
+            $this->noLiteralStrings = true;
+        }
+
+        if (!empty($cfg['profile'])) {
+            if (!$this->isLinux()) {
+                $this->climate->error('`profile` in YAML is only supported on Linux (requires gperftools)');
+                exit(1);
+            }
+            $this->enableProfiler = true;
+        }
+
+        if (!empty($cfg['no-progress'])) {
+            $this->noProgress = true;
+        }
+
+        if (!empty($cfg['no-console'])) {
+            $this->noConsole = true;
+        }
+
+        $sanitize = $cfg['sanitize'] ?? null;
+        if (!empty($sanitize)) {
+            $this->sanitize = (string) $sanitize;
+        }
+
         // 读取 cxx-flags
         $cxxFlags = $cfg['cxx-flags'] ?? null;
         if (!empty($cxxFlags)) {
@@ -1957,6 +2098,22 @@ CODE;
             $this->march = $march;
         }
 
+        // 读取 target-platform
+        $targetPlatform = $cfg['target-platform'] ?? null;
+        if (!empty($targetPlatform)) {
+            $this->targetPlatform = (string) $targetPlatform;
+        }
+
+        // 读取 build-dir
+        $buildDir = $cfg['build-dir'] ?? null;
+        if (!empty($buildDir)) {
+            $this->setBuildDir($this->resolvePath((string) $buildDir, $projectDir, 'Build path'));
+        }
+
+        if (!empty($cfg['dry'])) {
+            $this->dryRun = true;
+        }
+
         // 读取 ld-flags
         $ldflags = $cfg['ld-flags'] ?? null;
         if (!empty($ldflags)) {
@@ -1967,6 +2124,32 @@ CODE;
             }
         }
 
+        // 读取 include-paths
+        $includePaths = $cfg['include-paths'] ?? null;
+        if (!empty($includePaths) && is_array($includePaths)) {
+            foreach ($includePaths as $includePath) {
+                $this->userIncludePaths[] = $this->resolvePath((string) $includePath, $projectDir, 'Include path');
+            }
+        }
+
+        // 读取 defines
+        $defines = $cfg['defines'] ?? null;
+        if (!empty($defines) && is_array($defines)) {
+            foreach ($defines as $define) {
+                $this->userDefines[] = (string) $define;
+            }
+        }
+
+        // 读取 lto
+        if (!empty($cfg['lto'])) {
+            $this->enableLto = true;
+        }
+
+        // 读取 format
+        if (!empty($cfg['format'])) {
+            $this->enableCodeFormattingIfAvailable('YAML format');
+        }
+
         // 读取 link-libs
         $linkLibs = $cfg['link-libs'] ?? null;
         if (!empty($linkLibs) && is_array($linkLibs)) {
@@ -1979,13 +2162,14 @@ CODE;
         $linkPaths = $cfg['link-paths'] ?? null;
         if (!empty($linkPaths) && is_array($linkPaths)) {
             foreach ($linkPaths as $linkPath) {
-                $this->linkPaths[] = (string)$linkPath;
+                $this->linkPaths[] = $this->resolvePath((string) $linkPath, $projectDir, 'Link path');
             }
         }
 
-        // 读取 name
-        if (!empty($cfg['name'])) {
-            $this->setTargetName($cfg['name']);
+        // 读取 output/name
+        $output = $cfg['output'] ?? $cfg['name'] ?? null;
+        if (!empty($output)) {
+            $this->setTargetName($this->resolvePath((string) $output, $projectDir, 'Output path'));
         }
 
         // 读取 cpp-compiler
@@ -1994,8 +2178,8 @@ CODE;
             $this->setCppCompiler($cppCompiler);
         }
 
-        // 读取 type/build-mode（支持中横线和下划线）
-        $buildMode = $cfg['build-mode'] ?? $cfg['type'] ?? null;
+        // 读取 mode/type/build-mode（支持 CLI/YAML 两套命名）
+        $buildMode = $cfg['mode'] ?? $cfg['build-mode'] ?? $cfg['type'] ?? null;
         if (!empty($buildMode)) {
             // 映射常见的类型名称到内部 buildMode
             $modeMap = [
@@ -2048,7 +2232,7 @@ CODE;
             $this->resourceConfig['_projectDir'] = $projectDir;
         }
 
-        return $list;
+        return $this->filterIgnoredFiles($list);
     }
 
     protected function getInternalCeInfo(string $ce): array
@@ -2151,14 +2335,13 @@ CODE;
         $sorter = new StringSort();
 
         foreach ($this->interfaces as $interfaceDef) {
-            $parent = $interfaceDef->extends;
             $ce = $this->getClassCe($interfaceDef);
             $deps = [];
 
-            if ($parent) {
+            foreach ($interfaceDef->extendsList ?: ($interfaceDef->extends ? [$interfaceDef->extends] : []) as $parent) {
+                $tmpCe = self::PREFIX . 'class_entry_' . $this->escapeCeName($parent);
                 // 不存在的接口，说明可能是内置接口
-                $tmpCe = $this->getParentClassCe($interfaceDef);
-                if (!isset($this->interfaces[$parent])) {
+                if (!$this->hasInterface($parent)) {
                     $sorter->add($tmpCe);
                 }
                 $deps[] = $tmpCe;
@@ -2348,9 +2531,31 @@ CODE;
 
                 $traitAst = clone $traitDef->trait;
                 $traitStmts = $traitAst->stmts;
+                $aliasStmts = [];
                 foreach ($traitStmts as $k1 => $traitStmt) {
                     if ($traitStmt instanceof Node\Stmt\ClassMethod) {
                         $methodName = strtolower($traitStmt->name->toString());
+                        $fullMethodName = $this->getFullMethodName($traitFullName, $methodName);
+                        foreach ($classDef->traitAliases[$fullMethodName] ?? [] as $alias) {
+                            $aliasName = strtolower($alias['newName']);
+                            if ($aliasName === $methodName) {
+                                if ($alias['newModifier']) {
+                                    $traitStmt->flags = $alias['newModifier'];
+                                }
+                            } elseif (!isset($methods[$aliasName]) && !isset($traitMethods[$aliasName])) {
+                                $aliasStmt = clone $traitStmt;
+                                $aliasStmt->name = new Node\Identifier($alias['newName']);
+                                if ($alias['newModifier']) {
+                                    $aliasStmt->flags = $alias['newModifier'];
+                                }
+                                $aliasStmts[] = $aliasStmt;
+                                $traitMethods[$aliasName] = [$traitFullName, $aliasStmt];
+                            }
+                        }
+                        if (isset($classDef->traitIgnored[$fullMethodName])) {
+                            unset($traitStmts[$k1]);
+                            continue;
+                        }
                         if (isset($traitMethods[$methodName])) {
                             [$existingTraitName, $existingStmt] = $traitMethods[$methodName];
                             $newAbstract = $traitStmt->isAbstract();
@@ -2383,19 +2588,6 @@ CODE;
                             // Both concrete — error
                             $this->fatalError($classStmt, "Trait `{$traitFullName}` method `{$methodName}` already exists");
                         }
-                        $fullMethodName = $this->getFullMethodName($traitFullName, $methodName);
-                        if (isset($classDef->traitAliases[$fullMethodName])) {
-                            $alias = $classDef->traitAliases[$fullMethodName];
-                            $methodName = $alias['newName'];
-                            $traitStmt->name = new Node\Identifier($methodName);
-                            if ($alias['newModifier']) {
-                                $traitStmt->flags = $alias['newModifier'];
-                            }
-                        }
-                        if (isset($classDef->traitIgnored[$fullMethodName])) {
-                            unset($traitStmts[$k1]);
-                            continue;
-                        }
                         if (isset($methods[$methodName])) {
                             unset($traitStmts[$k1]);
                         }
@@ -2405,29 +2597,59 @@ CODE;
                         foreach ($traitStmt->consts as $k2 => $const) {
                             $constName = strtolower($const->name->toString());
                             if (isset($constants[$constName])) {
-                                unset($traitStmts[$k1][$k2]);
+                                unset($traitStmt->consts[$k2]);
+                                if (!$traitStmt->consts) {
+                                    unset($traitStmts[$k1]);
+                                }
+                                continue;
                             }
                             if (isset($traitConstants[$constName])) {
-                                $this->fatalError($classStmt, "Trait `{$traitFullName}` constant `{$constName}` already exists");
+                                [$existingConstStmt, $existingConst] = $traitConstants[$constName];
+                                if ($existingConstStmt->flags !== $traitStmt->flags ||
+                                    $this->typeNodeToStringOrNull($existingConstStmt->type) !== $this->typeNodeToStringOrNull($traitStmt->type) ||
+                                    $this->printer->prettyPrintExpr($existingConst->value) !== $this->printer->prettyPrintExpr($const->value)) {
+                                    $this->fatalError($classStmt, "Trait `{$traitFullName}` constant `{$constName}` already exists");
+                                }
+                                unset($traitStmt->consts[$k2]);
+                                if (!$traitStmt->consts) {
+                                    unset($traitStmts[$k1]);
+                                }
+                                continue;
                             }
-                            $traitConstants[$constName] = $const;
+                            $traitConstants[$constName] = [$traitStmt, $const];
                         }
                     }
                     if ($traitStmt instanceof Node\Stmt\Property) {
                         foreach ($traitStmt->props as $k2 => $prop) {
                             $propName = strtolower($prop->name->toString());
                             if (isset($properties[$propName])) {
-                                unset($traitStmts[$k1][$k2]);
+                                unset($traitStmt->props[$k2]);
+                                if (!$traitStmt->props) {
+                                    unset($traitStmts[$k1]);
+                                }
+                                continue;
                             }
                             if (isset($traitProperties[$propName])) {
-                                $this->fatalError($classStmt, "Trait `{$traitFullName}` property `{$propName}` already exists");
+                                [$existingPropStmt, $existingProp] = $traitProperties[$propName];
+                                $existingDefault = $existingProp->default ? $this->printer->prettyPrintExpr($existingProp->default) : null;
+                                $propDefault = $prop->default ? $this->printer->prettyPrintExpr($prop->default) : null;
+                                if ($existingPropStmt->flags !== $traitStmt->flags ||
+                                    $this->typeNodeToStringOrNull($existingPropStmt->type) !== $this->typeNodeToStringOrNull($traitStmt->type) ||
+                                    $existingDefault !== $propDefault) {
+                                    $this->fatalError($classStmt, "Trait `{$traitFullName}` property `{$propName}` already exists");
+                                }
+                                unset($traitStmt->props[$k2]);
+                                if (!$traitStmt->props) {
+                                    unset($traitStmts[$k1]);
+                                }
+                                continue;
                             }
-                            $traitProperties[$propName] = $prop;
+                            $traitProperties[$propName] = [$traitStmt, $prop];
                         }
                     }
                 }
 
-                $stmt->stmts = array_merge($stmt->stmts, $traitStmts);
+                $stmt->stmts = array_merge($stmt->stmts, $traitStmts, $aliasStmts);
             }
         }
     }
@@ -2537,6 +2759,11 @@ CODE;
         return $this->printer->prettyPrint([$typeNode]);
     }
 
+    private function typeNodeToStringOrNull(?NodeAbstract $typeNode): ?string
+    {
+        return $typeNode ? $this->typeNodeToString($typeNode) : null;
+    }
+
     protected function parseClass(Node\Stmt\Class_|Node\Stmt\Trait_|Node\Stmt\Enum_ $class): string
     {
         $this->class = $this->parseIdentifier($class->name);
@@ -2596,6 +2823,10 @@ CODE;
                     break;
             }
         }
+        if (!$class instanceof Node\Stmt\Trait_) {
+            $this->checkInterfaceImplementations($class);
+            $this->checkInheritedAbstractMethodsAreImplemented($class);
+        }
         $code = $this->genNativeMethod($methodCodes);
 
         $oriCtx = $this->context;
@@ -2621,10 +2852,13 @@ CODE;
         return $code;
     }
 
-    protected function genWrapperFunctionArgs(string $fn, FunctionDef $functionDef): string
+    protected function genWrapperFunctionArgs(string $fn, FunctionDef $functionDef, string $displayName): string
     {
         $cppCode = '';
         $callParams = '';
+        if ($functionDef->argCountRequired > 0) {
+            $cppCode .= $this->genWrapperRequiredArgCountCheck($functionDef, $displayName);
+        }
         foreach ($functionDef->argInfoList as $k => $argInfo) {
             $var = 'arg_' . $argInfo->name;
             if ($argInfo->variadic) {
@@ -2645,8 +2879,6 @@ CODE;
                 } else {
                     if ($argInfo->byRef) {
                         $argExpr = 'php::getCallArgByRef(' . $k . ')';
-                    } elseif ($argInfo->nullable) {
-                        $argExpr = 'php::getCallArg(' . $k . ', php::null)';
                     } else {
                         $argExpr = 'php::getCallArg(' . $k . ')';
                     }
@@ -2676,13 +2908,33 @@ CODE;
         return $cppCode;
     }
 
+    private function genWrapperRequiredArgCountCheck(FunctionDef $functionDef, string $displayName): string
+    {
+        $required = $functionDef->argCountRequired;
+        $expected = $required === count($functionDef->argInfoList) ? 'exactly' : 'at least';
+        $message = 'php::concat({'
+            . 'php::Str(' . $this->genCharPtr('Too few arguments to function ' . $displayName . '(), ', true) . '), '
+            . 'php::toString(php::getCallArgNum()), '
+            . 'php::Str(' . $this->genCharPtr(' passed and ' . $expected . ' ' . $required . ' expected', true) . ')'
+            . '})';
+
+        $code = $this->getIndent() . 'if (UNEXPECTED(php::getCallArgNum() < ' . $required . ')) {' . PHP_EOL;
+        $this->indentLevel++;
+        $code .= $this->getIndent() . 'php::throwException(zend_ce_argument_count_error, (' . $message . ').toCString());' . PHP_EOL;
+        $code .= $this->getIndent() . 'return;' . PHP_EOL;
+        $this->indentLevel--;
+        $code .= $this->getIndent() . '}' . PHP_EOL;
+
+        return $code;
+    }
+
     protected function genMethodWrapper(ClassDef $classDef, MethodDef $methodDef): string
     {
         $name = $classDef->getNamespacedName();
         $cppCode = 'ZEND_METHOD(' . $name . ', ' . $methodDef->name . '){' . PHP_EOL;
         $cppCode .= $this->getIndent() . self::TYPE_OBJECT . ' this_(&execute_data->This);' . PHP_EOL;
         $fn = self::PREFIX . $this->getNativeMethodName($classDef, $methodDef);
-        $cppCode .= $this->genWrapperFunctionArgs($fn, $methodDef->functionDef);
+        $cppCode .= $this->genWrapperFunctionArgs($fn, $methodDef->functionDef, $classDef->getNamespacedName(false) . '::' . $methodDef->name);
 
         return $cppCode;
     }
@@ -2875,19 +3127,19 @@ CODE;
         $this->indentLevel++;
         $code .= $this->genScopeVarDecl();
         $code .= "\n";
-        // Constructor Property Promotion
-        foreach ($this->functionDef->argInfoList as $argInfo) {
-            if (!$argInfo->property) {
-                continue;
-            }
-            $code .= $this->genPropertyPromotion($argInfo);
-        }
         // Runtime union/nullable parameter type checks
         foreach ($this->functionDef->argInfoList as $i => $argInfo) {
             if (!empty($argInfo->typeCheck)) {
                 $code .= $this->genUnionParamCheck($argInfo, $i);
             }
         }
+        // Constructor Property Promotion happens after parameter type validation.
+        foreach ($this->functionDef->argInfoList as $argInfo) {
+            if (!$argInfo->property) {
+                continue;
+            }
+            $code .= $this->genPropertyPromotion($argInfo);
+        }
         $this->indentLevel--;
         // 构建 PHP 级别的函数名用于 debug backtrace
         if ($this->class) {
@@ -2931,9 +3183,13 @@ CODE;
             }
             // 父类是内置类
             if ($classDef->inheritedFromInternalClass) {
-                if (Reflection::getClassMethodModifiers($extends, $name) & \ReflectionMethod::IS_PRIVATE) {
+                $modifiers = Reflection::getClassMethodModifiers($extends, $name);
+                if ($modifiers & \ReflectionMethod::IS_PRIVATE) {
                     goto _error;
                 }
+                if ($modifiers & \ReflectionMethod::IS_FINAL) {
+                    goto _final_error;
+                }
                 break;
             }
             $classDef = $this->getClass($extends);
@@ -2945,17 +3201,26 @@ CODE;
                         'Cannot override private method `' .
                         $extends . '::' . $name . '()`');
                 }
-                $parentFuncDef = $methodDef->functionDef;
-                $this->validateMethodOverrideSignature($v, $name, $childFuncDef, $methodDef, $extends);
+                if ($methodDef->flags & Modifiers::FINAL) {
+                    _final_error:
+                    $this->fatalError($v,
+                        'Cannot override final method `' .
+                        $extends . '::' . $name . '()`');
+                }
+                $this->validateMethodOverrideSignature($v, $name, $this->methodDef, $methodDef, $extends);
+                break;
+            }
+            if ($classDef->hasAbstractMethod($name) && isset($classDef->abstractMethodDefs[strtolower($name)])) {
+                $this->validateMethodOverrideSignature($v, $name, $this->methodDef, $classDef->getAbstractMethod($name), $extends);
                 break;
             }
         }
     }
 
     private function validateMethodOverrideSignature(
-        Node\Stmt\ClassMethod $v,
+        NodeAbstract $v,
         string $methodName,
-        FunctionDef $childFuncDef,
+        MethodDef $childMethodDef,
         MethodDef $parentMethodDef,
         string $parentClass
     ): void {
@@ -2966,31 +3231,39 @@ CODE;
                 "with `{$parentClass}::{$methodName}()`");
         };
 
-        // Compare visibility (public/protected/private)
-        if (($this->methodDef->flags & Modifiers::VISIBILITY_MASK) !== ($parentMethodDef->flags & Modifiers::VISIBILITY_MASK)) {
+        // PHP allows widening visibility in overrides (e.g. protected -> public),
+        // but forbids narrowing it.
+        if ($this->getVisibilityRank($childMethodDef->flags) < $this->getVisibilityRank($parentMethodDef->flags)) {
             $error('visibility mismatch');
         }
 
+        if (($childMethodDef->flags & Modifiers::STATIC) !== ($parentMethodDef->flags & Modifiers::STATIC)) {
+            $error('static mismatch');
+        }
+
+        $childFuncDef = $childMethodDef->functionDef;
         $parentFuncDef = $parentMethodDef->functionDef;
-        if (!$parentFuncDef) {
+        if (!$childFuncDef || !$parentFuncDef) {
             return;
         }
 
-        // Compare parameter count
-        if (count($childFuncDef->argInfoList) !== count($parentFuncDef->argInfoList)) {
-            $error('parameter count mismatch');
+        if (!$this->isReturnTypeOverrideCompatible($childFuncDef, $parentFuncDef)) {
+            $error('return type mismatch');
         }
 
-        // Compare return type
-        if ($childFuncDef->returnType !== $parentFuncDef->returnType ||
-            $childFuncDef->returnClass !== $parentFuncDef->returnClass) {
-            $error('return type mismatch');
+        // Child methods may add optional trailing parameters, but they cannot
+        // require more arguments than the parent contract.
+        if ($childFuncDef->argCountRequired > $parentFuncDef->argCountRequired) {
+            $error('required parameter count mismatch');
         }
 
-        // Compare each parameter
+        // Compare each parent-declared parameter position.
         foreach ($parentFuncDef->argInfoList as $i => $parentArg) {
+            if (!isset($childFuncDef->argInfoList[$i])) {
+                $error("missing parameter #{$i}");
+            }
             $childArg = $childFuncDef->argInfoList[$i];
-            if ($childArg->type !== $parentArg->type || $childArg->class !== $parentArg->class) {
+            if (!$this->isParameterTypeOverrideCompatible($childArg, $parentArg)) {
                 $error("parameter #{$i} type mismatch");
             }
             if ($childArg->byRef !== $parentArg->byRef) {
@@ -3000,6 +3273,162 @@ CODE;
                 $error("parameter #{$i} variadic mismatch");
             }
         }
+
+        // Any extra child parameters must be optional or variadic.
+        for ($i = count($parentFuncDef->argInfoList); $i < count($childFuncDef->argInfoList); $i++) {
+            $childArg = $childFuncDef->argInfoList[$i];
+            if (!$childArg->variadic && $childArg->defaultValue === null) {
+                $error("extra required parameter #{$i}");
+            }
+        }
+    }
+
+    private function isReturnTypeOverrideCompatible(FunctionDef $childFuncDef, FunctionDef $parentFuncDef): bool
+    {
+        if ($parentFuncDef->returnTypeUndeclared) {
+            return true;
+        }
+        if ($childFuncDef->returnTypeUndeclared) {
+            return false;
+        }
+        if ($parentFuncDef->returnTypeCheck || $childFuncDef->returnTypeCheck) {
+            return $parentFuncDef->returnTypeStr === $childFuncDef->returnTypeStr;
+        }
+        if ($parentFuncDef->returnType === self::TYPE_VAR) {
+            return true;
+        }
+        if ($childFuncDef->returnType !== $parentFuncDef->returnType) {
+            return false;
+        }
+        if ($parentFuncDef->returnType !== self::TYPE_OBJECT) {
+            return true;
+        }
+        if ($childFuncDef->returnClass === $parentFuncDef->returnClass) {
+            return true;
+        }
+        if (!$childFuncDef->returnClass || !$parentFuncDef->returnClass) {
+            return false;
+        }
+        return $this->isInheritedFrom($childFuncDef->returnClass, $parentFuncDef->returnClass);
+    }
+
+    private function isParameterTypeOverrideCompatible(ArgInfo $childArg, ArgInfo $parentArg): bool
+    {
+        if ($parentArg->typeCheck || $childArg->typeCheck) {
+            return $parentArg->typeStr === $childArg->typeStr;
+        }
+        if ($childArg->undeclared || $childArg->type === self::TYPE_VAR) {
+            return true;
+        }
+        if ($parentArg->undeclared || $parentArg->type === self::TYPE_VAR) {
+            return false;
+        }
+        if ($childArg->type !== $parentArg->type) {
+            return false;
+        }
+        if ($parentArg->type !== self::TYPE_OBJECT) {
+            return true;
+        }
+        if ($childArg->class === $parentArg->class) {
+            return true;
+        }
+        if (!$childArg->class || !$parentArg->class) {
+            return false;
+        }
+        return $this->isInheritedFrom($parentArg->class, $childArg->class);
+    }
+
+    private function checkInterfaceImplementations(Node\Stmt\Class_|Node\Stmt\Enum_ $classStmt): void
+    {
+        $classDef = $this->classDef;
+        foreach ($this->getClassImplementedInterfaces($classDef) as $interfaceName) {
+            $this->checkInterfaceImplementation($classStmt, $classDef, $interfaceName);
+        }
+    }
+
+    private function checkInterfaceImplementation(NodeAbstract $node, ClassDef $classDef, string $interfaceName): void
+    {
+        if ($this->isInternalInterface($interfaceName)) {
+            return;
+        }
+        if (!$this->hasInterface($interfaceName)) {
+            return;
+        }
+
+        $interfaceDef = $this->getInterface($interfaceName);
+        foreach ($interfaceDef->methods as $methodName => $interfaceMethodDef) {
+            $childMethodDef = $this->findClassMethodDef($classDef, $methodName, $classDef->isAbstract());
+            if ($childMethodDef === null) {
+                if ($classDef->isAbstract()) {
+                    continue;
+                }
+                $this->fatalError($node, "Class `{$classDef->getNamespacedName(false)}` must implement method `{$interfaceName}::{$interfaceMethodDef->name}()`");
+            }
+            $this->validateMethodOverrideSignature(
+                $node,
+                $interfaceMethodDef->name,
+                $childMethodDef,
+                $interfaceMethodDef,
+                $interfaceName
+            );
+        }
+
+        foreach ($interfaceDef->extendsList ?: ($interfaceDef->extends ? [$interfaceDef->extends] : []) as $parentInterface) {
+            $this->checkInterfaceImplementation($node, $classDef, $parentInterface);
+        }
+    }
+
+    private function findClassMethodDef(ClassDef $classDef, string $methodName, bool $includeAbstract = true): ?MethodDef
+    {
+        $current = $classDef;
+        while (true) {
+            if ($current->hasMethod($methodName)) {
+                return $current->getMethod($methodName);
+            }
+            if ($includeAbstract && $current->hasAbstractMethod($methodName) && isset($current->abstractMethodDefs[strtolower($methodName)])) {
+                return $current->getAbstractMethod($methodName);
+            }
+            if (!$current->extends || !$this->hasClass($current->extends)) {
+                return null;
+            }
+            $current = $this->getClass($current->extends);
+        }
+    }
+
+    private function checkInheritedAbstractMethodsAreImplemented(NodeAbstract $node): void
+    {
+        $classDef = $this->classDef;
+        if ($classDef->isAbstract()) {
+            return;
+        }
+
+        $current = $classDef;
+        while ($current->extends && $this->hasClass($current->extends)) {
+            $parent = $this->getClass($current->extends);
+            foreach ($parent->abstractMethodDefs as $methodName => $abstractMethodDef) {
+                if ($this->findClassMethodDef($classDef, $methodName, false) === null) {
+                    $this->fatalError(
+                        $node,
+                        "Class `{$classDef->getNamespacedName(false)}` must implement abstract method `{$parent->getNamespacedName(false)}::{$abstractMethodDef->name}()`"
+                    );
+                }
+            }
+            $current = $parent;
+        }
+    }
+
+    private function getVisibilityRank(int $flags): int
+    {
+        if ($flags & Modifiers::PUBLIC) {
+            return 3;
+        }
+        if ($flags & Modifiers::PROTECTED) {
+            return 2;
+        }
+        if ($flags & Modifiers::PRIVATE) {
+            return 1;
+        }
+        return 3;
     }
 
     private function checkPropertyOverride(Node\Stmt\Class_|Node\Stmt\Trait_|Node\Stmt\Enum_ $classStmt): void
@@ -3016,12 +3445,17 @@ CODE;
             foreach ($this->classDef->properties as $name => $childProp) {
                 if ($chainNode->hasProperty($name)) {
                     $parentProp = $chainNode->getProperty($name);
+                    if ($parentProp->flags & Modifiers::PRIVATE) {
+                        $this->fatalError($classStmt,
+                            "Declaration of `{$className}::\${$name}` conflicts with private property " .
+                            "`{$parentClass}::\${$name}`; property shadowing across inheritance is not allowed");
+                    }
                     if ($childProp->type !== $parentProp->type || $childProp->class !== $parentProp->class) {
                         $this->fatalError($classStmt,
                             "Declaration of `{$className}::\${$name}` must be compatible " .
                             "with `{$parentClass}::\${$name}`");
                     }
-                    if (($childProp->flags & Modifiers::VISIBILITY_MASK) !== ($parentProp->flags & Modifiers::VISIBILITY_MASK)) {
+                    if ($this->getVisibilityRank($childProp->flags) < $this->getVisibilityRank($parentProp->flags)) {
                         $this->fatalError($classStmt,
                             "Declaration of `{$className}::\${$name}` must be compatible " .
                             "with `{$parentClass}::\${$name}`");
@@ -3050,12 +3484,15 @@ CODE;
             foreach ($this->classDef->constants as $name => $childConst) {
                 if ($chainNode->hasConstant($name)) {
                     $parentConst = $chainNode->getConstant($name);
+                    if ($parentConst->flags & Modifiers::PRIVATE) {
+                        continue;
+                    }
                     if ($childConst->type !== $parentConst->type || $childConst->class !== $parentConst->class) {
                         $this->fatalError($classStmt,
                             "Declaration of `{$className}::{$name}` must be compatible " .
                             "with `{$parentClass}::{$name}`");
                     }
-                    if (($childConst->flags & Modifiers::VISIBILITY_MASK) !== ($parentConst->flags & Modifiers::VISIBILITY_MASK)) {
+                    if ($this->getVisibilityRank($childConst->flags) < $this->getVisibilityRank($parentConst->flags)) {
                         $this->fatalError($classStmt,
                             "Declaration of `{$className}::{$name}` must be compatible " .
                             "with `{$parentClass}::{$name}`");
@@ -3095,12 +3532,18 @@ CODE;
             // 将 Trait 中定义的 常量、静态常量、属性、方法、静态属性复制到当前类中
             foreach ($traitDef->constants as $const) {
                 if ($classDef->hasConstant($const->name)) {
+                    if (!$this->isCompatibleTraitConstant($classDef->getConstant($const->name), $const)) {
+                        $this->fatalError($v, "Trait `{$traitFullName}` constant `{$const->name}` conflicts with class `{$classDef->getNamespacedName(false)}`");
+                    }
                     continue;
                 }
                 $classDef->constants[$const->name] = $const;
             }
             foreach ($traitDef->properties as $prop) {
                 if ($classDef->hasProperty($prop->name)) {
+                    if (!$this->isCompatibleTraitProperty($classDef->getProperty($prop->name), $prop)) {
+                        $this->fatalError($v, "Trait `{$traitFullName}` property `{$prop->name}` conflicts with class `{$classDef->getNamespacedName(false)}`");
+                    }
                     continue;
                 }
                 $classDef->properties[$prop->name] = $prop;
@@ -3108,56 +3551,122 @@ CODE;
             foreach ($traitDef->methods as $methodDef) {
                 $classMethodName = $traitMethodName = $methodDef->name;
                 $fullMethodName = $this->getFullMethodName($traitFullName, $traitMethodName);
-                // Trait 设置了别名
-                if (isset($classDef->traitAliases[$fullMethodName])) {
-                    $alias = $classDef->traitAliases[$fullMethodName];
-                    $methodDef = clone $methodDef;
-                    $classMethodName = $methodDef->name = $alias['newName'];
+                $originalMethodDef = $methodDef;
+                $aliasMethodDefs = [];
+                foreach ($classDef->traitAliases[$fullMethodName] ?? [] as $alias) {
+                    if (strtolower($alias['newName']) === strtolower($traitMethodName)) {
+                        if ($alias['newModifier']) {
+                            if ($originalMethodDef === $methodDef) {
+                                $originalMethodDef = clone $methodDef;
+                            }
+                            $originalMethodDef->flags = $this->parseModifiers($alias['newModifier']);
+                        }
+                        continue;
+                    }
+                    $aliasMethodDef = clone $methodDef;
+                    $classMethodName = $aliasMethodDef->name = $alias['newName'];
                     if ($alias['newModifier']) {
-                        $methodDef->flags = $this->parseModifiers($alias['newModifier']);
+                        $aliasMethodDef->flags = $this->parseModifiers($alias['newModifier']);
                     }
+                    $aliasMethodDefs[strtolower($classMethodName)] = [$classMethodName, $aliasMethodDef];
                 }
                 // 设置了 insteadof 选项，此 Trait 的方法将不会被使用
                 if (isset($classDef->traitIgnored[$fullMethodName])) {
+                    foreach ($aliasMethodDefs as [$aliasMethodName, $aliasMethodDef]) {
+                        if ($classDef->hasMethod($aliasMethodName)) {
+                            continue;
+                        }
+                        $methodCodes[$aliasMethodName] = $this->addTraitMethodWrapper(
+                            $classDef,
+                            $traitDef,
+                            $aliasMethodDef,
+                            $traitMethodName,
+                            $aliasMethodName
+                        );
+                    }
                     continue;
                 }
                 // 类中已经有同名方法，则不使用 Trait 中的方法
-                if ($classDef->hasMethod($classMethodName)) {
-                    continue;
+                if (!$classDef->hasMethod($traitMethodName)) {
+                    $methodCodes[$traitMethodName] = $this->addTraitMethodWrapper(
+                        $classDef,
+                        $traitDef,
+                        $originalMethodDef,
+                        $traitMethodName,
+                        $traitMethodName
+                    );
                 }
 
-                $classDef->addMethod($methodDef);
-                $traitMethodNativeName = $this->getNativeName($traitMethodName, $traitDef->namespace, $traitDef->name);
-                $classMethodNativeName = $this->getNativeName($classMethodName, $classDef->namespace, $classDef->name);
-                $argList = ['this_'];
-                foreach ($methodDef->functionDef->argInfoList as $argInfo) {
-                    $argList[] = $argInfo->name;
-                }
-                $argv = implode(', ', $argList);
-
-                $code = $methodDef->getReturnType() . ' ' . self::PREFIX . $classMethodNativeName . '(';
-                if ($this->class) {
-                    $code .= self::TYPE_OBJECT . ' &this_';
-                    if ($methodDef->functionDef->params) {
-                        $code .= ', ';
+                foreach ($aliasMethodDefs as [$aliasMethodName, $aliasMethodDef]) {
+                    if ($classDef->hasMethod($aliasMethodName)) {
+                        continue;
                     }
+                    $methodCodes[$aliasMethodName] = $this->addTraitMethodWrapper(
+                        $classDef,
+                        $traitDef,
+                        $aliasMethodDef,
+                        $traitMethodName,
+                        $aliasMethodName
+                    );
                 }
+            }
+        }
+    }
 
-                $this->addFunction($classMethodNativeName, $methodDef->functionDef);
+    private function addTraitMethodWrapper(
+        ClassDef $classDef,
+        ClassDef $traitDef,
+        MethodDef $methodDef,
+        string $traitMethodName,
+        string $classMethodName
+    ): string {
+        $classDef->addMethod($methodDef);
+        $traitMethodNativeName = $this->getNativeName($traitMethodName, $traitDef->namespace, $traitDef->name);
+        $classMethodNativeName = $this->getNativeName($classMethodName, $classDef->namespace, $classDef->name);
+        $argList = ['this_'];
+        foreach ($methodDef->functionDef->argInfoList as $argInfo) {
+            $argList[] = $argInfo->name;
+        }
+        $argv = implode(', ', $argList);
 
-                $code .= $methodDef->functionDef->params . ')';
-                $code .= '{' . PHP_EOL;
-                $this->indentLevel++;
-                $methodCall = self::PREFIX . $traitMethodNativeName . '(' . $argv . ')';
-                if ($methodDef->getReturnType() !== self::TYPE_VOID) {
-                    $methodCall = 'return ' . $methodCall;
-                }
-                $code .= $this->getIndent() . $methodCall . ';' . PHP_EOL;
-                $this->indentLevel--;
-                $code .= $this->getIndent() . '}' . PHP_EOL;
-                $methodCodes[$classMethodName] = $code;
+        $code = $methodDef->getReturnType() . ' ' . self::PREFIX . $classMethodNativeName . '(';
+        if ($this->class) {
+            $code .= self::TYPE_OBJECT . ' &this_';
+            if ($methodDef->functionDef->params) {
+                $code .= ', ';
             }
         }
+
+        $this->addFunction($classMethodNativeName, $methodDef->functionDef);
+
+        $code .= $methodDef->functionDef->params . ')';
+        $code .= '{' . PHP_EOL;
+        $this->indentLevel++;
+        $methodCall = self::PREFIX . $traitMethodNativeName . '(' . $argv . ')';
+        if ($methodDef->getReturnType() !== self::TYPE_VOID) {
+            $methodCall = 'return ' . $methodCall;
+        }
+        $code .= $this->getIndent() . $methodCall . ';' . PHP_EOL;
+        $this->indentLevel--;
+        $code .= $this->getIndent() . '}' . PHP_EOL;
+        return $code;
+    }
+
+    private function isCompatibleTraitConstant(ConstantDef $existing, ConstantDef $incoming): bool
+    {
+        return $existing->flags === $incoming->flags &&
+            $existing->type === $incoming->type &&
+            $existing->class === $incoming->class &&
+            $existing->value === $incoming->value;
+    }
+
+    private function isCompatibleTraitProperty(PropertyDef $existing, PropertyDef $incoming): bool
+    {
+        return $existing->flags === $incoming->flags &&
+            $existing->type === $incoming->type &&
+            $existing->class === $incoming->class &&
+            $existing->nullable === $incoming->nullable &&
+            $existing->default === $incoming->default;
     }
 
     protected function parseForeachObject(Foreach_ $node): string
@@ -3249,7 +3758,7 @@ CODE;
         $name = $this->escapeZendFnName($functionDef->getNamespacedName());
         $cppCode = 'ZEND_FUNCTION(' . $name . '){' . PHP_EOL;
         $fn = self::PREFIX . $this->getNativeName($functionDef->name, $functionDef->namespace);
-        $cppCode .= $this->genWrapperFunctionArgs($fn, $functionDef);
+        $cppCode .= $this->genWrapperFunctionArgs($fn, $functionDef, $functionDef->getNamespacedName());
 
         return $cppCode;
     }
diff --git a/src/Php/UniversalMethodCall.php b/src/Php/UniversalMethodCall.php
index 2316f822..cbe8bf91 100644
--- a/src/Php/UniversalMethodCall.php
+++ b/src/Php/UniversalMethodCall.php
@@ -674,7 +674,7 @@ trait UniversalMethodCall
         }
         $argExprs = [];
         foreach ($args as $i => $arg) {
-            $expr = $this->parseExpr($arg->value);
+            $expr = $this->parseOrderedOperand($arg->value, false);
             if (in_array($i, $intCastArgs, true)) {
                 $expr = 'php::toInt(' . $expr . ')';
             }
@@ -804,7 +804,7 @@ trait UniversalMethodCall
     {
         $userArgs = [];
         foreach ($args as $arg) {
-            $userArgs[] = $this->parseExpr($arg->value);
+            $userArgs[] = $this->parseOrderedOperand($arg->value, false);
         }
 
         if ($receiverPos === 0) {
diff --git a/tests/aot/arrow_fn/002.phpt b/tests/aot/arrow_fn/002.phpt
index 56ba5c2d..67cb80b3 100644
--- a/tests/aot/arrow_fn/002.phpt
+++ b/tests/aot/arrow_fn/002.phpt
@@ -5,7 +5,7 @@ arrow function 2
 function main()
 {
     $array = [1, 5, 9];
-    $fn1 = fn($x) => var_dump(0, ...$array);
+    $fn1 = fn() => var_dump(0, ...$array);
     $fn1();
 }
 ?>
diff --git a/tests/aot/basic/condition-assign.phpt b/tests/aot/basic/condition-assign.phpt
new file mode 100644
index 00000000..645f7868
--- /dev/null
+++ b/tests/aot/basic/condition-assign.phpt
@@ -0,0 +1,12 @@
+--TEST--
+condition assign
+--FILE--
+<?php
+function main() {
+    if ($value = true) {
+        echo "success";
+    }
+}
+?>
+--EXPECT--
+success
diff --git a/tests/aot/class/new-and-call.phpt b/tests/aot/class/new-and-call.phpt
new file mode 100644
index 00000000..32731736
--- /dev/null
+++ b/tests/aot/class/new-and-call.phpt
@@ -0,0 +1,20 @@
+--TEST--
+new and call
+--FILE--
+<?php
+class FooTestNewAndCall {
+    public function bar(string $name)
+    {
+        var_dump('hello ' . $name . '!');
+    }
+}
+
+function main() {
+   (new FooTestNewAndCall())->bar('world');
+    echo "done\n";
+}
+
+?>
+--EXPECT--
+string(12) "hello world!"
+done
\ No newline at end of file
diff --git a/tests/aot/class/new-unpack-named.phpt b/tests/aot/class/new-unpack-named.phpt
new file mode 100644
index 00000000..a66e8f59
--- /dev/null
+++ b/tests/aot/class/new-unpack-named.phpt
@@ -0,0 +1,29 @@
+--TEST--
+new object with unpack before named arguments
+--FILE--
+<?php
+class PairValue
+{
+    public function __construct(public int $a, public int $b)
+    {
+    }
+
+    public function show(): void
+    {
+        echo $this->a . ':' . $this->b . "\n";
+    }
+}
+
+function main(): void
+{
+    $known = new PairValue(...[1], b: 2);
+    $known->show();
+
+    $class = PairValue::class;
+    $dynamic = new $class(...[3], b: 4);
+    $dynamic->show();
+}
+?>
+--EXPECT--
+1:2
+3:4
diff --git a/tests/aot/closure/closure-composite-type-check.phpt b/tests/aot/closure/closure-composite-type-check.phpt
new file mode 100644
index 00000000..457acac4
--- /dev/null
+++ b/tests/aot/closure/closure-composite-type-check.phpt
@@ -0,0 +1,82 @@
+--TEST--
+Closure composite type declarations use runtime type checks
+--ENV--
+USE_ZEND_ALLOC=0
+--FILE--
+<?php
+
+interface ClosureIA {}
+interface ClosureIB {}
+class ClosureBoth implements ClosureIA, ClosureIB {}
+class ClosureOnlyA implements ClosureIA {}
+
+function main(): void
+{
+    $nullable = function (?int $value) {
+        var_dump($value);
+    };
+    $nullable(null);
+
+    $union = function (int|string $union) {
+        var_dump($union);
+    };
+    $union("ok");
+
+    $variadic = function (int|string ...$values) {
+        var_dump($values);
+    };
+    $variadic(1, "two");
+
+    $intersection = function (ClosureIA&ClosureIB $value) {
+        var_dump(get_class($value));
+    };
+    $intersection(new ClosureBoth());
+
+    $returnUnion = function ($value): int|string {
+        return $value;
+    };
+    var_dump($returnUnion(42));
+
+    try {
+        $nullable("bad");
+    } catch (\TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    try {
+        $union([]);
+    } catch (\TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    try {
+        $variadic(1, []);
+    } catch (\TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    try {
+        $intersection(new ClosureOnlyA());
+    } catch (\TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    try {
+        $returnUnion([]);
+    } catch (\TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+}
+?>
+--EXPECT--
+NULL
+string(2) "ok"
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "two"
+}
+string(11) "ClosureBoth"
+int(42)
+{closure}(): Argument #1 ($value) must be of type ?int, string given
+{closure}(): Argument #1 ($union) must be of type int|string, array given
+{closure}(): Argument #2 ($values) must be of type int|string, array given
+{closure}(): Argument #1 ($value) must be of type ClosureIA&ClosureIB, object given
+{closure}(): Return value must be of type int|string, array given
diff --git a/tests/aot/closure/closure-param-defaults.phpt b/tests/aot/closure/closure-param-defaults.phpt
new file mode 100644
index 00000000..8a0c84a8
--- /dev/null
+++ b/tests/aot/closure/closure-param-defaults.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Closure parameters handle defaults and variadic arguments
+--ENV--
+USE_ZEND_ALLOC=0
+--FILE--
+<?php
+function main(): void
+{
+    $default = function ($value = 42) {
+        var_dump($value);
+    };
+    $default();
+
+    $variadic = function (...$values) {
+        var_dump($values);
+    };
+    $variadic(1, "two", null);
+
+    $required = function (?int $value) {
+        var_dump($value);
+    };
+    try {
+        $required();
+    } catch (\Throwable $e) {
+        var_dump(get_class($e));
+        var_dump($e->getMessage());
+    }
+
+    $requiredWithDefault = function ($value, $default = 42) {
+        var_dump($value, $default);
+    };
+    try {
+        $requiredWithDefault();
+    } catch (\Throwable $e) {
+        var_dump(get_class($e));
+        var_dump($e->getMessage());
+    }
+}
+?>
+--EXPECT--
+int(42)
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "two"
+  [2]=>
+  NULL
+}
+string(18) "ArgumentCountError"
+string(74) "Too few arguments to function {closure}(), 0 passed and exactly 1 expected"
+string(18) "ArgumentCountError"
+string(75) "Too few arguments to function {closure}(), 0 passed and at least 1 expected"
diff --git a/tests/aot/closure/read-private-prop-in-closure.phpt b/tests/aot/closure/read-private-prop-in-closure.phpt
new file mode 100644
index 00000000..14727d6f
--- /dev/null
+++ b/tests/aot/closure/read-private-prop-in-closure.phpt
@@ -0,0 +1,35 @@
+--TEST--
+closure 001
+--FILE--
+<?php
+class Bar {
+    public function __construct(callable $fn) {
+        $data = $fn();
+        var_dump($data);
+    }
+}
+
+class Foo {
+    private $arr = [1, 2, 3];
+    function run() {
+        $bar = new Bar(function () {
+            return $this->arr;
+        });
+    }
+}
+
+function main()
+{
+    $foo = new Foo();
+    $foo->run();
+}
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
diff --git a/tests/aot/coalesce/value-selection-lazy.phpt b/tests/aot/coalesce/value-selection-lazy.phpt
new file mode 100644
index 00000000..72f09f6e
--- /dev/null
+++ b/tests/aot/coalesce/value-selection-lazy.phpt
@@ -0,0 +1,48 @@
+--TEST--
+Coalesce and shorthand ternary evaluate right side lazily
+--FILE--
+<?php
+function makeArgs(string $name): array
+{
+    echo "args:$name\n";
+    return [$name];
+}
+
+function makeValue(string $name): string
+{
+    echo "value:$name\n";
+    return $name;
+}
+
+function build(string $id, string $value): string
+{
+    echo "body:$id:$value\n";
+    return $id . ':' . $value;
+}
+
+function main(): void
+{
+    $present = 'left';
+    var_dump($present ?? build(...makeArgs('coalesce-skip'), value: makeValue('coalesce-skip')));
+
+    $missing = null;
+    var_dump($missing ?? build(...makeArgs('coalesce-run'), value: makeValue('coalesce-run')));
+
+    $truthy = 'truthy';
+    var_dump($truthy ?: build(...makeArgs('shorthand-skip'), value: makeValue('shorthand-skip')));
+
+    $empty = '';
+    var_dump($empty ?: build(...makeArgs('shorthand-run'), value: makeValue('shorthand-run')));
+}
+?>
+--EXPECT--
+string(4) "left"
+args:coalesce-run
+value:coalesce-run
+body:coalesce-run:coalesce-run
+string(25) "coalesce-run:coalesce-run"
+string(6) "truthy"
+args:shorthand-run
+value:shorthand-run
+body:shorthand-run:shorthand-run
+string(27) "shorthand-run:shorthand-run"
diff --git a/tests/aot/const/interface-array-const-001.phpt b/tests/aot/const/interface-array-const-001.phpt
new file mode 100644
index 00000000..d5b7ec08
--- /dev/null
+++ b/tests/aot/const/interface-array-const-001.phpt
@@ -0,0 +1,60 @@
+--TEST--
+interface array constant inherited by implementing class
+--FILE--
+<?php
+interface InterfaceArrayConstSource
+{
+    public const DATA = [
+        'php',
+        'aot',
+    ];
+}
+
+class InterfaceArrayConstUser implements InterfaceArrayConstSource
+{
+}
+
+interface InterfaceArrayConstChild extends InterfaceArrayConstSource
+{
+}
+
+class InterfaceArrayConstChildUser implements InterfaceArrayConstChild
+{
+}
+
+class InterfaceArrayConstParentUser implements InterfaceArrayConstSource
+{
+}
+
+class InterfaceArrayConstGrandChildUser extends InterfaceArrayConstParentUser
+{
+}
+
+function main()
+{
+    var_dump(InterfaceArrayConstUser::DATA);
+    var_dump(InterfaceArrayConstUser::DATA[1]);
+    var_dump(InterfaceArrayConstChildUser::DATA);
+    var_dump(InterfaceArrayConstGrandChildUser::DATA);
+}
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  string(3) "php"
+  [1]=>
+  string(3) "aot"
+}
+string(3) "aot"
+array(2) {
+  [0]=>
+  string(3) "php"
+  [1]=>
+  string(3) "aot"
+}
+array(2) {
+  [0]=>
+  string(3) "php"
+  [1]=>
+  string(3) "aot"
+}
diff --git a/tests/aot/control_flow/condition-side-effects.phpt b/tests/aot/control_flow/condition-side-effects.phpt
new file mode 100644
index 00000000..84f6e0bb
--- /dev/null
+++ b/tests/aot/control_flow/condition-side-effects.phpt
@@ -0,0 +1,62 @@
+--TEST--
+If and while conditions evaluate side effects at the correct time
+--FILE--
+<?php
+function makeArgs(string $name): array
+{
+    echo "args:$name\n";
+    return [$name];
+}
+
+function makeValue(string $name): string
+{
+    echo "value:$name\n";
+    return $name;
+}
+
+function probe(string $id, string $value): bool
+{
+    echo "probe:$id:$value\n";
+    return $id !== 'elseif-false';
+}
+
+function loopProbe(int $i): bool
+{
+    echo "loop:$i\n";
+    return $i < 3;
+}
+
+function main(): void
+{
+    if (false && probe(...makeArgs('if-skip'), value: makeValue('if-skip'))) {
+        echo "if\n";
+    } elseif (probe(...makeArgs('elseif-false'), value: makeValue('elseif-false'))) {
+        echo "elseif false\n";
+    } elseif (probe(...makeArgs('elseif-true'), value: makeValue('elseif-true'))) {
+        echo "elseif true\n";
+    } else {
+        echo "else\n";
+    }
+
+    $i = 0;
+    while (loopProbe($i)) {
+        echo "body:$i\n";
+        $i++;
+    }
+}
+?>
+--EXPECT--
+args:elseif-false
+value:elseif-false
+probe:elseif-false:elseif-false
+args:elseif-true
+value:elseif-true
+probe:elseif-true:elseif-true
+elseif true
+loop:0
+body:0
+loop:1
+body:1
+loop:2
+body:2
+loop:3
diff --git a/tests/aot/control_flow/do-while-condition-side-effects.phpt b/tests/aot/control_flow/do-while-condition-side-effects.phpt
new file mode 100644
index 00000000..d81a6ff7
--- /dev/null
+++ b/tests/aot/control_flow/do-while-condition-side-effects.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Do-while condition evaluates side effects after continue
+--FILE--
+<?php
+function keepGoing(int $i): bool
+{
+    echo "cond:$i\n";
+    return $i < 3;
+}
+
+function main(): void
+{
+    $i = 0;
+    do {
+        echo "body:$i\n";
+        $i++;
+        if ($i < 2) {
+            continue;
+        }
+    } while (keepGoing($i));
+}
+?>
+--EXPECT--
+body:0
+cond:1
+body:1
+cond:2
+body:2
+cond:3
diff --git a/tests/aot/control_flow/for-condition-side-effects.phpt b/tests/aot/control_flow/for-condition-side-effects.phpt
new file mode 100644
index 00000000..f4e839cf
--- /dev/null
+++ b/tests/aot/control_flow/for-condition-side-effects.phpt
@@ -0,0 +1,56 @@
+--TEST--
+For condition and loop expressions evaluate side effects at the correct time
+--FILE--
+<?php
+function makeArgs(string $name): array
+{
+    echo "args:$name\n";
+    return [$name];
+}
+
+function keepGoing(string $id, int $value): bool
+{
+    echo "cond:$id:$value\n";
+    return $value < 3;
+}
+
+function step(string $id, int $value): void
+{
+    global $i;
+    echo "step:$id:$value\n";
+    $i++;
+}
+
+function main(): void
+{
+    global $i;
+    for (
+        $i = 0;
+        keepGoing(...makeArgs('cond-' . $i), value: $i);
+        step(...makeArgs('step-' . $i), value: $i)
+    ) {
+        echo "body:$i\n";
+        if ($i === 1) {
+            continue;
+        }
+    }
+}
+?>
+--EXPECT--
+args:cond-0
+cond:cond-0:0
+body:0
+args:step-0
+step:step-0:0
+args:cond-1
+cond:cond-1:1
+body:1
+args:step-1
+step:step-1:1
+args:cond-2
+cond:cond-2:2
+body:2
+args:step-2
+step:step-2:2
+args:cond-3
+cond:cond-3:3
diff --git a/tests/aot/control_flow/match-lazy-eval.phpt b/tests/aot/control_flow/match-lazy-eval.phpt
new file mode 100644
index 00000000..15142428
--- /dev/null
+++ b/tests/aot/control_flow/match-lazy-eval.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Match expression evaluates conditions and bodies lazily
+--FILE--
+<?php
+function marker(string $name): string
+{
+    echo "cond:$name\n";
+    return $name;
+}
+
+function makeArgs(string $name): array
+{
+    echo "args:$name\n";
+    return [$name];
+}
+
+function makeValue(string $name): string
+{
+    echo "value:$name\n";
+    return $name;
+}
+
+function build(string $id, string $value): string
+{
+    echo "body:$id:$value\n";
+    return $id . ':' . $value;
+}
+
+function test_match(string $value): string
+{
+    return match ($value) {
+        marker(name: 'a') => build(...makeArgs('A'), value: makeValue('A')),
+        marker(name: 'b'), marker(name: 'skip') => build(...makeArgs('B'), value: makeValue('B')),
+        marker(name: 'c') => build(...makeArgs('C'), value: makeValue('C')),
+        default => build(...makeArgs('D'), value: makeValue('D')),
+    };
+}
+
+function main(): void
+{
+    var_dump(test_match('b'));
+}
+?>
+--EXPECT--
+cond:a
+cond:b
+args:B
+value:B
+body:B:B
+string(3) "B:B"
diff --git a/tests/aot/exception/multi-catch.phpt b/tests/aot/exception/multi-catch.phpt
new file mode 100644
index 00000000..ec53d1f2
--- /dev/null
+++ b/tests/aot/exception/multi-catch.phpt
@@ -0,0 +1,29 @@
+--TEST--
+AOT multi-catch handles alternative exception types
+--FILE--
+<?php
+class MultiCatchFirst extends Exception {}
+class MultiCatchSecond extends Exception {}
+
+function raise_multi(int $kind): void
+{
+    if ($kind === 1) {
+        throw new MultiCatchFirst('first');
+    }
+    throw new MultiCatchSecond('second');
+}
+
+function main(): void
+{
+    foreach ([1, 2] as $kind) {
+        try {
+            raise_multi($kind);
+        } catch (MultiCatchFirst|MultiCatchSecond $e) {
+            var_dump($e->getMessage());
+        }
+    }
+}
+?>
+--EXPECT--
+string(5) "first"
+string(6) "second"
diff --git a/tests/aot/exception/throw-invalid.phpt b/tests/aot/exception/throw-invalid.phpt
new file mode 100644
index 00000000..483b0515
--- /dev/null
+++ b/tests/aot/exception/throw-invalid.phpt
@@ -0,0 +1,32 @@
+--TEST--
+AOT invalid throw object matches PHP error
+--FILE--
+<?php
+function throw_non_throwable_object(): void
+{
+    throw new stdClass();
+}
+
+function throw_mixed(mixed $value): void
+{
+    throw $value;
+}
+
+function main(): void
+{
+    try {
+        throw_mixed(1);
+    } catch (Error $e) {
+        var_dump($e->getMessage());
+    }
+
+    try {
+        throw_non_throwable_object();
+    } catch (Error $e) {
+        var_dump($e->getMessage());
+    }
+}
+?>
+--EXPECT--
+string(22) "Can only throw objects"
+string(52) "Cannot throw objects that do not implement Throwable"
diff --git a/tests/aot/functions/internal-named-args.phpt b/tests/aot/functions/internal-named-args.phpt
new file mode 100644
index 00000000..6d93c617
--- /dev/null
+++ b/tests/aot/functions/internal-named-args.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Internal function named arguments are validated before optimization
+--FILE--
+<?php
+
+function main(): void
+{
+    var_dump(strlen(string: "abc"));
+    var_dump(str_replace(replace: "x", subject: "abc", search: "a"));
+    var_dump(substr(length: 2, string: "abcdef", offset: 3));
+}
+?>
+--EXPECT--
+int(3)
+string(3) "xbc"
+string(2) "de"
diff --git a/tests/aot/functions/return-value.phpt b/tests/aot/functions/return-value.phpt
index 651046de..00ff4a68 100644
--- a/tests/aot/functions/return-value.phpt
+++ b/tests/aot/functions/return-value.phpt
@@ -2,9 +2,15 @@
 object link operator
 --FILE--
 <?php
+function var_dump_test()
+{
+    var_dump('foo');
+    return;
+}
+
 function main()
 {
-    $a = var_dump('foo');
+    $a = var_dump_test();
     var_dump($a);
 }
 ?>
diff --git a/tests/aot/functions/unpack-before-named.phpt b/tests/aot/functions/unpack-before-named.phpt
new file mode 100644
index 00000000..fb756b14
--- /dev/null
+++ b/tests/aot/functions/unpack-before-named.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Argument unpacking can be followed by named arguments
+--FILE--
+<?php
+
+function pair($a, $b): array
+{
+    return [$a, $b];
+}
+
+class DynamicUnpackNamed
+{
+    public function pair($a, $b): array
+    {
+        return [$a, $b];
+    }
+}
+
+function main(): void
+{
+    var_dump(pair(...[1], b: 2));
+
+    $fn = 'pair';
+    var_dump($fn(...[3], b: 4));
+
+    $object = new DynamicUnpackNamed();
+    $method = 'pair';
+    var_dump($object->$method(...[5], b: 6));
+}
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  [0]=>
+  int(3)
+  [1]=>
+  int(4)
+}
+array(2) {
+  [0]=>
+  int(5)
+  [1]=>
+  int(6)
+}
diff --git a/tests/aot/functions/unpack-fixed-native.phpt b/tests/aot/functions/unpack-fixed-native.phpt
new file mode 100644
index 00000000..11731c61
--- /dev/null
+++ b/tests/aot/functions/unpack-fixed-native.phpt
@@ -0,0 +1,45 @@
+--TEST--
+Argument unpacking can fill fixed native parameters
+--FILE--
+<?php
+
+function fixed_args(int $a, int $b): void
+{
+    echo $a, ',', $b, PHP_EOL;
+}
+
+function fixed_and_variadic(int $a, int ...$rest): void
+{
+    echo $a, ':', implode(',', $rest), PHP_EOL;
+}
+
+class NativeUnpackTarget
+{
+    public function method(int $a, int $b): void
+    {
+        echo 'm=', $a, ',', $b, PHP_EOL;
+    }
+
+    public static function staticMethod(int $a, int $b): void
+    {
+        echo 's=', $a, ',', $b, PHP_EOL;
+    }
+}
+
+function main(): void
+{
+    fixed_args(...[1, 2]);
+    fixed_and_variadic(...[3, 4, 5]);
+    fixed_and_variadic(6, ...[7, 8]);
+    $target = new NativeUnpackTarget();
+    $target->method(...[9, 10]);
+    NativeUnpackTarget::staticMethod(...[11, 12]);
+}
+
+?>
+--EXPECT--
+1,2
+3:4,5
+6:7,8
+m=9,10
+s=11,12
diff --git a/tests/aot/named_args/007.phpt b/tests/aot/named_args/007.phpt
new file mode 100644
index 00000000..705bdaff
--- /dev/null
+++ b/tests/aot/named_args/007.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Named arguments and promoted properties with C++ reserved parameter names
+--FILE--
+<?php
+
+function reserved_params($union, $class = 2): array
+{
+    return [$union, $class];
+}
+
+class ReservedPromotion
+{
+    public function __construct(
+        public int $union,
+        public string $class = "default"
+    ) {
+    }
+}
+
+function main(): void
+{
+    var_dump(reserved_params(class: 20, union: 10));
+
+    $object = new ReservedPromotion(class: "named", union: 42);
+    var_dump($object->union);
+    var_dump($object->class);
+}
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(20)
+}
+int(42)
+string(5) "named"
diff --git a/tests/aot/namespace/ns-const.phpt b/tests/aot/namespace/ns-const-01.phpt
similarity index 100%
rename from tests/aot/namespace/ns-const.phpt
rename to tests/aot/namespace/ns-const-01.phpt
diff --git a/tests/aot/namespace/ns-const-02.phpt b/tests/aot/namespace/ns-const-02.phpt
new file mode 100644
index 00000000..247e0dda
--- /dev/null
+++ b/tests/aot/namespace/ns-const-02.phpt
@@ -0,0 +1,28 @@
+--TEST--
+preprocessor registers namespace constants
+--FILE--
+<?php
+namespace Preprocessor\NsConst {
+    const VALUE = 123;
+    const LABEL = "ns-const";
+
+    function readLocal(): string {
+        return LABEL . ":" . VALUE;
+    }
+}
+
+namespace {
+    use const Preprocessor\NsConst\VALUE;
+    use function Preprocessor\NsConst\readLocal;
+
+    function main(): void {
+        var_dump(readLocal());
+        var_dump(\Preprocessor\NsConst\LABEL);
+        var_dump(VALUE);
+    }
+}
+?>
+--EXPECT--
+string(12) "ns-const:123"
+string(8) "ns-const"
+int(123)
diff --git a/tests/aot/namespace/ns-const-03.phpt b/tests/aot/namespace/ns-const-03.phpt
new file mode 100644
index 00000000..9d3b6c7d
--- /dev/null
+++ b/tests/aot/namespace/ns-const-03.phpt
@@ -0,0 +1,24 @@
+--TEST--
+namespace relative qualified constants
+--FILE--
+<?php
+namespace App\Sub {
+    const VALUE = 77;
+}
+
+namespace App {
+    function readRelative(): void {
+        var_dump(Sub\VALUE);
+    }
+}
+
+namespace {
+    function main(): void {
+        App\readRelative();
+        var_dump(\App\Sub\VALUE);
+    }
+}
+?>
+--EXPECT--
+int(77)
+int(77)
diff --git a/tests/aot/nullsafe/nullsafe-args-lazy.phpt b/tests/aot/nullsafe/nullsafe-args-lazy.phpt
new file mode 100644
index 00000000..59ada435
--- /dev/null
+++ b/tests/aot/nullsafe/nullsafe-args-lazy.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Nullsafe method call does not evaluate arguments when receiver is null
+--FILE--
+<?php
+class Recorder
+{
+    public function set(int $id, string $value): string
+    {
+        return $id . ':' . $value;
+    }
+}
+
+function makeArgs(): array
+{
+    echo "makeArgs\n";
+    return [7];
+}
+
+function makeValue(): string
+{
+    echo "makeValue\n";
+    return "ok";
+}
+
+function main(): void
+{
+    $null = null;
+    var_dump($null?->set(...makeArgs(), value: makeValue()));
+
+    $recorder = new Recorder();
+    var_dump($recorder?->set(...makeArgs(), value: makeValue()));
+}
+?>
+--EXPECT--
+NULL
+makeArgs
+makeValue
+string(4) "7:ok"
diff --git a/tests/aot/object_ctor/promotion-union-param-check.phpt b/tests/aot/object_ctor/promotion-union-param-check.phpt
new file mode 100644
index 00000000..501e95dc
--- /dev/null
+++ b/tests/aot/object_ctor/promotion-union-param-check.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Constructor property promotion checks union parameter before assignment
+--ENV--
+USE_ZEND_ALLOC=0
+--FILE--
+<?php
+class PromotedUnionHolder
+{
+    public function __construct(public int|string $value)
+    {
+    }
+}
+
+function main(): void
+{
+    try {
+        new PromotedUnionHolder([]);
+    } catch (TypeError $e) {
+        var_dump($e->getMessage());
+    }
+}
+?>
+--EXPECT--
+string(96) "PromotedUnionHolder::__construct(): Argument #1 ($value) must be of type int|string, array given"
diff --git a/tests/aot/operator/binary-eval-order.phpt b/tests/aot/operator/binary-eval-order.phpt
new file mode 100644
index 00000000..5e77f978
--- /dev/null
+++ b/tests/aot/operator/binary-eval-order.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Binary operator operands are evaluated left-to-right
+--FILE--
+<?php
+function main()
+{
+    var_dump((print "sub-left\n") - (print "sub-right\n"));
+    var_dump((print "nested-left\n") * ((print "nested-right-left\n") + (print "nested-right-right\n")));
+    var_dump((print "eq-left\n") == (print "eq-right\n"));
+    var_dump((print "same-left\n") === (print "same-right\n"));
+    var_dump((print "spaceship-left\n") <=> (print "spaceship-right\n"));
+    var_dump((print "pow-left\n") ** (print "pow-right\n"));
+    var_dump(((print "logic-left\n") && false && (print "logic-right\n")) + (print "logic-after\n"));
+}
+?>
+--EXPECT--
+sub-left
+sub-right
+int(0)
+nested-left
+nested-right-left
+nested-right-right
+int(2)
+eq-left
+eq-right
+bool(true)
+same-left
+same-right
+bool(true)
+spaceship-left
+spaceship-right
+int(0)
+pow-left
+pow-right
+int(1)
+logic-left
+logic-after
+int(1)
diff --git a/tests/aot/operator/logical-short-circuit-lazy.phpt b/tests/aot/operator/logical-short-circuit-lazy.phpt
new file mode 100644
index 00000000..fef51c0a
--- /dev/null
+++ b/tests/aot/operator/logical-short-circuit-lazy.phpt
@@ -0,0 +1,41 @@
+--TEST--
+Logical && and || evaluate right side lazily
+--FILE--
+<?php
+function makeArgs(string $name): array
+{
+    echo "args:$name\n";
+    return [$name];
+}
+
+function makeValue(string $name): string
+{
+    echo "value:$name\n";
+    return $name;
+}
+
+function check(string $id, string $value): bool
+{
+    echo "check:$id:$value\n";
+    return true;
+}
+
+function main(): void
+{
+    var_dump(false && check(...makeArgs('and-skip'), value: makeValue('and-skip')));
+    var_dump(true && check(...makeArgs('and-run'), value: makeValue('and-run')));
+    var_dump(true || check(...makeArgs('or-skip'), value: makeValue('or-skip')));
+    var_dump(false || check(...makeArgs('or-run'), value: makeValue('or-run')));
+}
+?>
+--EXPECT--
+bool(false)
+args:and-run
+value:and-run
+check:and-run:and-run
+bool(true)
+bool(true)
+args:or-run
+value:or-run
+check:or-run:or-run
+bool(true)
diff --git a/tests/aot/operator/ternary-lazy-eval.phpt b/tests/aot/operator/ternary-lazy-eval.phpt
new file mode 100644
index 00000000..1cb575e5
--- /dev/null
+++ b/tests/aot/operator/ternary-lazy-eval.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Ternary expression evaluates only selected branch
+--FILE--
+<?php
+function makeArgs(string $name): array
+{
+    echo "args:$name\n";
+    return [$name];
+}
+
+function makeValue(string $name): string
+{
+    echo "value:$name\n";
+    return $name;
+}
+
+function build(string $id, string $value): string
+{
+    echo "body:$id:$value\n";
+    return $id . ':' . $value;
+}
+
+function condition(string $id, string $value): bool
+{
+    echo "cond:$id:$value\n";
+    return true;
+}
+
+function choose(bool $flag): string
+{
+    return $flag
+        ? build(...makeArgs('T'), value: makeValue('T'))
+        : build(...makeArgs('F'), value: makeValue('F'));
+}
+
+function main(): void
+{
+    var_dump(condition(...makeArgs('C'), value: makeValue('C')) ? build('T', 'T') : build('F', 'F'));
+    var_dump(choose(true));
+    var_dump(choose(false));
+}
+?>
+--EXPECT--
+args:C
+value:C
+cond:C:C
+body:T:T
+string(3) "T:T"
+args:T
+value:T
+body:T:T
+string(3) "T:T"
+args:F
+value:F
+body:F:F
+string(3) "F:F"
diff --git a/tests/aot/optimizations/objprop-nullable-union-default-null.phpt b/tests/aot/optimizations/objprop-nullable-union-default-null.phpt
index 430acdae..7e3ac712 100644
--- a/tests/aot/optimizations/objprop-nullable-union-default-null.phpt
+++ b/tests/aot/optimizations/objprop-nullable-union-default-null.phpt
@@ -23,7 +23,7 @@ class FlexibleDefaults {
 
         $this->nullable = null;
         $this->nullableObject = null;
-        $this->union = null;
+        $this->union = '';
         var_dump($this->nullable);
         var_dump($this->nullableObject);
         var_dump($this->union);
@@ -43,4 +43,4 @@ NULL
 string(2) "ok"
 NULL
 NULL
-NULL
+string(0) ""
diff --git a/tests/aot/optimizations/objprop-typed-object-null-unset.phpt b/tests/aot/optimizations/objprop-typed-object-null-unset.phpt
index 9da6fa2d..76fb6c85 100644
--- a/tests/aot/optimizations/objprop-typed-object-null-unset.phpt
+++ b/tests/aot/optimizations/objprop-typed-object-null-unset.phpt
@@ -1,5 +1,5 @@
 --TEST--
-SSA object prop: typed object property allows null and unset
+SSA object prop: typed object property rejects null and supports unset
 --FILE--
 <?php
 use native_types;
@@ -28,9 +28,12 @@ class ObjPropHolder {
         var_dump(isset($this->prop));
         var_dump($this->prop->name());
 
-        $this->prop = null;
+        try {
+            $this->prop = null;
+        } catch (TypeError $e) {
+            var_dump($e->getMessage());
+        }
         var_dump(isset($this->prop));
-        var_dump($this->prop);
 
         $this->prop = new ObjPropValue();
         unset($this->prop);
@@ -51,8 +54,8 @@ function main(): void {
 --EXPECT--
 bool(true)
 string(5) "value"
-bool(false)
-NULL
+string(61) "ObjPropHolder::$prop must be of type ObjPropValue, null given"
+bool(true)
 bool(false)
 string(5) "value"
 string(5) "value"
diff --git a/tests/aot/optimizations/reserved-param-ssa.phpt b/tests/aot/optimizations/reserved-param-ssa.phpt
new file mode 100644
index 00000000..15d0ac61
--- /dev/null
+++ b/tests/aot/optimizations/reserved-param-ssa.phpt
@@ -0,0 +1,21 @@
+--TEST--
+SSA optimizations handle parameters with C++ reserved names
+--FILE--
+<?php
+
+function sum_reserved(int $union, int $class): int
+{
+    $total = 0;
+    for ($i = 0; $i < $union; $i++) {
+        $total += $class;
+    }
+    return $total;
+}
+
+function main(): void
+{
+    var_dump(sum_reserved(union: 4, class: 3));
+}
+?>
+--EXPECT--
+int(12)
diff --git a/tests/aot/parent_call/parent-unpack-named.phpt b/tests/aot/parent_call/parent-unpack-named.phpt
new file mode 100644
index 00000000..494a0ca6
--- /dev/null
+++ b/tests/aot/parent_call/parent-unpack-named.phpt
@@ -0,0 +1,35 @@
+--TEST--
+parent::method() with unpack before named arguments
+--FILE--
+<?php
+class ParentPair
+{
+    public function combine(int $a, int $b): string
+    {
+        return $a . ':' . $b;
+    }
+}
+
+class ChildPair extends ParentPair
+{
+    public function combine(int $a, int $b): string
+    {
+        return 'child';
+    }
+
+    public function callParent(): string
+    {
+        return parent::combine(...[1], b: 2);
+    }
+}
+
+function main(): void
+{
+    $child = new ChildPair();
+    echo $child->combine(9, 9) . "\n";
+    echo $child->callParent() . "\n";
+}
+?>
+--EXPECT--
+child
+1:2
diff --git a/tests/aot/ref/static-byref-call.phpt b/tests/aot/ref/static-byref-call.phpt
new file mode 100644
index 00000000..a0bfbc74
--- /dev/null
+++ b/tests/aot/ref/static-byref-call.phpt
@@ -0,0 +1,54 @@
+--TEST--
+Static function, method, and constructor calls pass by-reference args automatically
+--FILE--
+<?php
+
+function mutate_arg(&$value): void
+{
+    $value .= ':function';
+}
+
+function mutate_named_arg(string $prefix, &$value): void
+{
+    $value .= ':' . $prefix;
+}
+
+class RefTarget
+{
+    public function mutate(&$value): void
+    {
+        $value .= ':method';
+    }
+
+    public function mutateNamed(string $prefix, &$value): void
+    {
+        $value .= ':' . $prefix;
+    }
+
+    public function __construct(&$value)
+    {
+        $value .= ':ctor';
+    }
+}
+
+class RefChild extends RefTarget
+{
+}
+
+function main(): void
+{
+    $value = 'start';
+    mutate_arg($value);
+    $target = new RefTarget($value);
+    $target->mutate($value);
+    new RefChild($value);
+    mutate_named_arg(...['named-function'], value: $value);
+    $target->mutateNamed(...['named-method'], value: $value);
+    $fn = 'mutate_named_arg';
+    $fn(...['dynamic-refval'], value: refval($value));
+    echo $value, PHP_EOL;
+}
+
+?>
+--EXPECT--
+start:function:ctor:method:ctor:named-function:named-method:dynamic-refval
diff --git a/tests/aot/static/static_prop_write.phpt b/tests/aot/static/static_prop_write.phpt
index 7b71c01d..d25a74a8 100644
--- a/tests/aot/static/static_prop_write.phpt
+++ b/tests/aot/static/static_prop_write.phpt
@@ -13,12 +13,12 @@ class Select {
 
 class Worker
 {
-    public static ?stdClass $globalEvent = null;
+    public static ?Select $globalEvent = null;
     public static string $eventLoopClass = 'Select';
 
     public static function init() {
         self::$globalEvent = new static::$eventLoopClass();
-        self::$globalEvent->setErrorHandler(function ($exception) {
+        self::$globalEvent->setErrorHandler(function () {
             var_dump(__FUNCTION__);
         });
     }
diff --git a/tests/aot/stdlib/native-arg-eval-order.phpt b/tests/aot/stdlib/native-arg-eval-order.phpt
new file mode 100644
index 00000000..ac72de80
--- /dev/null
+++ b/tests/aot/stdlib/native-arg-eval-order.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Native optimized calls evaluate arguments left-to-right
+--FILE--
+<?php
+var_dump(str_repeat((print "repeat-left\n") ? "x" : "x", (print "repeat-right\n") + 1));
+var_dump(round((print "round-left\n") + 1.25, (print "round-right\n")));
+var_dump(strcmp((print "cmp-left\n") ? "a" : "a", (print "cmp-right\n") ? "b" : "b"));
+$text = '<x>';
+var_dump($text->replace((print "method-left\n") ? "x" : "x", (print "method-right\n") ? "y" : "y"));
+?>
+--EXPECT--
+repeat-left
+repeat-right
+string(2) "xx"
+round-left
+round-right
+float(2.3)
+cmp-left
+cmp-right
+int(-1)
+method-left
+method-right
+string(3) "<y>"
diff --git a/tests/aot/switch/switch-side-effects.phpt b/tests/aot/switch/switch-side-effects.phpt
new file mode 100644
index 00000000..c57e54d1
--- /dev/null
+++ b/tests/aot/switch/switch-side-effects.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Switch condition and case expressions evaluate side effects in order
+--FILE--
+<?php
+function makeArgs(string $name): array
+{
+    echo "args:$name\n";
+    return [$name];
+}
+
+function makeValue(string $name): string
+{
+    echo "value:$name\n";
+    return $name;
+}
+
+function subject(string $id, string $value): string
+{
+    echo "subject:$id:$value\n";
+    return $value;
+}
+
+function marker(string $id, string $value): string
+{
+    echo "case:$id:$value\n";
+    return $value;
+}
+
+function main(): void
+{
+    switch (subject(...makeArgs('subject'), value: makeValue('b'))) {
+        case marker(...makeArgs('a'), value: makeValue('a')):
+            echo "A\n";
+            break;
+        case marker(...makeArgs('b'), value: makeValue('b')):
+        case marker(...makeArgs('skip'), value: makeValue('skip')):
+            echo "B\n";
+            break;
+        default:
+            echo "default\n";
+            break;
+    }
+}
+?>
+--EXPECT--
+args:subject
+value:b
+subject:subject:b
+args:a
+value:a
+case:a:a
+args:b
+value:b
+case:b:b
+B
diff --git a/tests/aot/trait/015.phpt b/tests/aot/trait/015.phpt
new file mode 100644
index 00000000..d0475d0d
--- /dev/null
+++ b/tests/aot/trait/015.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Trait alias keeps original method
+--FILE--
+<?php
+trait TraitAliasOriginal
+{
+    public function hello(): void
+    {
+        echo "hello\n";
+    }
+}
+
+class TraitAliasOriginalUser
+{
+    use TraitAliasOriginal {
+        hello as hi;
+    }
+}
+
+function main()
+{
+    $user = new TraitAliasOriginalUser();
+    $user->hello();
+    $user->hi();
+}
+?>
+--EXPECT--
+hello
+hello
diff --git a/tests/aot/trait/016.phpt b/tests/aot/trait/016.phpt
new file mode 100644
index 00000000..303afdb3
--- /dev/null
+++ b/tests/aot/trait/016.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Trait insteadof works regardless of trait list order
+--FILE--
+<?php
+trait TraitOrderA
+{
+    public function hello(): void
+    {
+        echo "A\n";
+    }
+}
+
+trait TraitOrderB
+{
+    public function hello(): void
+    {
+        echo "B\n";
+    }
+}
+
+class TraitOrderUser
+{
+    use TraitOrderB, TraitOrderA {
+        TraitOrderB::hello insteadof TraitOrderA;
+        TraitOrderA::hello as helloA;
+    }
+}
+
+function main()
+{
+    $user = new TraitOrderUser();
+    $user->hello();
+    $user->helloA();
+}
+?>
+--EXPECT--
+B
+A
diff --git a/tests/aot/trait/017.phpt b/tests/aot/trait/017.phpt
new file mode 100644
index 00000000..65f370ca
--- /dev/null
+++ b/tests/aot/trait/017.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Trait method can have multiple aliases
+--FILE--
+<?php
+trait TraitMultipleAlias
+{
+    public function hello(): void
+    {
+        echo "hello\n";
+    }
+}
+
+class TraitMultipleAliasUser
+{
+    use TraitMultipleAlias {
+        hello as hi;
+        hello as hey;
+    }
+}
+
+function main()
+{
+    $user = new TraitMultipleAliasUser();
+    $user->hello();
+    $user->hi();
+    $user->hey();
+}
+?>
+--EXPECT--
+hello
+hello
+hello
diff --git a/tests/aot/type_decl/intersection-param-check.phpt b/tests/aot/type_decl/intersection-param-check.phpt
new file mode 100644
index 00000000..ad052f9f
--- /dev/null
+++ b/tests/aot/type_decl/intersection-param-check.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Intersection type: parameter runtime type checking
+--FILE--
+<?php
+
+interface IA {}
+interface IB {}
+
+class Both implements IA, IB {}
+class OnlyA implements IA {}
+
+function expect_both(IA&IB $value): void {
+    var_dump(get_class($value));
+}
+
+function main() {
+    expect_both(new Both());
+
+    $errors = [];
+
+    try {
+        expect_both(new OnlyA());
+    } catch (\TypeError $e) {
+        $errors[] = $e->getMessage();
+    }
+
+    foreach ($errors as $err) {
+        var_dump($err);
+    }
+}
+?>
+--EXPECT--
+string(4) "Both"
+string(71) "expect_both(): Argument #1 ($value) must be of type IA&IB, object given"
diff --git a/tests/aot/type_decl/intersection-return-check.phpt b/tests/aot/type_decl/intersection-return-check.phpt
new file mode 100644
index 00000000..dca68c9d
--- /dev/null
+++ b/tests/aot/type_decl/intersection-return-check.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Intersection type: return runtime type checking
+--FILE--
+<?php
+
+interface IA {}
+interface IB {}
+
+class Both implements IA, IB {}
+class OnlyA implements IA {}
+
+function return_both(object $value): IA&IB {
+    return $value;
+}
+
+function main() {
+    var_dump(get_class(return_both(new Both())));
+
+    $errors = [];
+
+    try {
+        return_both(new OnlyA());
+    } catch (\TypeError $e) {
+        $errors[] = $e->getMessage();
+    }
+
+    foreach ($errors as $err) {
+        var_dump($err);
+    }
+}
+?>
+--EXPECT--
+string(4) "Both"
+string(63) "return_both(): Return value must be of type IA&IB, object given"
diff --git a/tests/aot/type_decl/nullable-required-param-check.phpt b/tests/aot/type_decl/nullable-required-param-check.phpt
new file mode 100644
index 00000000..78174c6c
--- /dev/null
+++ b/tests/aot/type_decl/nullable-required-param-check.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Nullable parameter without default is still required
+--FILE--
+<?php
+function expect_nullable_int(?int $x): void
+{
+    var_dump($x);
+}
+
+function expect_nullable_with_default(?int $x, int $fallback = 1): void
+{
+    var_dump($x, $fallback);
+}
+
+function main(): void
+{
+    $fn = 'expect_nullable_int';
+    try {
+        $fn();
+    } catch (\Throwable $e) {
+        var_dump(get_class($e));
+        var_dump($e->getMessage());
+    }
+
+    $fn = 'expect_nullable_with_default';
+    try {
+        $fn();
+    } catch (\Throwable $e) {
+        var_dump(get_class($e));
+        var_dump($e->getMessage());
+    }
+}
+?>
+--EXPECT--
+string(18) "ArgumentCountError"
+string(84) "Too few arguments to function expect_nullable_int(), 0 passed and exactly 1 expected"
+string(18) "ArgumentCountError"
+string(94) "Too few arguments to function expect_nullable_with_default(), 0 passed and at least 1 expected"
diff --git a/tests/aot/type_hits/008.phpt b/tests/aot/type_hits/008.phpt
new file mode 100644
index 00000000..bbacd54c
--- /dev/null
+++ b/tests/aot/type_hits/008.phpt
@@ -0,0 +1,34 @@
+--TEST--
+type hits
+--FILE--
+<?php
+class Select {
+    public $errorHandler = null;
+}
+
+class Worker
+{
+    public static ?stdClass $globalEvent = null;
+    public static string $eventLoopClass = 'Select';
+
+    public static function init() {
+        self::$globalEvent = new stdClass();
+        var_dump(get_class(self::$globalEvent));
+        self::$globalEvent = null;
+        var_dump(self::$globalEvent);
+        try {
+            self::$globalEvent = new static::$eventLoopClass();
+        } catch (TypeError $e) {
+            var_dump($e->getMessage());
+        }
+    }
+}
+
+function main() {
+    Worker::init();
+}
+?>
+--EXPECT--
+string(8) "stdClass"
+NULL
+string(60) "Worker::$globalEvent must be of type ?stdClass, object given"
diff --git a/tests/aot/type_hits/009.phpt b/tests/aot/type_hits/009.phpt
new file mode 100644
index 00000000..28763bbe
--- /dev/null
+++ b/tests/aot/type_hits/009.phpt
@@ -0,0 +1,25 @@
+--TEST--
+type hits: instance property type check message includes class name
+--FILE--
+<?php
+class TypeHitPropertyMessage
+{
+    public int|string $union;
+
+    public function setInvalid(): void
+    {
+        try {
+            $this->union = null;
+        } catch (TypeError $e) {
+            var_dump($e->getMessage());
+        }
+    }
+}
+
+function main()
+{
+    (new TypeHitPropertyMessage())->setInvalid();
+}
+?>
+--EXPECT--
+string(69) "TypeHitPropertyMessage::$union must be of type int|string, null given"
diff --git a/tests/aot/type_hits/010.phpt b/tests/aot/type_hits/010.phpt
new file mode 100644
index 00000000..ab024bd4
--- /dev/null
+++ b/tests/aot/type_hits/010.phpt
@@ -0,0 +1,32 @@
+--TEST--
+type hits: property coalesce assignment uses runtime type check
+--ENV--
+USE_ZEND_ALLOC=0
+--FILE--
+<?php
+class TypeHitCoalesceProperty
+{
+    public int|string $union;
+
+    public function run(): void
+    {
+        try {
+            $this->union ??= null;
+        } catch (TypeError $e) {
+            var_dump($e->getMessage());
+        }
+
+        $this->union = "ok";
+        $this->union ??= null;
+        var_dump($this->union);
+    }
+}
+
+function main(): void
+{
+    (new TypeHitCoalesceProperty())->run();
+}
+?>
+--EXPECT--
+string(70) "TypeHitCoalesceProperty::$union must be of type int|string, null given"
+string(2) "ok"
diff --git a/tests/aot/type_hits/011.phpt b/tests/aot/type_hits/011.phpt
new file mode 100644
index 00000000..4c195609
--- /dev/null
+++ b/tests/aot/type_hits/011.phpt
@@ -0,0 +1,30 @@
+--TEST--
+AOT dynamic property assignment TypeError can be caught
+--FILE--
+<?php
+class TypeHitDynamicProperty {
+    public int|string $union;
+}
+
+function assign_dynamic(TypeHitDynamicProperty $obj, string $prop, mixed $value): void {
+    try {
+        $obj->$prop = $value;
+        var_dump('not reached');
+    } catch (TypeError $e) {
+        var_dump(get_class($e));
+        var_dump(str_contains($e->getMessage(), 'Cannot assign null to property TypeHitDynamicProperty::$union'));
+    }
+}
+
+function main(): void
+{
+    $obj = new TypeHitDynamicProperty();
+    assign_dynamic($obj, 'union', null);
+    $obj->union = 'ok';
+    var_dump($obj->union);
+}
+?>
+--EXPECT--
+string(9) "TypeError"
+bool(true)
+string(2) "ok"
diff --git a/tests/std/array/009.phpt b/tests/std/array/009.phpt
new file mode 100644
index 00000000..f4aab2fa
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_all_basic.phpt b/tests/std/array/array_all_basic.phpt
new file mode 100644
index 00000000..37a33069
--- /dev/null
+++ b/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)
diff --git a/tests/std/array/array_any_basic.phpt b/tests/std/array/array_any_basic.phpt
new file mode 100644
index 00000000..47606623
--- /dev/null
+++ b/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)
diff --git a/tests/std/array/array_change_key_case.phpt b/tests/std/array/array_change_key_case.phpt
new file mode 100644
index 00000000..92c45640
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_change_key_case_variation.phpt b/tests/std/array/array_change_key_case_variation.phpt
new file mode 100644
index 00000000..c221a3f3
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_change_key_case_variation3.phpt b/tests/std/array/array_change_key_case_variation3.phpt
new file mode 100644
index 00000000..8edec6ef
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_change_key_case_variation4.phpt b/tests/std/array/array_change_key_case_variation4.phpt
new file mode 100644
index 00000000..82d21145
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_change_key_case_variation5.phpt b/tests/std/array/array_change_key_case_variation5.phpt
new file mode 100644
index 00000000..7fe48e87
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_change_key_case_variation6.phpt b/tests/std/array/array_change_key_case_variation6.phpt
new file mode 100644
index 00000000..1357650e
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_change_key_case_variation7.phpt b/tests/std/array/array_change_key_case_variation7.phpt
new file mode 100644
index 00000000..44fd6adb
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_change_key_case_variation8.phpt b/tests/std/array/array_change_key_case_variation8.phpt
new file mode 100644
index 00000000..bb81d939
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_chunk2.phpt b/tests/std/array/array_chunk2.phpt
new file mode 100644
index 00000000..c83f051a
--- /dev/null
+++ b/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"
+  }
+}
diff --git a/tests/std/array/array_chunk_basic1.phpt b/tests/std/array/array_chunk_basic1.phpt
new file mode 100644
index 00000000..e03749ec
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_chunk_basic2.phpt b/tests/std/array/array_chunk_basic2.phpt
new file mode 100644
index 00000000..472df0fe
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_chunk_variation10.phpt b/tests/std/array/array_chunk_variation10.phpt
new file mode 100644
index 00000000..326d7de9
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation11.phpt b/tests/std/array/array_chunk_variation11.phpt
new file mode 100644
index 00000000..e3ce4453
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation12.phpt b/tests/std/array/array_chunk_variation12.phpt
new file mode 100644
index 00000000..3b0cb79b
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation13.phpt b/tests/std/array/array_chunk_variation13.phpt
new file mode 100644
index 00000000..f62d309c
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation14.phpt b/tests/std/array/array_chunk_variation14.phpt
new file mode 100644
index 00000000..64746bf6
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation15.phpt b/tests/std/array/array_chunk_variation15.phpt
new file mode 100644
index 00000000..294dd9f8
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation16.phpt b/tests/std/array/array_chunk_variation16.phpt
new file mode 100644
index 00000000..b7159cba
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation17.phpt b/tests/std/array/array_chunk_variation17.phpt
new file mode 100644
index 00000000..07826d06
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation18.phpt b/tests/std/array/array_chunk_variation18.phpt
new file mode 100644
index 00000000..1fa9ca6e
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation19.phpt b/tests/std/array/array_chunk_variation19.phpt
new file mode 100644
index 00000000..2591db89
--- /dev/null
+++ b/tests/std/array/array_chunk_variation19.phpt
@@ -0,0 +1,1013 @@
+--TEST--
+array_chunk() - variation 19
+--FILE--
+<?php
+$array = array (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+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(10) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+  [9]=>
+  int(10)
+}
+[1]
+array(10) {
+  [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)
+  }
+  [6]=>
+  array(1) {
+    [0]=>
+    int(7)
+  }
+  [7]=>
+  array(1) {
+    [0]=>
+    int(8)
+  }
+  [8]=>
+  array(1) {
+    [0]=>
+    int(9)
+  }
+  [9]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+array(10) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [2]=>
+    int(3)
+  }
+  [3]=>
+  array(1) {
+    [3]=>
+    int(4)
+  }
+  [4]=>
+  array(1) {
+    [4]=>
+    int(5)
+  }
+  [5]=>
+  array(1) {
+    [5]=>
+    int(6)
+  }
+  [6]=>
+  array(1) {
+    [6]=>
+    int(7)
+  }
+  [7]=>
+  array(1) {
+    [7]=>
+    int(8)
+  }
+  [8]=>
+  array(1) {
+    [8]=>
+    int(9)
+  }
+  [9]=>
+  array(1) {
+    [9]=>
+    int(10)
+  }
+}
+array(10) {
+  [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)
+  }
+  [6]=>
+  array(1) {
+    [0]=>
+    int(7)
+  }
+  [7]=>
+  array(1) {
+    [0]=>
+    int(8)
+  }
+  [8]=>
+  array(1) {
+    [0]=>
+    int(9)
+  }
+  [9]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+
+[2]
+array(5) {
+  [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]=>
+    int(7)
+    [1]=>
+    int(8)
+  }
+  [4]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+array(5) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [2]=>
+  array(2) {
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+  [3]=>
+  array(2) {
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+  }
+  [4]=>
+  array(2) {
+    [8]=>
+    int(9)
+    [9]=>
+    int(10)
+  }
+}
+array(5) {
+  [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]=>
+    int(7)
+    [1]=>
+    int(8)
+  }
+  [4]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+
+[3]
+array(4) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(5)
+    [2]=>
+    int(6)
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    int(7)
+    [1]=>
+    int(8)
+    [2]=>
+    int(9)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+array(4) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  array(3) {
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+  [2]=>
+  array(3) {
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+  }
+  [3]=>
+  array(1) {
+    [9]=>
+    int(10)
+  }
+}
+array(4) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(5)
+    [2]=>
+    int(6)
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    int(7)
+    [1]=>
+    int(8)
+    [2]=>
+    int(9)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+
+[4]
+array(3) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+    [2]=>
+    int(7)
+    [3]=>
+    int(8)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+array(3) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [1]=>
+  array(4) {
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+  }
+  [2]=>
+  array(2) {
+    [8]=>
+    int(9)
+    [9]=>
+    int(10)
+  }
+}
+array(3) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+    [2]=>
+    int(7)
+    [3]=>
+    int(8)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+
+[5]
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+    [2]=>
+    int(8)
+    [3]=>
+    int(9)
+    [4]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [1]=>
+  array(5) {
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+    [9]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+    [2]=>
+    int(8)
+    [3]=>
+    int(9)
+    [4]=>
+    int(10)
+  }
+}
+
+[6]
+array(2) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(7)
+    [1]=>
+    int(8)
+    [2]=>
+    int(9)
+    [3]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+  [1]=>
+  array(4) {
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+    [9]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(7)
+    [1]=>
+    int(8)
+    [2]=>
+    int(9)
+    [3]=>
+    int(10)
+  }
+}
+
+[7]
+array(2) {
+  [0]=>
+  array(7) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(8)
+    [1]=>
+    int(9)
+    [2]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(7) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+  }
+  [1]=>
+  array(3) {
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+    [9]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(7) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(8)
+    [1]=>
+    int(9)
+    [2]=>
+    int(10)
+  }
+}
+
+[8]
+array(2) {
+  [0]=>
+  array(8) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(8) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+  }
+  [1]=>
+  array(2) {
+    [8]=>
+    int(9)
+    [9]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(8) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+
+[9]
+array(2) {
+  [0]=>
+  array(9) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(9) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+  }
+  [1]=>
+  array(1) {
+    [9]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(9) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+
+[10]
+array(1) {
+  [0]=>
+  array(10) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+    [9]=>
+    int(10)
+  }
+}
+array(1) {
+  [0]=>
+  array(10) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+    [9]=>
+    int(10)
+  }
+}
+array(1) {
+  [0]=>
+  array(10) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+    [6]=>
+    int(7)
+    [7]=>
+    int(8)
+    [8]=>
+    int(9)
+    [9]=>
+    int(10)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation20.phpt b/tests/std/array/array_chunk_variation20.phpt
new file mode 100644
index 00000000..ec2e45b1
--- /dev/null
+++ b/tests/std/array/array_chunk_variation20.phpt
@@ -0,0 +1,1194 @@
+--TEST--
+array_chunk() - variation 20
+--FILE--
+<?php
+$array = array (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+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(11) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+  [6]=>
+  int(6)
+  [7]=>
+  int(7)
+  [8]=>
+  int(8)
+  [9]=>
+  int(9)
+  [10]=>
+  int(10)
+}
+[1]
+array(11) {
+  [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)
+  }
+  [5]=>
+  array(1) {
+    [0]=>
+    int(5)
+  }
+  [6]=>
+  array(1) {
+    [0]=>
+    int(6)
+  }
+  [7]=>
+  array(1) {
+    [0]=>
+    int(7)
+  }
+  [8]=>
+  array(1) {
+    [0]=>
+    int(8)
+  }
+  [9]=>
+  array(1) {
+    [0]=>
+    int(9)
+  }
+  [10]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+array(11) {
+  [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)
+  }
+  [5]=>
+  array(1) {
+    [5]=>
+    int(5)
+  }
+  [6]=>
+  array(1) {
+    [6]=>
+    int(6)
+  }
+  [7]=>
+  array(1) {
+    [7]=>
+    int(7)
+  }
+  [8]=>
+  array(1) {
+    [8]=>
+    int(8)
+  }
+  [9]=>
+  array(1) {
+    [9]=>
+    int(9)
+  }
+  [10]=>
+  array(1) {
+    [10]=>
+    int(10)
+  }
+}
+array(11) {
+  [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)
+  }
+  [5]=>
+  array(1) {
+    [0]=>
+    int(5)
+  }
+  [6]=>
+  array(1) {
+    [0]=>
+    int(6)
+  }
+  [7]=>
+  array(1) {
+    [0]=>
+    int(7)
+  }
+  [8]=>
+  array(1) {
+    [0]=>
+    int(8)
+  }
+  [9]=>
+  array(1) {
+    [0]=>
+    int(9)
+  }
+  [10]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+
+[2]
+array(6) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(3)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(5)
+  }
+  [3]=>
+  array(2) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+  }
+  [4]=>
+  array(2) {
+    [0]=>
+    int(8)
+    [1]=>
+    int(9)
+  }
+  [5]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+array(6) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+  [2]=>
+  array(2) {
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+  }
+  [3]=>
+  array(2) {
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+  }
+  [4]=>
+  array(2) {
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+  }
+  [5]=>
+  array(1) {
+    [10]=>
+    int(10)
+  }
+}
+array(6) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(3)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(5)
+  }
+  [3]=>
+  array(2) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+  }
+  [4]=>
+  array(2) {
+    [0]=>
+    int(8)
+    [1]=>
+    int(9)
+  }
+  [5]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+
+[3]
+array(4) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+    [2]=>
+    int(5)
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+    [2]=>
+    int(8)
+  }
+  [3]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+array(4) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(3) {
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+  }
+  [2]=>
+  array(3) {
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+  }
+  [3]=>
+  array(2) {
+    [9]=>
+    int(9)
+    [10]=>
+    int(10)
+  }
+}
+array(4) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(4)
+    [2]=>
+    int(5)
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+    [2]=>
+    int(8)
+  }
+  [3]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+
+[4]
+array(3) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(5)
+    [2]=>
+    int(6)
+    [3]=>
+    int(7)
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    int(8)
+    [1]=>
+    int(9)
+    [2]=>
+    int(10)
+  }
+}
+array(3) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+  [1]=>
+  array(4) {
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+  }
+  [2]=>
+  array(3) {
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+    [10]=>
+    int(10)
+  }
+}
+array(3) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(5)
+    [2]=>
+    int(6)
+    [3]=>
+    int(7)
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    int(8)
+    [1]=>
+    int(9)
+    [2]=>
+    int(10)
+  }
+}
+
+[5]
+array(3) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+    [2]=>
+    int(7)
+    [3]=>
+    int(8)
+    [4]=>
+    int(9)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+array(3) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+  }
+  [2]=>
+  array(1) {
+    [10]=>
+    int(10)
+  }
+}
+array(3) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+    [2]=>
+    int(7)
+    [3]=>
+    int(8)
+    [4]=>
+    int(9)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+
+[6]
+array(2) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+    [2]=>
+    int(8)
+    [3]=>
+    int(9)
+    [4]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+  }
+  [1]=>
+  array(5) {
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+    [10]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+    [2]=>
+    int(8)
+    [3]=>
+    int(9)
+    [4]=>
+    int(10)
+  }
+}
+
+[7]
+array(2) {
+  [0]=>
+  array(7) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(7)
+    [1]=>
+    int(8)
+    [2]=>
+    int(9)
+    [3]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(7) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+  }
+  [1]=>
+  array(4) {
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+    [10]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(7) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(7)
+    [1]=>
+    int(8)
+    [2]=>
+    int(9)
+    [3]=>
+    int(10)
+  }
+}
+
+[8]
+array(2) {
+  [0]=>
+  array(8) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(8)
+    [1]=>
+    int(9)
+    [2]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(8) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+  }
+  [1]=>
+  array(3) {
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+    [10]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(8) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(8)
+    [1]=>
+    int(9)
+    [2]=>
+    int(10)
+  }
+}
+
+[9]
+array(2) {
+  [0]=>
+  array(9) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(9) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+  }
+  [1]=>
+  array(2) {
+    [9]=>
+    int(9)
+    [10]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(9) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(9)
+    [1]=>
+    int(10)
+  }
+}
+
+[10]
+array(2) {
+  [0]=>
+  array(10) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(10) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+  }
+  [1]=>
+  array(1) {
+    [10]=>
+    int(10)
+  }
+}
+array(2) {
+  [0]=>
+  array(10) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(10)
+  }
+}
+
+[11]
+array(1) {
+  [0]=>
+  array(11) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+    [10]=>
+    int(10)
+  }
+}
+array(1) {
+  [0]=>
+  array(11) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+    [10]=>
+    int(10)
+  }
+}
+array(1) {
+  [0]=>
+  array(11) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(1)
+    [2]=>
+    int(2)
+    [3]=>
+    int(3)
+    [4]=>
+    int(4)
+    [5]=>
+    int(5)
+    [6]=>
+    int(6)
+    [7]=>
+    int(7)
+    [8]=>
+    int(8)
+    [9]=>
+    int(9)
+    [10]=>
+    int(10)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation21.phpt b/tests/std/array/array_chunk_variation21.phpt
new file mode 100644
index 00000000..ce672a92
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation22.phpt b/tests/std/array/array_chunk_variation22.phpt
new file mode 100644
index 00000000..d67269f4
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation23.phpt b/tests/std/array/array_chunk_variation23.phpt
new file mode 100644
index 00000000..99138eae
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation24.phpt b/tests/std/array/array_chunk_variation24.phpt
new file mode 100644
index 00000000..c96d59d8
--- /dev/null
+++ b/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"
+  }
+}
diff --git a/tests/std/array/array_chunk_variation25.phpt b/tests/std/array/array_chunk_variation25.phpt
new file mode 100644
index 00000000..978588e0
--- /dev/null
+++ b/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"
+  }
+}
diff --git a/tests/std/array/array_chunk_variation26.phpt b/tests/std/array/array_chunk_variation26.phpt
new file mode 100644
index 00000000..7b46215f
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation27.phpt b/tests/std/array/array_chunk_variation27.phpt
new file mode 100644
index 00000000..a91a8b91
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation28.phpt b/tests/std/array/array_chunk_variation28.phpt
new file mode 100644
index 00000000..707b0cde
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation29.phpt b/tests/std/array/array_chunk_variation29.phpt
new file mode 100644
index 00000000..07187135
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation30.phpt b/tests/std/array/array_chunk_variation30.phpt
new file mode 100644
index 00000000..5400b595
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation31.phpt b/tests/std/array/array_chunk_variation31.phpt
new file mode 100644
index 00000000..ffdfa2bc
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation32.phpt b/tests/std/array/array_chunk_variation32.phpt
new file mode 100644
index 00000000..b0a01f20
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation4.phpt b/tests/std/array/array_chunk_variation4.phpt
new file mode 100644
index 00000000..265fc390
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_chunk_variation5.phpt b/tests/std/array/array_chunk_variation5.phpt
new file mode 100644
index 00000000..dfae4897
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation6.phpt b/tests/std/array/array_chunk_variation6.phpt
new file mode 100644
index 00000000..c9c34e51
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_chunk_variation7.phpt b/tests/std/array/array_chunk_variation7.phpt
new file mode 100644
index 00000000..8deb9a32
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_chunk_variation8.phpt b/tests/std/array/array_chunk_variation8.phpt
new file mode 100644
index 00000000..2d8fa07c
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_chunk_variation9.phpt b/tests/std/array/array_chunk_variation9.phpt
new file mode 100644
index 00000000..2be7b81e
--- /dev/null
+++ b/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)
+  }
+}
diff --git a/tests/std/array/array_column_basic.phpt b/tests/std/array/array_column_basic.phpt
new file mode 100644
index 00000000..a7d0ec70
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_column_numeric_string_key.phpt b/tests/std/array/array_column_numeric_string_key.phpt
new file mode 100644
index 00000000..aed3c35e
--- /dev/null
+++ b/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"
+}
diff --git a/tests/std/array/array_column_object_cast.phpt b/tests/std/array/array_column_object_cast.phpt
new file mode 100644
index 00000000..eee58528
--- /dev/null
+++ 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) {
+}
diff --git a/tests/std/array/array_column_property_visibility.phpt b/tests/std/array/array_column_property_visibility.phpt
new file mode 100644
index 00000000..3595596c
--- /dev/null
+++ b/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)"
+}
diff --git a/tests/std/array/array_column_scalar_index_strict_types.phpt b/tests/std/array/array_column_scalar_index_strict_types.phpt
new file mode 100644
index 00000000..fbb4a641
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_column_scalar_index_weak_types.phpt b/tests/std/array/array_column_scalar_index_weak_types.phpt
new file mode 100644
index 00000000..4cba6919
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/tests/std/array/array_column_variant.phpt b/tests/std/array/array_column_variant.phpt
new file mode 100644
index 00000000..9673ff17
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_column_variant_objects.phpt b/tests/std/array/array_column_variant_objects.phpt
new file mode 100644
index 00000000..79174490
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_combine.phpt b/tests/std/array/array_combine.phpt
new file mode 100644
index 00000000..d6ec31b0
--- /dev/null
+++ b/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
+}
diff --git a/tests/std/array/array_combine_basic.phpt b/tests/std/array/array_combine_basic.phpt
new file mode 100644
index 00000000..ccf1bbf4
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_combine_error2.phpt b/tests/std/array/array_combine_error2.phpt
new file mode 100644
index 00000000..8d3440ea
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_combine_variation3.phpt b/tests/std/array/array_combine_variation3.phpt
new file mode 100644
index 00000000..a04c67e7
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_combine_variation4.phpt b/tests/std/array/array_combine_variation4.phpt
new file mode 100644
index 00000000..c8fca16a
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_combine_variation5.phpt b/tests/std/array/array_combine_variation5.phpt
new file mode 100644
index 00000000..2d80ac57
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_combine_variation6.phpt b/tests/std/array/array_combine_variation6.phpt
new file mode 100644
index 00000000..b9985a0a
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_count_values.phpt b/tests/std/array/array_count_values.phpt
new file mode 100644
index 00000000..eb515124
--- /dev/null
+++ b/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)
+}
diff --git a/tests/std/array/array_count_values2.phpt b/tests/std/array/array_count_values2.phpt
new file mode 100644
index 00000000..1b7d8442
--- /dev/null
+++ b/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)
+}
diff --git a/tests/std/array/array_count_values_variation.phpt b/tests/std/array/array_count_values_variation.phpt
new file mode 100644
index 00000000..9d895a33
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_1.phpt b/tests/std/array/array_diff_1.phpt
new file mode 100644
index 00000000..7b58077e
--- /dev/null
+++ b/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!
diff --git a/tests/std/array/array_diff_assoc.phpt b/tests/std/array/array_diff_assoc.phpt
new file mode 100644
index 00000000..ef659f50
--- /dev/null
+++ b/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
+        )
+
+)
diff --git a/tests/std/array/array_diff_assoc_basic.phpt b/tests/std/array/array_diff_assoc_basic.phpt
new file mode 100644
index 00000000..3a9ec872
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation1.phpt b/tests/std/array/array_diff_assoc_variation1.phpt
new file mode 100644
index 00000000..82618d0f
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation10.phpt b/tests/std/array/array_diff_assoc_variation10.phpt
new file mode 100644
index 00000000..edaaec73
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation2.phpt b/tests/std/array/array_diff_assoc_variation2.phpt
new file mode 100644
index 00000000..ff1c0ff8
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation3.phpt b/tests/std/array/array_diff_assoc_variation3.phpt
new file mode 100644
index 00000000..3826a907
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation4.phpt b/tests/std/array/array_diff_assoc_variation4.phpt
new file mode 100644
index 00000000..f18143fe
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation5.phpt b/tests/std/array/array_diff_assoc_variation5.phpt
new file mode 100644
index 00000000..09af9cb4
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation6.phpt b/tests/std/array/array_diff_assoc_variation6.phpt
new file mode 100644
index 00000000..bee55152
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation7.phpt b/tests/std/array/array_diff_assoc_variation7.phpt
new file mode 100644
index 00000000..ee791247
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation8.phpt b/tests/std/array/array_diff_assoc_variation8.phpt
new file mode 100644
index 00000000..0ca368f9
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_assoc_variation9.phpt b/tests/std/array/array_diff_assoc_variation9.phpt
new file mode 100644
index 00000000..e6d8ce06
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_basic.phpt b/tests/std/array/array_diff_basic.phpt
new file mode 100644
index 00000000..aa9f1cbf
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_key.phpt b/tests/std/array/array_diff_key.phpt
new file mode 100644
index 00000000..bb3db1a1
--- /dev/null
+++ b/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)
+}
diff --git a/tests/std/array/array_diff_key2.phpt b/tests/std/array/array_diff_key2.phpt
new file mode 100644
index 00000000..b7ef7f31
--- /dev/null
+++ b/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"
+  }
+}
diff --git a/tests/std/array/array_diff_key_basic.phpt b/tests/std/array/array_diff_key_basic.phpt
new file mode 100644
index 00000000..1ce70c6a
--- /dev/null
+++ b/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)
+}
diff --git a/tests/std/array/array_diff_key_variation1.phpt b/tests/std/array/array_diff_key_variation1.phpt
new file mode 100644
index 00000000..b9d38dde
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_key_variation2.phpt b/tests/std/array/array_diff_key_variation2.phpt
new file mode 100644
index 00000000..f18661a4
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_key_variation4.phpt b/tests/std/array/array_diff_key_variation4.phpt
new file mode 100644
index 00000000..eb358af0
--- /dev/null
+++ b/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"
+}
diff --git a/tests/std/array/array_diff_key_variation6.phpt b/tests/std/array/array_diff_key_variation6.phpt
new file mode 100644
index 00000000..b3b19db8
--- /dev/null
+++ b/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) {
+}
diff --git a/tests/std/array/array_diff_key_variation7.phpt b/tests/std/array/array_diff_key_variation7.phpt
new file mode 100644
index 00000000..f8821cb9
--- /dev/null
+++ b/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) {
+}
diff --git a/tests/std/array/array_diff_key_variation8.phpt b/tests/std/array/array_diff_key_variation8.phpt
new file mode 100644
index 00000000..dc54a976
--- /dev/null
+++ b/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"
+  }
+}
diff --git a/tests/std/array/array_diff_single_array.phpt b/tests/std/array/array_diff_single_array.phpt
new file mode 100644
index 00000000..83355b08
--- /dev/null
+++ b/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)
+}
diff --git a/tests/std/array/array_diff_uassoc_basic.phpt b/tests/std/array/array_diff_uassoc_basic.phpt
new file mode 100644
index 00000000..3a9296e5
--- /dev/null
+++ b/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"
+}
diff --git a/tests/std/array/array_diff_uassoc_error.phpt b/tests/std/array/array_diff_uassoc_error.phpt
new file mode 100644
index 00000000..8f166d50
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_uassoc_variation1.phpt b/tests/std/array/array_diff_uassoc_variation1.phpt
new file mode 100644
index 00000000..c7a737f6
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_uassoc_variation11.phpt b/tests/std/array/array_diff_uassoc_variation11.phpt
new file mode 100644
index 00000000..ac9544b1
--- /dev/null
+++ b/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"
+}
diff --git a/tests/std/array/array_diff_uassoc_variation12.phpt b/tests/std/array/array_diff_uassoc_variation12.phpt
new file mode 100644
index 00000000..4ab1cf0e
--- /dev/null
+++ b/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) {
+}
diff --git a/tests/std/array/array_diff_uassoc_variation13.phpt b/tests/std/array/array_diff_uassoc_variation13.phpt
new file mode 100644
index 00000000..7ff8e49b
--- /dev/null
+++ b/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) {
+}
diff --git a/tests/std/array/array_diff_uassoc_variation2.phpt b/tests/std/array/array_diff_uassoc_variation2.phpt
new file mode 100644
index 00000000..9f85ed89
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_uassoc_variation5.phpt b/tests/std/array/array_diff_uassoc_variation5.phpt
new file mode 100644
index 00000000..384c9774
--- /dev/null
+++ b/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) {
+}
diff --git a/tests/std/array/array_diff_uassoc_variation6.phpt b/tests/std/array/array_diff_uassoc_variation6.phpt
new file mode 100644
index 00000000..56c65590
--- /dev/null
+++ b/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"
+}
diff --git a/tests/std/array/array_diff_uassoc_variation7.phpt b/tests/std/array/array_diff_uassoc_variation7.phpt
new file mode 100644
index 00000000..63bdbdcb
--- /dev/null
+++ b/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"
+}
diff --git a/tests/std/array/array_diff_uassoc_variation8.phpt b/tests/std/array/array_diff_uassoc_variation8.phpt
new file mode 100644
index 00000000..1746f112
--- /dev/null
+++ b/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"
+}
diff --git a/tests/std/array/array_diff_uassoc_variation9.phpt b/tests/std/array/array_diff_uassoc_variation9.phpt
new file mode 100644
index 00000000..a8033ba3
--- /dev/null
+++ b/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)
+}
diff --git a/tests/std/array/array_diff_ukey_basic.phpt b/tests/std/array/array_diff_ukey_basic.phpt
new file mode 100644
index 00000000..3a925120
--- /dev/null
+++ b/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)
+}
diff --git a/tests/std/array/array_diff_ukey_variation1.phpt b/tests/std/array/array_diff_ukey_variation1.phpt
new file mode 100644
index 00000000..1ac2b870
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_ukey_variation10.phpt b/tests/std/array/array_diff_ukey_variation10.phpt
new file mode 100644
index 00000000..b8dfb738
--- /dev/null
+++ b/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
diff --git a/tests/std/array/array_diff_ukey_variation2.phpt b/tests/std/array/array_diff_ukey_variation2.phpt
new file mode 100644
index 00000000..0955b566
--- /dev/null
+++ b/tests/std/array/array_diff_ukey_variation2.phpt
@@ -0,0 +1,204 @@
+--TEST--
+Test array_diff_ukey() function : usage variation - Passing unexpected values to second argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+//Initialize key_comp_func of type callback
+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";
+    // Initialize function arguments not being substituted (if any)
+    $array1 = 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 array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_diff_ukey($array1, $value, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_diff_ukey($array1, $value, $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 #2 must be of type array, int given
+array_diff_ukey(): Argument #2 must be of type array, int given
+
+--int 1--
+array_diff_ukey(): Argument #2 must be of type array, int given
+array_diff_ukey(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_diff_ukey(): Argument #2 must be of type array, int given
+array_diff_ukey(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_diff_ukey(): Argument #2 must be of type array, int given
+array_diff_ukey(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_diff_ukey(): Argument #2 must be of type array, float given
+array_diff_ukey(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_diff_ukey(): Argument #2 must be of type array, float given
+array_diff_ukey(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_diff_ukey(): Argument #2 must be of type array, float given
+array_diff_ukey(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_diff_ukey(): Argument #2 must be of type array, float given
+array_diff_ukey(): Argument #2 must be of type array, float given
+
+--float .5--
+array_diff_ukey(): Argument #2 must be of type array, float given
+array_diff_ukey(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_diff_ukey(): Argument #2 must be of type array, null given
+array_diff_ukey(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_diff_ukey(): Argument #2 must be of type array, null given
+array_diff_ukey(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_diff_ukey(): Argument #2 must be of type array, true given
+array_diff_ukey(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_diff_ukey(): Argument #2 must be of type array, false given
+array_diff_ukey(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_diff_ukey(): Argument #2 must be of type array, true given
+array_diff_ukey(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_diff_ukey(): Argument #2 must be of type array, false given
+array_diff_ukey(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_diff_ukey(): Argument #2 must be of type array, string given
+array_diff_ukey(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_diff_ukey(): Argument #2 must be of type array, string given
+array_diff_ukey(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_diff_ukey(): Argument #2 must be of type array, string given
+array_diff_ukey(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_diff_ukey(): Argument #2 must be of type array, string given
+array_diff_ukey(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_diff_ukey(): Argument #2 must be of type array, string given
+array_diff_ukey(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_diff_ukey(): Argument #2 must be of type array, string given
+array_diff_ukey(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_diff_ukey(): Argument #2 must be of type array, classWithToString given
+array_diff_ukey(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_diff_ukey(): Argument #2 must be of type array, classWithoutToString given
+array_diff_ukey(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_diff_ukey(): Argument #2 must be of type array, null given
+array_diff_ukey(): Argument #2 must be of type array, null given
+
+--unset var--
+array_diff_ukey(): Argument #2 must be of type array, null given
+array_diff_ukey(): Argument #2 must be of type array, null given
+
+--resource--
+array_diff_ukey(): Argument #2 must be of type array, resource given
+array_diff_ukey(): Argument #2 must be of type array, resource given
diff --git a/tests/std/array/array_diff_ukey_variation5.phpt b/tests/std/array/array_diff_ukey_variation5.phpt
new file mode 100644
index 00000000..c41147d8
--- /dev/null
+++ b/tests/std/array/array_diff_ukey_variation5.phpt
@@ -0,0 +1,47 @@
+--TEST--
+Test array_diff_ukey() function : usage variation - Passing multi-dimensional array
+--FILE--
+<?php
+echo "*** Testing array_diff_ukey() : 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_ukey() function with multi dimensional array --\n";
+var_dump( array_diff_ukey($array1, $array2, 'strcasecmp') );
+var_dump( array_diff_ukey($array2, $array1, 'strcasecmp') );
+?>
+--EXPECT--
+*** Testing array_diff_ukey() : usage variation ***
+
+-- Testing array_diff_ukey() function with multi dimensional array --
+array(1) {
+  ["third"]=>
+  array(1) {
+    [0]=>
+    string(4) "zero"
+  }
+}
+array(1) {
+  ["fourth"]=>
+  array(1) {
+    [2]=>
+    string(3) "two"
+  }
+}
diff --git a/tests/std/array/array_diff_ukey_variation6.phpt b/tests/std/array/array_diff_ukey_variation6.phpt
new file mode 100644
index 00000000..fdc6dd65
--- /dev/null
+++ b/tests/std/array/array_diff_ukey_variation6.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Test array_diff_ukey() function : usage variation - Passing integer indexed array
+--FILE--
+<?php
+function key_compare_func($key1, $key2)
+{
+    return strcasecmp($key1, $key2);
+}
+function main()
+{
+    echo "*** Testing array_diff_ukey() : 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'));
+    foreach ($input_arrays as $key => $value) {
+        echo "\n--{$key}--\n";
+        var_dump(array_diff_ukey($value, $input_array, 'key_compare_func'));
+        var_dump(array_diff_ukey($input_array, $value, 'key_compare_func'));
+    }
+}
+?>
+--EXPECT--
+*** Testing array_diff_ukey() : usage variation ***
+
+--decimal indexed--
+array(1) {
+  [-17]=>
+  string(3) "-17"
+}
+array(1) {
+  [-7]=>
+  string(3) "-07"
+}
+
+--octal indexed--
+array(1) {
+  [-9]=>
+  string(4) "-011"
+}
+array(1) {
+  [-7]=>
+  string(3) "-07"
+}
+
+--hexa  indexed--
+array(1) {
+  [18]=>
+  string(4) "0x12"
+}
+array(1) {
+  [10]=>
+  string(3) "0xA"
+}
diff --git a/tests/std/array/array_diff_ukey_variation8.phpt b/tests/std/array/array_diff_ukey_variation8.phpt
new file mode 100644
index 00000000..24298a66
--- /dev/null
+++ b/tests/std/array/array_diff_ukey_variation8.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Test array_diff_ukey() function : usage variation - Passing boolean indexed array
+--SKIPIF--
+--FILE--
+<?php
+function key_compare_func($key1, $key2)
+{
+    return strcasecmp($key1, $key2);
+}
+function main()
+{
+    echo "*** Testing array_diff_ukey() : 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_ukey() function with boolean indexed array --\n";
+    var_dump(array_diff_ukey($boolean_indx_array, $input_array, 'key_compare_func'));
+    var_dump(array_diff_ukey($input_array, $boolean_indx_array, 'key_compare_func'));
+}
+?>
+--EXPECT--
+*** Testing array_diff_ukey() : usage variation ***
+
+-- Testing array_diff_ukey() function with boolean indexed array --
+array(0) {
+}
+array(3) {
+  [-10]=>
+  string(3) "-10"
+  ["true"]=>
+  int(1)
+  ["false"]=>
+  int(0)
+}
diff --git a/tests/std/array/array_diff_ukey_variation9.phpt b/tests/std/array/array_diff_ukey_variation9.phpt
new file mode 100644
index 00000000..f2ca3a66
--- /dev/null
+++ b/tests/std/array/array_diff_ukey_variation9.phpt
@@ -0,0 +1,57 @@
+--TEST--
+Test array_diff_ukey() 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_ukey() : 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";
+      var_dump( array_diff_ukey($value, $input_array, 'strcasecmp') );
+      var_dump( array_diff_ukey($input_array, $value, 'strcasecmp') );
+}
+
+?>
+--EXPECT--
+*** Testing array_diff_ukey() : usage variation ***
+
+--null indexed--
+array(0) {
+}
+array(1) {
+  [10]=>
+  string(2) "10"
+}
+
+--undefined indexed--
+array(0) {
+}
+array(1) {
+  [10]=>
+  string(2) "10"
+}
+
+--unset  indexed--
+array(0) {
+}
+array(1) {
+  [10]=>
+  string(2) "10"
+}
diff --git a/tests/std/array/array_diff_variation1.phpt b/tests/std/array/array_diff_variation1.phpt
new file mode 100644
index 00000000..e9cbad88
--- /dev/null
+++ b/tests/std/array/array_diff_variation1.phpt
@@ -0,0 +1,153 @@
+--TEST--
+Test array_diff() 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()
+{
+    /*
+     * Test array_diff by passing non array values in place of $array1
+     */
+    echo "*** Testing array_diff() : 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");
+    // unexpected values to be passed to $input 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
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "\n-- Iteration {$iterator} --";
+        try {
+            var_dump(array_diff($input, $array));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_diff() : usage variations ***
+
+-- Iteration 1 --array_diff(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 2 --array_diff(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 3 --array_diff(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 4 --array_diff(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 5 --array_diff(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 6 --array_diff(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 7 --array_diff(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 8 --array_diff(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 9 --array_diff(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 10 --array_diff(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 11 --array_diff(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 12 --array_diff(): Argument #1 ($array) must be of type array, true given
+
+-- Iteration 13 --array_diff(): Argument #1 ($array) must be of type array, false given
+
+-- Iteration 14 --array_diff(): Argument #1 ($array) must be of type array, true given
+
+-- Iteration 15 --array_diff(): Argument #1 ($array) must be of type array, false given
+
+-- Iteration 16 --array_diff(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 17 --array_diff(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 18 --array_diff(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 19 --array_diff(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 20 --array_diff(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 21 --array_diff(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 22 --array_diff(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 23 --array_diff(): Argument #1 ($array) must be of type array, classA given
+
+-- Iteration 24 --array_diff(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 25 --array_diff(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 26 --array_diff(): Argument #1 ($array) must be of type array, resource given
+Done
diff --git a/tests/std/array/array_diff_variation10.phpt b/tests/std/array/array_diff_variation10.phpt
new file mode 100644
index 00000000..01e849f2
--- /dev/null
+++ b/tests/std/array/array_diff_variation10.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Test array_diff() function : usage variations - binary safe checking
+--FILE--
+<?php
+/*
+ * Test behaviour of array_diff() function with binary input
+ */
+
+echo "*** Testing array_diff() : 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($array1, $array2));
+var_dump(array_diff($array2, $array1));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff() : usage variations ***
+array(1) {
+  [0]=>
+  string(1) "1"
+}
+array(1) {
+  [4]=>
+  string(4) "test"
+}
+Done
diff --git a/tests/std/array/array_diff_variation2.phpt b/tests/std/array/array_diff_variation2.phpt
new file mode 100644
index 00000000..bdc41144
--- /dev/null
+++ b/tests/std/array/array_diff_variation2.phpt
@@ -0,0 +1,153 @@
+--TEST--
+Test array_diff() function : usage variations - unexpected values for 'array2' 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()
+{
+    /*
+     * Test array_diff by passing non array values in place of $array2
+     */
+    echo "*** Testing array_diff() : 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");
+    // unexpected values to be passed to $input 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
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "\n-- Iteration {$iterator} --";
+        try {
+            var_dump(array_diff($array, $input));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_diff() : usage variations ***
+
+-- Iteration 1 --array_diff(): Argument #2 must be of type array, int given
+
+-- Iteration 2 --array_diff(): Argument #2 must be of type array, int given
+
+-- Iteration 3 --array_diff(): Argument #2 must be of type array, int given
+
+-- Iteration 4 --array_diff(): Argument #2 must be of type array, int given
+
+-- Iteration 5 --array_diff(): Argument #2 must be of type array, float given
+
+-- Iteration 6 --array_diff(): Argument #2 must be of type array, float given
+
+-- Iteration 7 --array_diff(): Argument #2 must be of type array, float given
+
+-- Iteration 8 --array_diff(): Argument #2 must be of type array, float given
+
+-- Iteration 9 --array_diff(): Argument #2 must be of type array, float given
+
+-- Iteration 10 --array_diff(): Argument #2 must be of type array, null given
+
+-- Iteration 11 --array_diff(): Argument #2 must be of type array, null given
+
+-- Iteration 12 --array_diff(): Argument #2 must be of type array, true given
+
+-- Iteration 13 --array_diff(): Argument #2 must be of type array, false given
+
+-- Iteration 14 --array_diff(): Argument #2 must be of type array, true given
+
+-- Iteration 15 --array_diff(): Argument #2 must be of type array, false given
+
+-- Iteration 16 --array_diff(): Argument #2 must be of type array, string given
+
+-- Iteration 17 --array_diff(): Argument #2 must be of type array, string given
+
+-- Iteration 18 --array_diff(): Argument #2 must be of type array, string given
+
+-- Iteration 19 --array_diff(): Argument #2 must be of type array, string given
+
+-- Iteration 20 --array_diff(): Argument #2 must be of type array, string given
+
+-- Iteration 21 --array_diff(): Argument #2 must be of type array, string given
+
+-- Iteration 22 --array_diff(): Argument #2 must be of type array, string given
+
+-- Iteration 23 --array_diff(): Argument #2 must be of type array, classA given
+
+-- Iteration 24 --array_diff(): Argument #2 must be of type array, null given
+
+-- Iteration 25 --array_diff(): Argument #2 must be of type array, null given
+
+-- Iteration 26 --array_diff(): Argument #2 must be of type array, resource given
+Done
diff --git a/tests/std/array/array_diff_variation3.phpt b/tests/std/array/array_diff_variation3.phpt
new file mode 100644
index 00000000..557b9166
--- /dev/null
+++ b/tests/std/array/array_diff_variation3.phpt
@@ -0,0 +1,189 @@
+--TEST--
+Test array_diff() function : usage variations  - array with different data types as values
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Test how array_diff() compares indexed arrays containing different
+ * data types as values in place of $arr1
+ */
+
+echo "*** Testing array_diff() : usage variations ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$array = array(1, 2);
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+//get heredoc
+$heredoc = <<<END
+This is a heredoc
+END;
+
+//array of values to iterate over
+$values = array(
+
+/*1*/"empty array" => array(),
+
+/*2*/
+"int" => array(
+      // int data
+      0,
+      1,
+      12345,
+      -2345),
+
+/*3*/
+"float" => array(
+      // float data
+       10.5,
+       -10.5,
+       12.3456789000e10,
+       12.3456789000E-10,
+       .5),
+
+/*4*/
+"null" => array(
+      // null data
+      NULL,
+      null),
+
+/*5*/
+"boolean" => array(
+      // boolean data
+      true,
+      false,
+      TRUE,
+      FALSE),
+
+/*6*/
+"empty" => array(
+      // empty data
+      "",
+      ''),
+
+/*7*/
+"string" => array(
+      // string data
+      "string",
+      'string',
+      $heredoc),
+
+/*8*/
+"binary" => array(
+       // binary data
+       b"binary",
+       (binary)"binary"),
+
+/*9*/
+"undefined" => array(
+      // undefined data
+      @$undefined_var),
+
+/*10*/
+"unset" => array(
+      // unset data
+      @$unset_var)
+);
+
+// loop through each element of the array for arr1
+$iterator = 1;
+foreach($values as $value) {
+      echo "\n Iteration: $iterator \n";
+      var_dump( array_diff($value, $array) );
+      $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff() : usage variations ***
+
+ Iteration: 1 
+array(0) {
+}
+
+ Iteration: 2 
+array(3) {
+  [0]=>
+  int(0)
+  [2]=>
+  int(12345)
+  [3]=>
+  int(-2345)
+}
+
+ Iteration: 3 
+array(5) {
+  [0]=>
+  float(10.5)
+  [1]=>
+  float(-10.5)
+  [2]=>
+  float(123456789000)
+  [3]=>
+  float(1.23456789E-9)
+  [4]=>
+  float(0.5)
+}
+
+ Iteration: 4 
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+
+ Iteration: 5 
+array(2) {
+  [1]=>
+  bool(false)
+  [3]=>
+  bool(false)
+}
+
+ Iteration: 6 
+array(2) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+}
+
+ Iteration: 7 
+array(3) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(6) "string"
+  [2]=>
+  string(17) "This is a heredoc"
+}
+
+ Iteration: 8 
+array(2) {
+  [0]=>
+  string(6) "binary"
+  [1]=>
+  string(6) "binary"
+}
+
+ Iteration: 9 
+array(1) {
+  [0]=>
+  NULL
+}
+
+ Iteration: 10 
+array(1) {
+  [0]=>
+  NULL
+}
+Done
diff --git a/tests/std/array/array_diff_variation4.phpt b/tests/std/array/array_diff_variation4.phpt
new file mode 100644
index 00000000..3ba95d96
--- /dev/null
+++ b/tests/std/array/array_diff_variation4.phpt
@@ -0,0 +1,183 @@
+--TEST--
+Test array_diff() function : usage variations  - array with different data types as values
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Test how array_diff() compares indexed arrays containing different
+ * data types as values in place of $arr2
+ */
+
+echo "*** Testing array_diff() : usage variations ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$array = array(1, 2);
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+//get heredoc
+$heredoc = <<<END
+This is a heredoc
+END;
+
+//array of values to iterate over
+$values = array(
+
+/*1*/"empty array" => array(),
+
+/*2*/
+"int" => array(
+      // int data
+      0,
+      1,
+      12345,
+      -2345),
+
+/*3*/
+"float" => array(
+      // float data
+       10.5,
+       -10.5,
+       12.3456789000e10,
+       12.3456789000E-10,
+       .5),
+
+/*4*/
+"null" => array(
+      // null data
+      NULL,
+      null),
+
+/*5*/
+"boolean" => array(
+      // boolean data
+      true,
+      false,
+      TRUE,
+      FALSE),
+
+/*6*/
+"empty" => array(
+      // empty data
+      "",
+      ''),
+
+/*7*/
+"string" => array(
+      // string data
+      "string",
+      'string',
+      $heredoc),
+
+/*8*/
+"binary" => array(
+       // binary data
+       b"binary",
+       (binary)"binary"),
+
+/*9*/
+"undefined" => array(
+      // undefined data
+      @$undefined_var),
+
+/*10*/
+"unset" => array(
+      // unset data
+      @$unset_var)
+);
+
+// loop through each element of the array for $arr2
+$iterator = 1;
+foreach($values as $value) {
+      echo "\n Iteration: $iterator \n";
+      var_dump( array_diff($array, $value) );
+      $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff() : usage variations ***
+
+ Iteration: 1 
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+ Iteration: 2 
+array(1) {
+  [1]=>
+  int(2)
+}
+
+ Iteration: 3 
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+ Iteration: 4 
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+ Iteration: 5 
+array(1) {
+  [1]=>
+  int(2)
+}
+
+ Iteration: 6 
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+ Iteration: 7 
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+ Iteration: 8 
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+ Iteration: 9 
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+ Iteration: 10 
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/array_diff_variation5.phpt b/tests/std/array/array_diff_variation5.phpt
new file mode 100644
index 00000000..9c9369de
--- /dev/null
+++ b/tests/std/array/array_diff_variation5.phpt
@@ -0,0 +1,113 @@
+--TEST--
+Test array_diff() function : usage variations - comparing integers, float
+and string array values
+--FILE--
+<?php
+/*
+ * Test how array_diff compares integers, floats and strings
+ */
+
+echo "*** Testing array_diff() : usage variations ***\n";
+
+$arr_int = array(1, 2, 3);
+$arr_float = array(1.00, 2.00, 3.00);
+$arr_int_str = array('1', '2', '3');
+$arr_float_str = array('1.00', '2.00', '3.00');
+
+print "-- Compare integers and floats: --\n";
+var_dump(array_diff($arr_int, $arr_float));
+var_dump(array_diff($arr_float, $arr_int));
+
+
+print "-- Compare integers and strings containing an integers: --\n";
+var_dump(array_diff($arr_int, $arr_int_str));
+var_dump(array_diff($arr_int_str, $arr_int));
+
+print "-- Compare integers and strings containing floats: --\n";
+var_dump(array_diff($arr_int, $arr_float_str));
+var_dump(array_diff($arr_float_str, $arr_int));
+
+print "-- Compare floats and strings containing integers: --\n";
+
+var_dump(array_diff($arr_float, $arr_int_str));
+var_dump(array_diff($arr_int_str, $arr_float));
+
+print "-- Compare floats and strings containing floats: --\n";
+var_dump(array_diff($arr_float, $arr_float_str));
+var_dump(array_diff($arr_float_str, $arr_float));
+
+print "-- Compare strings containing integers and strings containing floats: --\n";
+var_dump(array_diff($arr_int_str, $arr_float_str));
+var_dump(array_diff($arr_float_str, $arr_int_str));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff() : usage variations ***
+-- Compare integers and floats: --
+array(0) {
+}
+array(0) {
+}
+-- Compare integers and strings containing an integers: --
+array(0) {
+}
+array(0) {
+}
+-- Compare integers and strings containing floats: --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(3) {
+  [0]=>
+  string(4) "1.00"
+  [1]=>
+  string(4) "2.00"
+  [2]=>
+  string(4) "3.00"
+}
+-- Compare floats and strings containing integers: --
+array(0) {
+}
+array(0) {
+}
+-- Compare floats and strings containing floats: --
+array(3) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(2)
+  [2]=>
+  float(3)
+}
+array(3) {
+  [0]=>
+  string(4) "1.00"
+  [1]=>
+  string(4) "2.00"
+  [2]=>
+  string(4) "3.00"
+}
+-- Compare strings containing integers and strings containing floats: --
+array(3) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  string(1) "2"
+  [2]=>
+  string(1) "3"
+}
+array(3) {
+  [0]=>
+  string(4) "1.00"
+  [1]=>
+  string(4) "2.00"
+  [2]=>
+  string(4) "3.00"
+}
+Done
diff --git a/tests/std/array/array_diff_variation6.phpt b/tests/std/array/array_diff_variation6.phpt
new file mode 100644
index 00000000..15cedc6c
--- /dev/null
+++ b/tests/std/array/array_diff_variation6.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Test array_diff() function : usage variations - array containing duplicate keys and values
+--FILE--
+<?php
+/*
+ * Test that array_diff behaves as expected for comparing:
+ * 1. the order of the array
+ * 2. duplicate values
+ * 3. duplicate key names
+ */
+
+echo "*** Testing array_diff() : usage variations ***\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($array_index, $array_assoc));
+var_dump(array_diff($array_assoc, $array_index));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff() : usage variations ***
+array(1) {
+  [0]=>
+  string(1) "d"
+}
+array(3) {
+  [0]=>
+  string(1) "a"
+  ["b"]=>
+  string(1) "3"
+  ["c"]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/array_diff_variation7.phpt b/tests/std/array/array_diff_variation7.phpt
new file mode 100644
index 00000000..75374f1c
--- /dev/null
+++ b/tests/std/array/array_diff_variation7.phpt
@@ -0,0 +1,92 @@
+--TEST--
+Test array_diff() function : usage variations - arrays containing referenced variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support cross-type variable reassignment");
+?>
+
+--FILE--
+<?php
+/*
+ * Test how array_diff compares arrays that
+ * 1. Contain referenced variables
+ * 2. Have been referenced to each other
+ */
+
+echo "*** Testing array_diff() : usage variations ***\n";
+$a = 'a';
+
+$arr1 = array ("&$a", 'b', 'c');
+$arr2 = array (1, 2, 3);
+echo "-- Basic Comparison --\n";
+var_dump(array_diff($arr1, $arr2));
+var_dump(array_diff($arr2, $arr1));
+
+$a = 1;
+
+echo "-- \$a changed --\n";
+var_dump(array_diff($arr1, $arr2));
+var_dump(array_diff($arr2, $arr1));
+
+
+$arr2 = &$arr1;
+echo "-- Arrays referenced to each other --\n";
+var_dump(array_diff($arr1, $arr2));
+var_dump(array_diff($arr2, $arr1));
+
+
+$arr1 = array('x', 'y', 'z');
+echo "-- \$arr1 changed --\n";
+var_dump(array_diff($arr1, $arr2));
+var_dump(array_diff($arr2, $arr1));
+
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_diff() : usage variations ***
+-- Basic Comparison --
+array(3) {
+  [0]=>
+  string(2) "&a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+-- $a changed --
+array(3) {
+  [0]=>
+  string(2) "&a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+-- Arrays referenced to each other --
+array(0) {
+}
+array(0) {
+}
+-- $arr1 changed --
+array(0) {
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_diff_variation8.phpt b/tests/std/array/array_diff_variation8.phpt
new file mode 100644
index 00000000..0035f580
--- /dev/null
+++ b/tests/std/array/array_diff_variation8.phpt
@@ -0,0 +1,198 @@
+--TEST--
+Test array_diff() function : usage variations - associative arrays containing different data types
+--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");
+    /*
+     * Test array_diff() with associative arrays containing different data types as values
+     */
+    echo "*** Testing array_diff() : usage variations ***\n";
+    $array = array('a' => '1', 'b' => '2', 'c' => '3');
+    // 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;
+    // associative arrays with different values
+    $inputs = array(
+        // arrays with integer values
+        /*1*/
+        array('0' => 0, '1' => 0),
+        array("one" => 1, 'two' => 2, "three" => 1, 4 => 1),
+        // arrays with float values
+        /*3*/
+        array("float1" => 2.3333, "float2" => 2.3333),
+        array("f1" => 1.2, 'f2' => 3.33, 3 => 4.89999922839999, 'f4' => 1.2),
+        // arrays with string values
+        /*5*/
+        array(111 => "\tHello", "red" => "col\tor", 2 => "\v\fworld", 3 => "\tHello"),
+        array(111 => '\tHello', "red" => 'col\tor', 2 => '\v\fworld', 3 => '\tHello'),
+        array(1 => "hello", "heredoc" => $heredoc, $heredoc),
+        // array with object, unset variable and resource variable
+        /*8*/
+        array(11 => new classA(), "unset" => @$unset_var, "resource" => $fp, new classA(), $fp),
+    );
+    // loop through each sub-array of $inputs to check the behavior of array_unique()
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "-- Iteration {$iterator} --\n";
+        var_dump(array_diff($array, $input));
+        var_dump(array_diff($input, $array));
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_diff() : usage variations ***
+-- Iteration 1 --
+array(3) {
+  ["a"]=>
+  string(1) "1"
+  ["b"]=>
+  string(1) "2"
+  ["c"]=>
+  string(1) "3"
+}
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(0)
+}
+-- Iteration 2 --
+array(1) {
+  ["c"]=>
+  string(1) "3"
+}
+array(0) {
+}
+-- Iteration 3 --
+array(3) {
+  ["a"]=>
+  string(1) "1"
+  ["b"]=>
+  string(1) "2"
+  ["c"]=>
+  string(1) "3"
+}
+array(2) {
+  ["float1"]=>
+  float(2.3333)
+  ["float2"]=>
+  float(2.3333)
+}
+-- Iteration 4 --
+array(3) {
+  ["a"]=>
+  string(1) "1"
+  ["b"]=>
+  string(1) "2"
+  ["c"]=>
+  string(1) "3"
+}
+array(4) {
+  ["f1"]=>
+  float(1.2)
+  ["f2"]=>
+  float(3.33)
+  [3]=>
+  float(4.89999922839999)
+  ["f4"]=>
+  float(1.2)
+}
+-- Iteration 5 --
+array(3) {
+  ["a"]=>
+  string(1) "1"
+  ["b"]=>
+  string(1) "2"
+  ["c"]=>
+  string(1) "3"
+}
+array(4) {
+  [111]=>
+  string(6) "	Hello"
+  ["red"]=>
+  string(6) "col	or"
+  [2]=>
+  string(7) "world"
+  [3]=>
+  string(6) "	Hello"
+}
+-- Iteration 6 --
+array(3) {
+  ["a"]=>
+  string(1) "1"
+  ["b"]=>
+  string(1) "2"
+  ["c"]=>
+  string(1) "3"
+}
+array(4) {
+  [111]=>
+  string(7) "\tHello"
+  ["red"]=>
+  string(7) "col\tor"
+  [2]=>
+  string(9) "\v\fworld"
+  [3]=>
+  string(7) "\tHello"
+}
+-- Iteration 7 --
+array(3) {
+  ["a"]=>
+  string(1) "1"
+  ["b"]=>
+  string(1) "2"
+  ["c"]=>
+  string(1) "3"
+}
+array(3) {
+  [1]=>
+  string(5) "hello"
+  ["heredoc"]=>
+  string(11) "Hello world"
+  [2]=>
+  string(11) "Hello world"
+}
+-- Iteration 8 --
+array(3) {
+  ["a"]=>
+  string(1) "1"
+  ["b"]=>
+  string(1) "2"
+  ["c"]=>
+  string(1) "3"
+}
+array(5) {
+  [11]=>
+  object(classA)#%d (0) {
+  }
+  ["unset"]=>
+  NULL
+  ["resource"]=>
+  resource(%d) of type (stream)
+  [12]=>
+  object(classA)#%d (0) {
+  }
+  [13]=>
+  resource(%d) of type (stream)
+}
+Done
diff --git a/tests/std/array/array_diff_variation9.phpt b/tests/std/array/array_diff_variation9.phpt
new file mode 100644
index 00000000..3a956e99
--- /dev/null
+++ b/tests/std/array/array_diff_variation9.phpt
@@ -0,0 +1,118 @@
+--TEST--
+Test array_diff() function : usage variations - multidimensional arrays
+--FILE--
+<?php
+/*
+ * Test how array_diff() compares multidimensional arrays
+ */
+
+echo "*** Testing array_diff() : 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($array1, $array2));
+var_dump(array_diff($array2, $array1));
+
+echo "\n-- Compare subarrays from two 2-D arrays --\n";
+var_dump(array_diff($array1['sub_array1'], $array2['sub_arraya']));
+var_dump(array_diff($array2['sub_arraya'], $array1['sub_array1']));
+
+var_dump(array_diff($array1['sub_array2'], $array2['sub_arrayb']));
+var_dump(array_diff($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($array1['sub_array1'], $array2));
+var_dump(array_diff($array1, $array2['sub_arraya']));
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_diff() : usage variations ***
+-- Compare two 2-D arrays --
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+array(0) {
+}
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+array(0) {
+}
+
+-- Compare subarrays from two 2-D arrays --
+array(1) {
+  [1]=>
+  int(2)
+}
+array(1) {
+  [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 --
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+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
diff --git a/tests/std/array/array_fill.phpt b/tests/std/array/array_fill.phpt
new file mode 100644
index 00000000..cfc2126d
--- /dev/null
+++ b/tests/std/array/array_fill.phpt
@@ -0,0 +1,345 @@
+--TEST--
+basic array_fill test
+--FILE--
+<?php
+$array1 = array(0.0, 1, 2);
+$array2 = array(TRUE, FALSE, NULL, "d", "e", "f");
+foreach($array1 as $start)
+{
+   foreach($array1 as $num)
+   {
+      foreach($array2 as $value)
+      {
+         echo '==========================='."\n";
+     echo 'start: '.$start.' num: '.$num.' value: '. var_dump($value);
+     $output = array_fill($start, $num, $value);
+     var_dump($output);
+      }
+   }
+}
+?>
+--EXPECT--
+===========================
+bool(true)
+start: 0 num: 0 value: array(0) {
+}
+===========================
+bool(false)
+start: 0 num: 0 value: array(0) {
+}
+===========================
+NULL
+start: 0 num: 0 value: array(0) {
+}
+===========================
+string(1) "d"
+start: 0 num: 0 value: array(0) {
+}
+===========================
+string(1) "e"
+start: 0 num: 0 value: array(0) {
+}
+===========================
+string(1) "f"
+start: 0 num: 0 value: array(0) {
+}
+===========================
+bool(true)
+start: 0 num: 1 value: array(1) {
+  [0]=>
+  bool(true)
+}
+===========================
+bool(false)
+start: 0 num: 1 value: array(1) {
+  [0]=>
+  bool(false)
+}
+===========================
+NULL
+start: 0 num: 1 value: array(1) {
+  [0]=>
+  NULL
+}
+===========================
+string(1) "d"
+start: 0 num: 1 value: array(1) {
+  [0]=>
+  string(1) "d"
+}
+===========================
+string(1) "e"
+start: 0 num: 1 value: array(1) {
+  [0]=>
+  string(1) "e"
+}
+===========================
+string(1) "f"
+start: 0 num: 1 value: array(1) {
+  [0]=>
+  string(1) "f"
+}
+===========================
+bool(true)
+start: 0 num: 2 value: array(2) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(true)
+}
+===========================
+bool(false)
+start: 0 num: 2 value: array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(false)
+}
+===========================
+NULL
+start: 0 num: 2 value: array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+===========================
+string(1) "d"
+start: 0 num: 2 value: array(2) {
+  [0]=>
+  string(1) "d"
+  [1]=>
+  string(1) "d"
+}
+===========================
+string(1) "e"
+start: 0 num: 2 value: array(2) {
+  [0]=>
+  string(1) "e"
+  [1]=>
+  string(1) "e"
+}
+===========================
+string(1) "f"
+start: 0 num: 2 value: array(2) {
+  [0]=>
+  string(1) "f"
+  [1]=>
+  string(1) "f"
+}
+===========================
+bool(true)
+start: 1 num: 0 value: array(0) {
+}
+===========================
+bool(false)
+start: 1 num: 0 value: array(0) {
+}
+===========================
+NULL
+start: 1 num: 0 value: array(0) {
+}
+===========================
+string(1) "d"
+start: 1 num: 0 value: array(0) {
+}
+===========================
+string(1) "e"
+start: 1 num: 0 value: array(0) {
+}
+===========================
+string(1) "f"
+start: 1 num: 0 value: array(0) {
+}
+===========================
+bool(true)
+start: 1 num: 1 value: array(1) {
+  [1]=>
+  bool(true)
+}
+===========================
+bool(false)
+start: 1 num: 1 value: array(1) {
+  [1]=>
+  bool(false)
+}
+===========================
+NULL
+start: 1 num: 1 value: array(1) {
+  [1]=>
+  NULL
+}
+===========================
+string(1) "d"
+start: 1 num: 1 value: array(1) {
+  [1]=>
+  string(1) "d"
+}
+===========================
+string(1) "e"
+start: 1 num: 1 value: array(1) {
+  [1]=>
+  string(1) "e"
+}
+===========================
+string(1) "f"
+start: 1 num: 1 value: array(1) {
+  [1]=>
+  string(1) "f"
+}
+===========================
+bool(true)
+start: 1 num: 2 value: array(2) {
+  [1]=>
+  bool(true)
+  [2]=>
+  bool(true)
+}
+===========================
+bool(false)
+start: 1 num: 2 value: array(2) {
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(false)
+}
+===========================
+NULL
+start: 1 num: 2 value: array(2) {
+  [1]=>
+  NULL
+  [2]=>
+  NULL
+}
+===========================
+string(1) "d"
+start: 1 num: 2 value: array(2) {
+  [1]=>
+  string(1) "d"
+  [2]=>
+  string(1) "d"
+}
+===========================
+string(1) "e"
+start: 1 num: 2 value: array(2) {
+  [1]=>
+  string(1) "e"
+  [2]=>
+  string(1) "e"
+}
+===========================
+string(1) "f"
+start: 1 num: 2 value: array(2) {
+  [1]=>
+  string(1) "f"
+  [2]=>
+  string(1) "f"
+}
+===========================
+bool(true)
+start: 2 num: 0 value: array(0) {
+}
+===========================
+bool(false)
+start: 2 num: 0 value: array(0) {
+}
+===========================
+NULL
+start: 2 num: 0 value: array(0) {
+}
+===========================
+string(1) "d"
+start: 2 num: 0 value: array(0) {
+}
+===========================
+string(1) "e"
+start: 2 num: 0 value: array(0) {
+}
+===========================
+string(1) "f"
+start: 2 num: 0 value: array(0) {
+}
+===========================
+bool(true)
+start: 2 num: 1 value: array(1) {
+  [2]=>
+  bool(true)
+}
+===========================
+bool(false)
+start: 2 num: 1 value: array(1) {
+  [2]=>
+  bool(false)
+}
+===========================
+NULL
+start: 2 num: 1 value: array(1) {
+  [2]=>
+  NULL
+}
+===========================
+string(1) "d"
+start: 2 num: 1 value: array(1) {
+  [2]=>
+  string(1) "d"
+}
+===========================
+string(1) "e"
+start: 2 num: 1 value: array(1) {
+  [2]=>
+  string(1) "e"
+}
+===========================
+string(1) "f"
+start: 2 num: 1 value: array(1) {
+  [2]=>
+  string(1) "f"
+}
+===========================
+bool(true)
+start: 2 num: 2 value: array(2) {
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+===========================
+bool(false)
+start: 2 num: 2 value: array(2) {
+  [2]=>
+  bool(false)
+  [3]=>
+  bool(false)
+}
+===========================
+NULL
+start: 2 num: 2 value: array(2) {
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+}
+===========================
+string(1) "d"
+start: 2 num: 2 value: array(2) {
+  [2]=>
+  string(1) "d"
+  [3]=>
+  string(1) "d"
+}
+===========================
+string(1) "e"
+start: 2 num: 2 value: array(2) {
+  [2]=>
+  string(1) "e"
+  [3]=>
+  string(1) "e"
+}
+===========================
+string(1) "f"
+start: 2 num: 2 value: array(2) {
+  [2]=>
+  string(1) "f"
+  [3]=>
+  string(1) "f"
+}
diff --git a/tests/std/array/array_fill_basic.phpt b/tests/std/array/array_fill_basic.phpt
new file mode 100644
index 00000000..a613f5a2
--- /dev/null
+++ b/tests/std/array/array_fill_basic.phpt
@@ -0,0 +1,91 @@
+--TEST--
+Test array_fill() function : basic functionality
+--FILE--
+<?php
+echo "*** Testing array_fill() : basic functionality ***\n";
+
+// calling the array_fill with all possible valid values for 'val' argument
+$start_key = 0 ;
+$num = 2;
+$heredoc = <<<HERE_DOC
+Hello
+HERE_DOC;
+
+// array of possible valid values for 'val' argument
+$values = array (
+
+  /* 1  */  NULL,
+            0,
+            1,
+  /* 4  */  1.5,
+            'hi',
+            "hi",
+  /* 7  */  $heredoc
+
+);
+
+$counter = 1;
+for($i = 0; $i < count($values); $i ++)
+{
+  echo "-- Iteration $counter --\n";
+  $val = $values[$i];
+
+  var_dump( array_fill($start_key,$num,$val) );
+
+  $counter++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_fill() : basic functionality ***
+-- Iteration 1 --
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+-- Iteration 2 --
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(0)
+}
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+}
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  float(1.5)
+  [1]=>
+  float(1.5)
+}
+-- Iteration 5 --
+array(2) {
+  [0]=>
+  string(2) "hi"
+  [1]=>
+  string(2) "hi"
+}
+-- Iteration 6 --
+array(2) {
+  [0]=>
+  string(2) "hi"
+  [1]=>
+  string(2) "hi"
+}
+-- Iteration 7 --
+array(2) {
+  [0]=>
+  string(5) "Hello"
+  [1]=>
+  string(5) "Hello"
+}
+Done
diff --git a/tests/std/array/array_fill_error.phpt b/tests/std/array/array_fill_error.phpt
new file mode 100644
index 00000000..9b04f755
--- /dev/null
+++ b/tests/std/array/array_fill_error.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Test array_fill() function : error conditions
+--FILE--
+<?php
+echo "*** Testing array_fill() : error conditions ***\n";
+
+// calling array_fill with negative values for 'num' parameter
+$start_key = 0;
+$num = -1;
+$val = 1;
+
+try {
+    var_dump( array_fill($start_key,$num,$val) );
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+?>
+--EXPECT--
+*** Testing array_fill() : error conditions ***
+array_fill(): Argument #2 ($count) must be greater than or equal to 0
diff --git a/tests/std/array/array_fill_error2.phpt b/tests/std/array/array_fill_error2.phpt
new file mode 100644
index 00000000..054a52aa
--- /dev/null
+++ b/tests/std/array/array_fill_error2.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Test array_fill() function : error conditions - count is too large
+--SKIPIF--
+--FILE--
+<?php
+$intMax = 2147483647;
+
+// calling array_fill() with 'count' larger than INT_MAX
+try {
+    $array = array_fill(0, $intMax+1, 1);
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+// calling array_fill() with 'count' equals to INT_MAX
+$array = array_fill(0, $intMax, 1);
+
+?>
+--EXPECTF--
+%SFatal error: Possible integer overflow in memory allocation (%d * %d + %d) in %s
diff --git a/tests/std/array/array_fill_keys.phpt b/tests/std/array/array_fill_keys.phpt
new file mode 100644
index 00000000..eebfd0aa
--- /dev/null
+++ b/tests/std/array/array_fill_keys.phpt
@@ -0,0 +1,40 @@
+--TEST--
+basic array_fill_keys test
+--INI--
+precision=14
+--FILE--
+<?php
+    var_dump(array_fill_keys(array(), 1));
+    var_dump(array_fill_keys(array('foo', 'bar'), NULL));
+    var_dump(array_fill_keys(array('5', 'foo', 10, 1.23), 123));
+    var_dump(array_fill_keys(array('test', TRUE, 10, 100), ''));
+?>
+--EXPECT--
+array(0) {
+}
+array(2) {
+  ["foo"]=>
+  NULL
+  ["bar"]=>
+  NULL
+}
+array(4) {
+  [5]=>
+  int(123)
+  ["foo"]=>
+  int(123)
+  [10]=>
+  int(123)
+  ["1.23"]=>
+  int(123)
+}
+array(4) {
+  ["test"]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+  [10]=>
+  string(0) ""
+  [100]=>
+  string(0) ""
+}
diff --git a/tests/std/array/array_fill_keys_variation1.phpt b/tests/std/array/array_fill_keys_variation1.phpt
new file mode 100644
index 00000000..2f210823
--- /dev/null
+++ b/tests/std/array/array_fill_keys_variation1.phpt
@@ -0,0 +1,73 @@
+--TEST--
+Test array_fill_keys() function : variation of parameter
+--SKIPIF--
+<?php die("skip AOT array_fill_keys key handling differs from PHP"); ?>
+--FILE--
+<?php
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    echo "*** Testing array_fill_keys() : parameter variations ***\n";
+    $nullVal = null;
+    $simpleStr = "simple";
+    $fp = fopen(__FILE__, "r");
+    $emptyArr = array();
+    $bool = false;
+    $float = 2.4;
+    $obj = new classA();
+    echo "\n-- Testing array_fill_keys() function with empty arguments --\n";
+    var_dump(array_fill_keys($emptyArr, $nullVal));
+    echo "\n-- Testing array_fill_keys() function with keyed array --\n";
+    $keyedArray = array("two" => 2, "strk1" => "strv1", 4, $simpleStr);
+    var_dump(array_fill_keys($keyedArray, $simpleStr));
+    echo "\n-- Testing array_fill_keys() function with mixed array --\n";
+    $mixedArray = array($fp, $obj, $simpleStr, $emptyArr, 2, $bool, $float);
+    var_dump(array_fill_keys($mixedArray, $simpleStr));
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_fill_keys() : parameter variations ***
+
+-- Testing array_fill_keys() function with empty arguments --
+array(0) {
+}
+
+-- Testing array_fill_keys() function with keyed array --
+array(4) {
+  [2]=>
+  string(6) "simple"
+  ["strv1"]=>
+  string(6) "simple"
+  [4]=>
+  string(6) "simple"
+  ["simple"]=>
+  string(6) "simple"
+}
+
+-- Testing array_fill_keys() function with mixed array --
+
+Warning: Array to string conversion in %s on line %d
+array(7) {
+  ["Resource id #%d"]=>
+  string(6) "simple"
+  ["Class A object"]=>
+  string(6) "simple"
+  ["simple"]=>
+  string(6) "simple"
+  ["Array"]=>
+  string(6) "simple"
+  [2]=>
+  string(6) "simple"
+  [""]=>
+  string(6) "simple"
+  ["2.4"]=>
+  string(6) "simple"
+}
+Done
diff --git a/tests/std/array/array_fill_keys_variation2.phpt b/tests/std/array/array_fill_keys_variation2.phpt
new file mode 100644
index 00000000..15d0bfbf
--- /dev/null
+++ b/tests/std/array/array_fill_keys_variation2.phpt
@@ -0,0 +1,72 @@
+--TEST--
+Test array_fill_keys() function : variation of parameter
+--FILE--
+<?php
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /* Testing with reference types for the arguments */
+    echo "*** Testing array_fill_keys() : parameter variations ***\n";
+    $nullVal = null;
+    $simpleStr = "simple";
+    $refString =& $simpleStr;
+    $fp = fopen(__FILE__, "r");
+    $emptyArr = array();
+    $bool = false;
+    $float = 2.4;
+    $obj = new classA();
+    echo "\n-- Testing array_fill_keys() function with reference value --\n";
+    $keyedArray = array("one", "two");
+    var_dump(array_fill_keys($keyedArray, $refString));
+    echo "\n-- Testing array_fill_keys() function with reference keys --\n";
+    $refKeys = array("one", &$simpleStr);
+    $res = array_fill_keys($refKeys, $simpleStr);
+    var_dump($res);
+    $simpleStr = "bob";
+    var_dump($res);
+    echo "\n-- Testing array_fill_keys() function with reference array input --\n";
+    $newArray = array("one", "two");
+    $refArray =& $newArray;
+    var_dump(array_fill_keys($refArray, $simpleStr));
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_fill_keys() : parameter variations ***
+
+-- Testing array_fill_keys() function with reference value --
+array(2) {
+  ["one"]=>
+  string(6) "simple"
+  ["two"]=>
+  string(6) "simple"
+}
+
+-- Testing array_fill_keys() function with reference keys --
+array(2) {
+  ["one"]=>
+  string(6) "simple"
+  ["simple"]=>
+  string(6) "simple"
+}
+array(2) {
+  ["one"]=>
+  string(6) "simple"
+  ["simple"]=>
+  string(6) "simple"
+}
+
+-- Testing array_fill_keys() function with reference array input --
+array(2) {
+  ["one"]=>
+  string(3) "bob"
+  ["two"]=>
+  string(3) "bob"
+}
+Done
diff --git a/tests/std/array/array_fill_keys_variation3.phpt b/tests/std/array/array_fill_keys_variation3.phpt
new file mode 100644
index 00000000..a800965a
--- /dev/null
+++ b/tests/std/array/array_fill_keys_variation3.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Test array_fill_keys() function : variation of parameter
+--FILE--
+<?php
+/* Testing with unexpected argument types */
+
+echo "*** Testing array_fill_keys() : parameter variations ***\n";
+
+$fp = fopen(__FILE__, "r");
+$array = array("one", "two");
+
+echo "\n-- Testing array_fill_keys() function with unusual second arguments --\n";
+var_dump( array_fill_keys($array, $fp) );
+
+fclose($fp);
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_fill_keys() : parameter variations ***
+
+-- Testing array_fill_keys() function with unusual second arguments --
+array(2) {
+  ["one"]=>
+  resource(%d) of type (stream)
+  ["two"]=>
+  resource(%d) of type (stream)
+}
+Done
diff --git a/tests/std/array/array_fill_keys_variation4.phpt b/tests/std/array/array_fill_keys_variation4.phpt
new file mode 100644
index 00000000..995a30c2
--- /dev/null
+++ b/tests/std/array/array_fill_keys_variation4.phpt
@@ -0,0 +1,82 @@
+--TEST--
+Test array_fill_keys() function : variation of parameter
+--SKIPIF--
+<?php die("skip AOT array_fill_keys key handling differs from PHP"); ?>
+--FILE--
+<?php
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /* Testing with unexpected argument types */
+    echo "*** Testing array_fill_keys() : parameter variations ***\n";
+    $fp = fopen(__FILE__, "r");
+    $bool = false;
+    $float = 2.4;
+    $array = array("one");
+    $nullVal = null;
+    $unset_var = 10;
+    unset($unset_var);
+    $obj = new classA();
+    echo "\n-- Testing array_fill_keys() function with float --\n";
+    var_dump(array_fill_keys($array, $float));
+    echo "\n-- Testing array_fill_keys() function with null --\n";
+    var_dump(array_fill_keys($array, $nullVal));
+    echo "\n-- Testing array_fill_keys() function with object --\n";
+    var_dump(array_fill_keys($array, $obj));
+    echo "\n-- Testing array_fill_keys() function with boolean --\n";
+    var_dump(array_fill_keys($array, $bool));
+    echo "\n-- Testing array_fill_keys() function with resource --\n";
+    var_dump(array_fill_keys($array, $fp));
+    echo "\n-- Testing array_fill_keys() function with unset var --\n";
+    var_dump(array_fill_keys($array, $unset_var));
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_fill_keys() : parameter variations ***
+
+-- Testing array_fill_keys() function with float --
+array(1) {
+  ["one"]=>
+  float(2.4)
+}
+
+-- Testing array_fill_keys() function with null --
+array(1) {
+  ["one"]=>
+  NULL
+}
+
+-- Testing array_fill_keys() function with object --
+array(1) {
+  ["one"]=>
+  object(classA)#%d (0) {
+  }
+}
+
+-- Testing array_fill_keys() function with boolean --
+array(1) {
+  ["one"]=>
+  bool(false)
+}
+
+-- Testing array_fill_keys() function with resource --
+array(1) {
+  ["one"]=>
+  resource(%d) of type (stream)
+}
+
+-- Testing array_fill_keys() function with unset var --
+
+Warning: Undefined variable $unset_var in %s on line %d
+array(1) {
+  ["one"]=>
+  NULL
+}
+Done
diff --git a/tests/std/array/array_fill_object.phpt b/tests/std/array/array_fill_object.phpt
new file mode 100644
index 00000000..474c17f7
--- /dev/null
+++ b/tests/std/array/array_fill_object.phpt
@@ -0,0 +1,403 @@
+--TEST--
+Test array_fill() function : usage variations - various object values for 'val' argument
+--SKIPIF--
+<?php die("skip AOT var_dump differs for object properties"); ?>
+--FILE--
+<?php
+// class without a member
+class Test
+{
+}
+//class with public member, static member , constant and consturctor to initialize the public member
+class Test1
+{
+    const test1_constant = "test1";
+    public static $test1_static = 0;
+    public $member1;
+    var $var1 = 30;
+    var $var2;
+    function __construct($value1, $value2)
+    {
+        $this->member1 = $value1;
+        $this->var2 = $value2;
+    }
+}
+// child class which inherits parent class test1
+class Child_test1 extends Test1
+{
+    public $member2;
+    function __construct($value1, $value2, $value3)
+    {
+        parent::__construct($value1, $value2);
+        $this->member2 = $value3;
+    }
+}
+//class with private member, static member, constant and constructor to initialize the private member
+class Test2
+{
+    const test2_constant = "test2";
+    public static $test2_static = 0;
+    private $member1;
+    var $var1 = 30;
+    var $var2;
+    function __construct($value1, $value2)
+    {
+        $this->member1 = $value1;
+        $this->var2 = $value2;
+    }
+}
+// child class which inherits parent class test2
+class Child_test2 extends Test2
+{
+    private $member1;
+    function __construct($value1, $value2, $value3)
+    {
+        parent::__construct($value1, $value2);
+        $this->member1 = $value3;
+    }
+}
+// class with protected member, static member, constant and consturctor to initialize the protected member
+class Test3
+{
+    const test3_constant = "test3";
+    public static $test3_static = 0;
+    protected $member1;
+    var $var1 = 30;
+    var $var2;
+    function __construct($value1, $value2)
+    {
+        $this->member1 = $value1;
+        $this->var2 = $value2;
+    }
+}
+// child class which inherits parent class test3
+class Child_test3 extends Test3
+{
+    protected $member1;
+    function __construct($value1, $value2, $value3)
+    {
+        parent::__construct($value1, $value2);
+        $this->member1 = $value3;
+    }
+}
+// class with public, private, protected members, static, constant members and constructor to initialize all the members
+class Test4
+{
+    const test4_constant = "test4";
+    public static $test4_static = 0;
+    public $member1;
+    private $member2;
+    protected $member3;
+    function __construct($value1, $value2, $value3)
+    {
+        $this->member1 = $value1;
+        $this->member2 = $value2;
+        $this->member3 = $value3;
+    }
+}
+// child class which inherits parent class test4
+class Child_test4 extends Test4
+{
+    var $var1;
+    function __construct($value1, $value2, $value3, $value4)
+    {
+        parent::__construct($value1, $value2, $value3);
+        $this->var1 = $value4;
+    }
+}
+// abstract class with public, private, protected members
+abstract class AbstractClass
+{
+    public $member1;
+    private $member2;
+    protected $member3;
+    var $var1 = 30;
+    abstract protected function display();
+}
+// implement abstract 'AbstractClass' class
+class ConcreteClass1 extends AbstractClass
+{
+    protected function display()
+    {
+        echo "class name is ConcreteClass1 \n";
+    }
+}
+// declarationn of the interface 'iTemplate'
+interface iTemplate
+{
+    public function display();
+}
+// implement the interface 'iTemplate'
+class Template1 implements iTemplate
+{
+    public function display()
+    {
+        echo "class name is Template1\n";
+    }
+}
+function main()
+{
+    /*
+     * testing array_fill() by passing various  object values for 'val' argument
+     */
+    echo "*** Testing array_fill() : usage variations ***\n";
+    // Initialise function arguments not being substituted
+    $start_key = 0;
+    $num = 2;
+    //array of object values for 'val' argument
+    $objects = array(
+        /* 1  */
+        new Test(),
+        new Test1(100, 101),
+        new Child_test1(100, 101, 102),
+        new Test2(100, 101),
+        /* 5  */
+        new Child_test2(100, 101, 102),
+        new Test3(100, 101),
+        new Child_test3(100, 101, 102),
+        new Test4(100, 101, 102),
+        new Child_test4(100, 101, 102, 103),
+        new ConcreteClass1(),
+        /* 11 */
+        new Template1(),
+    );
+    // loop through each element of the array for 'val' argument
+    // check the working of array_fill()
+    echo "--- Testing array_fill() with different object values for 'val' argument ---\n";
+    $counter = 1;
+    for ($index = 0; $index < count($objects); $index++) {
+        echo "-- Iteration {$counter} --\n";
+        $val = $objects[$index];
+        var_dump(array_fill($start_key, $num, $val));
+        $counter++;
+    }
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_fill() : usage variations ***
+--- Testing array_fill() with different object values for 'val' argument ---
+-- Iteration 1 --
+array(2) {
+  [0]=>
+  object(Test)#%d (0) {
+  }
+  [1]=>
+  object(Test)#%d (0) {
+  }
+}
+-- Iteration 2 --
+array(2) {
+  [0]=>
+  object(Test1)#%d (3) {
+    ["member1"]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+  }
+  [1]=>
+  object(Test1)#%d (3) {
+    ["member1"]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+  }
+}
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  object(Child_test1)#%d (4) {
+    ["member1"]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+    ["member2"]=>
+    int(102)
+  }
+  [1]=>
+  object(Child_test1)#%d (4) {
+    ["member1"]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+    ["member2"]=>
+    int(102)
+  }
+}
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  object(Test2)#%d (3) {
+    ["member1":"Test2":private]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+  }
+  [1]=>
+  object(Test2)#%d (3) {
+    ["member1":"Test2":private]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+  }
+}
+-- Iteration 5 --
+array(2) {
+  [0]=>
+  object(Child_test2)#%d (4) {
+    ["member1":"Test2":private]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+    ["member1":"Child_test2":private]=>
+    int(102)
+  }
+  [1]=>
+  object(Child_test2)#%d (4) {
+    ["member1":"Test2":private]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+    ["member1":"Child_test2":private]=>
+    int(102)
+  }
+}
+-- Iteration 6 --
+array(2) {
+  [0]=>
+  object(Test3)#%d (3) {
+    ["member1":protected]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+  }
+  [1]=>
+  object(Test3)#%d (3) {
+    ["member1":protected]=>
+    int(100)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+  }
+}
+-- Iteration 7 --
+array(2) {
+  [0]=>
+  object(Child_test3)#%d (3) {
+    ["member1":protected]=>
+    int(102)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+  }
+  [1]=>
+  object(Child_test3)#%d (3) {
+    ["member1":protected]=>
+    int(102)
+    ["var1"]=>
+    int(30)
+    ["var2"]=>
+    int(101)
+  }
+}
+-- Iteration 8 --
+array(2) {
+  [0]=>
+  object(Test4)#%d (3) {
+    ["member1"]=>
+    int(100)
+    ["member2":"Test4":private]=>
+    int(101)
+    ["member3":protected]=>
+    int(102)
+  }
+  [1]=>
+  object(Test4)#%d (3) {
+    ["member1"]=>
+    int(100)
+    ["member2":"Test4":private]=>
+    int(101)
+    ["member3":protected]=>
+    int(102)
+  }
+}
+-- Iteration 9 --
+array(2) {
+  [0]=>
+  object(Child_test4)#%d (4) {
+    ["member1"]=>
+    int(100)
+    ["member2":"Test4":private]=>
+    int(101)
+    ["member3":protected]=>
+    int(102)
+    ["var1"]=>
+    int(103)
+  }
+  [1]=>
+  object(Child_test4)#%d (4) {
+    ["member1"]=>
+    int(100)
+    ["member2":"Test4":private]=>
+    int(101)
+    ["member3":protected]=>
+    int(102)
+    ["var1"]=>
+    int(103)
+  }
+}
+-- Iteration 10 --
+array(2) {
+  [0]=>
+  object(ConcreteClass1)#%d (4) {
+    ["member1"]=>
+    NULL
+    ["member2":"AbstractClass":private]=>
+    NULL
+    ["member3":protected]=>
+    NULL
+    ["var1"]=>
+    int(30)
+  }
+  [1]=>
+  object(ConcreteClass1)#%d (4) {
+    ["member1"]=>
+    NULL
+    ["member2":"AbstractClass":private]=>
+    NULL
+    ["member3":protected]=>
+    NULL
+    ["var1"]=>
+    int(30)
+  }
+}
+-- Iteration 11 --
+array(2) {
+  [0]=>
+  object(Template1)#%d (0) {
+  }
+  [1]=>
+  object(Template1)#%d (0) {
+  }
+}
+Done
diff --git a/tests/std/array/array_fill_variation3.phpt b/tests/std/array/array_fill_variation3.phpt
new file mode 100644
index 00000000..7963ea12
--- /dev/null
+++ b/tests/std/array/array_fill_variation3.phpt
@@ -0,0 +1,102 @@
+--TEST--
+Test array_fill() function : usage variations  - unexpected values for 'val' argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// define a class
+class test
+{
+    var $t = 10;
+    function __toString(): string {
+        return "testObject";
+    }
+}
+function main()
+{
+    /*
+     * testing array_fill() by passing different unexpected values for 'val' argument
+     */
+    echo "*** Testing array_fill() : usage variations ***\n";
+    // Initialise function arguments not being substituted
+    $start_key = 0;
+    $num = 2;
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    //array of different values for 'val' argument
+    $values = array(
+        // empty string
+        /* 1  */
+        "",
+        '',
+        // objects
+        /* 3  */
+        new test(),
+        // undefined variable
+        @$undefined_var,
+        // unset variable
+        /* 5  */
+        @$unset_var,
+    );
+    // loop through each element of the array for 'val' argument
+    // check the working of array_fill()
+    echo "--- Testing array_fill() with different values for 'val' argument ---\n";
+    $counter = 1;
+    for ($index = 0; $index < count($values); $index++) {
+        echo "-- Iteration {$counter} --\n";
+        $val = $values[$index];
+        var_dump(array_fill($start_key, $num, $val));
+        $counter++;
+    }
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_fill() : usage variations ***
+--- Testing array_fill() with different values for 'val' argument ---
+-- Iteration 1 --
+array(2) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+}
+-- Iteration 2 --
+array(2) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+}
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  object(test)#%d (1) {
+    ["t"]=>
+    int(10)
+  }
+  [1]=>
+  object(test)#%d (1) {
+    ["t"]=>
+    int(10)
+  }
+}
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+-- Iteration 5 --
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+Done
diff --git a/tests/std/array/array_fill_variation4.phpt b/tests/std/array/array_fill_variation4.phpt
new file mode 100644
index 00000000..79df201e
--- /dev/null
+++ b/tests/std/array/array_fill_variation4.phpt
@@ -0,0 +1,163 @@
+--TEST--
+Test array_fill() function : usage variations - using return value of array_fill for 'val' argument
+--FILE--
+<?php
+/* passing array_fill() as the 'val' argument in array_fill() function */
+
+echo "*** Testing array_fill() : variation ***\n";
+
+$start_key = 0;
+$num = 2;
+$heredoc = <<<HERE_DOC
+Hello
+HERE_DOC;
+
+// array of possible valid values for 'val' argument
+$values = array (
+
+  /* 1  */  NULL,
+            0,
+            1,
+  /* 4  */  1.0,
+            'hi',
+            "hi",
+  /* 7  */  $heredoc
+);
+
+echo "*** Filling 2 dimensional array with all basic valid values ***\n";
+$counter = 1;
+for($i =0; $i < count($values); $i ++)
+{
+  echo "-- Iteration $counter --\n";
+  $val = $values[$i];
+
+  var_dump( array_fill($start_key,$num,array_fill($start_key,$num,$val)) );
+
+  $counter++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_fill() : variation ***
+*** Filling 2 dimensional array with all basic valid values ***
+-- Iteration 1 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    NULL
+    [1]=>
+    NULL
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    NULL
+    [1]=>
+    NULL
+  }
+}
+-- Iteration 2 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(0)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(0)
+    [1]=>
+    int(0)
+  }
+}
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(1)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(1)
+  }
+}
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    float(1)
+    [1]=>
+    float(1)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    float(1)
+    [1]=>
+    float(1)
+  }
+}
+-- Iteration 5 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(2) "hi"
+    [1]=>
+    string(2) "hi"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(2) "hi"
+    [1]=>
+    string(2) "hi"
+  }
+}
+-- Iteration 6 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(2) "hi"
+    [1]=>
+    string(2) "hi"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(2) "hi"
+    [1]=>
+    string(2) "hi"
+  }
+}
+-- Iteration 7 --
+array(2) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(5) "Hello"
+    [1]=>
+    string(5) "Hello"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(5) "Hello"
+    [1]=>
+    string(5) "Hello"
+  }
+}
+Done
diff --git a/tests/std/array/array_fill_variation5.phpt b/tests/std/array/array_fill_variation5.phpt
new file mode 100644
index 00000000..43dd5fd3
--- /dev/null
+++ b/tests/std/array/array_fill_variation5.phpt
@@ -0,0 +1,289 @@
+--TEST--
+Test array_fill() function : usage variations - different types of array values for 'val' argument
+--SKIPIF--
+<?php die("skip AOT array_fill key handling differs from PHP"); ?>
+--FILE--
+<?php
+ini_set("serialize_precision", "14");
+/*
+ * testing array_fill() by passing different types of array  values for 'val' argument
+ */
+
+echo "*** Testing array_fill() : usage variations ***\n";
+
+// Initialise function arguments not being substituted
+$start_key = 0;
+$num = 2;
+
+
+//array of different types of array values for 'val' argument
+$values = array(
+
+  /* 1  */  array(),
+            array(1 , 2 , 3 , 4),
+            array(1 => "Hi" , 2 => "Hello"),
+            array("Saffron" , "White" , "Green"),
+  /* 5  */  array('color' => 'red' , 'item' => 'pen'),
+            array( 'color' => 'red' , 2 => 'green ' ),
+            array("colour" => "red" , "item" => "pen"),
+            array( TRUE => "red" , FALSE => "green" ),
+            array( true => "red" , FALSE => "green" ),
+  /* 10 */  array( 1 => "Hi" , "color" => "red" , 'item' => 'pen'),
+            array( NULL => "Hi", '1' => "Hello" , "1" => "Green"),
+            array( ""=>1, "color" => "green"),
+  /* 13 */  array('Saffron' , 'White' , 'Green')
+);
+
+// loop through each element of the values array for 'val' argument
+// check the working of array_fill()
+echo "--- Testing array_fill() with different types of array values for 'val' argument ---\n";
+$counter = 1;
+for($i = 0; $i < count($values); $i++)
+{
+  echo "-- Iteration $counter --\n";
+  $val = $values[$i];
+
+  var_dump( array_fill($start_key , $num , $val) );
+
+  $counter++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_fill() : usage variations ***
+--- Testing array_fill() with different types of array values for 'val' argument ---
+-- Iteration 1 --
+array(2) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(0) {
+  }
+}
+-- Iteration 2 --
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+}
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  array(2) {
+    [1]=>
+    string(2) "Hi"
+    [2]=>
+    string(5) "Hello"
+  }
+  [1]=>
+  array(2) {
+    [1]=>
+    string(2) "Hi"
+    [2]=>
+    string(5) "Hello"
+  }
+}
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(7) "Saffron"
+    [1]=>
+    string(5) "White"
+    [2]=>
+    string(5) "Green"
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    string(7) "Saffron"
+    [1]=>
+    string(5) "White"
+    [2]=>
+    string(5) "Green"
+  }
+}
+-- Iteration 5 --
+array(2) {
+  [0]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+  [1]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+}
+-- Iteration 6 --
+array(2) {
+  [0]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    [2]=>
+    string(6) "green "
+  }
+  [1]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    [2]=>
+    string(6) "green "
+  }
+}
+-- Iteration 7 --
+array(2) {
+  [0]=>
+  array(2) {
+    ["colour"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+  [1]=>
+  array(2) {
+    ["colour"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+}
+-- Iteration 8 --
+array(2) {
+  [0]=>
+  array(2) {
+    [1]=>
+    string(3) "red"
+    [0]=>
+    string(5) "green"
+  }
+  [1]=>
+  array(2) {
+    [1]=>
+    string(3) "red"
+    [0]=>
+    string(5) "green"
+  }
+}
+-- Iteration 9 --
+array(2) {
+  [0]=>
+  array(2) {
+    [1]=>
+    string(3) "red"
+    [0]=>
+    string(5) "green"
+  }
+  [1]=>
+  array(2) {
+    [1]=>
+    string(3) "red"
+    [0]=>
+    string(5) "green"
+  }
+}
+-- Iteration 10 --
+array(2) {
+  [0]=>
+  array(3) {
+    [1]=>
+    string(2) "Hi"
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+  [1]=>
+  array(3) {
+    [1]=>
+    string(2) "Hi"
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+}
+-- Iteration 11 --
+array(2) {
+  [0]=>
+  array(2) {
+    [""]=>
+    string(2) "Hi"
+    [1]=>
+    string(5) "Green"
+  }
+  [1]=>
+  array(2) {
+    [""]=>
+    string(2) "Hi"
+    [1]=>
+    string(5) "Green"
+  }
+}
+-- Iteration 12 --
+array(2) {
+  [0]=>
+  array(2) {
+    [""]=>
+    int(1)
+    ["color"]=>
+    string(5) "green"
+  }
+  [1]=>
+  array(2) {
+    [""]=>
+    int(1)
+    ["color"]=>
+    string(5) "green"
+  }
+}
+-- Iteration 13 --
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(7) "Saffron"
+    [1]=>
+    string(5) "White"
+    [2]=>
+    string(5) "Green"
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    string(7) "Saffron"
+    [1]=>
+    string(5) "White"
+    [2]=>
+    string(5) "Green"
+  }
+}
+Done
diff --git a/tests/std/array/array_fill_variation6.phpt b/tests/std/array/array_fill_variation6.phpt
new file mode 100644
index 00000000..c9ca2616
--- /dev/null
+++ b/tests/std/array/array_fill_variation6.phpt
@@ -0,0 +1,21 @@
+--TEST--
+array_fill(): last element
+--SKIPIF--
+<?php die("skip AOT does not throw error when appending to full array"); ?>
+--FILE--
+<?php
+$a = array_fill(PHP_INT_MAX, 1, "foo");
+var_dump(
+    count($a),
+    array_key_exists(PHP_INT_MAX, $a),
+);
+try {
+    $a[] = "bar";
+} catch (Error $ex) {
+    echo $ex->getMessage(), PHP_EOL;
+}
+?>
+--EXPECT--
+int(1)
+bool(true)
+Cannot add element to the array as the next element is already occupied
diff --git a/tests/std/array/array_filter.phpt b/tests/std/array/array_filter.phpt
new file mode 100644
index 00000000..6b7f45ad
--- /dev/null
+++ b/tests/std/array/array_filter.phpt
@@ -0,0 +1,77 @@
+--TEST--
+basic array_filter test
+--FILE--
+<?php
+function odd($var)
+{
+    return $var & 1;
+}
+function even($var)
+{
+    return !($var & 1);
+}
+function main()
+{
+    $array1 = array("a" => 1, "b" => 2, "c" => 3, "d" => 4, "e" => 5);
+    $array2 = array(6, 7, 8, 9, 10, 11, 12, 0);
+    $array3 = array(TRUE, FALSE, NULL);
+    echo "Odd :\n";
+    var_dump(array_filter($array1, "odd"));
+    var_dump(array_filter($array2, "odd"));
+    var_dump(array_filter($array3, "odd"));
+    echo "Even:\n";
+    var_dump(array_filter($array1, "even"));
+    var_dump(array_filter($array2, "even"));
+    var_dump(array_filter($array3, "even"));
+    var_dump(array_filter(array()));
+}
+?>
+--EXPECT--
+Odd :
+array(3) {
+  ["a"]=>
+  int(1)
+  ["c"]=>
+  int(3)
+  ["e"]=>
+  int(5)
+}
+array(3) {
+  [1]=>
+  int(7)
+  [3]=>
+  int(9)
+  [5]=>
+  int(11)
+}
+array(1) {
+  [0]=>
+  bool(true)
+}
+Even:
+array(2) {
+  ["b"]=>
+  int(2)
+  ["d"]=>
+  int(4)
+}
+array(5) {
+  [0]=>
+  int(6)
+  [2]=>
+  int(8)
+  [4]=>
+  int(10)
+  [6]=>
+  int(12)
+  [7]=>
+  int(0)
+}
+array(2) {
+  [1]=>
+  bool(false)
+  [2]=>
+  NULL
+}
+array(0) {
+}
diff --git a/tests/std/array/array_filter_basic.phpt b/tests/std/array/array_filter_basic.phpt
new file mode 100644
index 00000000..f13af677
--- /dev/null
+++ b/tests/std/array/array_filter_basic.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_filter() function : basic functionality
+--FILE--
+<?php
+function even($input)
+{
+  return ($input % 2 == 0);
+}
+
+function main() {
+echo "*** Testing array_filter() : basic functionality ***\n";
+
+// Initialise all required variables
+$input = array(1, 2, 3, 0, -1);  // 0 will be considered as FALSE and removed in default callback
+
+// with all possible arguments
+var_dump( array_filter($input,"even") );
+
+// with default arguments
+var_dump( array_filter($input) );
+// same as with default arguments
+var_dump( array_filter($input, null) );
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_filter() : basic functionality ***
+array(2) {
+  [1]=>
+  int(2)
+  [3]=>
+  int(0)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [4]=>
+  int(-1)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [4]=>
+  int(-1)
+}
+Done
diff --git a/tests/std/array/array_filter_object.phpt b/tests/std/array/array_filter_object.phpt
new file mode 100644
index 00000000..3b0c4776
--- /dev/null
+++ b/tests/std/array/array_filter_object.phpt
@@ -0,0 +1,151 @@
+--TEST--
+Test array_filter() function : object functionality
+--FILE--
+<?php
+/* This file uses 'input' array with different types of objects and passes
+ * it to array_filter() to test object functionality
+ * i.e. object of simple class with members and functions
+ * object of empty class
+ * object of child class extending abstract class
+ * object of class containing static member
+ */
+
+// simple class with members - variable and method
+class SimpleClass
+{
+  public $var1 = 10;
+  public function check() {
+    return $this->var1;
+  }
+}
+
+// class without members
+class EmptyClass
+{
+}
+
+// abstract class
+abstract class AbstractClass
+{
+  protected $var2 = 5;
+  abstract function emptyMethod();
+}
+
+// class deriving above abstract class
+class ChildClass extends AbstractClass
+{
+  private $var3;
+  public function emptyMethod() {
+    echo "defined in child";
+  }
+}
+
+// class with final method
+class FinalClass
+{
+  private $var4;
+  final function finalMethod() {
+    echo 'This cannot be overloaded';
+  }
+}
+
+// class with static members
+class StaticClass
+{
+  static $var5 = 5;
+  public static function staticMethod() {
+    echo 'this is static method';
+  }
+}
+
+function always_true($input)
+{
+  return true;
+}
+
+// Callback function which returns always false
+function always_false($input)
+{
+  return false;
+}
+
+function main() {
+echo "*** Testing array_filter() : object functionality ***\n";
+
+// 'input' array containing objects as elements
+$input = array(
+  new SimpleClass(),
+  new EmptyClass(),
+  new ChildClass(),
+  new FinalClass(),
+  new StaticClass()
+);
+
+
+// with default callback
+var_dump( array_filter($input) );
+
+// with always_true callback function
+var_dump( array_filter($input, "always_true") );
+
+// with always_false callback function
+var_dump( array_filter($input, "always_false") );
+
+echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_filter() : object functionality ***
+array(5) {
+  [0]=>
+  object(SimpleClass)#%d (1) {
+    ["var1"]=>
+    int(10)
+  }
+  [1]=>
+  object(EmptyClass)#%d (0) {
+  }
+  [2]=>
+  object(ChildClass)#%d (2) {
+    ["var2":protected]=>
+    int(5)
+    ["var3":"ChildClass":private]=>
+    NULL
+  }
+  [3]=>
+  object(FinalClass)#%d (1) {
+    ["var4":"FinalClass":private]=>
+    NULL
+  }
+  [4]=>
+  object(StaticClass)#%d (0) {
+  }
+}
+array(5) {
+  [0]=>
+  object(SimpleClass)#%d (1) {
+    ["var1"]=>
+    int(10)
+  }
+  [1]=>
+  object(EmptyClass)#%d (0) {
+  }
+  [2]=>
+  object(ChildClass)#%d (2) {
+    ["var2":protected]=>
+    int(5)
+    ["var3":"ChildClass":private]=>
+    NULL
+  }
+  [3]=>
+  object(FinalClass)#%d (1) {
+    ["var4":"FinalClass":private]=>
+    NULL
+  }
+  [4]=>
+  object(StaticClass)#%d (0) {
+  }
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_filter_variation10.phpt b/tests/std/array/array_filter_variation10.phpt
new file mode 100644
index 00000000..4688efab
--- /dev/null
+++ b/tests/std/array/array_filter_variation10.phpt
@@ -0,0 +1,79 @@
+--TEST--
+Test array_filter() function : usage variations - using the array keys inside 'callback'
+--SKIPIF--
+<?php
+//if (true) die("skip AOT arginfo validation for callbacks differs from PHP");
+?>
+--FILE--
+<?php
+/*
+* Using array keys as an argument to the 'callback'
+*/
+
+function dump($value, $key)
+{
+  echo "$key = $value\n";
+}
+
+function dump2($value, $key)
+{
+  return $key > 4;
+}
+
+function main() {
+echo "*** Testing array_filter() : usage variations - using array keys in 'callback' ***\n";
+
+$input = array(0, 1, -1, 10, 100, 1000, 'Hello', null);
+
+var_dump( array_filter($input, 'dump', true) );
+
+echo "*** Testing array_filter() : usage variations - 'callback' filters based on key value ***\n";
+
+var_dump( array_filter($input, 'dump2', true) );
+
+echo "*** Testing array_filter() with various use types ***\n";
+
+$mixed = array(1 => 'a', 2 => 'b', 'a' => 1, 'b' => 2);
+
+var_dump(array_filter($mixed, 'is_numeric', ARRAY_FILTER_USE_KEY));
+
+var_dump(array_filter($mixed, 'is_numeric', 0));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_filter() : usage variations - using array keys in 'callback' ***
+0 = 0
+1 = 1
+2 = -1
+3 = 10
+4 = 100
+5 = 1000
+6 = Hello
+7 = 
+array(0) {
+}
+*** Testing array_filter() : usage variations - 'callback' filters based on key value ***
+array(3) {
+  [5]=>
+  int(1000)
+  [6]=>
+  string(5) "Hello"
+  [7]=>
+  NULL
+}
+*** Testing array_filter() with various use types ***
+array(2) {
+  [1]=>
+  string(1) "a"
+  [2]=>
+  string(1) "b"
+}
+array(2) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/array_filter_variation3.phpt b/tests/std/array/array_filter_variation3.phpt
new file mode 100644
index 00000000..fd4b90b9
--- /dev/null
+++ b/tests/std/array/array_filter_variation3.phpt
@@ -0,0 +1,216 @@
+--TEST--
+Test array_filter() function : usage variations - Different types of array for 'input' argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT null key handling differs from PHP");
+?>
+--FILE--
+<?php
+/*
+* Passing different types of array as 'input' argument.
+*/
+
+function always_false($input)
+{
+  return false;
+}
+
+// callback function returning always true
+function always_true($input)
+{
+  return true;
+}
+
+function main() {
+echo "*** Testing array_filter() : usage variations - different types of array for 'input' argument***\n";
+
+// different types of 'input' array
+$input_values = array(
+  array(0, 1, 2, -1, 034, 0X4A),  // integer values
+  array(0.0, 1.2, 1.2e3, 1.2e-3),  // float values
+  array('value1', "value2", '', " ", ""),  // string values
+  array(true, false, TRUE, FALSE),  // bool values
+  array(null, NULL),  // null values
+  array(1 => 'one', 'zero' => 0, -2 => "value"), //associative array
+  array("one" => 1, null => 'null', 5 => "float", true => 1, "" => 'empty'),  // associative array with different keys
+  array(1 => 'one', 2, "key" => 'value')  // combinition of associative and non-associative array
+
+);
+
+// loop through each element of 'input' with default callback
+for($count = 0; $count < count($input_values); $count++)
+{
+  echo "-- Iteration ".($count + 1). " --\n";
+  var_dump( array_filter($input_values[$count]) );
+  var_dump( array_filter($input_values[$count], 'always_true') );
+  var_dump( array_filter($input_values[$count], 'always_false') );
+}
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_filter() : usage variations - different types of array for 'input' argument***
+-- Iteration 1 --
+array(5) {
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(-1)
+  [4]=>
+  int(28)
+  [5]=>
+  int(74)
+}
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(-1)
+  [4]=>
+  int(28)
+  [5]=>
+  int(74)
+}
+array(0) {
+}
+-- Iteration 2 --
+array(3) {
+  [1]=>
+  float(1.2)
+  [2]=>
+  float(1200)
+  [3]=>
+  float(0.0012)
+}
+array(4) {
+  [0]=>
+  float(0)
+  [1]=>
+  float(1.2)
+  [2]=>
+  float(1200)
+  [3]=>
+  float(0.0012)
+}
+array(0) {
+}
+-- Iteration 3 --
+array(3) {
+  [0]=>
+  string(6) "value1"
+  [1]=>
+  string(6) "value2"
+  [3]=>
+  string(1) " "
+}
+array(5) {
+  [0]=>
+  string(6) "value1"
+  [1]=>
+  string(6) "value2"
+  [2]=>
+  string(0) ""
+  [3]=>
+  string(1) " "
+  [4]=>
+  string(0) ""
+}
+array(0) {
+}
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  bool(true)
+  [2]=>
+  bool(true)
+}
+array(4) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(false)
+}
+array(0) {
+}
+-- Iteration 5 --
+array(0) {
+}
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+array(0) {
+}
+-- Iteration 6 --
+array(2) {
+  [1]=>
+  string(3) "one"
+  [-2]=>
+  string(5) "value"
+}
+array(3) {
+  [1]=>
+  string(3) "one"
+  ["zero"]=>
+  int(0)
+  [-2]=>
+  string(5) "value"
+}
+array(0) {
+}
+-- Iteration 7 --
+array(4) {
+  ["one"]=>
+  int(1)
+  [""]=>
+  string(5) "empty"
+  [5]=>
+  string(5) "float"
+  [1]=>
+  int(1)
+}
+array(4) {
+  ["one"]=>
+  int(1)
+  [""]=>
+  string(5) "empty"
+  [5]=>
+  string(5) "float"
+  [1]=>
+  int(1)
+}
+array(0) {
+}
+-- Iteration 8 --
+array(3) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  int(2)
+  ["key"]=>
+  string(5) "value"
+}
+array(3) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  int(2)
+  ["key"]=>
+  string(5) "value"
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_filter_variation4.phpt b/tests/std/array/array_filter_variation4.phpt
new file mode 100644
index 00000000..6db83574
--- /dev/null
+++ b/tests/std/array/array_filter_variation4.phpt
@@ -0,0 +1,99 @@
+--TEST--
+Test array_filter() function : usage variations - Different types of 'callback' function
+--FILE--
+<?php
+/*
+* Passing different types of callback functions to array_filter()
+* with parameters and return
+* without parameter and with return
+* with parameter and without return
+* without parameter and without return
+*/
+
+function callback1($input)
+{
+  return 1;
+}
+
+// callback function with parameter and without return value
+function callback2($input)
+{
+}
+
+function callback3($input)
+{
+}
+
+// callback function with parameter and with return value
+function callback4($input)
+{
+  if($input > 0 ) {
+    return true;
+  }
+  else {
+    return false;
+  }
+}
+
+function main() {
+echo "*** Testing array_filter() : usage variation - different 'callback' functions***\n";
+
+// Initialize variables
+$input = array(0, -1, 2, 3.4E-3, 'hello', "value", "key" => 4, 'null' => NULL);
+
+echo "-- Callback function without parameter and with return --\n";
+var_dump( array_filter($input, "callback1") );
+
+echo "-- Callback function with parameter and without return --\n";
+var_dump( array_filter($input, "callback2") );
+
+echo "-- Callback function without parameter and return --\n";
+var_dump( array_filter($input, "callback3") );
+
+echo "-- Callback function with parameter and return --\n";
+var_dump( array_filter($input, "callback4") );
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_filter() : usage variation - different 'callback' functions***
+-- Callback function without parameter and with return --
+array(8) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(-1)
+  [2]=>
+  int(2)
+  [3]=>
+  float(0.0034)
+  [4]=>
+  string(5) "hello"
+  [5]=>
+  string(5) "value"
+  ["key"]=>
+  int(4)
+  ["null"]=>
+  NULL
+}
+-- Callback function with parameter and without return --
+array(0) {
+}
+-- Callback function without parameter and return --
+array(0) {
+}
+-- Callback function with parameter and return --
+array(5) {
+  [2]=>
+  int(2)
+  [3]=>
+  float(0.0034)
+  [4]=>
+  string(5) "hello"
+  [5]=>
+  string(5) "value"
+  ["key"]=>
+  int(4)
+}
+Done
diff --git a/tests/std/array/array_filter_variation5.phpt b/tests/std/array/array_filter_variation5.phpt
new file mode 100644
index 00000000..d5dd6f91
--- /dev/null
+++ b/tests/std/array/array_filter_variation5.phpt
@@ -0,0 +1,109 @@
+--TEST--
+Test array_filter() function : usage variations - 'input' argument with different false entries
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+--FILE--
+<?php
+/*
+* With default callback function argument, array_filter() removes elements which are interpreted as false
+* Here Testing all the false array element possibilities
+*/
+
+function always_true($input)
+{
+  return true;
+}
+
+// callback function always_false
+function always_false($input)
+{
+  return false;
+}
+
+function main() {
+echo "*** Testing array_filter() : usage variations - different false elements in 'input' ***\n";
+
+// unset variable
+$unset_var = 10;
+unset($unset_var);
+
+// empty heredoc string
+$empty_heredoc =<<<EOT
+EOT;
+
+// input array with different false elements
+$input = array(
+  false,
+  False,
+  '',
+  "",
+  0,
+  0.0,
+  null,
+  NULL,
+  "0",
+  '0',
+  array(),
+  !1,
+  1==2,
+  $empty_heredoc,
+  @$unset_var,
+  @$undefined_var,
+);
+
+// With default callback function
+var_dump( array_filter($input) );
+
+// With callback function which returns always true
+var_dump( array_filter($input, 'always_true') );
+
+// With callback function which returns always false
+var_dump( array_filter($input, 'always_false') );
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_filter() : usage variations - different false elements in 'input' ***
+array(0) {
+}
+array(16) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(false)
+  [2]=>
+  string(0) ""
+  [3]=>
+  string(0) ""
+  [4]=>
+  int(0)
+  [5]=>
+  float(0)
+  [6]=>
+  NULL
+  [7]=>
+  NULL
+  [8]=>
+  string(1) "0"
+  [9]=>
+  string(1) "0"
+  [10]=>
+  array(0) {
+  }
+  [11]=>
+  bool(false)
+  [12]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+  [14]=>
+  NULL
+  [15]=>
+  NULL
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_filter_variation6.phpt b/tests/std/array/array_filter_variation6.phpt
new file mode 100644
index 00000000..adc1d4ff
--- /dev/null
+++ b/tests/std/array/array_filter_variation6.phpt
@@ -0,0 +1,90 @@
+--TEST--
+Test array_filter() function : usage variations - 'input' array containing references
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not fully support references");
+?>
+--FILE--
+<?php
+/*
+* Passing 'input' array which contains elements as reference to other data
+*/
+
+function callback($input)
+{
+  if($input > 5) {
+    return true;
+  }
+  else {
+    return false;
+  }
+}
+
+function main() {
+echo "*** Testing array_filter() : usage variations - 'input' containing references ***\n";
+
+// initializing variables
+$value1 = array(1, 2, 8);
+$value2 = array(5, 6, 4);
+$input = array(&$value1, 10, &$value2, 'value');
+
+// with 'callback' argument
+var_dump( array_filter($input, 'callback') );
+
+// with default 'callback' argument
+var_dump( array_filter($input) );
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_filter() : usage variations - 'input' containing references ***
+array(4) {
+  [0]=>
+  &array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(8)
+  }
+  [1]=>
+  int(10)
+  [2]=>
+  &array(3) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+    [2]=>
+    int(4)
+  }
+  [3]=>
+  string(5) "value"
+}
+array(4) {
+  [0]=>
+  &array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(8)
+  }
+  [1]=>
+  int(10)
+  [2]=>
+  &array(3) {
+    [0]=>
+    int(5)
+    [1]=>
+    int(6)
+    [2]=>
+    int(4)
+  }
+  [3]=>
+  string(5) "value"
+}
+Done
diff --git a/tests/std/array/array_filter_variation7.phpt b/tests/std/array/array_filter_variation7.phpt
new file mode 100644
index 00000000..cea5e7ae
--- /dev/null
+++ b/tests/std/array/array_filter_variation7.phpt
@@ -0,0 +1,62 @@
+--TEST--
+Test array_filter() function : usage variations - anonymous callback functions
+--FILE--
+<?php
+/*
+* Passing different anonymous callback functions with passed by value and reference arguments
+*/
+
+echo "*** Testing array_filter() : usage variations - Anonymous callback functions ***\n";
+
+$input = array(0, 1, -1, 10, 100, 1000, 'Hello', null);
+
+// anonymous callback function
+echo "Anonymous callback function with regular parameter and statement\n";
+var_dump( array_filter($input, function($input) { return ($input > 1); }) );
+
+// anonymous callback function with null argument
+echo "Anonymous callback function with null argument\n";
+var_dump( array_filter($input, function() { return true; }) );
+
+// anonymous callback function with argument and null statement
+echo "Anonymous callback function with regular argument and null statement\n";
+var_dump( array_filter($input, function($input) { }) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_filter() : usage variations - Anonymous callback functions ***
+Anonymous callback function with regular parameter and statement
+array(4) {
+  [3]=>
+  int(10)
+  [4]=>
+  int(100)
+  [5]=>
+  int(1000)
+  [6]=>
+  string(5) "Hello"
+}
+Anonymous callback function with null argument
+array(8) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(-1)
+  [3]=>
+  int(10)
+  [4]=>
+  int(100)
+  [5]=>
+  int(1000)
+  [6]=>
+  string(5) "Hello"
+  [7]=>
+  NULL
+}
+Anonymous callback function with regular argument and null statement
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_filter_variation8.phpt b/tests/std/array/array_filter_variation8.phpt
new file mode 100644
index 00000000..79978898
--- /dev/null
+++ b/tests/std/array/array_filter_variation8.phpt
@@ -0,0 +1,151 @@
+--TEST--
+Test array_filter() function : usage variations - Callback function with different return values
+--FILE--
+<?php
+/*
+* callback functions are expected to return bool value for array_filter()
+* here testing callback functions for return values other than bool
+*/
+
+function callback1($input)
+{
+  return 5;
+}
+
+// float as return value
+function callback2($input)
+{
+  return 3.4;
+}
+
+// string as return value
+function callback3($input)
+{
+  return 'value';
+}
+
+// null as return value
+function callback4($input)
+{
+  return null;
+}
+
+// array as return value
+function callback5($input)
+{
+  return array(8);
+}
+
+function main() {
+echo "*** Testing array_filter() : usage variations - callback function with different return values***\n";
+
+$input = array(0, 1, -1, 10, 100, 1000, 'Hello', null, true);
+
+echo "callback function with int return value\n";
+var_dump( array_filter($input, 'callback1') );
+
+echo "callback function with float return value\n";
+var_dump( array_filter($input, 'callback2') );
+
+echo "callback function with string return value\n";
+var_dump( array_filter($input, 'callback3') );
+
+echo "callback function with null return value\n";
+var_dump( array_filter($input, 'callback4') );
+
+echo "callback function with array as return value\n";
+var_dump( array_filter($input, 'callback5') );
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_filter() : usage variations - callback function with different return values***
+callback function with int return value
+array(9) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(-1)
+  [3]=>
+  int(10)
+  [4]=>
+  int(100)
+  [5]=>
+  int(1000)
+  [6]=>
+  string(5) "Hello"
+  [7]=>
+  NULL
+  [8]=>
+  bool(true)
+}
+callback function with float return value
+array(9) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(-1)
+  [3]=>
+  int(10)
+  [4]=>
+  int(100)
+  [5]=>
+  int(1000)
+  [6]=>
+  string(5) "Hello"
+  [7]=>
+  NULL
+  [8]=>
+  bool(true)
+}
+callback function with string return value
+array(9) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(-1)
+  [3]=>
+  int(10)
+  [4]=>
+  int(100)
+  [5]=>
+  int(1000)
+  [6]=>
+  string(5) "Hello"
+  [7]=>
+  NULL
+  [8]=>
+  bool(true)
+}
+callback function with null return value
+array(0) {
+}
+callback function with array as return value
+array(9) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(-1)
+  [3]=>
+  int(10)
+  [4]=>
+  int(100)
+  [5]=>
+  int(1000)
+  [6]=>
+  string(5) "Hello"
+  [7]=>
+  NULL
+  [8]=>
+  bool(true)
+}
+Done
diff --git a/tests/std/array/array_filter_variation9.phpt b/tests/std/array/array_filter_variation9.phpt
new file mode 100644
index 00000000..e0000612
--- /dev/null
+++ b/tests/std/array/array_filter_variation9.phpt
@@ -0,0 +1,67 @@
+--TEST--
+Test array_filter() function : usage variations - built-in functions as 'callback' argument
+--FILE--
+<?php
+/*
+* Passing built-in functions and different language constructs as 'callback' argument
+*/
+
+echo "*** Testing array_filter() : usage variations - built-in functions as 'callback' argument ***\n";
+
+$input = array(0, 1, -1, 10, 100, 1000);
+
+// using built-in function 'is_int' as 'callback'
+var_dump( array_filter($input, 'is_int') );
+
+// using built-in function 'chr' as 'callback'
+var_dump( array_filter($input, 'chr') );
+
+// using language construct 'echo' as 'callback'
+try {
+    var_dump( array_filter($input, 'echo') );
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+// using language construct 'isset' as 'callback'
+try {
+    var_dump( array_filter($input, 'isset') );
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_filter() : usage variations - built-in functions as 'callback' argument ***
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(-1)
+  [3]=>
+  int(10)
+  [4]=>
+  int(100)
+  [5]=>
+  int(1000)
+}
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(-1)
+  [3]=>
+  int(10)
+  [4]=>
+  int(100)
+  [5]=>
+  int(1000)
+}
+array_filter(): Argument #2 ($callback) must be a valid callback or null, function "echo" not found or invalid function name
+array_filter(): Argument #2 ($callback) must be a valid callback or null, function "isset" not found or invalid function name
+Done
diff --git a/tests/std/array/array_find_basic.phpt b/tests/std/array/array_find_basic.phpt
new file mode 100644
index 00000000..b98debee
--- /dev/null
+++ b/tests/std/array/array_find_basic.phpt
@@ -0,0 +1,51 @@
+--TEST--
+Test array_find() 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_find($array1, fn($value, $key) => $value > 3));
+    var_dump(array_find($array2, fn($value, $key) => $value > 3));
+    var_dump(array_find($array2, fn($value, $key) => $value > 5));
+    var_dump(array_find([], fn($value, $key) => true));
+    var_dump(array_find($array1, fn($value, $key) => $key === "c"));
+    var_dump(array_find($array1, fn($value, $key) => false));
+    var_dump(array_find($array1, 'even'));
+    var_dump(array_find($array1, 'return_nothing'));
+    var_dump(array_find($array1, ['EvenClass', 'even']));
+    var_dump(array_find($array1, "EvenClass::even"));
+}
+?>
+--EXPECT--
+int(4)
+int(4)
+NULL
+NULL
+int(3)
+NULL
+int(2)
+NULL
+int(2)
+int(2)
diff --git a/tests/std/array/array_find_key_basic.phpt b/tests/std/array/array_find_key_basic.phpt
new file mode 100644
index 00000000..6b972237
--- /dev/null
+++ b/tests/std/array/array_find_key_basic.phpt
@@ -0,0 +1,51 @@
+--TEST--
+Test array_find_key() 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_find_key($array1, fn($value, $key) => $value > 3));
+    var_dump(array_find_key($array2, fn($value, $key) => $value > 3));
+    var_dump(array_find_key($array2, fn($value, $key) => $value > 5));
+    var_dump(array_find_key([], fn($value, $key) => true));
+    var_dump(array_find_key($array1, fn($value, $key) => $key === "c"));
+    var_dump(array_find_key($array1, fn($value, $key) => false));
+    var_dump(array_find_key($array1, 'even'));
+    var_dump(array_find_key($array1, 'return_nothing'));
+    var_dump(array_find_key($array1, ['EvenClass', 'even']));
+    var_dump(array_find_key($array1, "EvenClass::even"));
+}
+?>
+--EXPECT--
+string(1) "d"
+int(3)
+NULL
+NULL
+string(1) "c"
+NULL
+string(1) "b"
+NULL
+string(1) "b"
+string(1) "b"
diff --git a/tests/std/array/array_find_types.phpt b/tests/std/array/array_find_types.phpt
new file mode 100644
index 00000000..9c6e5e96
--- /dev/null
+++ b/tests/std/array/array_find_types.phpt
@@ -0,0 +1,210 @@
+--TEST--
+basic array_find test
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+
+$stdClass = new stdClass();
+$stdClass->a = "1";
+
+$array = [
+    ...[0, 1, 2, -1, 034, 0X4A],
+    ...[0.0, 1.2, 1.2e3, 1.2e-3],
+    ...['value1', "value2", '', " ", ""],
+    ...[true, false, TRUE, FALSE],
+    ...[null, NULL],
+    ...[1 => 'one', 'zero' => 0, -2 => "value"],
+    ...["one" => 1, 5 => "float", true => 1, "" => 'empty'],
+    ...[1 => 'one', 2, "key" => 'value'],
+    ...[new stdClass(), $stdClass, (object)['b' => 2]],
+    ...[[], [1, 2, 3], [-1 => 1, -2 => 2]],
+    ...[@$undefined_var]
+];
+
+echo "*** Dumping each key value pair. ***". PHP_EOL;
+var_dump(array_find($array, function ($value, $key) {
+    var_dump($key, $value);
+
+    return false;
+}));
+
+echo "*** Dumping only first key value pair. ***". PHP_EOL;
+var_dump(array_find($array, function ($value, $key) {
+    var_dump($key, $value);
+
+    return true;
+}));
+
+echo "*** Returning each value. ***". PHP_EOL;
+foreach (array_keys($array) as $key) {
+    var_dump(array_find($array, function ($value, $arrayKey) use ($key) {
+        return $arrayKey === $key;
+    }));
+}
+?>
+--EXPECT--
+*** Dumping each key value pair. ***
+int(0)
+int(0)
+int(1)
+int(1)
+int(2)
+int(2)
+int(3)
+int(-1)
+int(4)
+int(28)
+int(5)
+int(74)
+int(6)
+float(0)
+int(7)
+float(1.2)
+int(8)
+float(1200)
+int(9)
+float(0.0012)
+int(10)
+string(6) "value1"
+int(11)
+string(6) "value2"
+int(12)
+string(0) ""
+int(13)
+string(1) " "
+int(14)
+string(0) ""
+int(15)
+bool(true)
+int(16)
+bool(false)
+int(17)
+bool(true)
+int(18)
+bool(false)
+int(19)
+NULL
+int(20)
+NULL
+int(21)
+string(3) "one"
+string(4) "zero"
+int(0)
+int(22)
+string(5) "value"
+string(3) "one"
+int(1)
+int(23)
+string(5) "float"
+int(24)
+int(1)
+string(0) ""
+string(5) "empty"
+int(25)
+string(3) "one"
+int(26)
+int(2)
+string(3) "key"
+string(5) "value"
+int(27)
+object(stdClass)#2 (0) {
+}
+int(28)
+object(stdClass)#1 (1) {
+  ["a"]=>
+  string(1) "1"
+}
+int(29)
+object(stdClass)#3 (1) {
+  ["b"]=>
+  int(2)
+}
+int(30)
+array(0) {
+}
+int(31)
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+int(32)
+array(2) {
+  [-1]=>
+  int(1)
+  [-2]=>
+  int(2)
+}
+int(33)
+NULL
+NULL
+*** Dumping only first key value pair. ***
+int(0)
+int(0)
+int(0)
+*** Returning each value. ***
+int(0)
+int(1)
+int(2)
+int(-1)
+int(28)
+int(74)
+float(0)
+float(1.2)
+float(1200)
+float(0.0012)
+string(6) "value1"
+string(6) "value2"
+string(0) ""
+string(1) " "
+string(0) ""
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+NULL
+NULL
+string(3) "one"
+int(0)
+string(5) "value"
+int(1)
+string(5) "float"
+int(1)
+string(5) "empty"
+string(3) "one"
+int(2)
+string(5) "value"
+object(stdClass)#2 (0) {
+}
+object(stdClass)#1 (1) {
+  ["a"]=>
+  string(1) "1"
+}
+object(stdClass)#3 (1) {
+  ["b"]=>
+  int(2)
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(2) {
+  [-1]=>
+  int(1)
+  [-2]=>
+  int(2)
+}
+NULL
diff --git a/tests/std/array/array_flip.phpt b/tests/std/array/array_flip.phpt
new file mode 100644
index 00000000..b16063a4
--- /dev/null
+++ b/tests/std/array/array_flip.phpt
@@ -0,0 +1,37 @@
+--TEST--
+basic array_flip test
+--FILE--
+<?php
+$trans = array("a" => 1,
+               "b" => 1,
+               "c" => 2,
+               "z" => 0,
+               "d" => TRUE,
+               "E" => FALSE,
+               "F" => NULL,
+               0 => "G",
+               1 => "h",
+               2 => "i");
+$trans = array_flip($trans);
+var_dump($trans);
+?>
+--EXPECTF--
+Warning:%S Can only flip string and integer values, entry skipped in %s on line %d
+
+Warning:%S Can only flip string and integer values, entry skipped in %s on line %d
+
+Warning:%S Can only flip string and integer values, entry skipped in %s on line %d
+array(6) {
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+  [0]=>
+  string(1) "z"
+  ["G"]=>
+  int(0)
+  ["h"]=>
+  int(1)
+  ["i"]=>
+  int(2)
+}
diff --git a/tests/std/array/array_flip_basic.phpt b/tests/std/array/array_flip_basic.phpt
new file mode 100644
index 00000000..3edcd3b5
--- /dev/null
+++ b/tests/std/array/array_flip_basic.phpt
@@ -0,0 +1,66 @@
+--TEST--
+Test array_flip() function : basic functionality
+--FILE--
+<?php
+echo "*** Testing array_flip() : basic functionality ***\n";
+
+// array with default keys - numeric values
+$input = array(1, 2);
+var_dump( array_flip($input) );
+
+// array with default keys - string values
+$input = array('value1', "value2");
+var_dump( array_flip($input) );
+
+// associative arrays - key as string
+$input = array('key1' => 1, "key2" => 2);
+var_dump( array_flip($input) );
+
+// associative arrays - key as numeric
+$input = array(1 => 'one', 2 => "two");
+var_dump( array_flip($input) );
+
+// combination of associative and non-associative array
+$input = array(1 => 'one','two', 3 => 'three', 4, "five" => 5);
+var_dump( array_flip($input) );
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_flip() : basic functionality ***
+array(2) {
+  [1]=>
+  int(0)
+  [2]=>
+  int(1)
+}
+array(2) {
+  ["value1"]=>
+  int(0)
+  ["value2"]=>
+  int(1)
+}
+array(2) {
+  [1]=>
+  string(4) "key1"
+  [2]=>
+  string(4) "key2"
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(5) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  string(4) "five"
+}
+Done
diff --git a/tests/std/array/array_flip_variation2.phpt b/tests/std/array/array_flip_variation2.phpt
new file mode 100644
index 00000000..f147fa9d
--- /dev/null
+++ b/tests/std/array/array_flip_variation2.phpt
@@ -0,0 +1,99 @@
+--TEST--
+Test array_flip() function : usage variations - 'input' array with different keys
+--SKIPIF--
+<?php die("skip AOT empty string key handling differs from PHP"); ?>
+--FILE--
+<?php
+/*
+* Trying different keys in $input array argument
+*/
+
+echo "*** Testing array_flip() : different keys for 'input' array argument ***\n";
+
+// different heredoc strings
+$empty_heredoc = <<<EOT1
+EOT1;
+
+$simple_heredoc = <<<EOT4
+simple
+EOT4;
+
+$multiline_heredoc = <<<EOT7
+multiline heredoc with 123 and
+speci@! ch@r$...checking\nand\talso
+EOT7;
+
+$input = array(
+  // default key
+  'one',  //expected: default key 0, value will be replaced by 'bool_key4'
+
+  // numeric keys
+  1 => 'int_key', // expected: value will be replaced by 'bool_key3'
+  -2 => 'negative_key',
+  012 => 'octal_key',
+  0x34 => 'hex_key',
+
+  // string keys
+  'key' => 'string_key1',
+  "two" => 'string_key2',
+  '' => 'string_key3',
+  "" => 'string_key4',
+  " " => 'string_key5',
+
+  // bool keys
+  true => 'bool_key1',
+  false => 'bool_key2',
+  TRUE => 'bool_key3',
+  FALSE => 'bool_key4',
+
+  // null keys
+  null => 'null_key1',  // expected: value will be replaced by 'null_key2'
+  NULL => 'null_key2',
+
+  // binary key
+  "a".chr(0)."b" => 'binary_key1',
+  b"binary" => 'binary_key2',
+
+  //heredoc keys
+  $empty_heredoc => 'empty_heredoc',
+  $simple_heredoc => 'simple_heredoc',
+  $multiline_heredoc => 'multiline_heredoc',
+);
+
+var_dump( array_flip($input) );
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_flip() : different keys for 'input' array argument ***
+array(13) {
+  ["bool_key4"]=>
+  int(0)
+  ["bool_key3"]=>
+  int(1)
+  ["negative_key"]=>
+  int(-2)
+  ["octal_key"]=>
+  int(10)
+  ["hex_key"]=>
+  int(52)
+  ["string_key1"]=>
+  string(3) "key"
+  ["string_key2"]=>
+  string(3) "two"
+  ["empty_heredoc"]=>
+  string(0) ""
+  ["string_key5"]=>
+  string(1) " "
+  ["binary_key1"]=>
+  string(3) "a%0b"
+  ["binary_key2"]=>
+  string(6) "binary"
+  ["simple_heredoc"]=>
+  string(6) "simple"
+  ["multiline_heredoc"]=>
+  string(6%d) "multiline heredoc with 123 and
+speci@! ch@r$...checking
+and	also"
+}
+Done
diff --git a/tests/std/array/array_flip_variation3.phpt b/tests/std/array/array_flip_variation3.phpt
new file mode 100644
index 00000000..32d7452d
--- /dev/null
+++ b/tests/std/array/array_flip_variation3.phpt
@@ -0,0 +1,120 @@
+--TEST--
+Test array_flip() function : usage variations - 'input' argument with different valid values
+--FILE--
+<?php
+/*
+* In 'input' array argument, values are expected to be valid keys i.e. string/integer
+* here testing for all different valid string and integer values
+*/
+
+echo "*** Testing array_flip() : different valid values in 'input' array argument ***\n";
+
+$empty_heredoc = <<<EOT1
+EOT1;
+
+$simple_heredoc = <<<EOT4
+simple
+EOT4;
+
+$multiline_heredoc = <<<EOT7
+multiline heredoc with 123 and
+speci@! ch@r$..checking\nwith\talso
+EOT7;
+
+$input = array(
+  // numeric values
+  'int_value' => 1,
+  'negative_value' => -2,
+  'zero_value' => 0,
+  'octal_value' => 012,
+  'hex_value' => 0x23,
+
+  // single quoted string value
+  'empty_value1' => '',
+  'space_value1' => ' ',
+  'char_value1' => 'a',
+  'string_value1' => 'string1',
+  'numeric_value1' => '123',
+  'special_char_value1' => '!@#$%',
+  'whitespace1_value1' => '\t',
+  'whitespace2_value1' => '\n',
+  'null_char_value1' => '\0',
+
+  // double quoted string value
+  'empty_value2' => "",
+  'space_value2' => " ",
+  'char_value2' => "b",
+  'string_value2' => "string2",
+  'numeric_value2' => "456",
+  'special_char_value2' => "^&*",
+  'whitespace1_value2' => "\t",
+  'whitespace2_value2' => "\n",
+  'null_char_value2' => "\0",
+  'binary_value' => "a".chr(0)."b",
+
+  // heredoc string value
+  'empty_heredoc' => $empty_heredoc,
+  'simple_heredoc' => $simple_heredoc,
+  'multiline_heredoc' => $multiline_heredoc,
+);
+
+var_dump( array_flip($input) );
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_flip() : different valid values in 'input' array argument ***
+array(24) {
+  [1]=>
+  string(9) "int_value"
+  [-2]=>
+  string(14) "negative_value"
+  [0]=>
+  string(10) "zero_value"
+  [10]=>
+  string(11) "octal_value"
+  [35]=>
+  string(9) "hex_value"
+  [""]=>
+  string(13) "empty_heredoc"
+  [" "]=>
+  string(12) "space_value2"
+  ["a"]=>
+  string(11) "char_value1"
+  ["string1"]=>
+  string(13) "string_value1"
+  [123]=>
+  string(14) "numeric_value1"
+  ["!@#$%"]=>
+  string(19) "special_char_value1"
+  ["\t"]=>
+  string(18) "whitespace1_value1"
+  ["\n"]=>
+  string(18) "whitespace2_value1"
+  ["\0"]=>
+  string(16) "null_char_value1"
+  ["b"]=>
+  string(11) "char_value2"
+  ["string2"]=>
+  string(13) "string_value2"
+  [456]=>
+  string(14) "numeric_value2"
+  ["^&*"]=>
+  string(19) "special_char_value2"
+  ["	"]=>
+  string(18) "whitespace1_value2"
+  ["
+"]=>
+  string(18) "whitespace2_value2"
+  ["%0"]=>
+  string(16) "null_char_value2"
+  ["a%0b"]=>
+  string(12) "binary_value"
+  ["simple"]=>
+  string(14) "simple_heredoc"
+  ["multiline heredoc with 123 and
+speci@! ch@r$..checking
+with	also"]=>
+  string(17) "multiline_heredoc"
+}
+Done
diff --git a/tests/std/array/array_flip_variation4.phpt b/tests/std/array/array_flip_variation4.phpt
new file mode 100644
index 00000000..60d51ef0
--- /dev/null
+++ b/tests/std/array/array_flip_variation4.phpt
@@ -0,0 +1,88 @@
+--TEST--
+Test array_flip() function : usage variations - 'input' argument with different invalid values for keys
+--SKIPIF--
+--FILE--
+<?php
+/*
+* Trying different invalid values for 'input' array argument
+*/
+
+// class definition for object data
+class MyClass
+{
+   public function __toString(): string {
+     return 'object';
+   }
+}
+
+function main() {
+echo "*** Testing array_flip() : different invalid values in 'input' array argument ***\n";
+
+$obj = new MyClass();
+
+// resource data
+$fp = fopen(__FILE__, 'r');
+
+$input = array(
+  // float values
+  'float_value1' => 1.2,
+  'float_value2' => 0.5,
+  'flaot_value3' => 3.4E3,
+  'flaot_value4' => 5.6E-6,
+
+  // bool values
+  'bool_value1' => true,
+  'bool_value2' => false,
+  'bool_value3' => TRUE,
+  'bool_value4' => FALSE,
+
+  // null values
+  'null_value1' => null,
+
+  // array value
+  'array_value' => array(1),
+
+  // object value
+  'obj_value' => $obj,
+
+  // resource value
+  'resource_value' => $fp,
+);
+
+var_dump( array_flip($input) );
+
+// closing resource
+fclose($fp);
+
+echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_flip() : different invalid values in 'input' array argument ***
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+
+Warning:%S Can only flip string and integer values, entry skipped in %s
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_flip_variation5.phpt b/tests/std/array/array_flip_variation5.phpt
new file mode 100644
index 00000000..6e75648f
--- /dev/null
+++ b/tests/std/array/array_flip_variation5.phpt
@@ -0,0 +1,79 @@
+--TEST--
+Test array_flip() function : usage variations - 'input' argument with repeatitive keys and values
+--SKIPIF--
+<?php die("skip AOT empty string key handling differs from PHP"); ?>
+--FILE--
+<?php
+/*
+* Using different types of repeatitive keys as well as values for 'input' array
+*/
+
+echo "*** Testing array_flip() : 'input' array with repeatitive keys/values ***\n";
+
+// array with numeric key repeatition
+$input = array(1 => 'value', 2 => 'VALUE', 1 => "VaLuE", 3 => 4, 3 => 5);
+var_dump( array_flip($input) );
+
+// array with string key repeatition
+$input = array("key" => 1, "two" => 'TWO', 'three' => 3, 'key' => "FOUR");
+var_dump( array_flip($input) );
+
+// array with bool key repeatition
+$input = array(true => 1, false => 0, TRUE => -1);
+var_dump( array_flip($input) );
+
+// array with null key repeatition
+$input = array(null => "Hello", NULL => 0);
+var_dump( array_flip($input) );
+
+// array with numeric value repeatition
+$input = array('one' => 1, 'two' => 2, 3 => 1, "index" => 1);
+var_dump( array_flip($input) );
+
+//array with string value repeatition
+$input = array('key1' => "value1", "key2" => '2', 'key3' => 'value1');
+var_dump( array_flip($input) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_flip() : 'input' array with repeatitive keys/values ***
+array(3) {
+  ["VaLuE"]=>
+  int(1)
+  ["VALUE"]=>
+  int(2)
+  [5]=>
+  int(3)
+}
+array(3) {
+  ["FOUR"]=>
+  string(3) "key"
+  ["TWO"]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+}
+array(2) {
+  [-1]=>
+  int(1)
+  [0]=>
+  int(0)
+}
+array(1) {
+  [0]=>
+  string(0) ""
+}
+array(2) {
+  [1]=>
+  string(5) "index"
+  [2]=>
+  string(3) "two"
+}
+array(2) {
+  ["value1"]=>
+  string(4) "key3"
+  [2]=>
+  string(4) "key2"
+}
+Done
diff --git a/tests/std/array/array_intersect_1.phpt b/tests/std/array/array_intersect_1.phpt
new file mode 100644
index 00000000..72a9fa56
--- /dev/null
+++ b/tests/std/array/array_intersect_1.phpt
@@ -0,0 +1,370 @@
+--TEST--
+Test of the *intersect* bunch of functions (both assoc and non-assoc)
+--FILE--
+<?php
+class cr
+{
+    private $priv_member;
+    public $public_member;
+    function __construct($val)
+    {
+        $this->priv_member = $val;
+        $this->public_member = $val;
+    }
+    static function comp_func_cr($a, $b)
+    {
+        if ($a->priv_member === $b->priv_member) {
+            return 0;
+        }
+        return $a->priv_member > $b->priv_member ? 1 : -1;
+    }
+}
+function comp_func($a, $b)
+{
+    if ($a === $b) {
+        return 0;
+    }
+    return $a > $b ? 1 : -1;
+}
+function comp_func_cr($a, $b)
+{
+    if ($a->public_member === $b->public_member) {
+        return 0;
+    }
+    return $a->public_member > $b->public_member ? 1 : -1;
+}
+function main()
+{
+    error_reporting(E_ALL);
+    $a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1 => new cr(4), 2 => new cr(-15));
+    $b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1 => new cr(4), 2 => new cr(-15));
+    /* array_uintersect() */
+    echo "begin ------------ array_uintersect() ---------------------------\n";
+    echo '$a=' . var_export($a, TRUE) . ";\n";
+    echo '$b=' . var_export($b, TRUE) . ";\n";
+    echo 'var_dump(array_uintersect($a, $b, "comp_func_cr"));' . "\n";
+    var_dump(array_uintersect($a, $b, "comp_func_cr"));
+    echo "end   ------------ array_uintersect() ---------------------------\n";
+    /* array_uintersect_assoc() */
+    echo "begin ------------ array_uintersect_assoc() ---------------------\n";
+    echo '$a=' . var_export($a, TRUE) . ";\n";
+    echo '$b=' . var_export($b, TRUE) . ";\n";
+    echo 'var_dump(array_uintersect_assoc($a, $b, "comp_func_cr"));' . "\n";
+    var_dump(array_uintersect_assoc($a, $b, "comp_func_cr"));
+    echo "end   ------------ array_uintersect_assoc() ---------------------\n";
+    /* array_uintersect_uassoc() - with ordinary function */
+    echo "begin ------------ array_uintersect_uassoc() with ordinary func -\n";
+    echo '$a=' . var_export($a, TRUE) . ";\n";
+    echo '$b=' . var_export($b, TRUE) . ";\n";
+    echo 'var_dump(array_uintersect_uassoc($a, $b, "comp_func_cr", "comp_func"));' . "\n";
+    var_dump(array_uintersect_uassoc($a, $b, "comp_func_cr", "comp_func"));
+    echo "end   ------------ array_uintersect_uassoc() with ordinary func -\n";
+    /* array_uintersect_uassoc() - by method call */
+    echo "begin ------------ array_uintersect_uassoc() with method --------\n";
+    echo '$a=' . var_export($a, TRUE) . ";\n";
+    echo '$b=' . var_export($b, TRUE) . ";\n";
+    echo 'var_dump(array_uintersect_uassoc($a, $b, array("cr", "comp_func_cr"), "comp_func"));' . "\n";
+    var_dump(array_uintersect_uassoc($a, $b, array("cr", "comp_func_cr"), "comp_func"));
+    echo "end   ------------ array_uintersect_uassoc() with method --------\n";
+}
+?>
+--EXPECTF--
+begin ------------ array_uintersect() ---------------------------
+$a=array (
+  '0.1' => 
+  \cr::__set_state(array(
+     'priv_member' => 9,
+     'public_member' => 9,
+  )),
+  '0.5' => 
+  \cr::__set_state(array(
+     'priv_member' => 12,
+     'public_member' => 12,
+  )),
+  0 => 
+  \cr::__set_state(array(
+     'priv_member' => 23,
+     'public_member' => 23,
+  )),
+  1 => 
+  \cr::__set_state(array(
+     'priv_member' => 4,
+     'public_member' => 4,
+  )),
+  2 => 
+  \cr::__set_state(array(
+     'priv_member' => -15,
+     'public_member' => -15,
+  )),
+);
+$b=array (
+  '0.2' => 
+  \cr::__set_state(array(
+     'priv_member' => 9,
+     'public_member' => 9,
+  )),
+  '0.5' => 
+  \cr::__set_state(array(
+     'priv_member' => 22,
+     'public_member' => 22,
+  )),
+  0 => 
+  \cr::__set_state(array(
+     'priv_member' => 3,
+     'public_member' => 3,
+  )),
+  1 => 
+  \cr::__set_state(array(
+     'priv_member' => 4,
+     'public_member' => 4,
+  )),
+  2 => 
+  \cr::__set_state(array(
+     'priv_member' => -15,
+     'public_member' => -15,
+  )),
+);
+var_dump(array_uintersect($a, $b, "comp_func_cr"));
+array(3) {
+  ["0.1"]=>
+  object(cr)#%d (2) {
+    ["priv_member":"cr":private]=>
+    int(9)
+    ["public_member"]=>
+    int(9)
+  }
+  [1]=>
+  object(cr)#%d (2) {
+    ["priv_member":"cr":private]=>
+    int(4)
+    ["public_member"]=>
+    int(4)
+  }
+  [2]=>
+  object(cr)#%d (2) {
+    ["priv_member":"cr":private]=>
+    int(-15)
+    ["public_member"]=>
+    int(-15)
+  }
+}
+end   ------------ array_uintersect() ---------------------------
+begin ------------ array_uintersect_assoc() ---------------------
+$a=array (
+  '0.1' => 
+  \cr::__set_state(array(
+     'priv_member' => 9,
+     'public_member' => 9,
+  )),
+  '0.5' => 
+  \cr::__set_state(array(
+     'priv_member' => 12,
+     'public_member' => 12,
+  )),
+  0 => 
+  \cr::__set_state(array(
+     'priv_member' => 23,
+     'public_member' => 23,
+  )),
+  1 => 
+  \cr::__set_state(array(
+     'priv_member' => 4,
+     'public_member' => 4,
+  )),
+  2 => 
+  \cr::__set_state(array(
+     'priv_member' => -15,
+     'public_member' => -15,
+  )),
+);
+$b=array (
+  '0.2' => 
+  \cr::__set_state(array(
+     'priv_member' => 9,
+     'public_member' => 9,
+  )),
+  '0.5' => 
+  \cr::__set_state(array(
+     'priv_member' => 22,
+     'public_member' => 22,
+  )),
+  0 => 
+  \cr::__set_state(array(
+     'priv_member' => 3,
+     'public_member' => 3,
+  )),
+  1 => 
+  \cr::__set_state(array(
+     'priv_member' => 4,
+     'public_member' => 4,
+  )),
+  2 => 
+  \cr::__set_state(array(
+     'priv_member' => -15,
+     'public_member' => -15,
+  )),
+);
+var_dump(array_uintersect_assoc($a, $b, "comp_func_cr"));
+array(2) {
+  [1]=>
+  object(cr)#%d (2) {
+    ["priv_member":"cr":private]=>
+    int(4)
+    ["public_member"]=>
+    int(4)
+  }
+  [2]=>
+  object(cr)#%d (2) {
+    ["priv_member":"cr":private]=>
+    int(-15)
+    ["public_member"]=>
+    int(-15)
+  }
+}
+end   ------------ array_uintersect_assoc() ---------------------
+begin ------------ array_uintersect_uassoc() with ordinary func -
+$a=array (
+  '0.1' => 
+  \cr::__set_state(array(
+     'priv_member' => 9,
+     'public_member' => 9,
+  )),
+  '0.5' => 
+  \cr::__set_state(array(
+     'priv_member' => 12,
+     'public_member' => 12,
+  )),
+  0 => 
+  \cr::__set_state(array(
+     'priv_member' => 23,
+     'public_member' => 23,
+  )),
+  1 => 
+  \cr::__set_state(array(
+     'priv_member' => 4,
+     'public_member' => 4,
+  )),
+  2 => 
+  \cr::__set_state(array(
+     'priv_member' => -15,
+     'public_member' => -15,
+  )),
+);
+$b=array (
+  '0.2' => 
+  \cr::__set_state(array(
+     'priv_member' => 9,
+     'public_member' => 9,
+  )),
+  '0.5' => 
+  \cr::__set_state(array(
+     'priv_member' => 22,
+     'public_member' => 22,
+  )),
+  0 => 
+  \cr::__set_state(array(
+     'priv_member' => 3,
+     'public_member' => 3,
+  )),
+  1 => 
+  \cr::__set_state(array(
+     'priv_member' => 4,
+     'public_member' => 4,
+  )),
+  2 => 
+  \cr::__set_state(array(
+     'priv_member' => -15,
+     'public_member' => -15,
+  )),
+);
+var_dump(array_uintersect_uassoc($a, $b, "comp_func_cr", "comp_func"));
+array(2) {
+  [1]=>
+  object(cr)#%d (2) {
+    ["priv_member":"cr":private]=>
+    int(4)
+    ["public_member"]=>
+    int(4)
+  }
+  [2]=>
+  object(cr)#%d (2) {
+    ["priv_member":"cr":private]=>
+    int(-15)
+    ["public_member"]=>
+    int(-15)
+  }
+}
+end   ------------ array_uintersect_uassoc() with ordinary func -
+begin ------------ array_uintersect_uassoc() with method --------
+$a=array (
+  '0.1' => 
+  \cr::__set_state(array(
+     'priv_member' => 9,
+     'public_member' => 9,
+  )),
+  '0.5' => 
+  \cr::__set_state(array(
+     'priv_member' => 12,
+     'public_member' => 12,
+  )),
+  0 => 
+  \cr::__set_state(array(
+     'priv_member' => 23,
+     'public_member' => 23,
+  )),
+  1 => 
+  \cr::__set_state(array(
+     'priv_member' => 4,
+     'public_member' => 4,
+  )),
+  2 => 
+  \cr::__set_state(array(
+     'priv_member' => -15,
+     'public_member' => -15,
+  )),
+);
+$b=array (
+  '0.2' => 
+  \cr::__set_state(array(
+     'priv_member' => 9,
+     'public_member' => 9,
+  )),
+  '0.5' => 
+  \cr::__set_state(array(
+     'priv_member' => 22,
+     'public_member' => 22,
+  )),
+  0 => 
+  \cr::__set_state(array(
+     'priv_member' => 3,
+     'public_member' => 3,
+  )),
+  1 => 
+  \cr::__set_state(array(
+     'priv_member' => 4,
+     'public_member' => 4,
+  )),
+  2 => 
+  \cr::__set_state(array(
+     'priv_member' => -15,
+     'public_member' => -15,
+  )),
+);
+var_dump(array_uintersect_uassoc($a, $b, array("cr", "comp_func_cr"), "comp_func"));
+array(2) {
+  [1]=>
+  object(cr)#%d (2) {
+    ["priv_member":"cr":private]=>
+    int(4)
+    ["public_member"]=>
+    int(4)
+  }
+  [2]=>
+  object(cr)#%d (2) {
+    ["priv_member":"cr":private]=>
+    int(-15)
+    ["public_member"]=>
+    int(-15)
+  }
+}
+end   ------------ array_uintersect_uassoc() with method --------
diff --git a/tests/std/array/array_intersect_assoc_basic.phpt b/tests/std/array/array_intersect_assoc_basic.phpt
new file mode 100644
index 00000000..d20cef75
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_basic.phpt
@@ -0,0 +1,63 @@
+--TEST--
+Test array_intersect_assoc() function : basic functionality
+--FILE--
+<?php
+/*
+* Testing the behavior of array_intersect_assoc() by passing different arrays for the arguments.
+* Function is tested by passing associative array as well as array with default keys.
+*/
+
+echo "*** Testing array_intersect_assoc() : basic functionality ***\n";
+
+// array with default keys
+$arr_default_keys = array(1, 2, "hello", 'world');
+
+// associative array
+$arr_associative = array("one" => 1, "two" => 2);
+
+// default key array for both $arr1 and $arr2 argument
+var_dump( array_intersect_assoc($arr_default_keys, $arr_default_keys) );
+
+// default key array for $arr1 and associative array for $arr2 argument
+var_dump( array_intersect_assoc($arr_default_keys, $arr_associative) );
+
+// associative array for $arr1 and default key array for $arr2
+var_dump( array_intersect_assoc($arr_associative, $arr_default_keys) );
+
+// associative array for both $arr1 and $arr2 argument
+var_dump( array_intersect_assoc($arr_associative, $arr_associative) );
+
+// more arrays to be intersected
+$arr3 = array(2, 3, 4);
+var_dump( array_intersect_assoc($arr_default_keys, $arr_associative, $arr3) );
+var_dump( array_intersect_assoc($arr_associative, $arr_default_keys, $arr3, $arr_associative) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect_assoc() : basic functionality ***
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(5) "hello"
+  [3]=>
+  string(5) "world"
+}
+array(0) {
+}
+array(0) {
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(0) {
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation1.phpt b/tests/std/array/array_intersect_assoc_variation1.phpt
new file mode 100644
index 00000000..245b9792
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation1.phpt
@@ -0,0 +1,183 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - unexpected values for 'array1' argument(Bug#43196)
+--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()
+{
+    /*
+    * Testing array_intersect_assoc() function by passing values to $array1 argument other than arrays
+    * and see that function emits proper warning messages wherever expected.
+    * The $array2 argument passed is a fixed array.
+    */
+    echo "*** Testing array_intersect_assoc() : Passing non-array values to \$array1 argument ***\n";
+    // array to be passsed to $array2 as default argument
+    $array2 = array(1, 2);
+    // additional array to be passed for intersection
+    $arr3 = array(1, 2, "one" => 1, "two" => 2);
+    // get an unset variable
+    $unset_var = null;
+    // already null
+    $undefined_var = null;
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    // get a resource variable
+    $fp = fopen(__FILE__, "r");
+    // unexpected values to be passed to $array1 argument
+    $arrays = 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,
+        // object data
+        /*21*/
+        new classA(),
+        // undefined data
+        /*22*/
+        @$undefined_var,
+        // unset data
+        /*23*/
+        @$unset_var,
+        // resource variable
+        /*24*/
+        $fp,
+    );
+    // loop through each sub-array within $arrays to check the behavior of array_intersect_assoc()
+    $iterator = 1;
+    foreach ($arrays as $unexpected_value) {
+        echo "\n-- Iteration {$iterator} --";
+        // Calling array_intersect_assoc() with default arguments
+        try {
+            var_dump(array_intersect_assoc($unexpected_value, $array2));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        // Calling array_intersect_assoc() with more arguments
+        try {
+            var_dump(array_intersect_assoc($unexpected_value, $array2, $arr3));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_intersect_assoc() : Passing non-array values to $array1 argument ***
+
+-- Iteration 1 --array_intersect_assoc(): Argument #1 ($array) must be of type array, int given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 2 --array_intersect_assoc(): Argument #1 ($array) must be of type array, int given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 3 --array_intersect_assoc(): Argument #1 ($array) must be of type array, int given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 4 --array_intersect_assoc(): Argument #1 ($array) must be of type array, int given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, int given
+
+-- Iteration 5 --array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 6 --array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 7 --array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 8 --array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 9 --array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+-- Iteration 10 --array_intersect_assoc(): Argument #1 ($array) must be of type array, null given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 11 --array_intersect_assoc(): Argument #1 ($array) must be of type array, null given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 12 --array_intersect_assoc(): Argument #1 ($array) must be of type array, true given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, true given
+
+-- Iteration 13 --array_intersect_assoc(): Argument #1 ($array) must be of type array, false given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, false given
+
+-- Iteration 14 --array_intersect_assoc(): Argument #1 ($array) must be of type array, true given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, true given
+
+-- Iteration 15 --array_intersect_assoc(): Argument #1 ($array) must be of type array, false given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, false given
+
+-- Iteration 16 --array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 17 --array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 18 --array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 19 --array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 20 --array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+-- Iteration 21 --array_intersect_assoc(): Argument #1 ($array) must be of type array, classA given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, classA given
+
+-- Iteration 22 --array_intersect_assoc(): Argument #1 ($array) must be of type array, null given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 23 --array_intersect_assoc(): Argument #1 ($array) must be of type array, null given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, null given
+
+-- Iteration 24 --array_intersect_assoc(): Argument #1 ($array) must be of type array, resource given
+array_intersect_assoc(): Argument #1 ($array) must be of type array, resource given
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation10.phpt b/tests/std/array/array_intersect_assoc_variation10.phpt
new file mode 100644
index 00000000..8e5c1adc
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation10.phpt
@@ -0,0 +1,48 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - binary safe checking
+--FILE--
+<?php
+/*
+* Testing the behavior of array_intersect_assoc() by passing array with
+* binary values for $arr1 and $arr2 argument.
+*/
+
+echo "*** Testing array_intersect_assoc() : binary safe checking ***\n";
+
+// array with binary values
+$arr_binary = array(b"hello", b"world");
+// simple array
+$arr_normal = array("hello", "world");
+
+// array with binary value for $arr1 argument
+var_dump( array_intersect_assoc($arr_binary, $arr_normal) );
+
+// array with binary value for $arr2 argument
+var_dump( array_intersect_assoc($arr_normal, $arr_binary) );
+
+// array with binary value for both $arr1 and $arr2 argument
+var_dump( array_intersect_assoc($arr_binary, $arr_binary) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect_assoc() : binary safe checking ***
+array(2) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+}
+array(2) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+}
+array(2) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+}
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation2.phpt b/tests/std/array/array_intersect_assoc_variation2.phpt
new file mode 100644
index 00000000..73645489
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation2.phpt
@@ -0,0 +1,182 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - unexpected values for 'array2' argument(Bug#43196)
+--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()
+{
+    /*
+    * Testing array_intersect_assoc() function by passing values to $array2 argument other than arrays
+    * and see that function emits proper warning messages wherever expected.
+    * The $array1 argument passed is a fixed array.
+    */
+    echo "*** Testing array_intersect_assoc() : Passing non-array values to \$array2 argument ***\n";
+    // array to be passsed to $array1 as default argument
+    $array1 = array(1, 2);
+    // additional array to be passed for intersection
+    $arr3 = array(1, 2, "one" => 1, "two" => 2);
+    // 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");
+    // unexpected values to be passed to $array2 argument
+    $arrays = 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,
+        // object data
+        /*21*/
+        new classA(),
+        // undefined data
+        /*22*/
+        @$undefined_var,
+        // unset data
+        /*23*/
+        @$unset_var,
+        // resource variable
+        /*24*/
+        $fp,
+    );
+    // loop through each sub-array within $arrays to check the behavior of array_intersect_assoc()
+    $iterator = 1;
+    foreach ($arrays as $unexpected_value) {
+        echo "\n-- Iteration {$iterator} --";
+        // Calling array_intersect_assoc() with default arguments
+        try {
+            var_dump(array_intersect_assoc($array1, $unexpected_value));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        // Calling array_intersect_assoc() with more arguments
+        try {
+            var_dump(array_intersect_assoc($array1, $unexpected_value, $arr3));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_intersect_assoc() : Passing non-array values to $array2 argument ***
+
+-- Iteration 1 --array_intersect_assoc(): Argument #2 must be of type array, int given
+array_intersect_assoc(): Argument #2 must be of type array, int given
+
+-- Iteration 2 --array_intersect_assoc(): Argument #2 must be of type array, int given
+array_intersect_assoc(): Argument #2 must be of type array, int given
+
+-- Iteration 3 --array_intersect_assoc(): Argument #2 must be of type array, int given
+array_intersect_assoc(): Argument #2 must be of type array, int given
+
+-- Iteration 4 --array_intersect_assoc(): Argument #2 must be of type array, int given
+array_intersect_assoc(): Argument #2 must be of type array, int given
+
+-- Iteration 5 --array_intersect_assoc(): Argument #2 must be of type array, float given
+array_intersect_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 6 --array_intersect_assoc(): Argument #2 must be of type array, float given
+array_intersect_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 7 --array_intersect_assoc(): Argument #2 must be of type array, float given
+array_intersect_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 8 --array_intersect_assoc(): Argument #2 must be of type array, float given
+array_intersect_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 9 --array_intersect_assoc(): Argument #2 must be of type array, float given
+array_intersect_assoc(): Argument #2 must be of type array, float given
+
+-- Iteration 10 --array_intersect_assoc(): Argument #2 must be of type array, null given
+array_intersect_assoc(): Argument #2 must be of type array, null given
+
+-- Iteration 11 --array_intersect_assoc(): Argument #2 must be of type array, null given
+array_intersect_assoc(): Argument #2 must be of type array, null given
+
+-- Iteration 12 --array_intersect_assoc(): Argument #2 must be of type array, true given
+array_intersect_assoc(): Argument #2 must be of type array, true given
+
+-- Iteration 13 --array_intersect_assoc(): Argument #2 must be of type array, false given
+array_intersect_assoc(): Argument #2 must be of type array, false given
+
+-- Iteration 14 --array_intersect_assoc(): Argument #2 must be of type array, true given
+array_intersect_assoc(): Argument #2 must be of type array, true given
+
+-- Iteration 15 --array_intersect_assoc(): Argument #2 must be of type array, false given
+array_intersect_assoc(): Argument #2 must be of type array, false given
+
+-- Iteration 16 --array_intersect_assoc(): Argument #2 must be of type array, string given
+array_intersect_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 17 --array_intersect_assoc(): Argument #2 must be of type array, string given
+array_intersect_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 18 --array_intersect_assoc(): Argument #2 must be of type array, string given
+array_intersect_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 19 --array_intersect_assoc(): Argument #2 must be of type array, string given
+array_intersect_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 20 --array_intersect_assoc(): Argument #2 must be of type array, string given
+array_intersect_assoc(): Argument #2 must be of type array, string given
+
+-- Iteration 21 --array_intersect_assoc(): Argument #2 must be of type array, classA given
+array_intersect_assoc(): Argument #2 must be of type array, classA given
+
+-- Iteration 22 --array_intersect_assoc(): Argument #2 must be of type array, null given
+array_intersect_assoc(): Argument #2 must be of type array, null given
+
+-- Iteration 23 --array_intersect_assoc(): Argument #2 must be of type array, null given
+array_intersect_assoc(): Argument #2 must be of type array, null given
+
+-- Iteration 24 --array_intersect_assoc(): Argument #2 must be of type array, resource given
+array_intersect_assoc(): Argument #2 must be of type array, resource given
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation3.phpt b/tests/std/array/array_intersect_assoc_variation3.phpt
new file mode 100644
index 00000000..bb439a05
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation3.phpt
@@ -0,0 +1,237 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - different arrays for 'arr1' argument
+--FILE--
+<?php
+/*
+* Passing different types of arrays to $arr1 argument and testing whether
+* array_intersect_assoc() behaves in an expected way with the other arguments passed to the function
+* The $arr2 argument passed is a fixed array.
+*/
+
+echo "*** Testing array_intersect_assoc() : Passing different types of arrays to \$arr1 argument ***\n";
+
+/* Different heredoc strings passed as argument to $arr1 */
+// heredoc with blank line
+$blank_line = <<<EOT
+
+
+EOT;
+
+// heredoc with multiline string
+$multiline_string = <<<EOT
+hello world
+The big 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 to be passed to $arr1 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)
+);
+
+
+// array to be passsed to $arr2 argument
+$arr2 = array (
+  1, 1.1, 2.2, "hello", "one", NULL, 2,
+  'world', true,5 => false, 1 => 'aaaa\r', "aaaa\r",
+  'h3' => $diff_whitespaces, $numeric_string,
+  "one" => "ten", 4 => "four", "two" => 2,
+  '', null => "null", '' => 'emptys', "emptyd" => "",
+);
+
+// loop through each sub-array within $arrays to check the behavior of array_intersect_assoc()
+$iterator = 1;
+foreach($arrays as $arr1) {
+  echo "-- Iteration $iterator --\n";
+
+  // Calling array_intersect_assoc() with default arguments
+  var_dump( array_intersect_assoc($arr1, $arr2) );
+
+  // Calling array_intersect_assoc() with more arguments.
+  // additional argument passed is the same as $arr1 argument
+  var_dump( array_intersect_assoc($arr1, $arr2, $arr1) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect_assoc() : Passing different types of arrays to $arr1 argument ***
+-- Iteration 1 --
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+-- Iteration 2 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 3 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 4 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 5 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 6 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 7 --
+array(1) {
+  [1]=>
+  string(6) "aaaa\r"
+}
+array(1) {
+  [1]=>
+  string(6) "aaaa\r"
+}
+-- Iteration 8 --
+array(1) {
+  ["h3"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+}
+array(1) {
+  ["h3"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+}
+-- Iteration 9 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 10 --
+array(1) {
+  ["two"]=>
+  int(2)
+}
+array(1) {
+  ["two"]=>
+  int(2)
+}
+-- Iteration 11 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 12 --
+array(1) {
+  ["one"]=>
+  string(3) "ten"
+}
+array(1) {
+  ["one"]=>
+  string(3) "ten"
+}
+-- Iteration 13 --
+array(1) {
+  [4]=>
+  string(4) "four"
+}
+array(1) {
+  [4]=>
+  string(4) "four"
+}
+-- Iteration 14 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 15 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 16 --
+array(2) {
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+}
+array(2) {
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+}
+-- Iteration 17 --
+array(1) {
+  [5]=>
+  bool(false)
+}
+array(1) {
+  [5]=>
+  bool(false)
+}
+-- Iteration 18 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 19 --
+array(0) {
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation4.phpt b/tests/std/array/array_intersect_assoc_variation4.phpt
new file mode 100644
index 00000000..859b7280
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation4.phpt
@@ -0,0 +1,248 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - different arrays for 'arr2' argument
+--FILE--
+<?php
+/*
+* Passing different types of arrays to $arr2 argument and testing whether
+* array_intersect_assoc() behaves in an expected way with the other arguments passed to the function.
+* The $arr1 argument passed is a fixed array.
+*/
+
+echo "*** Testing array_intersect_assoc() : Passing different types of arrays to \$arr2 argument ***\n";
+
+/* Different heredoc strings passed as argument to $arr2 */
+// heredoc with blank line
+$blank_line = <<<EOT
+
+
+EOT;
+
+// heredoc with multiline string
+$multiline_string = <<<EOT
+hello world
+The big 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;
+
+// array to be passsed to $arr1 argument
+$arr1 = array (
+  1, 1.1, 1.3, 1 => true, "hello", "one", NULL, 2,
+  'world', true, false, 3 => "b\tbbb", "aaaa\r",
+  $numeric_string, "h3" => $diff_whitespaces, "true" => true,
+  "one" => "ten", 4 => "four", "two" => 2, 6 => "six",
+  '', null => "null", '' => 'emptys'
+);
+
+// arrays to be passed to $arr2 argument
+$arrays = array (
+/*1*/  array(1, 2), // array with default keys and numeric values
+       array(1.1, 1.2, 1.3), // array with default keys & float values
+       array(false,true), // array with default keys and boolean values
+       array(), // empty array
+/*5*/  array(NULL), // array with NULL
+       array("a\v\f","aaaa\r","b","b\tbbb","c","\[\]\!\@\#\$\%\^\&\*\(\)\{\}"),  // array with double quoted strings
+       array('a\v\f','aaaa\r','b','b\tbbb','c','\[\]\!\@\#\$\%\^\&\*\(\)\{\}'),  // array with single quoted strings
+       array($blank_line, "h2" => $multiline_string, "h3" => $diff_whitespaces, $numeric_string),  // array with heredocs
+
+       // associative arrays
+/*9*/  array(1 => "one", 2 => "two", 6 => "six"),  // 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_intersect_assoc()
+$iterator = 1;
+foreach($arrays as $arr2) {
+  echo "-- Iteration $iterator --\n";
+
+  // Calling array_intersect_assoc() with default arguments
+  var_dump( array_intersect_assoc($arr1, $arr2) );
+
+  // Calling array_intersect_assoc() with more arguments
+  // additional argument passed is the same as $arr1 argument
+  var_dump( array_intersect_assoc($arr1, $arr2, $arr1) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect_assoc() : Passing different types of arrays to $arr2 argument ***
+-- Iteration 1 --
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+-- Iteration 2 --
+array(1) {
+  [2]=>
+  float(1.3)
+}
+array(1) {
+  [2]=>
+  float(1.3)
+}
+-- Iteration 3 --
+array(1) {
+  [1]=>
+  bool(true)
+}
+array(1) {
+  [1]=>
+  bool(true)
+}
+-- Iteration 4 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 5 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 6 --
+array(1) {
+  [3]=>
+  string(5) "b	bbb"
+}
+array(1) {
+  [3]=>
+  string(5) "b	bbb"
+}
+-- Iteration 7 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 8 --
+array(1) {
+  ["h3"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+}
+array(1) {
+  ["h3"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+}
+-- Iteration 9 --
+array(1) {
+  [6]=>
+  string(3) "six"
+}
+array(1) {
+  [6]=>
+  string(3) "six"
+}
+-- Iteration 10 --
+array(1) {
+  ["two"]=>
+  int(2)
+}
+array(1) {
+  ["two"]=>
+  int(2)
+}
+-- Iteration 11 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 12 --
+array(1) {
+  ["one"]=>
+  string(3) "ten"
+}
+array(1) {
+  ["one"]=>
+  string(3) "ten"
+}
+-- Iteration 13 --
+array(1) {
+  [4]=>
+  string(4) "four"
+}
+array(1) {
+  [4]=>
+  string(4) "four"
+}
+-- Iteration 14 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 15 --
+array(1) {
+  ["true"]=>
+  bool(true)
+}
+array(1) {
+  ["true"]=>
+  bool(true)
+}
+-- Iteration 16 --
+array(1) {
+  [""]=>
+  string(6) "emptys"
+}
+array(1) {
+  [""]=>
+  string(6) "emptys"
+}
+-- Iteration 17 --
+array(1) {
+  [5]=>
+  NULL
+}
+array(1) {
+  [5]=>
+  NULL
+}
+-- Iteration 18 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 19 --
+array(0) {
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation5.phpt b/tests/std/array/array_intersect_assoc_variation5.phpt
new file mode 100644
index 00000000..65ce1dae
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation5.phpt
@@ -0,0 +1,139 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - assoc array with diff keys for 'arr1' argument
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_intersect_assoc() by passing different
+ * associative arrays having different possible keys to $arr1 argument.
+ * The $arr2 argument passed is a fixed array
+*/
+
+echo "*** Testing array_intersect_assoc() : assoc array with diff keys to \$arr1 argument ***\n";
+
+// get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// 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"),
+
+       // array with mixed keys
+/*11*/ array('hello' => 1, "fruit" => 2.2,
+              133 => "int",
+             @$unset_var => "unset", $heredoc => "heredoc")
+);
+
+// array to be passed 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_intersect_assoc()
+$iterator = 1;
+foreach($arrays as $arr1) {
+  echo "-- Iteration $iterator --\n";
+
+  // Calling array_intersect_assoc() with default arguments
+  var_dump( array_intersect_assoc($arr1, $arr2) );
+
+  // Calling array_intersect_assoc() with more arguments.
+  // additional argument passed is the same as $arr1 argument
+  var_dump( array_intersect_assoc($arr1, $arr2, $arr1) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect_assoc() : assoc array with diff keys to $arr1 argument ***
+-- Iteration 1 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  string(1) "0"
+}
+array(1) {
+  [0]=>
+  string(1) "0"
+}
+-- Iteration 3 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 4 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 5 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 6 --
+array(2) {
+  ["	Hello"]=>
+  int(111)
+  ["pen
+"]=>
+  int(33)
+}
+array(2) {
+  ["	Hello"]=>
+  int(111)
+  ["pen
+"]=>
+  int(33)
+}
+-- Iteration 7 --
+array(1) {
+  ["Hello world"]=>
+  string(6) "string"
+}
+array(1) {
+  ["Hello world"]=>
+  string(6) "string"
+}
+-- Iteration 8 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 9 --
+array(1) {
+  [133]=>
+  string(3) "int"
+}
+array(1) {
+  [133]=>
+  string(3) "int"
+}
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation6.phpt b/tests/std/array/array_intersect_assoc_variation6.phpt
new file mode 100644
index 00000000..f446c687
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation6.phpt
@@ -0,0 +1,139 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - assoc array with diff keys for 'arr2' argument
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_intersect_assoc() by passing different
+ * associative arrays having different possible keys to $arr2 argument.
+ * The $arr1 argument passed is a fixed array.
+*/
+
+echo "*** Testing array_intersect_assoc() : assoc array with diff keys to \$arr2 argument ***\n";
+
+// get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// get a heredoc string
+$heredoc = <<<EOT
+Hello world
+EOT;
+
+// different variations of associative arrays to be passed to $arr2 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  unset variable
+/*10*/ array( @$unset_var => "hello"),
+
+       // array with mixed keys
+/*11*/ array('hello' => 1, "fruit" => 2.2,
+              133 => "int",
+             @$unset_var => "unset", $heredoc => "heredoc")
+);
+
+// array to be passed to $arr1 argument
+$arr1 = 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_intersect_assoc()
+$iterator = 1;
+foreach($arrays as $arr2) {
+  echo "-- Iteration $iterator --\n";
+
+  // Calling array_intersect_assoc() with default arguments
+  var_dump( array_intersect_assoc($arr1, $arr2) );
+
+  // Calling array_intersect_assoc() with more arguments.
+  // additional argument passed is the same as $arr1 argument
+  var_dump( array_intersect_assoc($arr1, $arr2, $arr1) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect_assoc() : assoc array with diff keys to $arr2 argument ***
+-- Iteration 1 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  int(0)
+}
+array(1) {
+  [0]=>
+  int(0)
+}
+-- Iteration 3 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 4 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 5 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 6 --
+array(2) {
+  ["	Hello"]=>
+  int(111)
+  ["pen
+"]=>
+  int(33)
+}
+array(2) {
+  ["	Hello"]=>
+  int(111)
+  ["pen
+"]=>
+  int(33)
+}
+-- Iteration 7 --
+array(1) {
+  ["Hello world"]=>
+  string(6) "string"
+}
+array(1) {
+  ["Hello world"]=>
+  string(6) "string"
+}
+-- Iteration 8 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 9 --
+array(1) {
+  [133]=>
+  string(3) "int"
+}
+array(1) {
+  [133]=>
+  string(3) "int"
+}
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation7.phpt b/tests/std/array/array_intersect_assoc_variation7.phpt
new file mode 100644
index 00000000..a1171fb9
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation7.phpt
@@ -0,0 +1,191 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - assoc array with diff values for 'arr1' argument
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Testing the functionality of array_intersect_assoc() by passing different
+     * associative arrays having different possible values to $arr1 argument.
+     * The $arr2 argument passed is a fixed array
+    */
+    echo "*** Testing array_intersect_assoc() : assoc array with diff values to \$arr1 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 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),
+    );
+    // array to be passsed to $arr2 argument
+    $arr2 = array(0 => "0", 1, "two" => 2, "float" => 2.3333, "f1" => 1.2, "f4" => 33333333.333, 111 => "\tHello", 3 => 'pen\n', '\v\fworld', "heredoc" => "Hello world", 11 => new classA(), "resource" => $fp, "int" => 133, 222 => "fruit");
+    // loop through each sub-array within $arrays to check the behavior of array_intersect_assoc()
+    $iterator = 1;
+    foreach ($arrays as $arr1) {
+        echo "-- Iteration {$iterator} --\n";
+        // Calling array_intersect_assoc() with default arguments
+        var_dump(array_intersect_assoc($arr1, $arr2));
+        // Calling array_intersect_assoc() with more arguments.
+        // additional argument passed is the same as $arr1 argument
+        var_dump(array_intersect_assoc($arr1, $arr2, $arr1));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_intersect_assoc() : assoc array with diff values to $arr1 argument ***
+-- Iteration 1 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  int(0)
+}
+array(1) {
+  [0]=>
+  int(0)
+}
+-- Iteration 3 --
+array(1) {
+  [1]=>
+  int(1)
+}
+array(1) {
+  [1]=>
+  int(1)
+}
+-- Iteration 4 --
+array(1) {
+  ["two"]=>
+  int(2)
+}
+array(1) {
+  ["two"]=>
+  int(2)
+}
+-- Iteration 5 --
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+-- Iteration 6 --
+array(2) {
+  ["f1"]=>
+  float(1.2)
+  ["f4"]=>
+  float(33333333.333)
+}
+array(2) {
+  ["f1"]=>
+  float(1.2)
+  ["f4"]=>
+  float(33333333.333)
+}
+-- Iteration 7 --
+array(1) {
+  [111]=>
+  string(6) "	Hello"
+}
+array(1) {
+  [111]=>
+  string(6) "	Hello"
+}
+-- Iteration 8 --
+array(1) {
+  [3]=>
+  string(5) "pen\n"
+}
+array(1) {
+  [3]=>
+  string(5) "pen\n"
+}
+-- Iteration 9 --
+array(1) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+array(1) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+-- Iteration 10 --
+array(2) {
+  [11]=>
+  object(classA)#%d (0) {
+  }
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+array(2) {
+  [11]=>
+  object(classA)#%d (0) {
+  }
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+-- Iteration 11 --
+array(4) {
+  [222]=>
+  string(5) "fruit"
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["int"]=>
+  int(133)
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+array(4) {
+  [222]=>
+  string(5) "fruit"
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["int"]=>
+  int(133)
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation8.phpt b/tests/std/array/array_intersect_assoc_variation8.phpt
new file mode 100644
index 00000000..4d252349
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation8.phpt
@@ -0,0 +1,191 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - assoc array with diff values for 'arr2' argument
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Testing the functionality of array_intersect_assoc() by passing different
+     * associative arrays having different possible values to $arr2 argument.
+     * The $arr1 argument passed is a fixed array.
+    */
+    echo "*** Testing array_intersect_assoc() : assoc array with diff values to \$arr2 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 $arr2 argument
+    $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),
+    );
+    // array to be passsed to $arr1 argument
+    $arr1 = array(0 => "0", 1, "two" => 2, "float" => 2.3333, "f1" => 1.2, "f4" => 33333333.333, 111 => "\tHello", 3 => 'pen\n', '\v\fworld', "heredoc" => "Hello world", 11 => new classA(), "resource" => $fp, "int" => 133, 222 => "fruit");
+    // loop through each sub-array within $arrays to check the behavior of array_intersect_assoc()
+    $iterator = 1;
+    foreach ($arrays as $arr2) {
+        echo "-- Iteration {$iterator} --\n";
+        // Calling array_intersect_assoc() with default arguments
+        var_dump(array_intersect_assoc($arr1, $arr2));
+        // Calling array_intersect_assoc() with more arguments.
+        // additional argument passed is the same as $arr1 argument
+        var_dump(array_intersect_assoc($arr1, $arr2, $arr1));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_intersect_assoc() : assoc array with diff values to $arr2 argument ***
+-- Iteration 1 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  string(1) "0"
+}
+array(1) {
+  [0]=>
+  string(1) "0"
+}
+-- Iteration 3 --
+array(1) {
+  [1]=>
+  int(1)
+}
+array(1) {
+  [1]=>
+  int(1)
+}
+-- Iteration 4 --
+array(1) {
+  ["two"]=>
+  int(2)
+}
+array(1) {
+  ["two"]=>
+  int(2)
+}
+-- Iteration 5 --
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+-- Iteration 6 --
+array(2) {
+  ["f1"]=>
+  float(1.2)
+  ["f4"]=>
+  float(33333333.333)
+}
+array(2) {
+  ["f1"]=>
+  float(1.2)
+  ["f4"]=>
+  float(33333333.333)
+}
+-- Iteration 7 --
+array(1) {
+  [111]=>
+  string(6) "	Hello"
+}
+array(1) {
+  [111]=>
+  string(6) "	Hello"
+}
+-- Iteration 8 --
+array(1) {
+  [3]=>
+  string(5) "pen\n"
+}
+array(1) {
+  [3]=>
+  string(5) "pen\n"
+}
+-- Iteration 9 --
+array(1) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+array(1) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+-- Iteration 10 --
+array(2) {
+  [11]=>
+  object(classA)#%d (0) {
+  }
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+array(2) {
+  [11]=>
+  object(classA)#%d (0) {
+  }
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+-- Iteration 11 --
+array(4) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["int"]=>
+  int(133)
+  [222]=>
+  string(5) "fruit"
+}
+array(4) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["int"]=>
+  int(133)
+  [222]=>
+  string(5) "fruit"
+}
+Done
diff --git a/tests/std/array/array_intersect_assoc_variation9.phpt b/tests/std/array/array_intersect_assoc_variation9.phpt
new file mode 100644
index 00000000..86d0e8e7
--- /dev/null
+++ b/tests/std/array/array_intersect_assoc_variation9.phpt
@@ -0,0 +1,146 @@
+--TEST--
+Test array_intersect_assoc() function : usage variations - two dimensional arrays for $arr1 and $arr2 arguments
+--FILE--
+<?php
+/*
+* Testing the behavior of array_intersect_assoc() by passing 2-D arrays
+* to both $arr1 and $arr2 argument.
+* Optional argument takes the same value as that of $arr1
+*/
+
+echo "*** Testing array_intersect_assoc() : passing two dimensional array to both \$arr1 and \$arr2 arguments ***\n";
+
+// two dimensional arrays for $arr1 and $arr2 argument
+$arr1 = array (
+
+  // arrays with default keys
+  array(1, 2, "hello", 'world'),
+  array(1, 2, 3, 4),
+
+  // arrays with explicit keys
+  array(1 => "one", 2 => "two", 3 => "three"),
+  array("ten" => 10, "twenty" => 20.00, "thirty" => 30)
+);
+
+$arr2 = array (
+  array(1, 2, 3, 4),
+  array(1 => "one", 2 => "two", 3 => "three")
+);
+
+/* Passing the entire array as argument to $arr1 and $arr2 */
+// Calling array_intersect_assoc() with default arguments
+echo "-- Passing the entire 2-D array to \$arr1 and \$arr2 --\n";
+echo "- With default arguments -\n";
+var_dump( array_intersect_assoc($arr1, $arr2) );
+
+// Calling array_intersect_assoc() with more arguments
+// additional argument passed is the same as $arr1
+echo "- With more arguments -\n";
+var_dump( array_intersect_assoc($arr1, $arr2, $arr1) );
+
+/* Passing the sub-array as argument to $arr1 and $arr2 */
+// Calling array_intersect_assoc() with default arguments
+echo "-- Passing the sub-array to \$arr1 and \$arr2 --\n";
+echo "- With default arguments -\n";
+var_dump( array_intersect_assoc($arr1[0], $arr2[0]) );
+
+// Calling array_intersect_assoc() with more arguments
+// additional argument passed is the same as $arr1
+echo "- With more arguments -\n";
+var_dump( array_intersect_assoc($arr1[0], $arr2[0], $arr1[0]) );
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_intersect_assoc() : passing two dimensional array to both $arr1 and $arr2 arguments ***
+-- Passing the entire 2-D array to $arr1 and $arr2 --
+- With default arguments -
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    string(5) "hello"
+    [3]=>
+    string(5) "world"
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+}
+- With more arguments -
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+array(2) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    string(5) "hello"
+    [3]=>
+    string(5) "world"
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+}
+-- Passing the sub-array to $arr1 and $arr2 --
+- With default arguments -
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+- With more arguments -
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/array_intersect_basic.phpt b/tests/std/array/array_intersect_basic.phpt
new file mode 100644
index 00000000..86ef64e1
--- /dev/null
+++ b/tests/std/array/array_intersect_basic.phpt
@@ -0,0 +1,75 @@
+--TEST--
+Test array_intersect() function : basic functionality
+--FILE--
+<?php
+/*
+* Testing the behavior of array_intersect() by passing different arrays for the arguments.
+* Function is tested by passing associative array as well as array with default keys.
+*/
+
+echo "*** Testing array_intersect() : basic functionality ***\n";
+
+// array with default keys
+$arr_default_keys = array(1, 2, "hello", 'world');
+
+// associative array
+$arr_associative = array("one" => 1, "two" => 2);
+
+// default key array for both $arr1 and $arr2 argument
+var_dump( array_intersect($arr_default_keys, $arr_default_keys) );
+
+// default key array for $arr1 and associative array for $arr2 argument
+var_dump( array_intersect($arr_default_keys, $arr_associative) );
+
+// associative array for $arr1 and default key array for $arr2
+var_dump( array_intersect($arr_associative, $arr_default_keys) );
+
+// associative array for both $arr1 and $arr2 argument
+var_dump( array_intersect($arr_associative, $arr_associative) );
+
+// more arrays to be intersected
+$arr3 = array(2, 3, 4);
+var_dump( array_intersect($arr_default_keys, $arr_associative, $arr3) );
+var_dump( array_intersect($arr_associative, $arr_default_keys, $arr3, $arr_associative) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect() : basic functionality ***
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(5) "hello"
+  [3]=>
+  string(5) "world"
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(1) {
+  [1]=>
+  int(2)
+}
+array(1) {
+  ["two"]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/array_intersect_key.phpt b/tests/std/array/array_intersect_key.phpt
new file mode 100644
index 00000000..a8b55156
--- /dev/null
+++ b/tests/std/array/array_intersect_key.phpt
@@ -0,0 +1,228 @@
+--TEST--
+Test of the array_intersect_key() and array_intersect_ukey()
+--FILE--
+<?php
+///////////////////////////////////////////////////////////////////////
+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);
+    /* 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;
+    }
+    var_dump(array_intersect_key($a_f, $b_f));
+    // keys -> 2, -20, -2500
+    var_dump(array_intersect_ukey($a_f, $b_f, "comp_func"));
+    // 2, 20, -2500
+    var_dump(array_intersect_key($a_f, $c_f));
+    // keys -> 6, 2, -20, -2500
+    var_dump(array_intersect_ukey($a_f, $c_f, "comp_func"));
+    // 6, 2, -20, -2500
+    var_dump(array_intersect_key($a_f, $d_f));
+    // -20
+    var_dump(array_intersect_ukey($a_f, $d_f, "comp_func"));
+    // -20
+    var_dump(array_intersect_key($a_f, $b_f, $c_f));
+    // 2, -20, -2500
+    var_dump(array_intersect_ukey($a_f, $b_f, $c_f, "comp_func"));
+    // 2, -20, -2500
+    var_dump(array_intersect_key($a_f, $b_f, $d_f));
+    // -20
+    var_dump(array_intersect_ukey($a_f, $b_f, $d_f, "comp_func"));
+    // -20
+    var_dump(array_intersect_key($a_f, $b_f, $c_f, $d_f));
+    // -20
+    var_dump(array_intersect_ukey($a_f, $b_f, $c_f, $d_f, "comp_func"));
+    //-20
+    var_dump(array_intersect_key($b_f, $c_f));
+    // 0, 2, -20, -2500
+    var_dump(array_intersect_ukey($b_f, $c_f, "comp_func"));
+    //0, 2, -20, 2500
+    var_dump(array_intersect_key($b_f, $d_f));
+    // -20
+    var_dump(array_intersect_ukey($b_f, $d_f, "comp_func"));
+    // -20
+    var_dump(array_intersect_key($b_f, $c_f, $d_f));
+    // -20
+    var_dump(array_intersect_ukey($b_f, $c_f, $d_f, "comp_func"));
+    // -20
+    echo "----- Now testing array_intersect() ------- \n";
+    var_dump(array_intersect($a, $b_f));
+    var_dump(array_uintersect($a, $b, "comp_func"));
+    var_dump(array_intersect($a, $b, $c));
+    var_dump(array_uintersect($a, $b, $c, "comp_func"));
+    var_dump(array_intersect($a, $b, $c, $d));
+    var_dump(array_uintersect($a, $b, $c, $d, "comp_func"));
+}
+?>
+--EXPECT--
+array(3) {
+  [2]=>
+  int(4)
+  [-20]=>
+  int(-40)
+  [-2500]=>
+  &int(-5000)
+}
+array(3) {
+  [2]=>
+  int(4)
+  [-20]=>
+  int(-40)
+  [-2500]=>
+  &int(-5000)
+}
+array(4) {
+  [6]=>
+  int(12)
+  [2]=>
+  int(4)
+  [-20]=>
+  int(-40)
+  [-2500]=>
+  &int(-5000)
+}
+array(4) {
+  [6]=>
+  int(12)
+  [2]=>
+  int(4)
+  [-20]=>
+  int(-40)
+  [-2500]=>
+  &int(-5000)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+array(3) {
+  [2]=>
+  int(4)
+  [-20]=>
+  int(-40)
+  [-2500]=>
+  &int(-5000)
+}
+array(3) {
+  [2]=>
+  int(4)
+  [-20]=>
+  int(-40)
+  [-2500]=>
+  &int(-5000)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [2]=>
+  int(4)
+  [-20]=>
+  int(-40)
+  [-2500]=>
+  &int(-5000)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [2]=>
+  int(4)
+  [-20]=>
+  int(-40)
+  [-2500]=>
+  &int(-5000)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+array(1) {
+  [-20]=>
+  int(-40)
+}
+----- Now testing array_intersect() ------- 
+array(0) {
+}
+array(3) {
+  [2]=>
+  int(2)
+  [3]=>
+  int(-20)
+  [6]=>
+  int(-2500)
+}
+array(3) {
+  [2]=>
+  int(2)
+  [3]=>
+  int(-20)
+  [6]=>
+  int(-2500)
+}
+array(3) {
+  [2]=>
+  int(2)
+  [3]=>
+  int(-20)
+  [6]=>
+  int(-2500)
+}
+array(1) {
+  [3]=>
+  int(-20)
+}
+array(1) {
+  [3]=>
+  int(-20)
+}
diff --git a/tests/std/array/array_intersect_key_basic.phpt b/tests/std/array/array_intersect_key_basic.phpt
new file mode 100644
index 00000000..4c650441
--- /dev/null
+++ b/tests/std/array/array_intersect_key_basic.phpt
@@ -0,0 +1,18 @@
+--TEST--
+array_intersect_key(): Basic Test
+--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_intersect_key($array1, $array2));
+?>
+--EXPECT--
+array(2) {
+  ["blue"]=>
+  int(1)
+  ["green"]=>
+  int(3)
+}
diff --git a/tests/std/array/array_intersect_key_variation1.phpt b/tests/std/array/array_intersect_key_variation1.phpt
new file mode 100644
index 00000000..8e28a3b6
--- /dev/null
+++ b/tests/std/array/array_intersect_key_variation1.phpt
@@ -0,0 +1,199 @@
+--TEST--
+Test array_intersect_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_intersect_key() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array2 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
+    $array3 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
+    //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' => -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 var' => $fp,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_intersect_key($value, $array2));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_intersect_key($value, $array2, $array3));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_intersect_key() : usage variation ***
+
+--int 0--
+array_intersect_key(): Argument #1 ($array) must be of type array, int given
+array_intersect_key(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_intersect_key(): Argument #1 ($array) must be of type array, int given
+array_intersect_key(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_intersect_key(): Argument #1 ($array) must be of type array, int given
+array_intersect_key(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_intersect_key(): Argument #1 ($array) must be of type array, int given
+array_intersect_key(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+array_intersect_key(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_intersect_key(): Argument #1 ($array) must be of type array, null given
+array_intersect_key(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_intersect_key(): Argument #1 ($array) must be of type array, null given
+array_intersect_key(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_intersect_key(): Argument #1 ($array) must be of type array, true given
+array_intersect_key(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_intersect_key(): Argument #1 ($array) must be of type array, false given
+array_intersect_key(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_intersect_key(): Argument #1 ($array) must be of type array, true given
+array_intersect_key(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_intersect_key(): Argument #1 ($array) must be of type array, false given
+array_intersect_key(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+array_intersect_key(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_intersect_key(): Argument #1 ($array) must be of type array, classWithToString given
+array_intersect_key(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_intersect_key(): Argument #1 ($array) must be of type array, classWithoutToString given
+array_intersect_key(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_intersect_key(): Argument #1 ($array) must be of type array, null given
+array_intersect_key(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_intersect_key(): Argument #1 ($array) must be of type array, null given
+array_intersect_key(): Argument #1 ($array) must be of type array, null given
+
+--resource var--
+array_intersect_key(): Argument #1 ($array) must be of type array, resource given
+array_intersect_key(): Argument #1 ($array) must be of type array, resource given
diff --git a/tests/std/array/array_intersect_key_variation2.phpt b/tests/std/array/array_intersect_key_variation2.phpt
new file mode 100644
index 00000000..fd3acf83
--- /dev/null
+++ b/tests/std/array/array_intersect_key_variation2.phpt
@@ -0,0 +1,199 @@
+--TEST--
+Test array_intersect_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_intersect_key() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
+    $array3 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
+    //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' => -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 var' => $fp,
+    );
+    // loop through each element of the array for array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_intersect_key($array1, $value));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_intersect_key($array1, $value, $array3));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_intersect_key() : usage variation ***
+
+--int 0--
+array_intersect_key(): Argument #2 must be of type array, int given
+array_intersect_key(): Argument #2 must be of type array, int given
+
+--int 1--
+array_intersect_key(): Argument #2 must be of type array, int given
+array_intersect_key(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_intersect_key(): Argument #2 must be of type array, int given
+array_intersect_key(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_intersect_key(): Argument #2 must be of type array, int given
+array_intersect_key(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_intersect_key(): Argument #2 must be of type array, float given
+array_intersect_key(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_intersect_key(): Argument #2 must be of type array, float given
+array_intersect_key(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_intersect_key(): Argument #2 must be of type array, float given
+array_intersect_key(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_intersect_key(): Argument #2 must be of type array, float given
+array_intersect_key(): Argument #2 must be of type array, float given
+
+--float .5--
+array_intersect_key(): Argument #2 must be of type array, float given
+array_intersect_key(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_intersect_key(): Argument #2 must be of type array, null given
+array_intersect_key(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_intersect_key(): Argument #2 must be of type array, null given
+array_intersect_key(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_intersect_key(): Argument #2 must be of type array, true given
+array_intersect_key(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_intersect_key(): Argument #2 must be of type array, false given
+array_intersect_key(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_intersect_key(): Argument #2 must be of type array, true given
+array_intersect_key(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_intersect_key(): Argument #2 must be of type array, false given
+array_intersect_key(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_intersect_key(): Argument #2 must be of type array, string given
+array_intersect_key(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_intersect_key(): Argument #2 must be of type array, string given
+array_intersect_key(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_intersect_key(): Argument #2 must be of type array, string given
+array_intersect_key(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_intersect_key(): Argument #2 must be of type array, string given
+array_intersect_key(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_intersect_key(): Argument #2 must be of type array, string given
+array_intersect_key(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_intersect_key(): Argument #2 must be of type array, string given
+array_intersect_key(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_intersect_key(): Argument #2 must be of type array, classWithToString given
+array_intersect_key(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_intersect_key(): Argument #2 must be of type array, classWithoutToString given
+array_intersect_key(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_intersect_key(): Argument #2 must be of type array, null given
+array_intersect_key(): Argument #2 must be of type array, null given
+
+--unset var--
+array_intersect_key(): Argument #2 must be of type array, null given
+array_intersect_key(): Argument #2 must be of type array, null given
+
+--resource var--
+array_intersect_key(): Argument #2 must be of type array, resource given
+array_intersect_key(): Argument #2 must be of type array, resource given
diff --git a/tests/std/array/array_intersect_key_variation4.phpt b/tests/std/array/array_intersect_key_variation4.phpt
new file mode 100644
index 00000000..50b2828f
--- /dev/null
+++ b/tests/std/array/array_intersect_key_variation4.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Test array_intersect_key() function : usage variation - Passing integer indexed array
+--FILE--
+<?php
+echo "*** Testing array_intersect_key() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$input_array = array(0 => '0', -1 => '-1' , 02 => 'two', -07 => '-07', 0xA => '0xA', -0xC => '-0xc');
+
+$input_arrays = array(
+      'decimal indexed' => array(10 => '10', '-17' => '-17'),
+      'octal indexed' => array(-011 => '-011', 012 => '012'),
+      'hexa  indexed' => array(0x12 => '0x12', -0x7 => '-0x7', ),
+);
+
+foreach($input_arrays as $key =>$value) {
+      echo "\n--$key--\n";
+      var_dump( array_intersect_key($input_array, $value) );
+      var_dump( array_intersect_key($value,$input_array ) );
+}
+?>
+--EXPECT--
+*** Testing array_intersect_key() : usage variation ***
+
+--decimal indexed--
+array(1) {
+  [10]=>
+  string(3) "0xA"
+}
+array(1) {
+  [10]=>
+  string(2) "10"
+}
+
+--octal indexed--
+array(1) {
+  [10]=>
+  string(3) "0xA"
+}
+array(1) {
+  [10]=>
+  string(3) "012"
+}
+
+--hexa  indexed--
+array(1) {
+  [-7]=>
+  string(3) "-07"
+}
+array(1) {
+  [-7]=>
+  string(4) "-0x7"
+}
diff --git a/tests/std/array/array_intersect_key_variation6.phpt b/tests/std/array/array_intersect_key_variation6.phpt
new file mode 100644
index 00000000..b0113628
--- /dev/null
+++ b/tests/std/array/array_intersect_key_variation6.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Test array_intersect_key() function : usage variation - Passing boolean indexed array
+--SKIPIF--
+--FILE--
+<?php
+echo "*** Testing array_intersect_key() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$input_array = array(0 => '0', 1 => '1' , -10 => '-10');
+$boolean_indx_array = array(true => 'boolt', false => 'boolf', TRUE => 'boolT', FALSE => 'boolF');
+
+echo "\n-- Testing array_intersect_key() function with boolean indexed array --\n";
+var_dump( array_intersect_key($input_array, $boolean_indx_array) );
+var_dump( array_intersect_key($boolean_indx_array,$input_array ) );
+?>
+--EXPECT--
+*** Testing array_intersect_key() : usage variation ***
+
+-- Testing array_intersect_key() function with boolean indexed array --
+array(2) {
+  [0]=>
+  string(1) "0"
+  [1]=>
+  string(1) "1"
+}
+array(2) {
+  [1]=>
+  string(5) "boolT"
+  [0]=>
+  string(5) "boolF"
+}
diff --git a/tests/std/array/array_intersect_key_variation7.phpt b/tests/std/array/array_intersect_key_variation7.phpt
new file mode 100644
index 00000000..06126612
--- /dev/null
+++ b/tests/std/array/array_intersect_key_variation7.phpt
@@ -0,0 +1,61 @@
+--TEST--
+Test array_intersect_key() function : usage variation - Passing null,unset and undefeined variable indexed array
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+echo "*** Testing array_intersect_key() : usage variation ***\n";
+
+// Initialise function arguments not being substituted (if any)
+$input_array = array(0 => '0', 1 => '1' , -10 => '-10' , null => 'null');
+//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";
+      var_dump( array_intersect_key($input_array, $value) );
+      var_dump( array_intersect_key($value,$input_array ) );
+}
+?>
+--EXPECT--
+*** Testing array_intersect_key() : usage variation ***
+
+--null indexed--
+array(1) {
+  [""]=>
+  string(4) "null"
+}
+array(1) {
+  [""]=>
+  string(6) "null 2"
+}
+
+--undefined indexed--
+array(1) {
+  [""]=>
+  string(4) "null"
+}
+array(1) {
+  [""]=>
+  string(9) "undefined"
+}
+
+--unset  indexed--
+array(1) {
+  [""]=>
+  string(4) "null"
+}
+array(1) {
+  [""]=>
+  string(5) "unset"
+}
diff --git a/tests/std/array/array_intersect_key_variation8.phpt b/tests/std/array/array_intersect_key_variation8.phpt
new file mode 100644
index 00000000..b16c324d
--- /dev/null
+++ b/tests/std/array/array_intersect_key_variation8.phpt
@@ -0,0 +1,57 @@
+--TEST--
+Test array_intersect_key() function : usage variation - Passing Multi dimensional array
+--FILE--
+<?php
+echo "*** Testing array_intersect_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'),
+);
+var_dump( array_intersect_key($array1, $array2) );
+var_dump( array_intersect_key($array2,$array1 ) );
+?>
+--EXPECT--
+*** Testing array_intersect_key() : usage variation ***
+array(2) {
+  ["first"]=>
+  array(2) {
+    ["blue"]=>
+    int(1)
+    ["red"]=>
+    int(2)
+  }
+  ["second"]=>
+  array(1) {
+    ["yellow"]=>
+    int(7)
+  }
+}
+array(2) {
+  ["first"]=>
+  array(2) {
+    ["blue"]=>
+    int(1)
+    ["red"]=>
+    int(2)
+  }
+  ["second"]=>
+  array(1) {
+    ["cyan"]=>
+    int(8)
+  }
+}
diff --git a/tests/std/array/array_intersect_uassoc_basic.phpt b/tests/std/array/array_intersect_uassoc_basic.phpt
new file mode 100644
index 00000000..7721772d
--- /dev/null
+++ b/tests/std/array/array_intersect_uassoc_basic.phpt
@@ -0,0 +1,28 @@
+--TEST--
+array_intersect_uassoc(): Basic test
+--FILE--
+<?php
+/*
+* array array_intersect_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_intersect_uassoc($array1, $array2, "key_compare_func");
+    var_dump($result);
+}
+?>
+--EXPECT--
+array(1) {
+  ["a"]=>
+  string(5) "green"
+}
diff --git a/tests/std/array/array_intersect_uassoc_variation1.phpt b/tests/std/array/array_intersect_uassoc_variation1.phpt
new file mode 100644
index 00000000..c5bbded7
--- /dev/null
+++ b/tests/std/array/array_intersect_uassoc_variation1.phpt
@@ -0,0 +1,207 @@
+--TEST--
+Test array_intersect_uassoc() function : usage variation - Passing unexpected values to first argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+//Callback function
+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_intersect_uassoc() : usage variation ***\n";
+    // Initialise function arguments
+    $array2 = array("a" => "green", "yellow", "red");
+    $array3 = array("a" => "green", "brown");
+    //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' => -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_intersect_uassoc($value, $array2, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_intersect_uassoc($value, $array2, $array3, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_intersect_uassoc() : usage variation ***
+
+--int 0--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, int given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, int given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, int given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, int given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, null given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, null given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, true given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, false given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, true given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, false given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, classWithToString given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, classWithoutToString given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, null given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, null given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--resource--
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, resource given
+array_intersect_uassoc(): Argument #1 ($array) must be of type array, resource given
diff --git a/tests/std/array/array_intersect_uassoc_variation10.phpt b/tests/std/array/array_intersect_uassoc_variation10.phpt
new file mode 100644
index 00000000..c18a90aa
--- /dev/null
+++ b/tests/std/array/array_intersect_uassoc_variation10.phpt
@@ -0,0 +1,48 @@
+--TEST--
+Test array_intersect_uassoc() function : usage variation - Passing class/object methods to callback
+--FILE--
+<?php
+// define some class with method
+class MyClass
+{
+    static function static_compare_func($a, $b)
+    {
+        return strcasecmp($a, $b);
+    }
+    public function class_compare_func($a, $b)
+    {
+        return strcasecmp($a, $b);
+    }
+}
+function main()
+{
+    echo "*** Testing array_intersect_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $array1 = array("a" => "green", "c" => "blue", "red");
+    $array2 = array("a" => "green", "yellow", "red");
+    echo "\n-- Testing array_intersect_uassoc() function using class with static method as callback --\n";
+    var_dump(array_intersect_uassoc($array1, $array2, array('MyClass', 'static_compare_func')));
+    var_dump(array_intersect_uassoc($array1, $array2, 'MyClass::static_compare_func'));
+    echo "\n-- Testing array_intersect_uassoc() function using class with regular method as callback --\n";
+    $obj = new MyClass();
+    var_dump(array_intersect_uassoc($array1, $array2, array($obj, 'class_compare_func')));
+}
+?>
+--EXPECT--
+*** Testing array_intersect_uassoc() : usage variation ***
+
+-- Testing array_intersect_uassoc() function using class with static method as callback --
+array(1) {
+  ["a"]=>
+  string(5) "green"
+}
+array(1) {
+  ["a"]=>
+  string(5) "green"
+}
+
+-- Testing array_intersect_uassoc() function using class with regular method as callback --
+array(1) {
+  ["a"]=>
+  string(5) "green"
+}
diff --git a/tests/std/array/array_intersect_uassoc_variation2.phpt b/tests/std/array/array_intersect_uassoc_variation2.phpt
new file mode 100644
index 00000000..b775702f
--- /dev/null
+++ b/tests/std/array/array_intersect_uassoc_variation2.phpt
@@ -0,0 +1,207 @@
+--TEST--
+Test array_intersect_uassoc() function : usage variation - Passing unexpected values to second argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+//Callback function
+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_intersect_uassoc() : usage variation ***\n";
+    // Initialise function arguments
+    $array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
+    $array3 = array("a" => "green", "brown");
+    //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' => -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_intersect_uassoc($array1, $value, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_intersect_uassoc($array1, $value, $array3, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_intersect_uassoc() : usage variation ***
+
+--int 0--
+array_intersect_uassoc(): Argument #2 must be of type array, int given
+array_intersect_uassoc(): Argument #2 must be of type array, int given
+
+--int 1--
+array_intersect_uassoc(): Argument #2 must be of type array, int given
+array_intersect_uassoc(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_intersect_uassoc(): Argument #2 must be of type array, int given
+array_intersect_uassoc(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_intersect_uassoc(): Argument #2 must be of type array, int given
+array_intersect_uassoc(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+
+--float .5--
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+array_intersect_uassoc(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_intersect_uassoc(): Argument #2 must be of type array, null given
+array_intersect_uassoc(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_intersect_uassoc(): Argument #2 must be of type array, null given
+array_intersect_uassoc(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_intersect_uassoc(): Argument #2 must be of type array, true given
+array_intersect_uassoc(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_intersect_uassoc(): Argument #2 must be of type array, false given
+array_intersect_uassoc(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_intersect_uassoc(): Argument #2 must be of type array, true given
+array_intersect_uassoc(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_intersect_uassoc(): Argument #2 must be of type array, false given
+array_intersect_uassoc(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+array_intersect_uassoc(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_intersect_uassoc(): Argument #2 must be of type array, classWithToString given
+array_intersect_uassoc(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_intersect_uassoc(): Argument #2 must be of type array, classWithoutToString given
+array_intersect_uassoc(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_intersect_uassoc(): Argument #2 must be of type array, null given
+array_intersect_uassoc(): Argument #2 must be of type array, null given
+
+--unset var--
+array_intersect_uassoc(): Argument #2 must be of type array, null given
+array_intersect_uassoc(): Argument #2 must be of type array, null given
+
+--resource--
+array_intersect_uassoc(): Argument #2 must be of type array, resource given
+array_intersect_uassoc(): Argument #2 must be of type array, resource given
diff --git a/tests/std/array/array_intersect_uassoc_variation5.phpt b/tests/std/array/array_intersect_uassoc_variation5.phpt
new file mode 100644
index 00000000..9ed4fd68
--- /dev/null
+++ b/tests/std/array/array_intersect_uassoc_variation5.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Test array_intersect_uassoc() function : usage variation - Intersection of integers with floats and strings.
+--FILE--
+<?php
+function key_compare_func($a, $b)
+{
+    if ($a === $b) {
+        return 0;
+    }
+    return $a > $b ? 1 : -1;
+}
+function main()
+{
+    echo "*** Testing array_intersect_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $arr_default_int = array(1, 2);
+    $arr_float = array(0 => 1.0, 1 => 2.0, 2 => 3.0);
+    $arr_string = array('1', '2', '3');
+    $arr_string_float = array('1.00', '2.00');
+    echo "\n-- Result of integers and floating point intersection --\n";
+    var_dump(array_intersect_uassoc($arr_default_int, $arr_float, "key_compare_func"));
+    echo "\n-- Result of integers and strings containing integers intersection --\n";
+    var_dump(array_intersect_uassoc($arr_default_int, $arr_string, "key_compare_func"));
+    echo "\n-- Result of integers and strings containing floating points intersection --\n";
+    var_dump(array_intersect_uassoc($arr_default_int, $arr_string_float, "key_compare_func"));
+}
+?>
+--EXPECT--
+*** Testing array_intersect_uassoc() : usage variation ***
+
+-- Result of integers and floating point intersection --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+-- Result of integers and strings containing integers intersection --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+-- Result of integers and strings containing floating points intersection --
+array(0) {
+}
diff --git a/tests/std/array/array_intersect_uassoc_variation6.phpt b/tests/std/array/array_intersect_uassoc_variation6.phpt
new file mode 100644
index 00000000..77ef7bdc
--- /dev/null
+++ b/tests/std/array/array_intersect_uassoc_variation6.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Test array_intersect_uassoc() function : usage variation - Intersection of floating points with strings.
+--FILE--
+<?php
+function key_compare_func($a, $b)
+{
+    if ($a === $b) {
+        return 0;
+    }
+    return $a > $b ? 1 : -1;
+}
+function main()
+{
+    echo "*** Testing array_intersect_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $arr_float = array(0 => 1.0, 1 => 2.0);
+    $arr_string = array('1', '2', '3');
+    $arr_string_float = array('1.00', '2.00');
+    echo "\n-- Result of floating points and strings containing integers intersection --\n";
+    var_dump(array_intersect_uassoc($arr_float, $arr_string, "key_compare_func"));
+    echo "\n-- Result of floating points and strings containing floating point intersection --\n";
+    var_dump(array_intersect_uassoc($arr_float, $arr_string_float, "key_compare_func"));
+}
+?>
+--EXPECT--
+*** Testing array_intersect_uassoc() : usage variation ***
+
+-- Result of floating points and strings containing integers intersection --
+array(2) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(2)
+}
+
+-- Result of floating points and strings containing floating point intersection --
+array(0) {
+}
diff --git a/tests/std/array/array_intersect_uassoc_variation7.phpt b/tests/std/array/array_intersect_uassoc_variation7.phpt
new file mode 100644
index 00000000..0fc689e2
--- /dev/null
+++ b/tests/std/array/array_intersect_uassoc_variation7.phpt
@@ -0,0 +1,45 @@
+--TEST--
+Test array_intersect_uassoc() function : usage variation - Intersection of strings containing integers, float
+--FILE--
+<?php
+function key_compare_func($a, $b)
+{
+    if ($a === $b) {
+        return 0;
+    }
+    return $a > $b ? 1 : -1;
+}
+function main()
+{
+    echo "*** Testing array_intersect_uassoc() : usage variation ***\n";
+    //Initialize variables
+    $arr1_string_int = array('1', '2');
+    $arr2_string_int = array('1', '3');
+    $arr1_string_float = array('1.00', '2.00');
+    $arr2_string_float = array('1.00', '3.00');
+    echo "\n-- Result of strings containing integers intersection --\n";
+    var_dump(array_intersect_uassoc($arr1_string_int, $arr2_string_int, "key_compare_func"));
+    echo "\n-- Result of strings containing floating points intersection --\n";
+    var_dump(array_intersect_uassoc($arr1_string_float, $arr2_string_float, "key_compare_func"));
+    echo "\n-- Result of strings containing integers and strings containing floating points intersection --\n";
+    var_dump(array_intersect_uassoc($arr1_string_int, $arr2_string_float, "key_compare_func"));
+}
+?>
+--EXPECT--
+*** Testing array_intersect_uassoc() : usage variation ***
+
+-- Result of strings containing integers intersection --
+array(1) {
+  [0]=>
+  string(1) "1"
+}
+
+-- Result of strings containing floating points intersection --
+array(1) {
+  [0]=>
+  string(4) "1.00"
+}
+
+-- Result of strings containing integers and strings containing floating points intersection --
+array(0) {
+}
diff --git a/tests/std/array/array_intersect_uassoc_variation8.phpt b/tests/std/array/array_intersect_uassoc_variation8.phpt
new file mode 100644
index 00000000..fd94f4bc
--- /dev/null
+++ b/tests/std/array/array_intersect_uassoc_variation8.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Test array_intersect_uassoc() function : usage variation - arrays containing referenced variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support cross-type variable reassignment");
+?>
+
+--FILE--
+<?php
+echo "*** Testing array_intersect_uassoc() : usage variation ***\n";
+
+//Initialize variables
+$ref_var = 'a';
+$array1 = array('a', $ref_var);
+$array2 = array('a' => 1, &$ref_var);
+
+echo "\n-- Testing array_intersect_uassoc() function with referenced variable \$ref_var has value '$ref_var' --\n";
+var_dump( array_intersect_uassoc($array1, $array2, "strcasecmp") );
+
+// re-assign reference variable to different value
+$ref_var = 10;
+echo "\n-- Testing array_intersect_uassoc() function with referenced variable \$ref_var value changed to $ref_var --\n";
+var_dump( array_intersect_uassoc($array1, $array2, "strcasecmp") );
+
+//When array are referenced
+$array2 = &$array1;
+echo "\n-- Testing array_intersect_uassoc() function when \$array2 is referencd to \$array1 --\n";
+var_dump( array_intersect_uassoc($array1, $array2, "strcasecmp") );
+?>
+--EXPECT--
+*** Testing array_intersect_uassoc() : usage variation ***
+
+-- Testing array_intersect_uassoc() function with referenced variable $ref_var has value 'a' --
+array(1) {
+  [0]=>
+  string(1) "a"
+}
+
+-- Testing array_intersect_uassoc() function with referenced variable $ref_var value changed to 10 --
+array(0) {
+}
+
+-- Testing array_intersect_uassoc() function when $array2 is referencd to $array1 --
+array(2) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "a"
+}
diff --git a/tests/std/array/array_intersect_ukey_basic.phpt b/tests/std/array/array_intersect_ukey_basic.phpt
new file mode 100644
index 00000000..e16f110f
--- /dev/null
+++ b/tests/std/array/array_intersect_ukey_basic.phpt
@@ -0,0 +1,31 @@
+--TEST--
+array_intersect_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_intersect_ukey($array1, $array2, 'key_compare_func'));
+}
+?>
+--EXPECT--
+array(2) {
+  ["blue"]=>
+  int(1)
+  ["green"]=>
+  int(3)
+}
diff --git a/tests/std/array/array_intersect_ukey_variation1.phpt b/tests/std/array/array_intersect_ukey_variation1.phpt
new file mode 100644
index 00000000..28b89895
--- /dev/null
+++ b/tests/std/array/array_intersect_ukey_variation1.phpt
@@ -0,0 +1,205 @@
+--TEST--
+Test array_intersect_ukey() function : usage variation - Passing unexpected values to first argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+//Call back function
+function key_compare_func($key1, $key2)
+{
+    if ($key1 == $key2) {
+        return 0;
+    } else {
+        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_intersect_ukey() : usage variation ***\n";
+    //Initialise arguments
+    $array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
+    $array3 = array('green' => 5, 'cyan' => 8);
+    //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 var' => $fp,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_intersect_ukey($value, $array2, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_intersect_ukey($value, $array2, $array3, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_intersect_ukey() : usage variation ***
+
+--int 0--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, int given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, int given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, int given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, int given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, null given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, null given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, true given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, false given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, true given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, false given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, classWithToString given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, classWithoutToString given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, null given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, null given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, null given
+
+--resource var--
+array_intersect_ukey(): Argument #1 ($array) must be of type array, resource given
+array_intersect_ukey(): Argument #1 ($array) must be of type array, resource given
diff --git a/tests/std/array/array_intersect_ukey_variation2.phpt b/tests/std/array/array_intersect_ukey_variation2.phpt
new file mode 100644
index 00000000..43f411af
--- /dev/null
+++ b/tests/std/array/array_intersect_ukey_variation2.phpt
@@ -0,0 +1,205 @@
+--TEST--
+Test array_intersect_ukey() function : usage variation - Passing unexpected values to second argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+//Call back function
+function key_compare_func($key1, $key2)
+{
+    if ($key1 == $key2) {
+        return 0;
+    } else {
+        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_intersect_ukey() : usage variation ***\n";
+    //Initialise arguments
+    $array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
+    $array3 = array('green' => 5, 'cyan' => 8);
+    //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 var' => $fp,
+    );
+    // loop through each element of the array for array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_intersect_ukey($array1, $value, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            var_dump(array_intersect_ukey($array1, $value, $array3, 'key_compare_func'));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+}
+?>
+--EXPECT--
+*** Testing array_intersect_ukey() : usage variation ***
+
+--int 0--
+array_intersect_ukey(): Argument #2 must be of type array, int given
+array_intersect_ukey(): Argument #2 must be of type array, int given
+
+--int 1--
+array_intersect_ukey(): Argument #2 must be of type array, int given
+array_intersect_ukey(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_intersect_ukey(): Argument #2 must be of type array, int given
+array_intersect_ukey(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_intersect_ukey(): Argument #2 must be of type array, int given
+array_intersect_ukey(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_intersect_ukey(): Argument #2 must be of type array, float given
+array_intersect_ukey(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_intersect_ukey(): Argument #2 must be of type array, float given
+array_intersect_ukey(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_intersect_ukey(): Argument #2 must be of type array, float given
+array_intersect_ukey(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_intersect_ukey(): Argument #2 must be of type array, float given
+array_intersect_ukey(): Argument #2 must be of type array, float given
+
+--float .5--
+array_intersect_ukey(): Argument #2 must be of type array, float given
+array_intersect_ukey(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_intersect_ukey(): Argument #2 must be of type array, null given
+array_intersect_ukey(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_intersect_ukey(): Argument #2 must be of type array, null given
+array_intersect_ukey(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_intersect_ukey(): Argument #2 must be of type array, true given
+array_intersect_ukey(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_intersect_ukey(): Argument #2 must be of type array, false given
+array_intersect_ukey(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_intersect_ukey(): Argument #2 must be of type array, true given
+array_intersect_ukey(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_intersect_ukey(): Argument #2 must be of type array, false given
+array_intersect_ukey(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_intersect_ukey(): Argument #2 must be of type array, string given
+array_intersect_ukey(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_intersect_ukey(): Argument #2 must be of type array, string given
+array_intersect_ukey(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_intersect_ukey(): Argument #2 must be of type array, string given
+array_intersect_ukey(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_intersect_ukey(): Argument #2 must be of type array, string given
+array_intersect_ukey(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_intersect_ukey(): Argument #2 must be of type array, string given
+array_intersect_ukey(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_intersect_ukey(): Argument #2 must be of type array, string given
+array_intersect_ukey(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_intersect_ukey(): Argument #2 must be of type array, classWithToString given
+array_intersect_ukey(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_intersect_ukey(): Argument #2 must be of type array, classWithoutToString given
+array_intersect_ukey(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_intersect_ukey(): Argument #2 must be of type array, null given
+array_intersect_ukey(): Argument #2 must be of type array, null given
+
+--unset var--
+array_intersect_ukey(): Argument #2 must be of type array, null given
+array_intersect_ukey(): Argument #2 must be of type array, null given
+
+--resource var--
+array_intersect_ukey(): Argument #2 must be of type array, resource given
+array_intersect_ukey(): Argument #2 must be of type array, resource given
diff --git a/tests/std/array/array_intersect_ukey_variation5.phpt b/tests/std/array/array_intersect_ukey_variation5.phpt
new file mode 100644
index 00000000..b870b52b
--- /dev/null
+++ b/tests/std/array/array_intersect_ukey_variation5.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_intersect_ukey() function : usage variation - Intersection of integers with floats and strings.
+--FILE--
+<?php
+//Call back function
+function key_compare_func($key1, $key2)
+{
+    if ($key1 == $key2) {
+        return 0;
+    } else {
+        return $key1 > $key2 ? 1 : -1;
+    }
+}
+function main()
+{
+    echo "*** Testing array_intersect_ukey() : usage variation ***\n";
+    //Initialize variables
+    $arr_default_int = array(1, 2);
+    $arr_float = array(0 => 1.0, 1 => 2.0, 2 => 3.0);
+    $arr_string = array('0' => '1', '1' => '2', '2' => '3');
+    $arr_string_float = array('0.00' => '1.00', '1.00' => '2.00');
+    echo "\n-- Result of integers and floating point intersection --\n";
+    var_dump(array_intersect_ukey($arr_default_int, $arr_float, "key_compare_func"));
+    echo "\n-- Result of integers and strings containing integers intersection --\n";
+    var_dump(array_intersect_ukey($arr_default_int, $arr_string, "key_compare_func"));
+    echo "\n-- Result of integers and strings containing floating points intersection --\n";
+    var_dump(array_intersect_ukey($arr_default_int, $arr_string_float, "key_compare_func"));
+}
+?>
+--EXPECT--
+*** Testing array_intersect_ukey() : usage variation ***
+
+-- Result of integers and floating point intersection --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+-- Result of integers and strings containing integers intersection --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+-- Result of integers and strings containing floating points intersection --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
diff --git a/tests/std/array/array_intersect_ukey_variation6.phpt b/tests/std/array/array_intersect_ukey_variation6.phpt
new file mode 100644
index 00000000..b7da0c29
--- /dev/null
+++ b/tests/std/array/array_intersect_ukey_variation6.phpt
@@ -0,0 +1,44 @@
+--TEST--
+Test array_intersect_ukey() function : usage variation - Intersection of floating points with strings.
+--FILE--
+<?php
+//Call back function
+function key_compare_func($key1, $key2)
+{
+    if ($key1 == $key2) {
+        return 0;
+    } else {
+        return $key1 > $key2 ? 1 : -1;
+    }
+}
+function main()
+{
+    echo "*** Testing array_intersect_ukey() : usage variation ***\n";
+    //Initialize variables
+    $arr_float = array(0 => 1.0, 1 => 2.0);
+    $arr_string = array('0' => '1', '1' => '2', '2' => '3');
+    $arr_string_float = array('0.00' => '1.00', '1.00' => '2.00');
+    echo "\n-- Result of floating points and strings containing integers intersection --\n";
+    var_dump(array_intersect_ukey($arr_float, $arr_string, 'key_compare_func'));
+    echo "\n-- Result of floating points and strings containing floating point intersection --\n";
+    var_dump(array_intersect_ukey($arr_float, $arr_string_float, 'key_compare_func'));
+}
+?>
+--EXPECT--
+*** Testing array_intersect_ukey() : usage variation ***
+
+-- Result of floating points and strings containing integers intersection --
+array(2) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(2)
+}
+
+-- Result of floating points and strings containing floating point intersection --
+array(2) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(2)
+}
diff --git a/tests/std/array/array_intersect_ukey_variation7.phpt b/tests/std/array/array_intersect_ukey_variation7.phpt
new file mode 100644
index 00000000..832053f5
--- /dev/null
+++ b/tests/std/array/array_intersect_ukey_variation7.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_intersect_ukey() function : usage variation - Intersection of strings containing integer and float
+--FILE--
+<?php
+//Call back function
+function key_compare_func($key1, $key2)
+{
+    if ($key1 == $key2) {
+        return 0;
+    } else {
+        return $key1 > $key2 ? 1 : -1;
+    }
+}
+function main()
+{
+    echo "*** Testing array_intersect_ukey() : usage variation ***\n";
+    //Initialize variables
+    $arr1_string_int = array('0' => '1', '1' => '2');
+    $arr2_string_int = array('0' => '1', '1' => '3');
+    $arr1_string_float = array('0.00' => '1.00', '1.00' => '2.00');
+    $arr2_string_float = array('0.00' => '1.00', '1.00' => '3.00');
+    echo "\n-- Result of strings containing integers intersection --\n";
+    var_dump(array_intersect_ukey($arr1_string_int, $arr2_string_int, 'key_compare_func'));
+    echo "\n-- Result of strings containing floating points intersection --\n";
+    var_dump(array_intersect_ukey($arr1_string_float, $arr2_string_float, 'key_compare_func'));
+    echo "\n-- Result of strings containing integers and strings containing floating points intersection --\n";
+    var_dump(array_intersect_ukey($arr1_string_int, $arr2_string_float, 'key_compare_func'));
+}
+?>
+--EXPECT--
+*** Testing array_intersect_ukey() : usage variation ***
+
+-- Result of strings containing integers intersection --
+array(2) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  string(1) "2"
+}
+
+-- Result of strings containing floating points intersection --
+array(2) {
+  ["0.00"]=>
+  string(4) "1.00"
+  ["1.00"]=>
+  string(4) "2.00"
+}
+
+-- Result of strings containing integers and strings containing floating points intersection --
+array(2) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  string(1) "2"
+}
diff --git a/tests/std/array/array_intersect_ukey_variation8.phpt b/tests/std/array/array_intersect_ukey_variation8.phpt
new file mode 100644
index 00000000..71126a1e
--- /dev/null
+++ b/tests/std/array/array_intersect_ukey_variation8.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test array_intersect_ukey() function : usage variation - Passing non-existing function name to callback
+--FILE--
+<?php
+echo "*** Testing array_intersect_ukey() : usage variation ***\n";
+
+//Initialise arguments
+$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
+$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);
+
+//function name within double quotes
+try {
+    var_dump( array_intersect_ukey($array1, $array2, "unknown_function") );
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+//function name within single quotes
+try {
+    var_dump( array_intersect_ukey($array1, $array2, 'unknown_function') );
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+*** Testing array_intersect_ukey() : usage variation ***
+array_intersect_ukey(): Argument #3 must be a valid callback, function "unknown_function" not found or invalid function name
+array_intersect_ukey(): Argument #3 must be a valid callback, function "unknown_function" not found or invalid function name
diff --git a/tests/std/array/array_intersect_ukey_variation9.phpt b/tests/std/array/array_intersect_ukey_variation9.phpt
new file mode 100644
index 00000000..1eb5d750
--- /dev/null
+++ b/tests/std/array/array_intersect_ukey_variation9.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Test array_intersect_ukey() function : usage variation - Passing class/object methods to callback
+--FILE--
+<?php
+class MyClass
+{
+    static function static_compare_func($key1, $key2)
+    {
+        return strcasecmp($key1, $key2);
+    }
+    public function class_compare_func($key1, $key2)
+    {
+        return strcasecmp($key1, $key2);
+    }
+}
+function main()
+{
+    echo "*** Testing array_intersect_ukey() : usage variation ***\n";
+    //Initialise arguments
+    $array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
+    $array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
+    echo "\n-- Testing array_intersect_ukey() function using class with static method as callback --\n";
+    var_dump(array_intersect_ukey($array1, $array2, array('MyClass', 'static_compare_func')));
+    var_dump(array_intersect_ukey($array1, $array2, 'MyClass::static_compare_func'));
+    echo "\n-- Testing array_intersect_uassoc() function using class with regular method as callback --\n";
+    $obj = new MyClass();
+    var_dump(array_intersect_ukey($array1, $array2, array($obj, 'class_compare_func')));
+}
+?>
+--EXPECT--
+*** Testing array_intersect_ukey() : usage variation ***
+
+-- Testing array_intersect_ukey() function using class with static method as callback --
+array(2) {
+  ["blue"]=>
+  int(1)
+  ["green"]=>
+  int(3)
+}
+array(2) {
+  ["blue"]=>
+  int(1)
+  ["green"]=>
+  int(3)
+}
+
+-- Testing array_intersect_uassoc() function using class with regular method as callback --
+array(2) {
+  ["blue"]=>
+  int(1)
+  ["green"]=>
+  int(3)
+}
diff --git a/tests/std/array/array_intersect_variation1.phpt b/tests/std/array/array_intersect_variation1.phpt
new file mode 100644
index 00000000..22a31a3e
--- /dev/null
+++ b/tests/std/array/array_intersect_variation1.phpt
@@ -0,0 +1,182 @@
+--TEST--
+Test array_intersect() 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()
+{
+    /*
+    * Testing array_intersect() function by passing values to $array1 argument other than arrays
+    * and see that function emits proper warning messages wherever expected.
+    * The $array2 argument is a fixed array.
+    */
+    echo "*** Testing array_intersect() : Passing non-array values to \$array1 argument ***\n";
+    // array to be passsed to $array2 as default argument
+    $array2 = array(1, 2);
+    // array to be passed to optional argument
+    $arr3 = array(1, 2, "one" => 1, "two" => 2);
+    // 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");
+    // unexpected values to be passed to $array1 argument
+    $arrays = 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,
+        // object data
+        /*21*/
+        new classA(),
+        // undefined data
+        /*22*/
+        @$undefined_var,
+        // unset data
+        /*23*/
+        @$unset_var,
+        // resource variable
+        /*24*/
+        $fp,
+    );
+    // loop through each sub-array within $arrays to check the behavior of array_intersect()
+    $iterator = 1;
+    foreach ($arrays as $unexpected_value) {
+        echo "\n-- Iterator {$iterator} --";
+        // Calling array_intersect() with default arguments
+        try {
+            var_dump(array_intersect($unexpected_value, $array2));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        // Calling array_intersect() with more arguments
+        try {
+            var_dump(array_intersect($unexpected_value, $array2, $arr3));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_intersect() : Passing non-array values to $array1 argument ***
+
+-- Iterator 1 --array_intersect(): Argument #1 ($array) must be of type array, int given
+array_intersect(): Argument #1 ($array) must be of type array, int given
+
+-- Iterator 2 --array_intersect(): Argument #1 ($array) must be of type array, int given
+array_intersect(): Argument #1 ($array) must be of type array, int given
+
+-- Iterator 3 --array_intersect(): Argument #1 ($array) must be of type array, int given
+array_intersect(): Argument #1 ($array) must be of type array, int given
+
+-- Iterator 4 --array_intersect(): Argument #1 ($array) must be of type array, int given
+array_intersect(): Argument #1 ($array) must be of type array, int given
+
+-- Iterator 5 --array_intersect(): Argument #1 ($array) must be of type array, float given
+array_intersect(): Argument #1 ($array) must be of type array, float given
+
+-- Iterator 6 --array_intersect(): Argument #1 ($array) must be of type array, float given
+array_intersect(): Argument #1 ($array) must be of type array, float given
+
+-- Iterator 7 --array_intersect(): Argument #1 ($array) must be of type array, float given
+array_intersect(): Argument #1 ($array) must be of type array, float given
+
+-- Iterator 8 --array_intersect(): Argument #1 ($array) must be of type array, float given
+array_intersect(): Argument #1 ($array) must be of type array, float given
+
+-- Iterator 9 --array_intersect(): Argument #1 ($array) must be of type array, float given
+array_intersect(): Argument #1 ($array) must be of type array, float given
+
+-- Iterator 10 --array_intersect(): Argument #1 ($array) must be of type array, null given
+array_intersect(): Argument #1 ($array) must be of type array, null given
+
+-- Iterator 11 --array_intersect(): Argument #1 ($array) must be of type array, null given
+array_intersect(): Argument #1 ($array) must be of type array, null given
+
+-- Iterator 12 --array_intersect(): Argument #1 ($array) must be of type array, true given
+array_intersect(): Argument #1 ($array) must be of type array, true given
+
+-- Iterator 13 --array_intersect(): Argument #1 ($array) must be of type array, false given
+array_intersect(): Argument #1 ($array) must be of type array, false given
+
+-- Iterator 14 --array_intersect(): Argument #1 ($array) must be of type array, true given
+array_intersect(): Argument #1 ($array) must be of type array, true given
+
+-- Iterator 15 --array_intersect(): Argument #1 ($array) must be of type array, false given
+array_intersect(): Argument #1 ($array) must be of type array, false given
+
+-- Iterator 16 --array_intersect(): Argument #1 ($array) must be of type array, string given
+array_intersect(): Argument #1 ($array) must be of type array, string given
+
+-- Iterator 17 --array_intersect(): Argument #1 ($array) must be of type array, string given
+array_intersect(): Argument #1 ($array) must be of type array, string given
+
+-- Iterator 18 --array_intersect(): Argument #1 ($array) must be of type array, string given
+array_intersect(): Argument #1 ($array) must be of type array, string given
+
+-- Iterator 19 --array_intersect(): Argument #1 ($array) must be of type array, string given
+array_intersect(): Argument #1 ($array) must be of type array, string given
+
+-- Iterator 20 --array_intersect(): Argument #1 ($array) must be of type array, string given
+array_intersect(): Argument #1 ($array) must be of type array, string given
+
+-- Iterator 21 --array_intersect(): Argument #1 ($array) must be of type array, classA given
+array_intersect(): Argument #1 ($array) must be of type array, classA given
+
+-- Iterator 22 --array_intersect(): Argument #1 ($array) must be of type array, null given
+array_intersect(): Argument #1 ($array) must be of type array, null given
+
+-- Iterator 23 --array_intersect(): Argument #1 ($array) must be of type array, null given
+array_intersect(): Argument #1 ($array) must be of type array, null given
+
+-- Iterator 24 --array_intersect(): Argument #1 ($array) must be of type array, resource given
+array_intersect(): Argument #1 ($array) must be of type array, resource given
+Done
diff --git a/tests/std/array/array_intersect_variation10.phpt b/tests/std/array/array_intersect_variation10.phpt
new file mode 100644
index 00000000..e8ade132
--- /dev/null
+++ b/tests/std/array/array_intersect_variation10.phpt
@@ -0,0 +1,48 @@
+--TEST--
+Test array_intersect() function : usage variations - binary safe checking
+--FILE--
+<?php
+/*
+* Testing the behavior of array_intersect() by passing array with
+* binary values for $arr1 and $arr2 argument.
+*/
+
+echo "*** Testing array_intersect() : binary safe checking ***\n";
+
+// array with binary values
+$arr_binary = array(b"hello", b"world");
+// simple array
+$arr_normal = array("hello", "world");
+
+// array with binary value for $arr1 argument
+var_dump( array_intersect($arr_binary, $arr_normal) );
+
+// array with binary value for $arr2 argument
+var_dump( array_intersect($arr_normal, $arr_binary) );
+
+// array with binary value for both $arr1 and $arr2 argument
+var_dump( array_intersect($arr_binary, $arr_binary) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect() : binary safe checking ***
+array(2) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+}
+array(2) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+}
+array(2) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+}
+Done
diff --git a/tests/std/array/array_intersect_variation2.phpt b/tests/std/array/array_intersect_variation2.phpt
new file mode 100644
index 00000000..613e6a28
--- /dev/null
+++ b/tests/std/array/array_intersect_variation2.phpt
@@ -0,0 +1,182 @@
+--TEST--
+Test array_intersect() function : usage variations - unexpected values for 'array2' 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()
+{
+    /*
+    * Testing array_intersect() function by passing values to $array2 argument other than arrays
+    * and see that function emits proper warning messages wherever expected.
+    * The $array1 argument is a fixed array.
+    */
+    echo "*** Testing array_intersect() : Passing non-array values to \$array2 argument ***\n";
+    // array to be passsed to $array1 as default argument
+    $array1 = array(1, 2);
+    // arrays to be passed to optional argument
+    $arr3 = array(1, 2, "one" => 1, "two" => 2);
+    // 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");
+    // unexpected values to be passed to $array2 argument
+    $arrays = 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,
+        // object data
+        /*21*/
+        new classA(),
+        // undefined data
+        /*22*/
+        @$undefined_var,
+        // unset data
+        /*23*/
+        @$unset_var,
+        // resource variable
+        /*24*/
+        $fp,
+    );
+    // loop through each sub-array within $arrays to check the behavior of array_intersect()
+    $iterator = 1;
+    foreach ($arrays as $unexpected_value) {
+        echo "\n-- Iterator {$iterator} --";
+        // Calling array_intersect() with default arguments
+        try {
+            var_dump(array_intersect($array1, $unexpected_value));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        // Calling array_intersect() with more arguments
+        try {
+            var_dump(array_intersect($array1, $unexpected_value, $arr3));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_intersect() : Passing non-array values to $array2 argument ***
+
+-- Iterator 1 --array_intersect(): Argument #2 must be of type array, int given
+array_intersect(): Argument #2 must be of type array, int given
+
+-- Iterator 2 --array_intersect(): Argument #2 must be of type array, int given
+array_intersect(): Argument #2 must be of type array, int given
+
+-- Iterator 3 --array_intersect(): Argument #2 must be of type array, int given
+array_intersect(): Argument #2 must be of type array, int given
+
+-- Iterator 4 --array_intersect(): Argument #2 must be of type array, int given
+array_intersect(): Argument #2 must be of type array, int given
+
+-- Iterator 5 --array_intersect(): Argument #2 must be of type array, float given
+array_intersect(): Argument #2 must be of type array, float given
+
+-- Iterator 6 --array_intersect(): Argument #2 must be of type array, float given
+array_intersect(): Argument #2 must be of type array, float given
+
+-- Iterator 7 --array_intersect(): Argument #2 must be of type array, float given
+array_intersect(): Argument #2 must be of type array, float given
+
+-- Iterator 8 --array_intersect(): Argument #2 must be of type array, float given
+array_intersect(): Argument #2 must be of type array, float given
+
+-- Iterator 9 --array_intersect(): Argument #2 must be of type array, float given
+array_intersect(): Argument #2 must be of type array, float given
+
+-- Iterator 10 --array_intersect(): Argument #2 must be of type array, null given
+array_intersect(): Argument #2 must be of type array, null given
+
+-- Iterator 11 --array_intersect(): Argument #2 must be of type array, null given
+array_intersect(): Argument #2 must be of type array, null given
+
+-- Iterator 12 --array_intersect(): Argument #2 must be of type array, true given
+array_intersect(): Argument #2 must be of type array, true given
+
+-- Iterator 13 --array_intersect(): Argument #2 must be of type array, false given
+array_intersect(): Argument #2 must be of type array, false given
+
+-- Iterator 14 --array_intersect(): Argument #2 must be of type array, true given
+array_intersect(): Argument #2 must be of type array, true given
+
+-- Iterator 15 --array_intersect(): Argument #2 must be of type array, false given
+array_intersect(): Argument #2 must be of type array, false given
+
+-- Iterator 16 --array_intersect(): Argument #2 must be of type array, string given
+array_intersect(): Argument #2 must be of type array, string given
+
+-- Iterator 17 --array_intersect(): Argument #2 must be of type array, string given
+array_intersect(): Argument #2 must be of type array, string given
+
+-- Iterator 18 --array_intersect(): Argument #2 must be of type array, string given
+array_intersect(): Argument #2 must be of type array, string given
+
+-- Iterator 19 --array_intersect(): Argument #2 must be of type array, string given
+array_intersect(): Argument #2 must be of type array, string given
+
+-- Iterator 20 --array_intersect(): Argument #2 must be of type array, string given
+array_intersect(): Argument #2 must be of type array, string given
+
+-- Iterator 21 --array_intersect(): Argument #2 must be of type array, classA given
+array_intersect(): Argument #2 must be of type array, classA given
+
+-- Iterator 22 --array_intersect(): Argument #2 must be of type array, null given
+array_intersect(): Argument #2 must be of type array, null given
+
+-- Iterator 23 --array_intersect(): Argument #2 must be of type array, null given
+array_intersect(): Argument #2 must be of type array, null given
+
+-- Iterator 24 --array_intersect(): Argument #2 must be of type array, resource given
+array_intersect(): Argument #2 must be of type array, resource given
+Done
diff --git a/tests/std/array/array_intersect_variation3.phpt b/tests/std/array/array_intersect_variation3.phpt
new file mode 100644
index 00000000..05fcf78d
--- /dev/null
+++ b/tests/std/array/array_intersect_variation3.phpt
@@ -0,0 +1,340 @@
+--TEST--
+Test array_intersect() function : usage variations - different arrays for 'arr1' argument
+--SKIPIF--
+<?php die("skip AOT array_intersect differs from PHP"); ?>
+--FILE--
+<?php
+ini_set("serialize_precision", "14");
+/*
+* Passing different types of arrays to $arr1 argument and testing whether
+* array_intersect() behaves in expected way with the other arguments passed to the function
+* The $arr2 argument is a fixed array.
+*/
+
+echo "*** Testing array_intersect() : Passing different types of arrays to \$arr1 argument ***\n";
+
+/* Different heredoc strings passed as argument to $arr1 */
+// heredoc with blank line
+$blank_line = <<<EOT
+
+
+EOT;
+
+// heredoc with multiline string
+$multiline_string = <<<EOT
+hello world
+The big 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 to be passed to $arr1 argument
+$arrays = array (
+/*1*/  array(1, 2), // array with default keys and numeric values
+       array(1.1, 2.2), // array with default keys & float values
+       array(false,true), // array with default keys and boolean values
+       array(), // empty array
+/*5*/  array(NULL), // array with NULL
+       array("a\v\f","aaaa\r","b","b\tbbb","c","\[\]\!\@\#\$\%\^\&\*\(\)\{\}"),  // array with double quoted strings
+       array('a\v\f','aaaa\r','b','b\tbbb','c','\[\]\!\@\#\$\%\^\&\*\(\)\{\}'),  // array with single quoted strings
+       array($blank_line, $multiline_string, $diff_whitespaces, $numeric_string),  // array 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)
+);
+
+
+// array to be passsed to $arr2 argument
+$arr2 = array (
+  1, 1.1, "hello", "one", NULL, 2,
+  'world', true, false, false => 5, 'aaaa\r', "aaaa\r",
+  $numeric_string,  $diff_whitespaces,
+  "one" => "ten", 4 => "four", "two" => 2, 2 => "two",
+  '', null => "null", '' => 'emptys'
+);
+
+// loop through each sub-array within $arrays to check the behavior of array_intersect()
+$iterator = 1;
+foreach($arrays as $arr1) {
+  echo "-- Iterator $iterator --\n";
+
+  // Calling array_intersect() with default arguments
+  var_dump( array_intersect($arr1, $arr2) );
+
+  // Calling array_intersect() with more arguments.
+  // additional argument passed is the same as $arr1 argument
+  var_dump( array_intersect($arr1, $arr2, $arr1) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect() : Passing different types of arrays to $arr1 argument ***
+-- Iterator 1 --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+-- Iterator 2 --
+array(1) {
+  [0]=>
+  float(1.1)
+}
+array(1) {
+  [0]=>
+  float(1.1)
+}
+-- Iterator 3 --
+array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+-- Iterator 4 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 5 --
+array(1) {
+  [0]=>
+  NULL
+}
+array(1) {
+  [0]=>
+  NULL
+}
+-- Iterator 6 --
+array(1) {
+  [1]=>
+  string(5) "aaaa
"
+}
+array(1) {
+  [1]=>
+  string(5) "aaaa
"
+}
+-- Iterator 7 --
+array(1) {
+  [1]=>
+  string(6) "aaaa\r"
+}
+array(1) {
+  [1]=>
+  string(6) "aaaa\r"
+}
+-- Iterator 8 --
+array(2) {
+  [2]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+  [3]=>
+  string(90) "11 < 12. 123 >22
+'single quoted string'
+"double quoted string"
+2222 != 1111.	 0000 = 0000
+"
+}
+array(2) {
+  [2]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+  [3]=>
+  string(90) "11 < 12. 123 >22
+'single quoted string'
+"double quoted string"
+2222 != 1111.	 0000 = 0000
+"
+}
+-- Iterator 9 --
+array(2) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+array(2) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+-- Iterator 10 --
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+-- Iterator 11 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 12 --
+array(1) {
+  ["one"]=>
+  string(3) "ten"
+}
+array(1) {
+  ["one"]=>
+  string(3) "ten"
+}
+-- Iterator 13 --
+array(3) {
+  ["one"]=>
+  int(1)
+  [2]=>
+  string(3) "two"
+  [4]=>
+  string(4) "four"
+}
+array(3) {
+  ["one"]=>
+  int(1)
+  [2]=>
+  string(3) "two"
+  [4]=>
+  string(4) "four"
+}
+-- Iterator 14 --
+array(2) {
+  ["NULL"]=>
+  NULL
+  ["null"]=>
+  NULL
+}
+array(2) {
+  ["NULL"]=>
+  NULL
+  ["null"]=>
+  NULL
+}
+-- Iterator 15 --
+array(2) {
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+}
+array(2) {
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+}
+-- Iterator 16 --
+array(3) {
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+  ["emptys"]=>
+  string(0) ""
+}
+array(3) {
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+  ["emptys"]=>
+  string(0) ""
+}
+-- Iterator 17 --
+array(6) {
+  [1]=>
+  string(0) ""
+  [2]=>
+  string(0) ""
+  [3]=>
+  NULL
+  [4]=>
+  NULL
+  [5]=>
+  bool(false)
+  [6]=>
+  bool(true)
+}
+array(6) {
+  [1]=>
+  string(0) ""
+  [2]=>
+  string(0) ""
+  [3]=>
+  NULL
+  [4]=>
+  NULL
+  [5]=>
+  bool(false)
+  [6]=>
+  bool(true)
+}
+-- Iterator 18 --
+array(1) {
+  [0]=>
+  int(5)
+}
+array(1) {
+  [0]=>
+  int(5)
+}
+-- Iterator 19 --
+array(0) {
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_intersect_variation4.phpt b/tests/std/array/array_intersect_variation4.phpt
new file mode 100644
index 00000000..f2fb9df5
--- /dev/null
+++ b/tests/std/array/array_intersect_variation4.phpt
@@ -0,0 +1,347 @@
+--TEST--
+Test array_intersect() function : usage variations - different arrays for 'arr2' argument
+--SKIPIF--
+<?php die("skip AOT array_intersect differs from PHP"); ?>
+--FILE--
+<?php
+ini_set("serialize_precision", "14");
+/*
+* Passing different types of arrays to $arr2 argument and testing whether
+* array_intersect() behaves in expected way with the other arguments passed to the function.
+* The $arr1 argument is a fixed array.
+*/
+
+echo "*** Testing array_intersect() : Passing different types of arrays to \$arr2 argument ***\n";
+
+/* Different heredoc strings passed as argument to $arr2 */
+// heredoc with blank line
+$blank_line = <<<EOT
+
+
+EOT;
+
+// heredoc with multiline string
+$multiline_string = <<<EOT
+hello world
+The big 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;
+
+// array to be passsed to $arr1 argument
+$arr1 = array (
+  1, 1.1, "hello", "one", NULL, 2,
+  'world', true, false, false => 5, 'aaaa\r', "aaaa\r",
+  $numeric_string, $diff_whitespaces,
+  "one" => "ten", 4 => "four", "two" => 2, 2 => "two",
+  '', null => "null", '' => 'emptys'
+);
+
+// arrays to be passed to $arr2 argument
+$arrays = array (
+/*1*/  array(1, 2), // array with default keys and numeric values
+       array(1.1, 2.2), // array with default keys & float values
+       array(false,true), // array with default keys and boolean values
+       array(), // empty array
+/*5*/  array(NULL), // array with NULL
+       array("a\v\f","aaaa\r","b","b\tbbb","c","\[\]\!\@\#\$\%\^\&\*\(\)\{\}"),  // array with double quoted strings
+       array('a\v\f','aaaa\r','b','b\tbbb','c','\[\]\!\@\#\$\%\^\&\*\(\)\{\}'),  // array with single quoted strings
+       array($blank_line, $multiline_string, $diff_whitespaces, $numeric_string),  // array 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_intersect()
+$iterator = 1;
+foreach($arrays as $arr2) {
+  echo "-- Iteration $iterator --\n";
+
+  // Calling array_intersect() with default arguments
+  var_dump( array_intersect($arr1, $arr2) );
+
+  // Calling array_intersect() with more arguments
+  // additional argument passed is the same as $arr1 argument
+  var_dump( array_intersect($arr1, $arr2, $arr1) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect() : Passing different types of arrays to $arr2 argument ***
+-- Iteration 1 --
+array(3) {
+  [5]=>
+  int(2)
+  [7]=>
+  bool(true)
+  ["two"]=>
+  int(2)
+}
+array(3) {
+  [5]=>
+  int(2)
+  [7]=>
+  bool(true)
+  ["two"]=>
+  int(2)
+}
+-- Iteration 2 --
+array(1) {
+  [1]=>
+  float(1.1)
+}
+array(1) {
+  [1]=>
+  float(1.1)
+}
+-- Iteration 3 --
+array(3) {
+  [7]=>
+  bool(true)
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+array(3) {
+  [7]=>
+  bool(true)
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+-- Iteration 4 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 5 --
+array(2) {
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+array(2) {
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+-- Iteration 6 --
+array(1) {
+  [10]=>
+  string(5) "aaaa
"
+}
+array(1) {
+  [10]=>
+  string(5) "aaaa
"
+}
+-- Iteration 7 --
+array(1) {
+  [9]=>
+  string(6) "aaaa\r"
+}
+array(1) {
+  [9]=>
+  string(6) "aaaa\r"
+}
+-- Iteration 8 --
+array(2) {
+  [11]=>
+  string(90) "11 < 12. 123 >22
+'single quoted string'
+"double quoted string"
+2222 != 1111.	 0000 = 0000
+"
+  [12]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+}
+array(2) {
+  [11]=>
+  string(90) "11 < 12. 123 >22
+'single quoted string'
+"double quoted string"
+2222 != 1111.	 0000 = 0000
+"
+  [12]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+}
+-- Iteration 9 --
+array(2) {
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(3) "one"
+}
+array(2) {
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(3) "one"
+}
+-- Iteration 10 --
+array(3) {
+  [5]=>
+  int(2)
+  [7]=>
+  bool(true)
+  ["two"]=>
+  int(2)
+}
+array(3) {
+  [5]=>
+  int(2)
+  [7]=>
+  bool(true)
+  ["two"]=>
+  int(2)
+}
+-- Iteration 11 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 12 --
+array(1) {
+  ["one"]=>
+  string(3) "ten"
+}
+array(1) {
+  ["one"]=>
+  string(3) "ten"
+}
+-- Iteration 13 --
+array(3) {
+  [2]=>
+  string(3) "two"
+  [4]=>
+  string(4) "four"
+  [7]=>
+  bool(true)
+}
+array(3) {
+  [2]=>
+  string(3) "two"
+  [4]=>
+  string(4) "four"
+  [7]=>
+  bool(true)
+}
+-- Iteration 14 --
+array(2) {
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+array(2) {
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+-- Iteration 15 --
+array(3) {
+  [7]=>
+  bool(true)
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+array(3) {
+  [7]=>
+  bool(true)
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+-- Iteration 16 --
+array(3) {
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+  [""]=>
+  string(6) "emptys"
+}
+array(3) {
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+  [""]=>
+  string(6) "emptys"
+}
+-- Iteration 17 --
+array(3) {
+  [7]=>
+  bool(true)
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+array(3) {
+  [7]=>
+  bool(true)
+  [8]=>
+  bool(false)
+  [13]=>
+  string(0) ""
+}
+-- Iteration 18 --
+array(1) {
+  [0]=>
+  int(5)
+}
+array(1) {
+  [0]=>
+  int(5)
+}
+-- Iteration 19 --
+array(0) {
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_intersect_variation5.phpt b/tests/std/array/array_intersect_variation5.phpt
new file mode 100644
index 00000000..12edea88
--- /dev/null
+++ b/tests/std/array/array_intersect_variation5.phpt
@@ -0,0 +1,159 @@
+--TEST--
+Test array_intersect() function : usage variations - assoc array with diff keys for 'arr1' argument
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_intersect() by passing different
+ * associative arrays having different possible keys to $arr1 argument.
+ * The $arr2 argument is a fixed array
+*/
+
+echo "*** Testing array_intersect() : assoc array with diff keys to \$arr1 argument ***\n";
+
+// get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// 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 unset variable
+/*10*/ array( @$unset_var => "hello"),
+
+       // array with mixed keys
+/*11*/ array('hello' => 1,  "fruit" => 2.2,
+              133 => "int",
+             @$unset_var => "unset", $heredoc => "heredoc")
+);
+
+// array to be passed to $arr2 argument
+$arr2 = array(1, "float", "f4", "hello", 2.2, 'color', "string", "pen\n", 11);
+
+// loop through each sub-array within $arrays to check the behavior of array_intersect()
+$iterator = 1;
+foreach($arrays as $arr1) {
+  echo "-- Iterator $iterator --\n";
+
+  // Calling array_intersect() with default arguments
+  var_dump( array_intersect($arr1, $arr2) );
+
+  // Calling array_intersect() with more arguments.
+  // additional argument passed is the same as $arr1 argument
+  var_dump( array_intersect($arr1, $arr2, $arr1) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect() : assoc array with diff keys to $arr1 argument ***
+-- Iterator 1 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 2 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 3 --
+array(1) {
+  [1]=>
+  string(1) "1"
+}
+array(1) {
+  [1]=>
+  string(1) "1"
+}
+-- Iterator 4 --
+array(1) {
+  [1]=>
+  string(1) "1"
+}
+array(1) {
+  [1]=>
+  string(1) "1"
+}
+-- Iterator 5 --
+array(2) {
+  ["re\td"]=>
+  string(5) "color"
+  ["\v\fworld"]=>
+  float(2.2)
+}
+array(2) {
+  ["re\td"]=>
+  string(5) "color"
+  ["\v\fworld"]=>
+  float(2.2)
+}
+-- Iterator 6 --
+array(2) {
+  ["re	d"]=>
+  string(5) "color"
+  ["world"]=>
+  float(2.2)
+}
+array(2) {
+  ["re	d"]=>
+  string(5) "color"
+  ["world"]=>
+  float(2.2)
+}
+-- Iterator 7 --
+array(2) {
+  [0]=>
+  string(5) "hello"
+  ["Hello world"]=>
+  string(6) "string"
+}
+array(2) {
+  [0]=>
+  string(5) "hello"
+  ["Hello world"]=>
+  string(6) "string"
+}
+-- Iterator 8 --
+array(1) {
+  [""]=>
+  string(5) "hello"
+}
+array(1) {
+  [""]=>
+  string(5) "hello"
+}
+-- Iterator 9 --
+array(2) {
+  ["hello"]=>
+  int(1)
+  ["fruit"]=>
+  float(2.2)
+}
+array(2) {
+  ["hello"]=>
+  int(1)
+  ["fruit"]=>
+  float(2.2)
+}
+Done
diff --git a/tests/std/array/array_intersect_variation6.phpt b/tests/std/array/array_intersect_variation6.phpt
new file mode 100644
index 00000000..93ff4271
--- /dev/null
+++ b/tests/std/array/array_intersect_variation6.phpt
@@ -0,0 +1,159 @@
+--TEST--
+Test array_intersect() function : usage variations - assoc array with diff keys for 'arr2' argument
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_intersect() by passing different
+ * associative arrays having different possible keys to $arr2 argument.
+ * The $arr1 argument is a fixed array.
+*/
+
+echo "*** Testing array_intersect() : assoc array with diff keys to \$arr2 argument ***\n";
+
+// get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// get a heredoc string
+$heredoc = <<<EOT
+Hello world
+EOT;
+
+// different variations of associative arrays to be passed to $arr2 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 unset variable
+/*10*/ array( @$unset_var => "hello"),
+
+       // array with mixed keys
+/*11*/ array('hello' => 1,  "fruit" => 2.2,
+             133 => "int",
+             @$unset_var => "unset", $heredoc => "heredoc")
+);
+
+// array to be passed to $arr1 argument
+$arr1 = array(1, "float", "f4", "hello", 2.2, 'color', "string", "pen\n", 11);
+
+// loop through each sub-array within $arrays to check the behavior of array_intersect()
+$iterator = 1;
+foreach($arrays as $arr2) {
+  echo "-- Iterator $iterator --\n";
+
+  // Calling array_intersect() with default arguments
+  var_dump( array_intersect($arr1, $arr2) );
+
+  // Calling array_intersect() with more arguments.
+  // additional argument passed is the same as $arr1 argument
+  var_dump( array_intersect($arr1, $arr2, $arr1) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_intersect() : assoc array with diff keys to $arr2 argument ***
+-- Iterator 1 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 2 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 3 --
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+-- Iterator 4 --
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+-- Iterator 5 --
+array(2) {
+  [4]=>
+  float(2.2)
+  [5]=>
+  string(5) "color"
+}
+array(2) {
+  [4]=>
+  float(2.2)
+  [5]=>
+  string(5) "color"
+}
+-- Iterator 6 --
+array(2) {
+  [4]=>
+  float(2.2)
+  [5]=>
+  string(5) "color"
+}
+array(2) {
+  [4]=>
+  float(2.2)
+  [5]=>
+  string(5) "color"
+}
+-- Iterator 7 --
+array(2) {
+  [3]=>
+  string(5) "hello"
+  [6]=>
+  string(6) "string"
+}
+array(2) {
+  [3]=>
+  string(5) "hello"
+  [6]=>
+  string(6) "string"
+}
+-- Iterator 8 --
+array(1) {
+  [3]=>
+  string(5) "hello"
+}
+array(1) {
+  [3]=>
+  string(5) "hello"
+}
+-- Iterator 9 --
+array(2) {
+  [0]=>
+  int(1)
+  [4]=>
+  float(2.2)
+}
+array(2) {
+  [0]=>
+  int(1)
+  [4]=>
+  float(2.2)
+}
+Done
diff --git a/tests/std/array/array_intersect_variation7.phpt b/tests/std/array/array_intersect_variation7.phpt
new file mode 100644
index 00000000..8282af87
--- /dev/null
+++ b/tests/std/array/array_intersect_variation7.phpt
@@ -0,0 +1,196 @@
+--TEST--
+Test array_intersect() function : usage variations - assoc array with diff values for 'arr1' argument
+--SKIPIF--
+<?php die("skip AOT array_intersect 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_intersect() by passing different
+     * associative arrays having different possible values to $arr1 argument.
+     * The $arr2 argument is a fixed array
+    */
+    echo "*** Testing array_intersect() : assoc array with diff values to \$arr1 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 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.333333),
+        // 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),
+    );
+    // array to be passsed to $arr2 argument
+    $arr2 = array(1, 2, 1.2, 2.3333, "col\tor", '\v\fworld', $fp, "Hello world", $heredoc, new classA(), 444.432, "fruit");
+    // loop through each sub-array within $arrays to check the behavior of array_intersect()
+    $iterator = 1;
+    foreach ($arrays as $arr1) {
+        echo "-- Iterator {$iterator} --\n";
+        // Calling array_intersect() with default arguments
+        var_dump(array_intersect($arr1, $arr2));
+        // Calling array_intersect() with more arguments.
+        // additional argument passed is the same as $arr1 argument
+        var_dump(array_intersect($arr1, $arr2, $arr1));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_intersect() : assoc array with diff values to $arr1 argument ***
+-- Iterator 1 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 2 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 3 --
+array(1) {
+  [1]=>
+  int(1)
+}
+array(1) {
+  [1]=>
+  int(1)
+}
+-- Iterator 4 --
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+-- Iterator 5 --
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+-- Iterator 6 --
+array(1) {
+  ["f1"]=>
+  float(1.2)
+}
+array(1) {
+  ["f1"]=>
+  float(1.2)
+}
+-- Iterator 7 --
+array(1) {
+  ["red"]=>
+  string(6) "col	or"
+}
+array(1) {
+  ["red"]=>
+  string(6) "col	or"
+}
+-- Iterator 8 --
+array(1) {
+  [2]=>
+  string(9) "\v\fworld"
+}
+array(1) {
+  [2]=>
+  string(9) "\v\fworld"
+}
+-- Iterator 9 --
+array(1) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+array(1) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+-- Iterator 10 --
+array(2) {
+  [11]=>
+  object(classA)#%d (0) {
+  }
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+array(2) {
+  [11]=>
+  object(classA)#%d (0) {
+  }
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+-- Iterator 11 --
+array(5) {
+  [2]=>
+  object(classA)#%d (0) {
+  }
+  [222]=>
+  string(5) "fruit"
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["float"]=>
+  float(444.432)
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+array(5) {
+  [2]=>
+  object(classA)#%d (0) {
+  }
+  [222]=>
+  string(5) "fruit"
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["float"]=>
+  float(444.432)
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+Done
diff --git a/tests/std/array/array_intersect_variation8.phpt b/tests/std/array/array_intersect_variation8.phpt
new file mode 100644
index 00000000..706480b1
--- /dev/null
+++ b/tests/std/array/array_intersect_variation8.phpt
@@ -0,0 +1,204 @@
+--TEST--
+Test array_intersect() function : usage variations - assoc array with diff values for 'arr2' argument
+--SKIPIF--
+<?php die("skip AOT array_intersect 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_intersect() by passing different
+     * associative arrays having different possible values to $arr2 argument.
+     * The $arr1 argument is a fixed array.
+    */
+    echo "*** Testing array_intersect() : assoc array with diff values to \$arr2 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 $arr2 argument
+    $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.333333),
+        // 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),
+    );
+    // array to be passsed to $arr1 argument
+    $arr1 = array(1, 2, 1.2, 2.3333, "col\tor", '\v\fworld', $fp, "Hello world", $heredoc, new classA(), 444.432, "fruit");
+    // loop through each sub-array within $arrays to check the behavior of array_intersect()
+    $iterator = 1;
+    foreach ($arrays as $arr2) {
+        echo "-- Iterator {$iterator} --\n";
+        // Calling array_intersect() with default arguments
+        var_dump(array_intersect($arr1, $arr2));
+        // Calling array_intersect() with more arguments.
+        // additional argument passed is the same as $arr1 argument
+        var_dump(array_intersect($arr1, $arr2, $arr1));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_intersect() : assoc array with diff values to $arr2 argument ***
+-- Iterator 1 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 2 --
+array(0) {
+}
+array(0) {
+}
+-- Iterator 3 --
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+-- Iterator 4 --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+-- Iterator 5 --
+array(1) {
+  [3]=>
+  float(2.3333)
+}
+array(1) {
+  [3]=>
+  float(2.3333)
+}
+-- Iterator 6 --
+array(1) {
+  [2]=>
+  float(1.2)
+}
+array(1) {
+  [2]=>
+  float(1.2)
+}
+-- Iterator 7 --
+array(1) {
+  [4]=>
+  string(6) "col	or"
+}
+array(1) {
+  [4]=>
+  string(6) "col	or"
+}
+-- Iterator 8 --
+array(1) {
+  [5]=>
+  string(9) "\v\fworld"
+}
+array(1) {
+  [5]=>
+  string(9) "\v\fworld"
+}
+-- Iterator 9 --
+array(2) {
+  [7]=>
+  string(11) "Hello world"
+  [8]=>
+  string(11) "Hello world"
+}
+array(2) {
+  [7]=>
+  string(11) "Hello world"
+  [8]=>
+  string(11) "Hello world"
+}
+-- Iterator 10 --
+array(2) {
+  [6]=>
+  resource(%d) of type (stream)
+  [9]=>
+  object(classA)#%d (0) {
+  }
+}
+array(2) {
+  [6]=>
+  resource(%d) of type (stream)
+  [9]=>
+  object(classA)#%d (0) {
+  }
+}
+-- Iterator 11 --
+array(6) {
+  [6]=>
+  resource(%d) of type (stream)
+  [7]=>
+  string(11) "Hello world"
+  [8]=>
+  string(11) "Hello world"
+  [9]=>
+  object(classA)#%d (0) {
+  }
+  [10]=>
+  float(444.432)
+  [11]=>
+  string(5) "fruit"
+}
+array(6) {
+  [6]=>
+  resource(%d) of type (stream)
+  [7]=>
+  string(11) "Hello world"
+  [8]=>
+  string(11) "Hello world"
+  [9]=>
+  object(classA)#%d (0) {
+  }
+  [10]=>
+  float(444.432)
+  [11]=>
+  string(5) "fruit"
+}
+Done
diff --git a/tests/std/array/array_intersect_variation9.phpt b/tests/std/array/array_intersect_variation9.phpt
new file mode 100644
index 00000000..c73b0f3d
--- /dev/null
+++ b/tests/std/array/array_intersect_variation9.phpt
@@ -0,0 +1,238 @@
+--TEST--
+Test array_intersect() function : usage variations - two dimensional arrays for $arr1 and $arr2 arguments(Bug#43109)
+--FILE--
+<?php
+/*
+* Testing the behavior of array_intersect() by passing 2-D arrays
+* to both $arr1 and $arr2 argument.
+* Optional argument takes the same value as that of $arr1
+*/
+
+echo "*** Testing array_intersect() : passing two dimensional array to both \$arr1 and \$arr2 arguments ***\n";
+
+// two dimensional arrays for $arr1 and $arr2 argument
+$arr1 = array (
+
+  // arrays with default keys
+  array(1, 2, "hello", 'world'),
+  array(1, 2, 3, 4),
+
+  // arrays with explicit keys
+  array(1 => "one", 2 => "two", 3 => "three"),
+  array("ten" => 10, "twenty" => 20.00, "thirty" => 30)
+);
+
+$arr2 = array (
+  array(1, 2, 3, 4),
+  array(1 => "one", 2 => "two", 3 => "three")
+);
+
+/* Passing the entire array as argument to $arr1 and $arr2 */
+// Calling array_intersect() with default arguments
+echo "-- Passing the entire 2-D array to \$arr1 and \$arr2 --\n";
+echo "- With default arguments -\n";
+var_dump( array_intersect($arr1, $arr2) );
+
+// Calling array_intersect() with more arguments
+// additional argument passed is the same as $arr1
+echo "- With more arguments -\n";
+var_dump( array_intersect($arr1, $arr2, $arr1) );
+
+/* Passing the sub-array as argument to $arr1 and $arr2 */
+// Calling array_intersect() with default arguments
+echo "-- Passing the sub-array to \$arr1 and \$arr2 --\n";
+echo "- With default arguments -\n";
+var_dump( array_intersect($arr1[0], $arr2[0]) );
+
+// Calling array_intersect() with more arguments
+// additional argument passed is the same as $arr1
+echo "- With more arguments -\n";
+var_dump( array_intersect($arr1[0], $arr2[0], $arr1[0]) );
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_intersect() : passing two dimensional array to both $arr1 and $arr2 arguments ***
+-- Passing the entire 2-D array to $arr1 and $arr2 --
+- With default arguments -
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+array(4) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    string(5) "hello"
+    [3]=>
+    string(5) "world"
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [2]=>
+  array(3) {
+    [1]=>
+    string(3) "one"
+    [2]=>
+    string(3) "two"
+    [3]=>
+    string(5) "three"
+  }
+  [3]=>
+  array(3) {
+    ["ten"]=>
+    int(10)
+    ["twenty"]=>
+    float(20)
+    ["thirty"]=>
+    int(30)
+  }
+}
+- With more arguments -
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+array(4) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    string(5) "hello"
+    [3]=>
+    string(5) "world"
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+  }
+  [2]=>
+  array(3) {
+    [1]=>
+    string(3) "one"
+    [2]=>
+    string(3) "two"
+    [3]=>
+    string(5) "three"
+  }
+  [3]=>
+  array(3) {
+    ["ten"]=>
+    int(10)
+    ["twenty"]=>
+    float(20)
+    ["thirty"]=>
+    int(30)
+  }
+}
+-- Passing the sub-array to $arr1 and $arr2 --
+- With default arguments -
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+- With more arguments -
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/array_key_exists.phpt b/tests/std/array/array_key_exists.phpt
new file mode 100644
index 00000000..0e9bc66b
--- /dev/null
+++ b/tests/std/array/array_key_exists.phpt
@@ -0,0 +1,197 @@
+--TEST--
+Test array_key_exists() function
+--SKIPIF--
+<?php die("skip AOT error handling differs from PHP for non-array arguments"); ?>
+--FILE--
+<?php
+class key_check
+{
+    public $public_var = "Public var";
+}
+function main()
+{
+    echo "*** Testing basic functionalities ***\n";
+    /* Arrays with regular values */
+    $search_arrays = array(array(1, 2, 3, 4), array('a', 'b', 'c'), array('abc', 'bcd', 'dcf'), array("test", "rest", "enjoy"), array("Name" => "Jack", "Loc" => "Mars", "Id" => "MS123"), array('Red' => 'Rose', 'I' => 'You'), array(0 => 'Zero', 1 => 'One', 2 => 'Two', 3 => "Three"));
+    /* keys to search in $search_arrays. $keys[0]
+       is the key to be searched in $search_arrays[0] and so on */
+    $keys = array(1, 'a', 2, 4, "Name", "Red", 0, 3);
+    $key_counter = 0;
+    foreach ($search_arrays as $search_array) {
+        $key = $keys[$key_counter++];
+        echo "-- Iteration {$key_counter} --\n";
+        var_dump(array_key_exists($key, $search_array));
+    }
+    echo "\n*** Testing possible variations ***\n";
+    // use different keys on each sub array of  $search_arrays
+    $key_variations = array("", NULL, null, " ", '', "test", 1);
+    $key_counter = 0;
+    $key_count = count($key_variations);
+    echo "\n** Variation loop 1 **\n";
+    $out_loop_count = 0;
+    foreach ($search_arrays as $search_array) {
+        $key_counter = 0;
+        $out_loop_count++;
+        echo "-- Iteration {$out_loop_count} --\n";
+        while ($key_counter < $key_count) {
+            $key = $key_variations[$key_counter++];
+            var_dump(array_key_exists($key, $search_array));
+        }
+    }
+    // arrays with variation in elements
+    $search_arrays_v = array(array(), array(NULL), array(array(), 1, 2), array(1, 2, 3, "" => "value", NULL => "value", true => "value"), array(array(2, 4, 5), array("a", "b", "d")));
+    // search for $key_variations in each sub array of $search_arrays_v
+    echo "\n** Variation loop 2 **\n";
+    $out_loop_count = 0;
+    foreach ($search_arrays_v as $search_array) {
+        $key_counter = 0;
+        $out_loop_count++;
+        echo "-- Iteration {$out_loop_count} --\n";
+        while ($key_counter < $key_count) {
+            $key = $key_variations[$key_counter++];
+            var_dump(array_key_exists($key, $search_array));
+        }
+    }
+    echo "\n*** Testing error conditions ***\n";
+    // first args as array
+    try {
+        array_key_exists(array(), array());
+    } catch (TypeError $exception) {
+        echo $exception->getMessage() . "\n";
+    }
+    echo "\n*** Testing operation on objects ***\n";
+    $key_check_obj = new key_check();
+    //new object
+    try {
+        var_dump(array_key_exists("public_var", $key_check_obj));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    echo "Done\n";
+}
+?>
+--EXPECT--
+*** Testing basic functionalities ***
+-- Iteration 1 --
+bool(true)
+-- Iteration 2 --
+bool(false)
+-- Iteration 3 --
+bool(true)
+-- Iteration 4 --
+bool(false)
+-- Iteration 5 --
+bool(true)
+-- Iteration 6 --
+bool(true)
+-- Iteration 7 --
+bool(true)
+
+*** Testing possible variations ***
+
+** Variation loop 1 **
+-- Iteration 1 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+-- Iteration 2 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+-- Iteration 3 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+-- Iteration 4 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+-- Iteration 5 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 6 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 7 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+
+** Variation loop 2 **
+-- Iteration 1 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 2 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 3 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+-- Iteration 4 --
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 5 --
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+
+*** Testing error conditions ***
+Cannot access offset of type array on array
+
+*** Testing operation on objects ***
+array_key_exists(): Argument #2 ($array) must be of type array, key_check given
+Done
diff --git a/tests/std/array/array_key_exists_basic.phpt b/tests/std/array/array_key_exists_basic.phpt
new file mode 100644
index 00000000..4753633d
--- /dev/null
+++ b/tests/std/array/array_key_exists_basic.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Test array_key_exists() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of array_key_exists()
+ */
+
+echo "*** Testing array_key_exists() : basic functionality ***\n";
+
+$key1 = 'key';
+$key2 = 'val';
+$search = array('one', 'key' => 'value', 'val');
+var_dump(array_key_exists($key1, $search));
+var_dump(array_key_exists($key2, $search));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_key_exists() : basic functionality ***
+bool(true)
+bool(false)
+Done
diff --git a/tests/std/array/array_key_exists_variation1.phpt b/tests/std/array/array_key_exists_variation1.phpt
new file mode 100644
index 00000000..e45364dd
--- /dev/null
+++ b/tests/std/array/array_key_exists_variation1.phpt
@@ -0,0 +1,154 @@
+--TEST--
+Test array_key_exists() function : usage variations - Pass different data types as $key arg
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "key";
+    }
+}
+function main()
+{
+    /*
+     * Pass different data types as $key argument to array_key_exists() to test behaviour
+     */
+    echo "*** Testing array_key_exists() : usage variations ***\n";
+    // Initialise function arguments not being substituted
+    $search = array('zero', 'key' => 'val', 'two', 10 => 'value');
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // heredoc string
+    $heredoc = <<<EOT
+    key
+    EOT;
+    // get a resource variable
+    $fp = fopen(__FILE__, "r");
+    // unexpected values to be passed to $key argument
+    $inputs = array(
+        // int data
+        /*1*/
+        0,
+        1,
+        12345,
+        -2345,
+        // null data
+        /*10*/
+        NULL,
+        null,
+        // boolean data
+        /*12*/
+        true,
+        false,
+        TRUE,
+        FALSE,
+        // empty data
+        /*16*/
+        "",
+        '',
+        array(),
+        // string data
+        /*19*/
+        "key",
+        'key',
+        $heredoc,
+        // object data
+        /*22*/
+        new classA(),
+        // undefined data
+        /*23*/
+        @$undefined_var,
+        // unset data
+        /*24*/
+        @$unset_var,
+        // resource variable
+        /*25*/
+        $fp,
+    );
+    // loop through each element of $inputs to check the behavior of array_key_exists()
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "\n-- Iteration {$iterator} --\n";
+        try {
+            var_dump(array_key_exists($input, $search));
+        } catch (TypeError $exception) {
+            echo $exception->getMessage() . "\n";
+        }
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_key_exists() : usage variations ***
+
+-- Iteration 1 --
+bool(true)
+
+-- Iteration 2 --
+bool(true)
+
+-- Iteration 3 --
+bool(false)
+
+-- Iteration 4 --
+bool(false)
+
+-- Iteration 5 --
+bool(false)
+
+-- Iteration 6 --
+bool(false)
+
+-- Iteration 7 --
+bool(true)
+
+-- Iteration 8 --
+bool(true)
+
+-- Iteration 9 --
+bool(true)
+
+-- Iteration 10 --
+bool(true)
+
+-- Iteration 11 --
+bool(false)
+
+-- Iteration 12 --
+bool(false)
+
+-- Iteration 13 --
+Cannot access offset of type array on array
+
+-- Iteration 14 --
+bool(true)
+
+-- Iteration 15 --
+bool(true)
+
+-- Iteration 16 --
+bool(true)
+
+-- Iteration 17 --
+Cannot access offset of type classA on array
+
+-- Iteration 18 --
+bool(false)
+
+-- Iteration 19 --
+bool(false)
+
+-- Iteration 20 --
+
+Warning: Resource ID#%d used as offset, casting to integer (%d) in %s on line %d
+bool(false)
+Done
diff --git a/tests/std/array/array_key_exists_variation3.phpt b/tests/std/array/array_key_exists_variation3.phpt
new file mode 100644
index 00000000..1eaab11b
--- /dev/null
+++ b/tests/std/array/array_key_exists_variation3.phpt
@@ -0,0 +1,59 @@
+--TEST--
+Test array_key_exists() function : usage variations - floats and casting to ints
+--SKIPIF--
+<?php die("skip AOT float-to-int casting differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * Pass floats as $key argument, then cast float values
+ * to integers and pass as $key argument
+ */
+
+echo "*** Testing array_key_exists() : usage variations ***\n";
+
+$keys = array(1.2345678900E-10, 1.00000000000001, 1.99999999999999);
+
+$search = array ('zero', 'one', 'two');
+
+$iterator = 1;
+foreach($keys as $key) {
+    echo "\n-- Iteration $iterator --\n";
+    echo "Pass float as \$key:\n";
+    try {
+        var_dump(array_key_exists($key, $search));
+    } catch (TypeError $exception) {
+        echo $exception->getMessage() . "\n";
+    }
+    echo "Cast float to int:\n";
+    var_dump(array_key_exists((int)$key, $search));
+}
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_key_exists() : usage variations ***
+
+-- Iteration 1 --
+Pass float as $key:
+
+Deprecated: Implicit conversion from float 1.23456789E-10 to int loses precision in %s on line %d
+bool(true)
+Cast float to int:
+bool(true)
+
+-- Iteration 1 --
+Pass float as $key:
+
+Deprecated: Implicit conversion from float 1.00000000000001 to int loses precision in %s on line %d
+bool(true)
+Cast float to int:
+bool(true)
+
+-- Iteration 1 --
+Pass float as $key:
+
+Deprecated: Implicit conversion from float 1.99999999999999 to int loses precision in %s on line %d
+bool(true)
+Cast float to int:
+bool(true)
+Done
diff --git a/tests/std/array/array_key_exists_variation4.phpt b/tests/std/array/array_key_exists_variation4.phpt
new file mode 100644
index 00000000..8d768042
--- /dev/null
+++ b/tests/std/array/array_key_exists_variation4.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Test array_key_exists() function : usage variations - referenced variables
+--FILE--
+<?php
+/*
+ * Pass referenced variables as arguments to array_key_exists() to test behaviour
+ */
+
+echo "*** Testing array_key_exists() : usage variations ***\n";
+
+$array = array('one' => 1, 'two' => 2, 'three' => 3);
+
+echo "\n-- \$search is a reference to \$array --\n";
+$search = &$array;
+var_dump(array_key_exists('one', $search));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_key_exists() : usage variations ***
+
+-- $search is a reference to $array --
+bool(true)
+Done
diff --git a/tests/std/array/array_key_exists_variation5.phpt b/tests/std/array/array_key_exists_variation5.phpt
new file mode 100644
index 00000000..41a28c5b
--- /dev/null
+++ b/tests/std/array/array_key_exists_variation5.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Test array_key_exists() function : usage variations - multidimensional arrays
+--FILE--
+<?php
+/*
+ * Test how array_key_exists() behaves with multi-dimensional arrays
+ */
+
+echo "*** Testing array_key_exists() : usage variations ***\n";
+
+$multi_array = array ('zero' => 'val1',
+                      'one' => 'val2',
+                      'sub1' => array (1, 2, 3));
+
+echo "\n-- Attempt to match key in sub-array --\n";
+// this key is in the sub-array
+var_dump(array_key_exists(0, $multi_array));
+
+echo "\n-- \$search arg points to sub-array --\n";
+var_dump(array_key_exists(0, $multi_array['sub1']));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_key_exists() : usage variations ***
+
+-- Attempt to match key in sub-array --
+bool(false)
+
+-- $search arg points to sub-array --
+bool(true)
+Done
diff --git a/tests/std/array/array_key_exists_variation6.phpt b/tests/std/array/array_key_exists_variation6.phpt
new file mode 100644
index 00000000..ef25b45a
--- /dev/null
+++ b/tests/std/array/array_key_exists_variation6.phpt
@@ -0,0 +1,94 @@
+--TEST--
+Test array_key_exists() function : usage variations -  equality test for certain data types
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Pass certain data types that can be taken as a key in an array
+ * and test whether array_key_exists(() thinks they are equal and therefore
+ * returns true when searching for them
+ */
+
+echo "*** Testing array_key_exists() : usage variations ***\n";
+
+$unset = 10;
+unset($unset);
+$array = array ('null' => null,
+                'NULL' => NULL,
+                'empty single quoted string' => '',
+                "empty double quoted string" => "",
+                'undefined variable' => @$undefined,
+                'unset variable' => @$unset);
+
+//iterate through original array
+foreach($array as $name => $input) {
+    $iterator = 1;
+    echo "\n-- Key in \$search array is : $name --\n";
+    $search[$input] = 'test';
+
+    //iterate through array again to see which values are considered equal
+    foreach($array as $key) {
+        echo "Iteration $iterator:  ";
+        var_dump(array_key_exists($key, $search));
+        $iterator++;
+    }
+    $search = null;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_key_exists() : usage variations ***
+
+-- Key in $search array is : null --
+Iteration 1:  bool(true)
+Iteration 2:  bool(true)
+Iteration 3:  bool(true)
+Iteration 4:  bool(true)
+Iteration 5:  bool(true)
+Iteration 6:  bool(true)
+
+-- Key in $search array is : NULL --
+Iteration 1:  bool(true)
+Iteration 2:  bool(true)
+Iteration 3:  bool(true)
+Iteration 4:  bool(true)
+Iteration 5:  bool(true)
+Iteration 6:  bool(true)
+
+-- Key in $search array is : empty single quoted string --
+Iteration 1:  bool(true)
+Iteration 2:  bool(true)
+Iteration 3:  bool(true)
+Iteration 4:  bool(true)
+Iteration 5:  bool(true)
+Iteration 6:  bool(true)
+
+-- Key in $search array is : empty double quoted string --
+Iteration 1:  bool(true)
+Iteration 2:  bool(true)
+Iteration 3:  bool(true)
+Iteration 4:  bool(true)
+Iteration 5:  bool(true)
+Iteration 6:  bool(true)
+
+-- Key in $search array is : undefined variable --
+Iteration 1:  bool(true)
+Iteration 2:  bool(true)
+Iteration 3:  bool(true)
+Iteration 4:  bool(true)
+Iteration 5:  bool(true)
+Iteration 6:  bool(true)
+
+-- Key in $search array is : unset variable --
+Iteration 1:  bool(true)
+Iteration 2:  bool(true)
+Iteration 3:  bool(true)
+Iteration 4:  bool(true)
+Iteration 5:  bool(true)
+Iteration 6:  bool(true)
+Done
diff --git a/tests/std/array/array_key_exists_variation7.phpt b/tests/std/array/array_key_exists_variation7.phpt
new file mode 100644
index 00000000..2d001bd4
--- /dev/null
+++ b/tests/std/array/array_key_exists_variation7.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test array_key_exists() function : usage variations - position of internal array pointer
+--FILE--
+<?php
+/*
+ * Check the position of the internal array pointer after calling array_key_exists()
+ */
+
+echo "*** Testing array_key_exists() : usage variations ***\n";
+
+$input = array ('one' => 'un', 'two' => 'deux', 'three' => 'trois');
+
+echo "\n-- Call array_key_exists() --\n";
+var_dump($result = array_key_exists('one', $input));
+
+echo "\n-- Position of Internal Pointer in Original Array: --\n";
+echo key($input) . " => " . current ($input) . "\n";
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_key_exists() : usage variations ***
+
+-- Call array_key_exists() --
+bool(true)
+
+-- Position of Internal Pointer in Original Array: --
+one => un
+Done
diff --git a/tests/std/array/array_key_exists_variation8.phpt b/tests/std/array/array_key_exists_variation8.phpt
new file mode 100644
index 00000000..15810b91
--- /dev/null
+++ b/tests/std/array/array_key_exists_variation8.phpt
@@ -0,0 +1,391 @@
+--TEST--
+Test array_key_exists() function : usage variations - array keys are different data types
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Pass an array where the keys are different data types as the $search argument
+ * then pass many different data types as $key argument to test where array_key_exist()
+ * returns true.
+ */
+
+echo "*** Testing array_key_exists() : usage variations ***\n";
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// heredoc string
+$heredoc = <<<EOT
+string
+EOT;
+
+// different data types to be iterated over
+$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 element of $inputs to check the behavior of array_key_exists()
+$iterator = 1;
+foreach($inputs as $type => $input) {
+    echo "\n-- Iteration $iterator: $type data --\n";
+
+    //iterate over again to get all different key values
+    foreach ($inputs as $new_type => $new_input) {
+        echo "-- \$key arguments are $new_type data:\n";
+        foreach ($new_input as $key => $search) {
+            var_dump(array_key_exists($key, $input));
+        }
+    }
+    $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_key_exists() : usage variations ***
+
+-- Iteration 1: int data --
+-- $key arguments are int data:
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+-- $key arguments are null uppercase data:
+bool(false)
+-- $key arguments are null lowercase data:
+bool(false)
+-- $key arguments are bool lowercase data:
+bool(true)
+bool(true)
+-- $key arguments are bool uppercase data:
+bool(true)
+bool(true)
+-- $key arguments are empty double quotes data:
+bool(false)
+-- $key arguments are empty single quotes data:
+bool(false)
+-- $key arguments are string data:
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are undefined data:
+bool(false)
+-- $key arguments are unset data:
+bool(false)
+
+-- Iteration 2: null uppercase data --
+-- $key arguments are int data:
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are null uppercase data:
+bool(true)
+-- $key arguments are null lowercase data:
+bool(true)
+-- $key arguments are bool lowercase data:
+bool(false)
+bool(false)
+-- $key arguments are bool uppercase data:
+bool(false)
+bool(false)
+-- $key arguments are empty double quotes data:
+bool(true)
+-- $key arguments are empty single quotes data:
+bool(true)
+-- $key arguments are string data:
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are undefined data:
+bool(true)
+-- $key arguments are unset data:
+bool(true)
+
+-- Iteration 3: null lowercase data --
+-- $key arguments are int data:
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are null uppercase data:
+bool(true)
+-- $key arguments are null lowercase data:
+bool(true)
+-- $key arguments are bool lowercase data:
+bool(false)
+bool(false)
+-- $key arguments are bool uppercase data:
+bool(false)
+bool(false)
+-- $key arguments are empty double quotes data:
+bool(true)
+-- $key arguments are empty single quotes data:
+bool(true)
+-- $key arguments are string data:
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are undefined data:
+bool(true)
+-- $key arguments are unset data:
+bool(true)
+
+-- Iteration 4: bool lowercase data --
+-- $key arguments are int data:
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+-- $key arguments are null uppercase data:
+bool(false)
+-- $key arguments are null lowercase data:
+bool(false)
+-- $key arguments are bool lowercase data:
+bool(true)
+bool(true)
+-- $key arguments are bool uppercase data:
+bool(true)
+bool(true)
+-- $key arguments are empty double quotes data:
+bool(false)
+-- $key arguments are empty single quotes data:
+bool(false)
+-- $key arguments are string data:
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are undefined data:
+bool(false)
+-- $key arguments are unset data:
+bool(false)
+
+-- Iteration 5: bool uppercase data --
+-- $key arguments are int data:
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+-- $key arguments are null uppercase data:
+bool(false)
+-- $key arguments are null lowercase data:
+bool(false)
+-- $key arguments are bool lowercase data:
+bool(true)
+bool(true)
+-- $key arguments are bool uppercase data:
+bool(true)
+bool(true)
+-- $key arguments are empty double quotes data:
+bool(false)
+-- $key arguments are empty single quotes data:
+bool(false)
+-- $key arguments are string data:
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are undefined data:
+bool(false)
+-- $key arguments are unset data:
+bool(false)
+
+-- Iteration 6: empty double quotes data --
+-- $key arguments are int data:
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are null uppercase data:
+bool(true)
+-- $key arguments are null lowercase data:
+bool(true)
+-- $key arguments are bool lowercase data:
+bool(false)
+bool(false)
+-- $key arguments are bool uppercase data:
+bool(false)
+bool(false)
+-- $key arguments are empty double quotes data:
+bool(true)
+-- $key arguments are empty single quotes data:
+bool(true)
+-- $key arguments are string data:
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are undefined data:
+bool(true)
+-- $key arguments are unset data:
+bool(true)
+
+-- Iteration 7: empty single quotes data --
+-- $key arguments are int data:
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are null uppercase data:
+bool(true)
+-- $key arguments are null lowercase data:
+bool(true)
+-- $key arguments are bool lowercase data:
+bool(false)
+bool(false)
+-- $key arguments are bool uppercase data:
+bool(false)
+bool(false)
+-- $key arguments are empty double quotes data:
+bool(true)
+-- $key arguments are empty single quotes data:
+bool(true)
+-- $key arguments are string data:
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are undefined data:
+bool(true)
+-- $key arguments are unset data:
+bool(true)
+
+-- Iteration 8: string data --
+-- $key arguments are int data:
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are null uppercase data:
+bool(false)
+-- $key arguments are null lowercase data:
+bool(false)
+-- $key arguments are bool lowercase data:
+bool(false)
+bool(false)
+-- $key arguments are bool uppercase data:
+bool(false)
+bool(false)
+-- $key arguments are empty double quotes data:
+bool(false)
+-- $key arguments are empty single quotes data:
+bool(false)
+-- $key arguments are string data:
+bool(true)
+bool(true)
+bool(true)
+-- $key arguments are undefined data:
+bool(false)
+-- $key arguments are unset data:
+bool(false)
+
+-- Iteration 9: undefined data --
+-- $key arguments are int data:
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are null uppercase data:
+bool(true)
+-- $key arguments are null lowercase data:
+bool(true)
+-- $key arguments are bool lowercase data:
+bool(false)
+bool(false)
+-- $key arguments are bool uppercase data:
+bool(false)
+bool(false)
+-- $key arguments are empty double quotes data:
+bool(true)
+-- $key arguments are empty single quotes data:
+bool(true)
+-- $key arguments are string data:
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are undefined data:
+bool(true)
+-- $key arguments are unset data:
+bool(true)
+
+-- Iteration 10: unset data --
+-- $key arguments are int data:
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are null uppercase data:
+bool(true)
+-- $key arguments are null lowercase data:
+bool(true)
+-- $key arguments are bool lowercase data:
+bool(false)
+bool(false)
+-- $key arguments are bool uppercase data:
+bool(false)
+bool(false)
+-- $key arguments are empty double quotes data:
+bool(true)
+-- $key arguments are empty single quotes data:
+bool(true)
+-- $key arguments are string data:
+bool(false)
+bool(false)
+bool(false)
+-- $key arguments are undefined data:
+bool(true)
+-- $key arguments are unset data:
+bool(true)
+Done
diff --git a/tests/std/array/array_key_first.phpt b/tests/std/array/array_key_first.phpt
new file mode 100644
index 00000000..9d5452d3
--- /dev/null
+++ b/tests/std/array/array_key_first.phpt
@@ -0,0 +1,296 @@
+--TEST--
+Test array_key_first() function
+--SKIPIF--
+<?php
+if (true) die("skip AOT has a known issue with this test pattern");
+?>
+
+--FILE--
+<?php
+
+array_key_first($GLOBALS);
+
+/* Various combinations of arrays to be used for the test */
+$mixed_array = array(
+  array(),
+  array( 1,2,3,4,5,6,7,8,9 ),
+  array( "One", "_Two", "Three", "Four", "Five" ),
+  array( 6, "six", 7, "seven", 8, "eight", 9, "nine" ),
+  array( "a" => "aaa", "A" => "AAA", "c" => "ccc", "d" => "ddd", "e" => "eee" ),
+  array( "1" => "one", "2" => "two", "3" => "three", "4" => "four", "5" => "five" ),
+  array( 1 => "one", 2 => "two", 3 => 7, 4 => "four", 5 => "five" ),
+  array( "f" => "fff", "1" => "one", 4 => 6, "" => "blank", 2 => "float", "F" => "FFF",
+         "blank" => "", 3 => 3.7, 5 => 7, 6 => 8.6, '5' => "Five", "4name" => "jonny", "a" => NULL, NULL => 3 ),
+  array( 12, "name", 'age', '45' ),
+  array( array("oNe", "tWo", 4), array(10, 20, 30, 40, 50), array() ),
+  array( "one" => 1, "one" => 2, "three" => 3, 3, 4, 3 => 33, 4 => 44, 5, 6,
+          5 => 57, "5.4" => 554, "5.7" => 557 ),
+  array( "foo" ),
+  array( 1 => "42" )
+);
+
+/* Loop to test normal functionality with different arrays inputs */
+echo "\n*** Normal testing with various array inputs ***\n";
+
+$counter = 1;
+foreach( $mixed_array as $sub_array )
+{
+ echo "\n-- Input Array for Iteration $counter is --\n";
+ var_dump( $sub_array );
+ echo "\nFirst key is :\n";
+ var_dump( array_key_first($sub_array) );
+ $counter++;
+}
+
+echo"\nDone";
+?>
+--EXPECT--
+*** Normal testing with various array inputs ***
+
+-- Input Array for Iteration 1 is --
+array(0) {
+}
+
+First key is :
+NULL
+
+-- Input Array for Iteration 2 is --
+array(9) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+}
+
+First key is :
+int(0)
+
+-- Input Array for Iteration 3 is --
+array(5) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(4) "_Two"
+  [2]=>
+  string(5) "Three"
+  [3]=>
+  string(4) "Four"
+  [4]=>
+  string(4) "Five"
+}
+
+First key is :
+int(0)
+
+-- Input Array for Iteration 4 is --
+array(8) {
+  [0]=>
+  int(6)
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+  [3]=>
+  string(5) "seven"
+  [4]=>
+  int(8)
+  [5]=>
+  string(5) "eight"
+  [6]=>
+  int(9)
+  [7]=>
+  string(4) "nine"
+}
+
+First key is :
+int(0)
+
+-- Input Array for Iteration 5 is --
+array(5) {
+  ["a"]=>
+  string(3) "aaa"
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+  ["d"]=>
+  string(3) "ddd"
+  ["e"]=>
+  string(3) "eee"
+}
+
+First key is :
+string(1) "a"
+
+-- Input Array for Iteration 6 is --
+array(5) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+
+First key is :
+int(1)
+
+-- Input Array for Iteration 7 is --
+array(5) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  int(7)
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+
+First key is :
+int(1)
+
+-- Input Array for Iteration 8 is --
+array(12) {
+  ["f"]=>
+  string(3) "fff"
+  [1]=>
+  string(3) "one"
+  [4]=>
+  int(6)
+  [""]=>
+  int(3)
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+  [3]=>
+  float(3.7)
+  [5]=>
+  string(4) "Five"
+  [6]=>
+  float(8.6)
+  ["4name"]=>
+  string(5) "jonny"
+  ["a"]=>
+  NULL
+}
+
+First key is :
+string(1) "f"
+
+-- Input Array for Iteration 9 is --
+array(4) {
+  [0]=>
+  int(12)
+  [1]=>
+  string(4) "name"
+  [2]=>
+  string(3) "age"
+  [3]=>
+  string(2) "45"
+}
+
+First key is :
+int(0)
+
+-- Input Array for Iteration 10 is --
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(3) "oNe"
+    [1]=>
+    string(3) "tWo"
+    [2]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [2]=>
+  array(0) {
+  }
+}
+
+First key is :
+int(0)
+
+-- Input Array for Iteration 11 is --
+array(10) {
+  ["one"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [0]=>
+  int(3)
+  [1]=>
+  int(4)
+  [3]=>
+  int(33)
+  [4]=>
+  int(44)
+  [5]=>
+  int(57)
+  [6]=>
+  int(6)
+  ["5.4"]=>
+  int(554)
+  ["5.7"]=>
+  int(557)
+}
+
+First key is :
+string(3) "one"
+
+-- Input Array for Iteration 12 is --
+array(1) {
+  [0]=>
+  string(3) "foo"
+}
+
+First key is :
+int(0)
+
+-- Input Array for Iteration 13 is --
+array(1) {
+  [1]=>
+  string(2) "42"
+}
+
+First key is :
+int(1)
+
+Done
diff --git a/tests/std/array/array_key_first_variation.phpt b/tests/std/array/array_key_first_variation.phpt
new file mode 100644
index 00000000..d619ed01
--- /dev/null
+++ b/tests/std/array/array_key_first_variation.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Test array_key_first() function (variation)
+--FILE--
+<?php
+
+/* Various combinations of arrays to be used for the test */
+$array = array( 1,2,3,4,5,6,7,8,9 );
+
+echo"\n*** Checking for internal array pointer not being changed by array_key_first ***\n";
+
+echo "\nCurrent Element is : ";
+var_dump( current($array) );
+
+echo "\nNext Element is : ";
+var_dump( next($array) );
+
+echo "\nFirst key is : ";
+var_dump( array_key_first($array) );
+
+echo "\nCurrent Element after array_key_first operation is: ";
+var_dump( current($array) );
+
+echo"\nDone";
+?>
+--EXPECT--
+*** Checking for internal array pointer not being changed by array_key_first ***
+
+Current Element is : int(1)
+
+Next Element is : int(2)
+
+First key is : int(0)
+
+Current Element after array_key_first operation is: int(2)
+
+Done
diff --git a/tests/std/array/array_key_last.phpt b/tests/std/array/array_key_last.phpt
new file mode 100644
index 00000000..a81d7ca9
--- /dev/null
+++ b/tests/std/array/array_key_last.phpt
@@ -0,0 +1,296 @@
+--TEST--
+Test array_key_last() function
+--SKIPIF--
+<?php
+if (true) die("skip AOT has a known issue with this test pattern");
+?>
+
+--FILE--
+<?php
+
+array_key_last($GLOBALS);
+
+/* Various combinations of arrays to be used for the test */
+$mixed_array = array(
+  array(),
+  array( 1,2,3,4,5,6,7,8,9 ),
+  array( "One", "_Two", "Three", "Four", "Five" ),
+  array( 6, "six", 7, "seven", 8, "eight", 9, "nine" ),
+  array( "a" => "aaa", "A" => "AAA", "c" => "ccc", "d" => "ddd", "e" => "eee" ),
+  array( "1" => "one", "2" => "two", "3" => "three", "4" => "four", "5" => "five" ),
+  array( 1 => "one", 2 => "two", 3 => 7, 4 => "four", 5 => "five" ),
+  array( "f" => "fff", "1" => "one", 4 => 6, "" => "blank", 2 => "float", "F" => "FFF",
+         "blank" => "", 3 => 3.7, 5 => 7, 6 => 8.6, '5' => "Five", "4name" => "jonny", "a" => NULL, NULL => 3 ),
+  array( 12, "name", 'age', '45' ),
+  array( array("oNe", "tWo", 4), array(10, 20, 30, 40, 50), array() ),
+  array( "one" => 1, "one" => 2, "three" => 3, 3, 4, 3 => 33, 4 => 44, 5, 6,
+          5 => 57, "5.4" => 554, "5.7" => 557 ),
+  array( "foo" ),
+  array( 1 => "42" )
+);
+
+/* Loop to test normal functionality with different arrays inputs */
+echo "\n*** Normal testing with various array inputs ***\n";
+
+$counter = 1;
+foreach( $mixed_array as $sub_array )
+{
+ echo "\n-- Input Array for Iteration $counter is --\n";
+ var_dump( $sub_array );
+ echo "\nLast key is :\n";
+ var_dump( array_key_last($sub_array) );
+ $counter++;
+}
+
+echo"\nDone";
+?>
+--EXPECT--
+*** Normal testing with various array inputs ***
+
+-- Input Array for Iteration 1 is --
+array(0) {
+}
+
+Last key is :
+NULL
+
+-- Input Array for Iteration 2 is --
+array(9) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+}
+
+Last key is :
+int(8)
+
+-- Input Array for Iteration 3 is --
+array(5) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(4) "_Two"
+  [2]=>
+  string(5) "Three"
+  [3]=>
+  string(4) "Four"
+  [4]=>
+  string(4) "Five"
+}
+
+Last key is :
+int(4)
+
+-- Input Array for Iteration 4 is --
+array(8) {
+  [0]=>
+  int(6)
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+  [3]=>
+  string(5) "seven"
+  [4]=>
+  int(8)
+  [5]=>
+  string(5) "eight"
+  [6]=>
+  int(9)
+  [7]=>
+  string(4) "nine"
+}
+
+Last key is :
+int(7)
+
+-- Input Array for Iteration 5 is --
+array(5) {
+  ["a"]=>
+  string(3) "aaa"
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+  ["d"]=>
+  string(3) "ddd"
+  ["e"]=>
+  string(3) "eee"
+}
+
+Last key is :
+string(1) "e"
+
+-- Input Array for Iteration 6 is --
+array(5) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+
+Last key is :
+int(5)
+
+-- Input Array for Iteration 7 is --
+array(5) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  int(7)
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+
+Last key is :
+int(5)
+
+-- Input Array for Iteration 8 is --
+array(12) {
+  ["f"]=>
+  string(3) "fff"
+  [1]=>
+  string(3) "one"
+  [4]=>
+  int(6)
+  [""]=>
+  int(3)
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+  [3]=>
+  float(3.7)
+  [5]=>
+  string(4) "Five"
+  [6]=>
+  float(8.6)
+  ["4name"]=>
+  string(5) "jonny"
+  ["a"]=>
+  NULL
+}
+
+Last key is :
+string(1) "a"
+
+-- Input Array for Iteration 9 is --
+array(4) {
+  [0]=>
+  int(12)
+  [1]=>
+  string(4) "name"
+  [2]=>
+  string(3) "age"
+  [3]=>
+  string(2) "45"
+}
+
+Last key is :
+int(3)
+
+-- Input Array for Iteration 10 is --
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(3) "oNe"
+    [1]=>
+    string(3) "tWo"
+    [2]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [2]=>
+  array(0) {
+  }
+}
+
+Last key is :
+int(2)
+
+-- Input Array for Iteration 11 is --
+array(10) {
+  ["one"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [0]=>
+  int(3)
+  [1]=>
+  int(4)
+  [3]=>
+  int(33)
+  [4]=>
+  int(44)
+  [5]=>
+  int(57)
+  [6]=>
+  int(6)
+  ["5.4"]=>
+  int(554)
+  ["5.7"]=>
+  int(557)
+}
+
+Last key is :
+string(3) "5.7"
+
+-- Input Array for Iteration 12 is --
+array(1) {
+  [0]=>
+  string(3) "foo"
+}
+
+Last key is :
+int(0)
+
+-- Input Array for Iteration 13 is --
+array(1) {
+  [1]=>
+  string(2) "42"
+}
+
+Last key is :
+int(1)
+
+Done
diff --git a/tests/std/array/array_key_last_variation.phpt b/tests/std/array/array_key_last_variation.phpt
new file mode 100644
index 00000000..3b2a4867
--- /dev/null
+++ b/tests/std/array/array_key_last_variation.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Test array_key_last() function (variation)
+--FILE--
+<?php
+
+/* Various combinations of arrays to be used for the test */
+$array = array( 1,2,3,4,5,6,7,8,9 );
+
+echo"\n*** Checking for internal array pointer not being changed by array_key_last ***\n";
+
+echo "\nCurrent Element is : ";
+var_dump( current($array) );
+
+echo "\nNext Element is : ";
+var_dump( next($array) );
+
+echo "\nLast key is : ";
+var_dump( array_key_last($array) );
+
+echo "\nCurrent Element after array_key_last operation is: ";
+var_dump( current($array) );
+
+echo"\nDone";
+?>
+--EXPECT--
+*** Checking for internal array pointer not being changed by array_key_last ***
+
+Current Element is : int(1)
+
+Next Element is : int(2)
+
+Last key is : int(8)
+
+Current Element after array_key_last operation is: int(2)
+
+Done
diff --git a/tests/std/array/array_keys_basic.phpt b/tests/std/array/array_keys_basic.phpt
new file mode 100644
index 00000000..dc54976d
--- /dev/null
+++ b/tests/std/array/array_keys_basic.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Test array_keys() function (basic)
+--FILE--
+<?php
+
+echo "*** Testing array_keys() on basic array operation ***\n";
+$basic_arr = array("a" => 1, "b" => 2, 2 => 2.0, -23 => "asdasd",
+                   array(1,2,3));
+var_dump(array_keys($basic_arr));
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing array_keys() on basic array operation ***
+array(5) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  int(2)
+  [3]=>
+  int(-23)
+  [4]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/array_keys_on_GLOBALS.phpt b/tests/std/array/array_keys_on_GLOBALS.phpt
new file mode 100644
index 00000000..6231d5e6
--- /dev/null
+++ b/tests/std/array/array_keys_on_GLOBALS.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Using array_keys() on $GLOBALS
+--SKIPIF--
+<?php
+if (true) die("skip AOT has a known issue with this test pattern");
+?>
+
+--FILE--
+<?php
+
+$foo = 'bar';
+unset($foo);
+var_dump(in_array('foo', array_keys($GLOBALS)));
+
+?>
+--EXPECT--
+bool(false)
diff --git a/tests/std/array/array_keys_variation_001.phpt b/tests/std/array/array_keys_variation_001.phpt
new file mode 100644
index 00000000..1e194ae8
--- /dev/null
+++ b/tests/std/array/array_keys_variation_001.phpt
@@ -0,0 +1,149 @@
+--TEST--
+Test array_keys() function (variation - 1)
+--SKIPIF--
+<?php die("skip AOT empty string key handling differs from PHP"); ?>
+--FILE--
+<?php
+
+echo "\n*** Testing array_keys() on various arrays ***";
+$arrays = array(
+  array(),
+  array(0),
+  array( array() ),
+  array("Hello" => "World"),
+  array("" => ""),
+  array(1,2,3, "d" => array(4,6, "d")),
+  array("a" => 1, "b" => 2, "c" =>3, "d" => array()),
+  array(0 => 0, 1 => 1, 2 => 2, 3 => 3),
+  array(0 =>3.000, 1 =>2, 1 =>3, "a"=>3, 3=>5, "5"=>3.000),
+  array(TRUE => TRUE, FALSE => FALSE, NULL => NULL, "\x000", "\000"),
+  array("a" => "abcd", "a" => "", "ab" => -6, "cd" => -0.5 ),
+  array(0 => array(), 1=> array(0), 2 => array(1), ""=> array(),""=>"" )
+);
+
+$i = 0;
+/* loop through to test array_keys() with different arrays */
+foreach ($arrays as $array) {
+  echo "\n-- Iteration $i --\n";
+  var_dump(array_keys($array));
+  $i++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing array_keys() on various arrays ***
+-- Iteration 0 --
+array(0) {
+}
+
+-- Iteration 1 --
+array(1) {
+  [0]=>
+  int(0)
+}
+
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  int(0)
+}
+
+-- Iteration 3 --
+array(1) {
+  [0]=>
+  string(5) "Hello"
+}
+
+-- Iteration 4 --
+array(1) {
+  [0]=>
+  string(0) ""
+}
+
+-- Iteration 5 --
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  string(1) "d"
+}
+
+-- Iteration 6 --
+array(4) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+  [3]=>
+  string(1) "d"
+}
+
+-- Iteration 7 --
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+}
+
+-- Iteration 8 --
+array(5) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  string(1) "a"
+  [3]=>
+  int(3)
+  [4]=>
+  int(5)
+}
+
+-- Iteration 9 --
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(0)
+  [2]=>
+  string(0) ""
+  [3]=>
+  int(2)
+  [4]=>
+  int(3)
+}
+
+-- Iteration 10 --
+array(3) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(2) "ab"
+  [2]=>
+  string(2) "cd"
+}
+
+-- Iteration 11 --
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  string(0) ""
+}
+Done
diff --git a/tests/std/array/array_keys_variation_002.phpt b/tests/std/array/array_keys_variation_002.phpt
new file mode 100644
index 00000000..1765c217
--- /dev/null
+++ b/tests/std/array/array_keys_variation_002.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Test array_keys() function (variation - 2)
+--FILE--
+<?php
+
+echo "\n*** Testing array_keys() on an array created on the fly ***\n";
+var_dump(array_keys(array("a" => 1, "b" => 2, "c" => 3)));
+var_dump(array_keys(array()));  // null array
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing array_keys() on an array created on the fly ***
+array(3) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_keys_variation_003.phpt b/tests/std/array/array_keys_variation_003.phpt
new file mode 100644
index 00000000..b04c5445
--- /dev/null
+++ b/tests/std/array/array_keys_variation_003.phpt
@@ -0,0 +1,114 @@
+--TEST--
+Test array_keys() function (variation - 3)
+--SKIPIF--
+<?php die("skip AOT array_keys strict comparison differs from PHP"); ?>
+--FILE--
+<?php
+
+echo "*** Testing array_keys() on all the types other than arrays ***\n";
+$types_arr = array(
+  TRUE => TRUE,
+  FALSE => FALSE,
+  1 => 1,
+  0 => 0,
+  -1 => -1,
+  "1" => "1",
+  "0" => "0",
+  "-1" => "-1",
+  NULL,
+  array(),
+  "php" => "php",
+  "" => ""
+);
+$values = array(TRUE, FALSE, 1, 0, -1, "1", "0", "-1",  NULL, array(), "php", "");
+foreach ($values as $value){
+    var_dump($value);
+    var_dump(array_keys($types_arr, $value));
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing array_keys() on all the types other than arrays ***
+bool(true)
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(-1)
+  [2]=>
+  string(3) "php"
+}
+bool(false)
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  string(0) ""
+}
+int(1)
+array(1) {
+  [0]=>
+  int(1)
+}
+int(0)
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(2)
+}
+int(-1)
+array(1) {
+  [0]=>
+  int(-1)
+}
+string(1) "1"
+array(1) {
+  [0]=>
+  int(1)
+}
+string(1) "0"
+array(1) {
+  [0]=>
+  int(0)
+}
+string(2) "-1"
+array(1) {
+  [0]=>
+  int(-1)
+}
+NULL
+array(3) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+  [2]=>
+  string(0) ""
+}
+array(0) {
+}
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+string(3) "php"
+array(1) {
+  [0]=>
+  string(3) "php"
+}
+string(0) ""
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  string(0) ""
+}
+Done
diff --git a/tests/std/array/array_keys_variation_004.phpt b/tests/std/array/array_keys_variation_004.phpt
new file mode 100644
index 00000000..a919d69e
--- /dev/null
+++ b/tests/std/array/array_keys_variation_004.phpt
@@ -0,0 +1,73 @@
+--TEST--
+Test array_keys() function (variation - 4)
+--SKIPIF--
+<?php
+if (true) die("skip AOT has a known issue with this test pattern");
+?>
+
+--FILE--
+<?php
+
+echo "*** Testing array_keys() on all the types other than arrays ***\n";
+$types_arr = array(
+  TRUE => TRUE,
+  FALSE => FALSE,
+  1 => 1,
+  0 => 0,
+  -1 => -1,
+  "1" => "1",
+  "0" => "0",
+  "-1" => "-1",
+  NULL,
+  array(),
+  "php" => "php",
+  "" => ""
+);
+$values = array(TRUE, FALSE, 1, 0, -1, "1", "0", "-1",  NULL, array(), "php", "");
+foreach ($values as $value){
+  var_dump(array_keys($types_arr, $value, TRUE));
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing array_keys() on all the types other than arrays ***
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(0)
+}
+array(1) {
+  [0]=>
+  int(-1)
+}
+array(1) {
+  [0]=>
+  int(2)
+}
+array(1) {
+  [0]=>
+  int(3)
+}
+array(1) {
+  [0]=>
+  string(3) "php"
+}
+array(1) {
+  [0]=>
+  string(0) ""
+}
+Done
diff --git a/tests/std/array/array_keys_variation_005.phpt b/tests/std/array/array_keys_variation_005.phpt
new file mode 100644
index 00000000..c9870ec6
--- /dev/null
+++ b/tests/std/array/array_keys_variation_005.phpt
@@ -0,0 +1,45 @@
+--TEST--
+Test array_keys() function (variation - 5)
+--SKIPIF--
+<?php
+if (true) die("skip AOT has a known issue with this test pattern");
+?>
+
+--FILE--
+<?php
+
+echo "\n*** Testing array_keys() with resource type ***\n";
+$resource1 = fopen( __FILE__, "r");
+$resource2 = opendir( "." );
+
+/* creating an array with resource types as elements */
+$arr_resource = array($resource1, $resource2);
+
+var_dump(array_keys($arr_resource, $resource1));  // loose type checking
+var_dump(array_keys($arr_resource, $resource1, TRUE));  // strict type checking
+var_dump(array_keys($arr_resource, $resource2));  // loose type checking
+var_dump(array_keys($arr_resource, $resource2, TRUE));  // strict type checking
+
+/* Closing the resource handles */
+fclose( $resource1 );
+closedir( $resource2 );
+
+?>
+--EXPECT--
+*** Testing array_keys() with resource type ***
+array(1) {
+  [0]=>
+  int(0)
+}
+array(1) {
+  [0]=>
+  int(0)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
diff --git a/tests/std/array/array_map_001.phpt b/tests/std/array/array_map_001.phpt
new file mode 100644
index 00000000..964480cd
--- /dev/null
+++ b/tests/std/array/array_map_001.phpt
@@ -0,0 +1,24 @@
+--TEST--
+array_map() and exceptions in the callback
+--SKIPIF--
+<?php die("skip AOT array_map with exceptions differs from PHP"); ?>
+--FILE--
+<?php
+function foo()
+{
+    throw new exception(1);
+}
+function main()
+{
+    $a = array(1, 2, 3);
+    try {
+        array_map("foo", $a, array(2, 3));
+    } catch (Exception $e) {
+        var_dump("exception caught!");
+    }
+    echo "Done\n";
+}
+?>
+--EXPECT--
+string(17) "exception caught!"
+Done
diff --git a/tests/std/array/array_map_basic.phpt b/tests/std/array/array_map_basic.phpt
new file mode 100644
index 00000000..70d260c1
--- /dev/null
+++ b/tests/std/array/array_map_basic.phpt
@@ -0,0 +1,62 @@
+--TEST--
+Test array_map() function : basic functionality
+--FILE--
+<?php
+function multiply($p, $q)
+{
+    return $p * $q;
+}
+function square($p)
+{
+    return $p * $p;
+}
+function concatenate($a, $b)
+{
+    return "{$a} = {$b}";
+}
+function main()
+{
+    echo "*** Testing array_map() : basic functionality ***\n";
+    // integer array
+    $arr1 = array(1, 2, 3);
+    $arr2 = array(4, 5, 6);
+    echo "-- With two integer array --\n";
+    var_dump(array_map('multiply', $arr1, $arr2));
+    echo "-- With single integer array --\n";
+    var_dump(array_map('square', $arr1));
+    // string array
+    $arr1 = array("one", "two");
+    $arr2 = array("single", "double");
+    echo "-- With string array --\n";
+    var_dump(array_map('concatenate', $arr1, $arr2));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : basic functionality ***
+-- With two integer array --
+array(3) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(10)
+  [2]=>
+  int(18)
+}
+-- With single integer array --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(4)
+  [2]=>
+  int(9)
+}
+-- With string array --
+array(2) {
+  [0]=>
+  string(12) "one = single"
+  [1]=>
+  string(12) "two = double"
+}
+Done
diff --git a/tests/std/array/array_map_error.phpt b/tests/std/array/array_map_error.phpt
new file mode 100644
index 00000000..aaacbebc
--- /dev/null
+++ b/tests/std/array/array_map_error.phpt
@@ -0,0 +1,58 @@
+--TEST--
+Test array_map() function : error conditions
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support testing invalid argument counts in this way");
+?>
+
+--FILE--
+<?php
+function callback1()
+{
+    return 1;
+}
+function callback2($p, $q)
+{
+    return $p * $q;
+}
+function main()
+{
+    echo "*** Testing array_map() : error conditions ***\n";
+    // Testing array_map with one less than the expected number of arguments
+    echo "\n-- Testing array_map() function with one less than expected no. of arguments --\n";
+    try {
+        var_dump(array_map('callback1'));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "\n-- Testing array_map() function with less no. of arrays than callback function arguments --\n";
+    $arr1 = array(1, 2);
+    try {
+        var_dump(array_map('callback2', $arr1));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "\n-- Testing array_map() function with more no. of arrays than callback function arguments --\n";
+    $arr2 = array(3, 4);
+    $arr3 = array(5, 6);
+    var_dump(array_map('callback2', $arr1, $arr2, $arr3));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : error conditions ***
+
+-- Testing array_map() function with one less than expected no. of arguments --
+Exception: array_map() expects at least 2 arguments, 1 given
+
+-- Testing array_map() function with less no. of arrays than callback function arguments --
+Exception: Too few arguments to function callback2(), 1 passed and exactly 2 expected
+
+-- Testing array_map() function with more no. of arrays than callback function arguments --
+array(2) {
+  [0]=>
+  int(3)
+  [1]=>
+  int(8)
+}
+Done
diff --git a/tests/std/array/array_map_object1.phpt b/tests/std/array/array_map_object1.phpt
new file mode 100644
index 00000000..1baeeba6
--- /dev/null
+++ b/tests/std/array/array_map_object1.phpt
@@ -0,0 +1,195 @@
+--TEST--
+Test array_map() function : usage variations - object functionality
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+class SimpleClass
+{
+    public $var1 = 1;
+    public static function square($n)
+    {
+        return $n * $n;
+    }
+}
+function test($cb, $args)
+{
+    echo join('::', $cb) . "\n";
+    try {
+        var_dump(array_map($cb, $args));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+}
+class SimpleClassPri
+{
+    private $var1 = 10;
+    private static function add($n)
+    {
+        return $var + $n;
+    }
+}
+class SimpleClassPro
+{
+    protected $var1 = 5;
+    protected static function mul($n)
+    {
+        return $var1 * $n;
+    }
+}
+class EmptyClass
+{
+}
+abstract class AbstractClass
+{
+    protected $var2 = 5;
+    abstract static function emptyFunction();
+}
+// class deriving the above abstract class
+class ChildClass extends AbstractClass
+{
+    private $var3;
+    public static function emptyFunction()
+    {
+        echo "defined in child\n";
+    }
+}
+class FinalClass
+{
+    private $var4;
+    final static function finalMethod()
+    {
+        echo "This function can't be overloaded\n";
+    }
+}
+class StaticClass
+{
+    static $var5 = 2;
+    public static function square($n)
+    {
+        return $n * $n;
+    }
+    private static function cube($n)
+    {
+        return $n * $n * $n;
+    }
+    protected static function retVal($n)
+    {
+        return array($n);
+    }
+}
+interface myInterface
+{
+    public function toImplement();
+}
+class InterClass implements myInterface
+{
+    public static function square($n)
+    {
+        return $n * $n;
+    }
+    public function toImplement()
+    {
+        return 1;
+    }
+}
+function main()
+{
+    /*
+     * Testing array_map() for object functionalities:
+     *   1) simple class with variable and method
+     *   2) class without members
+     *   3) class with only one method and no variable
+     *   4) abstract and child class
+     *   5) class with static and final members
+     *   6) interface and implemented class
+     */
+    echo "*** Testing array_map() : object functionality ***\n";
+    echo "-- simple class with public variable and method --\n";
+    test(array('SimpleClass', 'square'), array(1, 2));
+    echo "\n-- simple class with private variable and method --\n";
+    test(array('SimpleClassPri', 'add'), array(1));
+    echo "\n-- simple class with protected variable and method --\n";
+    test(array('SimpleClassPro', 'mul'), array(2));
+    echo "\n-- class without members --\n";
+    test(array('EmptyClass'), array(1, 2));
+    echo "\n-- abstract class --\n";
+    test(array('ChildClass', 'emptyFunction'), array(1, 2));
+    echo "\n-- class with final method --\n";
+    test(array('FinalClass', 'finalMethod'), array(1, 2));
+    echo "\n-- class with static members --\n";
+    test(array('StaticClass', 'square'), array(1, 2));
+    test(array('StaticClass', 'cube'), array(2));
+    test(array('StaticClass', 'retVal'), array(3, 4));
+    echo "-- class implementing an interface --\n";
+    test(array('InterClass', 'square'), array(1, 2));
+}
+?>
+--EXPECT--
+*** Testing array_map() : object functionality ***
+-- simple class with public variable and method --
+SimpleClass::square
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(4)
+}
+
+-- simple class with private variable and method --
+SimpleClassPri::add
+array_map(): Argument #1 ($callback) must be a valid callback or null, cannot access private method SimpleClassPri::add()
+
+-- simple class with protected variable and method --
+SimpleClassPro::mul
+array_map(): Argument #1 ($callback) must be a valid callback or null, cannot access protected method SimpleClassPro::mul()
+
+-- class without members --
+EmptyClass
+array_map(): Argument #1 ($callback) must be a valid callback or null, array callback must have exactly two members
+
+-- abstract class --
+ChildClass::emptyFunction
+defined in child
+defined in child
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+
+-- class with final method --
+FinalClass::finalMethod
+This function can't be overloaded
+This function can't be overloaded
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+
+-- class with static members --
+StaticClass::square
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(4)
+}
+StaticClass::cube
+array_map(): Argument #1 ($callback) must be a valid callback or null, cannot access private method StaticClass::cube()
+StaticClass::retVal
+array_map(): Argument #1 ($callback) must be a valid callback or null, cannot access protected method StaticClass::retVal()
+-- class implementing an interface --
+InterClass::square
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(4)
+}
diff --git a/tests/std/array/array_map_object2.phpt b/tests/std/array/array_map_object2.phpt
new file mode 100644
index 00000000..3f281e0a
--- /dev/null
+++ b/tests/std/array/array_map_object2.phpt
@@ -0,0 +1,46 @@
+--TEST--
+Test array_map() function : object functionality - with non-existent class and method
+--FILE--
+<?php
+class SimpleClass
+{
+    public $var1 = 1;
+    public function square($n)
+    {
+        return $n * $n;
+    }
+    public static function cube($n)
+    {
+        return $n * $n * $n;
+    }
+}
+function main()
+{
+    /*
+     * Testing array_map() for following object functionalities:
+     *   1) non-existent class
+     *   2) existent class and non-existent function
+     */
+    echo "*** Testing array_map() :  with non-existent class and method ***\n";
+    echo "-- with non-existent class --\n";
+    try {
+        var_dump(array_map(array('non-existent', 'square'), array(1, 2)));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    echo "-- with existent class and non-existent method --\n";
+    try {
+        var_dump(array_map(array('SimpleClass', 'non-existent'), array(1, 2)));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() :  with non-existent class and method ***
+-- with non-existent class --
+array_map(): Argument #1 ($callback) must be a valid callback or null, class "non-existent" not found
+-- with existent class and non-existent method --
+array_map(): Argument #1 ($callback) must be a valid callback or null, class SimpleClass does not have a method "non-existent"
+Done
diff --git a/tests/std/array/array_map_object3.phpt b/tests/std/array/array_map_object3.phpt
new file mode 100644
index 00000000..7786801a
--- /dev/null
+++ b/tests/std/array/array_map_object3.phpt
@@ -0,0 +1,90 @@
+--TEST--
+Test array_map() function : object functionality - class methods as callback function
+--FILE--
+<?php
+class ParentClass
+{
+    public $var1 = 10;
+    public static function staticParent1($n)
+    {
+        return $n;
+    }
+    private static function staticParent2($n)
+    {
+        return $n;
+    }
+}
+class ChildClass extends ParentClass
+{
+    var $parent_obj;
+    public function __construct()
+    {
+        $this->parent_obj = new ParentClass();
+    }
+    public $var2 = 5;
+    public static function staticChild($n)
+    {
+        return $n;
+    }
+    public function nonstaticChild($n)
+    {
+        return $n;
+    }
+}
+function main()
+{
+    /*
+     * Testing array_map() for object functionality with following callback function variations:
+     *   1) child class method using parent object
+     *   2) parent class method using child object
+     *   3) child class method using parent class
+     *   4) parent class method using child class
+     */
+    echo "*** Testing array_map() : class methods as callback function ***\n";
+    $arr1 = array(1, 5, 7);
+    $childobj = new ChildClass();
+    $parentobj = new ParentClass();
+    echo "-- accessing parent method from child class --\n";
+    var_dump(array_map(array('ChildClass', 'staticParent1'), $arr1));
+    echo "-- accessing child method from parent class --\n";
+    try {
+        var_dump(array_map(array('ParentClass', 'staticChild'), $arr1));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    echo "-- accessing parent method using child class object --\n";
+    var_dump(array_map(array($childobj, 'staticParent1'), $arr1));
+    echo "-- accessing child method using parent class object --\n";
+    try {
+        var_dump(array_map(array($parentobj, 'staticChild'), $arr1));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : class methods as callback function ***
+-- accessing parent method from child class --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(5)
+  [2]=>
+  int(7)
+}
+-- accessing child method from parent class --
+array_map(): Argument #1 ($callback) must be a valid callback or null, class ParentClass does not have a method "staticChild"
+-- accessing parent method using child class object --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(5)
+  [2]=>
+  int(7)
+}
+-- accessing child method using parent class object --
+array_map(): Argument #1 ($callback) must be a valid callback or null, class ParentClass does not have a method "staticChild"
+Done
diff --git a/tests/std/array/array_map_variation1.phpt b/tests/std/array/array_map_variation1.phpt
new file mode 100644
index 00000000..68f77437
--- /dev/null
+++ b/tests/std/array/array_map_variation1.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_map() function : usage variations - string keys
+--FILE--
+<?php
+function cb1($a)
+{
+    return array($a);
+}
+function cb2($a, $b)
+{
+    return array($a, $b);
+}
+function main()
+{
+    echo "*** Testing array_map() : string keys ***\n";
+    $arr = array("stringkey" => "value");
+    var_dump(array_map("cb1", $arr));
+    var_dump(array_map("cb2", $arr, $arr));
+    var_dump(array_map(null, $arr));
+    var_dump(array_map(null, $arr, $arr));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : string keys ***
+array(1) {
+  ["stringkey"]=>
+  array(1) {
+    [0]=>
+    string(5) "value"
+  }
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(5) "value"
+    [1]=>
+    string(5) "value"
+  }
+}
+array(1) {
+  ["stringkey"]=>
+  string(5) "value"
+}
+array(1) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(5) "value"
+    [1]=>
+    string(5) "value"
+  }
+}
+Done
diff --git a/tests/std/array/array_map_variation10.phpt b/tests/std/array/array_map_variation10.phpt
new file mode 100644
index 00000000..1d79ffed
--- /dev/null
+++ b/tests/std/array/array_map_variation10.phpt
@@ -0,0 +1,89 @@
+--TEST--
+Test array_map() function : usage variations - anonymous callback function
+--SKIPIF--
+<?php die("skip AOT array_map with anonymous callback differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * Test array_map() by passing anonymous callback function with following variations
+ */
+
+echo "*** Testing array_map() : anonymous callback function ***\n";
+
+$array1 = array(1, 2, 3);
+$array2 = array(3, 4, 5);
+
+echo "-- anonymous function with all parameters and body --\n";
+var_dump( array_map( function($a, $b) { return array($a, $b); }, $array1, $array2));
+
+echo "-- anonymous function with two parameters and passing one array --\n";
+try {
+    var_dump( array_map( function($a, $b) { return array($a, $b); }, $array1));
+} catch (Throwable $e) {
+    echo "Exception: " . $e->getMessage() . "\n";
+}
+
+echo "-- anonymous function with NULL parameter --\n";
+var_dump( array_map( function() { return NULL; }, $array1));
+
+echo "-- anonymous function with NULL body --\n";
+var_dump( array_map( function($a) { }, $array1));
+
+echo "-- passing NULL as 'array1' --\n";
+try {
+    var_dump( array_map( function($a) { return array($a); }, NULL));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_map() : anonymous callback function ***
+-- anonymous function with all parameters and body --
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(3)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(4)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(5)
+  }
+}
+-- anonymous function with two parameters and passing one array --
+Exception: Too few arguments to function {closure:%s:%d}(), 1 passed and exactly 2 expected
+-- anonymous function with NULL parameter --
+array(3) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  NULL
+}
+-- anonymous function with NULL body --
+array(3) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  NULL
+}
+-- passing NULL as 'array1' --
+array_map(): Argument #2 ($array) must be of type array, null given
+Done
diff --git a/tests/std/array/array_map_variation11.phpt b/tests/std/array/array_map_variation11.phpt
new file mode 100644
index 00000000..7749af78
--- /dev/null
+++ b/tests/std/array/array_map_variation11.phpt
@@ -0,0 +1,46 @@
+--TEST--
+Test array_map() function : usage variations - with recursive callback
+--FILE--
+<?php
+function square_recur_single_array($var)
+{
+    if (is_array($var)) {
+        return array_map('square_recur_single_array', $var);
+    }
+    return $var * $var;
+}
+function main()
+{
+    /*
+     * Test array_map() by passing subarrays and recursive callback function
+     */
+    echo "*** Testing array_map() : recursive callback function ***\n";
+    $array1 = array(1, array(2, 3, array(5)), array(4));
+    var_dump(array_map('square_recur_single_array', $array1));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : recursive callback function ***
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  array(3) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(9)
+    [2]=>
+    array(1) {
+      [0]=>
+      int(25)
+    }
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(16)
+  }
+}
+Done
diff --git a/tests/std/array/array_map_variation12.phpt b/tests/std/array/array_map_variation12.phpt
new file mode 100644
index 00000000..d3fa62e9
--- /dev/null
+++ b/tests/std/array/array_map_variation12.phpt
@@ -0,0 +1,48 @@
+--TEST--
+Test array_map() function : usage variations - built-in function as callback
+--FILE--
+<?php
+/*
+ * Test array_map() by passing buit-in function as callback function
+ */
+
+echo "*** Testing array_map() : built-in function ***\n";
+
+$array1 = array(1, 2, 3);
+$array2 = array(3, 4, 5);
+
+echo "-- with built-in function 'pow' and two parameters --\n";
+var_dump( array_map('pow', $array1, $array2));
+
+echo "-- with built-in function 'pow' and one parameter --\n";
+try {
+    var_dump( array_map('pow', $array1));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "-- with language construct --\n";
+try {
+    var_dump( array_map('echo', $array1));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_map() : built-in function ***
+-- with built-in function 'pow' and two parameters --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(16)
+  [2]=>
+  int(243)
+}
+-- with built-in function 'pow' and one parameter --
+pow() expects exactly 2 arguments, 1 given
+-- with language construct --
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "echo" not found or invalid function name
+Done
diff --git a/tests/std/array/array_map_variation13.phpt b/tests/std/array/array_map_variation13.phpt
new file mode 100644
index 00000000..596e04af
--- /dev/null
+++ b/tests/std/array/array_map_variation13.phpt
@@ -0,0 +1,97 @@
+--TEST--
+Test array_map() function : usage variations - callback function with different return types
+--FILE--
+<?php
+function callback_int($a, $b)
+{
+    return $a + $b;
+}
+function callback_string($a, $b)
+{
+    return "{$a}" . "{$b}";
+}
+function callback_bool($a, $b)
+{
+    return TRUE;
+}
+function callback_null($array1)
+{
+    return NULL;
+}
+function callback_without_ret($arr1)
+{
+    echo "callback_without_ret called\n";
+}
+function main()
+{
+    /*
+     * Test array_map() by passing different callback function returning:
+     *   int, string, bool, null values
+     */
+    echo "*** Testing array_map() : callback with diff return value ***\n";
+    $array1 = array(1, 2, 3);
+    $array2 = array(3, 4, 5);
+    echo "-- with integer return value --\n";
+    var_dump(array_map('callback_int', $array1, $array2));
+    echo "-- with string return value --\n";
+    var_dump(array_map('callback_string', $array1, $array2));
+    echo "-- with bool return value --\n";
+    var_dump(array_map('callback_bool', $array1, $array2));
+    echo "-- with null return value --\n";
+    var_dump(array_map('callback_null', $array1));
+    echo "-- with no return value --\n";
+    var_dump(array_map('callback_without_ret', $array1));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : callback with diff return value ***
+-- with integer return value --
+array(3) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(6)
+  [2]=>
+  int(8)
+}
+-- with string return value --
+array(3) {
+  [0]=>
+  string(2) "13"
+  [1]=>
+  string(2) "24"
+  [2]=>
+  string(2) "35"
+}
+-- with bool return value --
+array(3) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(true)
+  [2]=>
+  bool(true)
+}
+-- with null return value --
+array(3) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  NULL
+}
+-- with no return value --
+callback_without_ret called
+callback_without_ret called
+callback_without_ret called
+array(3) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  NULL
+}
+Done
diff --git a/tests/std/array/array_map_variation14.phpt b/tests/std/array/array_map_variation14.phpt
new file mode 100644
index 00000000..b1276b92
--- /dev/null
+++ b/tests/std/array/array_map_variation14.phpt
@@ -0,0 +1,129 @@
+--TEST--
+Test array_map() function : usage variations - null value for 'callback' argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Test array_map() by passing null values for $callback argument and testing whether shortest
+ * array will be extended with empty elements
+ */
+
+echo "*** Testing array_map() : null value for 'callback' argument ***\n";
+
+// arrays to be passed as arguments
+$arr1 = array(1, 2);
+$arr2 = array("one", "two");
+$arr3 = array(1.1, 2.2);
+
+// get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+/* calling array_map() with null callback */
+
+echo "-- with null --\n";
+var_dump( array_map(null, $arr1, $arr2, $arr3) );
+var_dump( array_map(NULL, $arr1, $arr2, $arr3) );
+
+echo "-- with unset variable --\n";
+var_dump( array_map(@$unset_var, $arr1, $arr2, $arr3) );
+
+echo "-- with undefined variable --\n";
+var_dump( array_map(@$undefined_var, $arr1) );
+
+echo "-- with empty string --\n";
+try {
+    var_dump( array_map("", $arr1, $arr2) );
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "-- with empty array --\n";
+try {
+    var_dump( array_map(array(), $arr1, $arr2) );
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_map() : null value for 'callback' argument ***
+-- with null --
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    string(3) "one"
+    [2]=>
+    float(1.1)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(2)
+    [1]=>
+    string(3) "two"
+    [2]=>
+    float(2.2)
+  }
+}
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    string(3) "one"
+    [2]=>
+    float(1.1)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(2)
+    [1]=>
+    string(3) "two"
+    [2]=>
+    float(2.2)
+  }
+}
+-- with unset variable --
+array(2) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    string(3) "one"
+    [2]=>
+    float(1.1)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(2)
+    [1]=>
+    string(3) "two"
+    [2]=>
+    float(2.2)
+  }
+}
+-- with undefined variable --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+-- with empty string --
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "" not found or invalid function name
+-- with empty array --
+array_map(): Argument #1 ($callback) must be a valid callback or null, array callback must have exactly two members
+Done
diff --git a/tests/std/array/array_map_variation15.phpt b/tests/std/array/array_map_variation15.phpt
new file mode 100644
index 00000000..d053a720
--- /dev/null
+++ b/tests/std/array/array_map_variation15.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Test array_map() function : usage variations - non existent 'callback' function
+--FILE--
+<?php
+/*
+ * Test array_map() by passing non existent function for $callback argument
+ */
+
+echo "*** Testing array_map() : non existent 'callback' function ***\n";
+
+// arrays to be passed as arguments
+$arr1 = array(1, 2);
+$arr2 = array("one", "two");
+$arr3 = array(1.1, 2.2);
+
+try {
+    var_dump( array_map('non_existent', $arr1, $arr2, $arr3) );
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_map() : non existent 'callback' function ***
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "non_existent" not found or invalid function name
+Done
diff --git a/tests/std/array/array_map_variation16.phpt b/tests/std/array/array_map_variation16.phpt
new file mode 100644
index 00000000..7ee1f049
--- /dev/null
+++ b/tests/std/array/array_map_variation16.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Test array_map() function : usage variations - failing built-in functions & language constructs
+--FILE--
+<?php
+
+$arg = [1, 2];
+
+// built-in functions & language constructs
+$callbacks = [
+    'echo',
+    'array',
+    'empty',
+    'eval',
+    'isset',
+    'list',
+    'print',
+];
+
+foreach($callbacks as $callback)
+{
+    try {
+        var_dump( array_map($callback, $arg) );
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+}
+
+echo "Done";
+?>
+--EXPECT--
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "echo" not found or invalid function name
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "array" not found or invalid function name
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "empty" not found or invalid function name
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "eval" not found or invalid function name
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "isset" not found or invalid function name
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "list" not found or invalid function name
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "print" not found or invalid function name
+Done
diff --git a/tests/std/array/array_map_variation17.phpt b/tests/std/array/array_map_variation17.phpt
new file mode 100644
index 00000000..24cf2892
--- /dev/null
+++ b/tests/std/array/array_map_variation17.phpt
@@ -0,0 +1,133 @@
+--TEST--
+Test array_map() function : usage variations - unexpected values for 'callback' argument
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Test array_map() by passing different scalar/nonscalar values in place of $callback
+     */
+    echo "*** Testing array_map() : unexpected values for 'callback' argument ***\n";
+    $arr1 = array(1, 2, 3);
+    // get a resource variable
+    $fp = fopen(__FILE__, "r");
+    // unexpected values to be passed to $input argument
+    $unexpected_callbacks = array(
+        // int data
+        /*1*/
+        0,
+        1,
+        12345,
+        -2345,
+        // float data
+        /*5*/
+        10.5,
+        -10.5,
+        123456789000.0,
+        1.23456789E-9,
+        0.5,
+        // boolean data
+        /*10*/
+        true,
+        false,
+        TRUE,
+        FALSE,
+        // empty data
+        /*14*/
+        "",
+        '',
+        // array data
+        /*16*/
+        array(),
+        array(1, 2),
+        array(1, array(2)),
+        // object data
+        /*19*/
+        new classA(),
+        // resource variable
+        /*20*/
+        $fp,
+    );
+    // loop through each element of $inputs to check the behavior of array_map
+    for ($count = 0; $count < count($unexpected_callbacks); $count++) {
+        echo "\n-- Iteration " . ($count + 1) . " --\n";
+        try {
+            var_dump(array_map($unexpected_callbacks[$count], $arr1));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : unexpected values for 'callback' argument ***
+
+-- Iteration 1 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 2 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 3 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 4 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 5 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 6 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 7 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 8 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 9 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 10 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 11 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 12 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 13 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 14 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "" not found or invalid function name
+
+-- Iteration 15 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, function "" not found or invalid function name
+
+-- Iteration 16 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, array callback must have exactly two members
+
+-- Iteration 17 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, first array member is not a valid class name or object
+
+-- Iteration 18 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, first array member is not a valid class name or object
+
+-- Iteration 19 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+
+-- Iteration 20 --
+array_map(): Argument #1 ($callback) must be a valid callback or null, no array or string given
+Done
diff --git a/tests/std/array/array_map_variation19.phpt b/tests/std/array/array_map_variation19.phpt
new file mode 100644
index 00000000..a725117a
--- /dev/null
+++ b/tests/std/array/array_map_variation19.phpt
@@ -0,0 +1,35 @@
+--TEST--
+Test array_map() function : usage variations - callback pass semantics
+--FILE--
+<?php
+function callback($a)
+{
+    $a = "changed";
+}
+function main()
+{
+    /*
+     * Test array_map() with a pass-by-value callback forced to behave as a pass-by-reference function.
+     */
+    $arr1 = array('original.0', 'original.1');
+    $arr2 = array('original.0', 'original.1');
+    array_map('callback', $arr1);
+    var_dump($arr1);
+    $ref =& $arr2[0];
+    array_map("callback", $arr2);
+    var_dump($arr2);
+}
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  string(10) "original.0"
+  [1]=>
+  string(10) "original.1"
+}
+array(2) {
+  [0]=>
+  &string(10) "original.0"
+  [1]=>
+  string(10) "original.1"
+}
diff --git a/tests/std/array/array_map_variation2.phpt b/tests/std/array/array_map_variation2.phpt
new file mode 100644
index 00000000..6101ca2f
--- /dev/null
+++ b/tests/std/array/array_map_variation2.phpt
@@ -0,0 +1,134 @@
+--TEST--
+Test array_map() function : usage variations - references
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support dynamic array access");
+?>
+
+--FILE--
+<?php
+function cb1($a)
+{
+    var_dump($a);
+    return array($a);
+}
+function main()
+{
+    echo "*** Testing array_map() : references ***\n";
+    $arr = array("k1" => "v1", "k2" => "v2");
+    $arr[] =& $arr["k1"];
+    $arr[] =& $arr;
+    var_dump(array_map("cb1", $arr));
+    var_dump(array_map(null, $arr));
+    var_dump(array_map(null, $arr, $arr));
+    // break cycles
+    $arr[0] = null;
+    $arr[1] = null;
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : references ***
+string(2) "v1"
+string(2) "v2"
+string(2) "v1"
+array(4) {
+  ["k1"]=>
+  &string(2) "v1"
+  ["k2"]=>
+  string(2) "v2"
+  [0]=>
+  &string(2) "v1"
+  [1]=>
+  *RECURSION*
+}
+array(4) {
+  ["k1"]=>
+  array(1) {
+    [0]=>
+    string(2) "v1"
+  }
+  ["k2"]=>
+  array(1) {
+    [0]=>
+    string(2) "v2"
+  }
+  [0]=>
+  array(1) {
+    [0]=>
+    string(2) "v1"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    array(4) {
+      ["k1"]=>
+      &string(2) "v1"
+      ["k2"]=>
+      string(2) "v2"
+      [0]=>
+      &string(2) "v1"
+      [1]=>
+      *RECURSION*
+    }
+  }
+}
+array(4) {
+  ["k1"]=>
+  &string(2) "v1"
+  ["k2"]=>
+  string(2) "v2"
+  [0]=>
+  &string(2) "v1"
+  [1]=>
+  *RECURSION*
+}
+array(4) {
+  [0]=>
+  array(2) {
+    [0]=>
+    &string(2) "v1"
+    [1]=>
+    &string(2) "v1"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(2) "v2"
+    [1]=>
+    string(2) "v2"
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    &string(2) "v1"
+    [1]=>
+    &string(2) "v1"
+  }
+  [3]=>
+  array(2) {
+    [0]=>
+    &array(4) {
+      ["k1"]=>
+      &string(2) "v1"
+      ["k2"]=>
+      string(2) "v2"
+      [0]=>
+      &string(2) "v1"
+      [1]=>
+      *RECURSION*
+    }
+    [1]=>
+    &array(4) {
+      ["k1"]=>
+      &string(2) "v1"
+      ["k2"]=>
+      string(2) "v2"
+      [0]=>
+      &string(2) "v1"
+      [1]=>
+      *RECURSION*
+    }
+  }
+}
+Done
diff --git a/tests/std/array/array_map_variation3.phpt b/tests/std/array/array_map_variation3.phpt
new file mode 100644
index 00000000..778fdc6a
--- /dev/null
+++ b/tests/std/array/array_map_variation3.phpt
@@ -0,0 +1,234 @@
+--TEST--
+Test array_map() function : usage variations - different arrays for 'arr1' argument
+--SKIPIF--
+<?php die("skip AOT array_map differs from PHP for different array types"); ?>
+--FILE--
+<?php
+function callback($a)
+{
+    return $a;
+}
+function main()
+{
+    /*
+     * Test array_map() by passing different arrays for $arr1 argument
+     */
+    echo "*** Testing array_map() : different arrays for 'arr1' argument ***\n";
+    // different arrays
+    $arrays = array(
+        /*1*/
+        array(1, 2),
+        // array with default keys and numeric values
+        array(1.1, 2.2),
+        // array with default keys & float values
+        array(array(2), array(1)),
+        // sub arrays
+        array(false, true),
+        // array with default keys and boolean values
+        array(),
+        // empty array
+        array(NULL),
+        // array with NULL
+        array("a", "aaaa", "b", "bbbb", "c", "ccccc"),
+        // associative arrays
+        /*8*/
+        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
+        /*13*/
+        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
+        /*18*/
+        array("One" => 1, "two" => 2, "One" => 10, "two" => 20, "three" => 3),
+    );
+    // loop through the various elements of $arrays to test array_map()
+    $iterator = 1;
+    foreach ($arrays as $arr1) {
+        echo "-- Iteration {$iterator} --\n";
+        var_dump(array_map('callback', $arr1));
+        $iterator++;
+    }
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : different arrays for 'arr1' argument ***
+-- Iteration 1 --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+-- Iteration 2 --
+array(2) {
+  [0]=>
+  float(1.1)
+  [1]=>
+  float(2.2)
+}
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+-- Iteration 4 --
+array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+-- Iteration 5 --
+array(0) {
+}
+-- Iteration 6 --
+array(1) {
+  [0]=>
+  NULL
+}
+-- Iteration 7 --
+array(6) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(4) "aaaa"
+  [2]=>
+  string(1) "b"
+  [3]=>
+  string(4) "bbbb"
+  [4]=>
+  string(1) "c"
+  [5]=>
+  string(5) "ccccc"
+}
+-- Iteration 8 --
+array(3) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+}
+-- Iteration 9 --
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+}
+-- Iteration 10 --
+array(4) {
+  [1]=>
+  int(10)
+  [2]=>
+  int(20)
+  [4]=>
+  int(40)
+  [3]=>
+  int(30)
+}
+-- Iteration 11 --
+array(3) {
+  ["one"]=>
+  string(3) "ten"
+  ["two"]=>
+  string(6) "twenty"
+  ["three"]=>
+  string(6) "thirty"
+}
+-- Iteration 12 --
+array(3) {
+  ["one"]=>
+  int(1)
+  [2]=>
+  string(3) "two"
+  [4]=>
+  string(4) "four"
+}
+-- Iteration 13 --
+array(3) {
+  [""]=>
+  string(4) "null"
+  ["NULL"]=>
+  NULL
+  ["null"]=>
+  NULL
+}
+-- Iteration 14 --
+array(4) {
+  [1]=>
+  string(4) "true"
+  [0]=>
+  string(5) "false"
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+}
+-- Iteration 15 --
+array(3) {
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+  ["emptys"]=>
+  string(0) ""
+}
+-- Iteration 16 --
+array(6) {
+  [1]=>
+  string(0) ""
+  [2]=>
+  string(0) ""
+  [3]=>
+  NULL
+  [4]=>
+  NULL
+  [5]=>
+  bool(false)
+  [6]=>
+  bool(true)
+}
+-- Iteration 17 --
+array(3) {
+  [""]=>
+  int(4)
+  [0]=>
+  int(5)
+  [1]=>
+  int(6)
+}
+-- Iteration 18 --
+array(3) {
+  ["One"]=>
+  int(10)
+  ["two"]=>
+  int(20)
+  ["three"]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/array_map_variation4.phpt b/tests/std/array/array_map_variation4.phpt
new file mode 100644
index 00000000..9190ffdf
--- /dev/null
+++ b/tests/std/array/array_map_variation4.phpt
@@ -0,0 +1,147 @@
+--TEST--
+Test array_map() function : usage variations - associative array with different keys
+--SKIPIF--
+<?php die("skip AOT array_map differs from PHP for associative arrays"); ?>
+--FILE--
+<?php
+function callback($a)
+{
+    return $a;
+}
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Test array_map() by passing associative array with different keys for $arr1 argument
+     */
+    echo "*** Testing array_map() : associative array with diff. keys for 'arr1' 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;
+    // initializing the array
+    $arrays = array(
+        // empty array
+        /*1*/
+        array(),
+        // arrays with integer keys
+        /*2*/
+        array(0 => "0"),
+        array(1 => "1"),
+        array(1 => "1", 2 => "2", 3 => "3", 4 => "4"),
+        // arrays with string keys
+        array('\tHello' => 111, 're\td' => 'color', '\v\fworld' => 2.2, 'pen\n' => 33),
+        /*8*/
+        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
+        array(@$unset_var => "hello", $fp => 'resource'),
+        // array with mixed values
+        /*11*/
+        array('hello' => 1, "fruit" => 2.2, $fp => 'resource', 133 => "int", @$unset_var => "unset", $heredoc => "heredoc"),
+    );
+    // loop through the various elements of $arrays to test array_map()
+    $iterator = 1;
+    foreach ($arrays as $arr1) {
+        echo "-- Iteration {$iterator} --\n";
+        var_dump(array_map('callback', $arr1));
+        $iterator++;
+    }
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_map() : associative array with diff. keys for 'arr1' 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) {
+  ["\tHello"]=>
+  int(111)
+  ["re\td"]=>
+  string(5) "color"
+  ["\v\fworld"]=>
+  float(2.2)
+  ["pen\n"]=>
+  int(33)
+}
+-- Iteration 6 --
+array(4) {
+  ["	Hello"]=>
+  int(111)
+  ["re	d"]=>
+  string(5) "color"
+  ["world"]=>
+  float(2.2)
+  ["pen
+"]=>
+  int(33)
+}
+-- Iteration 7 --
+array(2) {
+  [0]=>
+  string(5) "hello"
+  ["Hello world"]=>
+  string(6) "string"
+}
+-- Iteration 8 --
+array(2) {
+  [""]=>
+  string(5) "hello"
+  [5]=>
+  string(8) "resource"
+}
+-- Iteration 9 --
+array(6) {
+  ["hello"]=>
+  int(1)
+  ["fruit"]=>
+  float(2.2)
+  [5]=>
+  string(8) "resource"
+  [133]=>
+  string(3) "int"
+  [""]=>
+  string(5) "unset"
+  ["Hello world"]=>
+  string(7) "heredoc"
+}
+Done
diff --git a/tests/std/array/array_map_variation5.phpt b/tests/std/array/array_map_variation5.phpt
new file mode 100644
index 00000000..dfb9ecf2
--- /dev/null
+++ b/tests/std/array/array_map_variation5.phpt
@@ -0,0 +1,169 @@
+--TEST--
+Test array_map() function : usage variations - associative array with different values
+--SKIPIF--
+<?php die("skip AOT array_map differs from PHP for associative arrays"); ?>
+--FILE--
+<?php
+function callback($a)
+{
+    return $a;
+}
+//get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Test array_map() by passing associative array with different values for $arr1 argument
+     */
+    echo "*** Testing array_map() : associative array with diff. values for 'arr1' argument ***\n";
+    //get an unset variable
+    $unset_var = array(1, 2);
+    unset($unset_var);
+    //get a resource variable
+    $fp = fopen(__FILE__, "r");
+    // get a heredoc string
+    $heredoc = <<<EOT
+    Hello world
+    EOT;
+    // initializing the 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.3333),
+        // arrays with string values
+        array(111 => "\tHello", "red" => "col\tor", 2 => "\v\fworld", 3 => "pen\n"),
+        /*8*/
+        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
+        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 the various elements of $arrays to test array_map()
+    $iterator = 1;
+    foreach ($arrays as $arr1) {
+        echo "-- Iteration {$iterator} --\n";
+        var_dump(array_map('callback', $arr1));
+        $iterator++;
+    }
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_map() : associative array with diff. values for 'arr1' argument ***
+-- Iteration 1 --
+array(0) {
+}
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  int(0)
+}
+-- Iteration 3 --
+array(1) {
+  [1]=>
+  int(1)
+}
+-- Iteration 4 --
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [4]=>
+  int(4)
+}
+-- Iteration 5 --
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+-- Iteration 6 --
+array(4) {
+  ["f1"]=>
+  float(1.2)
+  ["f2"]=>
+  float(3.33)
+  [3]=>
+  float(4.89999922839999)
+  ["f4"]=>
+  float(33333333.3333)
+}
+-- Iteration 7 --
+array(4) {
+  [111]=>
+  string(6) "	Hello"
+  ["red"]=>
+  string(6) "col	or"
+  [2]=>
+  string(7) "world"
+  [3]=>
+  string(4) "pen
+"
+}
+-- Iteration 8 --
+array(4) {
+  [111]=>
+  string(7) "\tHello"
+  ["red"]=>
+  string(7) "col\tor"
+  [2]=>
+  string(9) "\v\fworld"
+  [3]=>
+  string(5) "pen\n"
+}
+-- Iteration 9 --
+array(2) {
+  [1]=>
+  string(5) "hello"
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+-- Iteration 10 --
+array(3) {
+  [11]=>
+  object(classA)#%d (0) {
+  }
+  ["unset"]=>
+  NULL
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+-- Iteration 11 --
+array(8) {
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  object(classA)#%d (0) {
+  }
+  [222]=>
+  string(5) "fruit"
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["int"]=>
+  int(133)
+  ["float"]=>
+  float(444.432)
+  ["unset"]=>
+  NULL
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+Done
diff --git a/tests/std/array/array_map_variation6.phpt b/tests/std/array/array_map_variation6.phpt
new file mode 100644
index 00000000..d82eebb9
--- /dev/null
+++ b/tests/std/array/array_map_variation6.phpt
@@ -0,0 +1,60 @@
+--TEST--
+Test array_map() function : usage variations - array having subarrays
+--FILE--
+<?php
+function callback($a)
+{
+    return $a;
+}
+function main()
+{
+    /*
+     * Test array_map() by passing array having different subarrays
+     */
+    echo "*** Testing array_map() : array having subarrays ***\n";
+    // different subarrays
+    $arr1 = array(array(), array(1, 2), array('a', 'b'), array(1, 2, 'a', 'b'), array(1 => 'a', 'b' => 2));
+    var_dump(array_map('callback', $arr1));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : array having subarrays ***
+array(5) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+  }
+  [3]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    string(1) "a"
+    [3]=>
+    string(1) "b"
+  }
+  [4]=>
+  array(2) {
+    [1]=>
+    string(1) "a"
+    ["b"]=>
+    int(2)
+  }
+}
+Done
diff --git a/tests/std/array/array_map_variation7.phpt b/tests/std/array/array_map_variation7.phpt
new file mode 100644
index 00000000..6ac8b51b
--- /dev/null
+++ b/tests/std/array/array_map_variation7.phpt
@@ -0,0 +1,101 @@
+--TEST--
+Test array_map() function : usage variations - arrays of different size
+--SKIPIF--
+<?php //die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function callback($a, $b)
+{
+    return array($a => $b);
+}
+function main()
+{
+    /*
+     * Test array_map() by passing array having different size
+     *   1) first array as empty array
+     *   2) second array as empty array
+     *   3) second array shorter than first array
+     *   4) first array shorter than second array
+     *   5) one more array than callback function arguments
+     */
+    echo "*** Testing array_map() : arrays with diff. size ***\n";
+    // calling array_map with different arrays
+    var_dump(array_map('callback', array(1, 2, 3), array()));
+    var_dump(array_map('callback', array(), array('a', 'b', 'c')));
+    var_dump(array_map('callback', array(1, 2, 3), array('a', 'b')));
+    var_dump(array_map('callback', array(012, 0x2f, 0x1a), array(2.3, 1240.0)));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : arrays with diff. size ***
+array(3) {
+  [0]=>
+  array(1) {
+    [1]=>
+    NULL
+  }
+  [1]=>
+  array(1) {
+    [2]=>
+    NULL
+  }
+  [2]=>
+  array(1) {
+    [3]=>
+    NULL
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [0]=>
+    string(1) "a"
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(1) "b"
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    string(1) "c"
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [1]=>
+    string(1) "a"
+  }
+  [1]=>
+  array(1) {
+    [2]=>
+    string(1) "b"
+  }
+  [2]=>
+  array(1) {
+    [3]=>
+    NULL
+  }
+}
+array(3) {
+  [0]=>
+  array(1) {
+    [10]=>
+    float(2.3)
+  }
+  [1]=>
+  array(1) {
+    [47]=>
+    float(1240)
+  }
+  [2]=>
+  array(1) {
+    [26]=>
+    NULL
+  }
+}
+Done
diff --git a/tests/std/array/array_map_variation8.phpt b/tests/std/array/array_map_variation8.phpt
new file mode 100644
index 00000000..28391ff4
--- /dev/null
+++ b/tests/std/array/array_map_variation8.phpt
@@ -0,0 +1,65 @@
+--TEST--
+Test array_map() function : usage variations - array with references
+--FILE--
+<?php
+function callback1($a)
+{
+    return $a;
+}
+function callback_cat($a, $b)
+{
+    return $a . $b;
+}
+function main()
+{
+    /*
+     * Test array_map() by passing array having reference values for $arr1 argument
+     */
+    echo "*** Testing array_map() : array with references for 'arr1' argument ***\n";
+    // reference variables
+    $value1 = 10;
+    $value2 = "hello";
+    $value3 = 0;
+    $value4 =& $value2;
+    // array containing reference variables
+    $arr1 = array(0 => 0, 1 => &$value4, 2 => &$value2, 3 => "hello", 4 => &$value3, $value4 => &$value2);
+    echo "-- with one array --\n";
+    var_dump(array_map('callback1', $arr1));
+    echo "-- with two arrays --\n";
+    var_dump(array_map('callback_cat', $arr1, $arr1));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : array with references for 'arr1' argument ***
+-- with one array --
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "hello"
+  [3]=>
+  string(5) "hello"
+  [4]=>
+  int(0)
+  ["hello"]=>
+  string(5) "hello"
+}
+-- with two arrays --
+array(6) {
+  [0]=>
+  string(2) "00"
+  [1]=>
+  string(10) "hellohello"
+  [2]=>
+  string(10) "hellohello"
+  [3]=>
+  string(10) "hellohello"
+  [4]=>
+  string(2) "00"
+  [5]=>
+  string(10) "hellohello"
+}
+Done
diff --git a/tests/std/array/array_map_variation9.phpt b/tests/std/array/array_map_variation9.phpt
new file mode 100644
index 00000000..4ac45686
--- /dev/null
+++ b/tests/std/array/array_map_variation9.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Test array_map() function : usage variations - binary safe checking
+--SKIPIF--
+<?php die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function callback1($a)
+{
+    return $a;
+}
+function callback2($a, $b)
+{
+    return array($a => $b);
+}
+function main()
+{
+    /*
+     * Test array_map() by passing array having binary values for $arr1 argument
+     */
+    echo "*** Testing array_map() : array with binary data for 'arr1' argument ***\n";
+    // array with binary data
+    $arr1 = array("hello", "world", "1", "22.22");
+    echo "-- checking binary safe array with one parameter callback function --\n";
+    var_dump(array_map('callback1', $arr1));
+    echo "-- checking binary safe array with two parameter callback function --\n";
+    try {
+        var_dump(array_map("callback2", $arr1));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_map() : array with binary data for 'arr1' argument ***
+-- checking binary safe array with one parameter callback function --
+array(4) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+  [2]=>
+  string(1) "1"
+  [3]=>
+  string(5) "22.22"
+}
+-- checking binary safe array with two parameter callback function --
+Exception: Too few arguments to function callback2(), 1 passed and exactly 2 expected
+Done
diff --git a/tests/std/array/array_merge.phpt b/tests/std/array/array_merge.phpt
new file mode 100644
index 00000000..5890f94a
--- /dev/null
+++ b/tests/std/array/array_merge.phpt
@@ -0,0 +1,914 @@
+--TEST--
+Test array_merge() function
+--INI--
+precision=14
+--SKIPIF--
+<?php die("skip AOT array_merge numeric key reindexing differs from PHP"); ?>
+--FILE--
+<?php
+echo "\n*** Testing array_merge() basic functionality ***";
+$begin_array = array(
+  array(),
+  array( 1 => "string"),
+  array( "" => "string"),
+  array( -2 => 12),
+  array( "a" => 1, "b" => -2.344, "b" => "string", "c" => NULL,	"d" => -2.344),
+  array( 4 => 1, 3 => -2.344, "3" => "string", "2" => NULL,1 => -2.344),
+  array( NULL, 1 => "Hi", "string" => "hello",
+  array("" => "World", "-2.34" => "a", "0" => "b"))
+);
+
+$end_array   = array(
+  array(),
+  array( 1 => "string"),
+  array( "" => "string"),
+  array( -2 => 12),
+  array( "a" => 1, "b" => -2.344, "b" => "string", "c" => NULL, "d" => -2.344),
+  array( 4 => 1, 3 => -2.344, "3" => "string", "2" => NULL, 1=> -2.344),
+  array( NULL, 1 => "Hi", "string" => "hello",
+         array("" => "World", "-2.34" => "a", "0" => "b"))
+);
+
+/* loop through to merge two arrays */
+$count_outer = 0;
+foreach($begin_array as $first) {
+  echo "\n\n--- Iteration $count_outer ---";
+  $count_inner = 0;
+  foreach($end_array as $second) {
+    echo "\n-- Inner iteration $count_inner of Iteration $count_outer --\n";
+    $result = array_merge($first, $second);
+    var_dump($result);
+    $count_inner++;
+  }
+  $count_outer++;
+}
+
+
+echo "\n*** Testing array_merge() with three or more arrays ***\n";
+var_dump( array_merge( $end_array[0],
+                       $end_array[5],
+                       $end_array[4],
+                       $end_array[6]
+                     )
+        );
+
+var_dump( array_merge( $end_array[0],
+                       $end_array[5],
+                       array("array on fly"),
+                       array("nullarray" => array())
+                     )
+        );
+
+
+echo "\n*** Testing single array argument ***\n";
+/* Empty array */
+var_dump(array_merge(array()));
+
+/* associative array with string keys, which will not be re-indexed */
+var_dump(array_merge($begin_array[4]));
+
+/* associative array with numeric keys, which will be re-indexed */
+var_dump(array_merge($begin_array[5]));
+
+/* associative array with mixed keys and sub-array as element */
+var_dump(array_merge($begin_array[6]));
+
+echo "\n*** Testing array_merge() with typecasting non-array to array ***\n";
+var_dump(array_merge($begin_array[4], (array)"type1", (array)10, (array)12.34));
+
+echo "\n*** Testing array_merge without any arguments ***\n";
+var_dump(array_merge());
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing array_merge() basic functionality ***
+
+--- Iteration 0 ---
+-- Inner iteration 0 of Iteration 0 --
+array(0) {
+}
+
+-- Inner iteration 1 of Iteration 0 --
+array(1) {
+  [0]=>
+  string(6) "string"
+}
+
+-- Inner iteration 2 of Iteration 0 --
+array(1) {
+  [""]=>
+  string(6) "string"
+}
+
+-- Inner iteration 3 of Iteration 0 --
+array(1) {
+  [0]=>
+  int(12)
+}
+
+-- Inner iteration 4 of Iteration 0 --
+array(4) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+}
+
+-- Inner iteration 5 of Iteration 0 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+}
+
+-- Inner iteration 6 of Iteration 0 --
+array(4) {
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+
+
+--- Iteration 1 ---
+-- Inner iteration 0 of Iteration 1 --
+array(1) {
+  [0]=>
+  string(6) "string"
+}
+
+-- Inner iteration 1 of Iteration 1 --
+array(2) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(6) "string"
+}
+
+-- Inner iteration 2 of Iteration 1 --
+array(2) {
+  [0]=>
+  string(6) "string"
+  [""]=>
+  string(6) "string"
+}
+
+-- Inner iteration 3 of Iteration 1 --
+array(2) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  int(12)
+}
+
+-- Inner iteration 4 of Iteration 1 --
+array(5) {
+  [0]=>
+  string(6) "string"
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+}
+
+-- Inner iteration 5 of Iteration 1 --
+array(5) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  int(1)
+  [2]=>
+  string(6) "string"
+  [3]=>
+  NULL
+  [4]=>
+  float(-2.344)
+}
+
+-- Inner iteration 6 of Iteration 1 --
+array(5) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  NULL
+  [2]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [3]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+
+
+--- Iteration 2 ---
+-- Inner iteration 0 of Iteration 2 --
+array(1) {
+  [""]=>
+  string(6) "string"
+}
+
+-- Inner iteration 1 of Iteration 2 --
+array(2) {
+  [""]=>
+  string(6) "string"
+  [0]=>
+  string(6) "string"
+}
+
+-- Inner iteration 2 of Iteration 2 --
+array(1) {
+  [""]=>
+  string(6) "string"
+}
+
+-- Inner iteration 3 of Iteration 2 --
+array(2) {
+  [""]=>
+  string(6) "string"
+  [0]=>
+  int(12)
+}
+
+-- Inner iteration 4 of Iteration 2 --
+array(5) {
+  [""]=>
+  string(6) "string"
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+}
+
+-- Inner iteration 5 of Iteration 2 --
+array(5) {
+  [""]=>
+  string(6) "string"
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+}
+
+-- Inner iteration 6 of Iteration 2 --
+array(5) {
+  [""]=>
+  string(6) "string"
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+
+
+--- Iteration 3 ---
+-- Inner iteration 0 of Iteration 3 --
+array(1) {
+  [0]=>
+  int(12)
+}
+
+-- Inner iteration 1 of Iteration 3 --
+array(2) {
+  [0]=>
+  int(12)
+  [1]=>
+  string(6) "string"
+}
+
+-- Inner iteration 2 of Iteration 3 --
+array(2) {
+  [0]=>
+  int(12)
+  [""]=>
+  string(6) "string"
+}
+
+-- Inner iteration 3 of Iteration 3 --
+array(2) {
+  [0]=>
+  int(12)
+  [1]=>
+  int(12)
+}
+
+-- Inner iteration 4 of Iteration 3 --
+array(5) {
+  [0]=>
+  int(12)
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+}
+
+-- Inner iteration 5 of Iteration 3 --
+array(5) {
+  [0]=>
+  int(12)
+  [1]=>
+  int(1)
+  [2]=>
+  string(6) "string"
+  [3]=>
+  NULL
+  [4]=>
+  float(-2.344)
+}
+
+-- Inner iteration 6 of Iteration 3 --
+array(5) {
+  [0]=>
+  int(12)
+  [1]=>
+  NULL
+  [2]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [3]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+
+
+--- Iteration 4 ---
+-- Inner iteration 0 of Iteration 4 --
+array(4) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+}
+
+-- Inner iteration 1 of Iteration 4 --
+array(5) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+  [0]=>
+  string(6) "string"
+}
+
+-- Inner iteration 2 of Iteration 4 --
+array(5) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+  [""]=>
+  string(6) "string"
+}
+
+-- Inner iteration 3 of Iteration 4 --
+array(5) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+  [0]=>
+  int(12)
+}
+
+-- Inner iteration 4 of Iteration 4 --
+array(4) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+}
+
+-- Inner iteration 5 of Iteration 4 --
+array(8) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+}
+
+-- Inner iteration 6 of Iteration 4 --
+array(8) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+
+
+--- Iteration 5 ---
+-- Inner iteration 0 of Iteration 5 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+}
+
+-- Inner iteration 1 of Iteration 5 --
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+  [4]=>
+  string(6) "string"
+}
+
+-- Inner iteration 2 of Iteration 5 --
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+  [""]=>
+  string(6) "string"
+}
+
+-- Inner iteration 3 of Iteration 5 --
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+  [4]=>
+  int(12)
+}
+
+-- Inner iteration 4 of Iteration 5 --
+array(8) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+}
+
+-- Inner iteration 5 of Iteration 5 --
+array(8) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+  [4]=>
+  int(1)
+  [5]=>
+  string(6) "string"
+  [6]=>
+  NULL
+  [7]=>
+  float(-2.344)
+}
+
+-- Inner iteration 6 of Iteration 5 --
+array(8) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+  [4]=>
+  NULL
+  [5]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [6]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+
+
+--- Iteration 6 ---
+-- Inner iteration 0 of Iteration 6 --
+array(4) {
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+
+-- Inner iteration 1 of Iteration 6 --
+array(5) {
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+  [3]=>
+  string(6) "string"
+}
+
+-- Inner iteration 2 of Iteration 6 --
+array(5) {
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+  [""]=>
+  string(6) "string"
+}
+
+-- Inner iteration 3 of Iteration 6 --
+array(5) {
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+  [3]=>
+  int(12)
+}
+
+-- Inner iteration 4 of Iteration 6 --
+array(8) {
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+}
+
+-- Inner iteration 5 of Iteration 6 --
+array(8) {
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+  [3]=>
+  int(1)
+  [4]=>
+  string(6) "string"
+  [5]=>
+  NULL
+  [6]=>
+  float(-2.344)
+}
+
+-- Inner iteration 6 of Iteration 6 --
+array(7) {
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+  [3]=>
+  NULL
+  [4]=>
+  string(2) "Hi"
+  [5]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+
+*** Testing array_merge() with three or more arrays ***
+array(12) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+  [4]=>
+  NULL
+  [5]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [6]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+  [4]=>
+  string(12) "array on fly"
+  ["nullarray"]=>
+  array(0) {
+  }
+}
+
+*** Testing single array argument ***
+array(0) {
+}
+array(4) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(6) "string"
+  [2]=>
+  NULL
+  [3]=>
+  float(-2.344)
+}
+array(4) {
+  [0]=>
+  NULL
+  [1]=>
+  string(2) "Hi"
+  ["string"]=>
+  string(5) "hello"
+  [2]=>
+  array(3) {
+    [""]=>
+    string(5) "World"
+    ["-2.34"]=>
+    string(1) "a"
+    [0]=>
+    string(1) "b"
+  }
+}
+
+*** Testing array_merge() with typecasting non-array to array ***
+array(7) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  string(6) "string"
+  ["c"]=>
+  NULL
+  ["d"]=>
+  float(-2.344)
+  [0]=>
+  string(5) "type1"
+  [1]=>
+  int(10)
+  [2]=>
+  float(12.34)
+}
+
+*** Testing array_merge without any arguments ***
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_merge_basic.phpt b/tests/std/array/array_merge_basic.phpt
new file mode 100644
index 00000000..e58d0cf5
--- /dev/null
+++ b/tests/std/array/array_merge_basic.phpt
@@ -0,0 +1,52 @@
+--TEST--
+Test array_merge() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of array_merge()
+ */
+
+echo "*** Testing array_merge() : basic functionality ***\n";
+
+//indexed array
+$array1 = array ('zero', 'one', 'two');
+//associative array
+$array2 = array ('a' => 1, 'b' => 2, 'c' => 3);
+
+var_dump(array_merge($array1, $array2));
+
+var_dump(array_merge($array2, $array1));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge() : basic functionality ***
+array(6) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  int(2)
+  ["c"]=>
+  int(3)
+}
+array(6) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  int(2)
+  ["c"]=>
+  int(3)
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_basic1.phpt b/tests/std/array/array_merge_recursive_basic1.phpt
new file mode 100644
index 00000000..97f38706
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_basic1.phpt
@@ -0,0 +1,99 @@
+--TEST--
+Test array_merge_recursive() function : basic functionality - array with default keys
+--FILE--
+<?php
+echo "*** Testing array_merge_recursive() : array with default keys ***\n";
+
+// Initialise the arrays
+$arr1 = array(1, array(1, 2));
+$arr2 = array(3, array("hello", 'world'));
+$arr3 = array(array(6, 7), array("str1", 'str2'));
+
+// Calling array_merge_recursive() without arguments
+echo "-- Without arguments --\n";
+var_dump( array_merge_recursive() );
+
+// Calling array_merge_recursive() with default arguments
+echo "-- With default argument --\n";
+var_dump( array_merge_recursive($arr1) );
+
+// Calling array_merge_recursive() with more arguments
+echo "-- With more arguments --\n";
+var_dump( array_merge_recursive($arr1,$arr2) );
+var_dump( array_merge_recursive($arr1,$arr2,$arr3) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : array with default keys ***
+-- Without arguments --
+array(0) {
+}
+-- With default argument --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+}
+-- With more arguments --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  int(3)
+  [3]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+}
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  int(3)
+  [3]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+  [4]=>
+  array(2) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+  }
+  [5]=>
+  array(2) {
+    [0]=>
+    string(4) "str1"
+    [1]=>
+    string(4) "str2"
+  }
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_basic2.phpt b/tests/std/array/array_merge_recursive_basic2.phpt
new file mode 100644
index 00000000..ee311113
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_basic2.phpt
@@ -0,0 +1,89 @@
+--TEST--
+Test array_merge_recursive() function : basic functionality - associative arrays
+--FILE--
+<?php
+echo "*** Testing array_merge_recursive() : associative arrays ***\n";
+
+// Initialise the arrays
+$arr1 = array(1 => "one", 2 => array(1, 2));
+$arr2 = array(2 => 'three', "four" => array("hello", 'world'));
+$arr3 = array(1 => array(6, 7), 'four' => array("str1", 'str2'));
+
+// Calling array_merge_recursive() with default arguments
+echo "-- With default argument --\n";
+var_dump( array_merge_recursive($arr1) );
+
+// Calling array_merge_recursive() with more arguments
+echo "-- With more arguments --\n";
+var_dump( array_merge_recursive($arr1,$arr2) );
+var_dump( array_merge_recursive($arr1,$arr2,$arr3) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : associative arrays ***
+-- With default argument --
+array(2) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+}
+-- With more arguments --
+array(4) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  string(5) "three"
+  ["four"]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+}
+array(5) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  string(5) "three"
+  ["four"]=>
+  array(4) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+    [2]=>
+    string(4) "str1"
+    [3]=>
+    string(4) "str2"
+  }
+  [3]=>
+  array(2) {
+    [0]=>
+    int(6)
+    [1]=>
+    int(7)
+  }
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_variation1.phpt b/tests/std/array/array_merge_recursive_variation1.phpt
new file mode 100644
index 00000000..f94a7165
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation1.phpt
@@ -0,0 +1,205 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - unexpected values for $arr1 argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+class A
+{
+    //  public $var = 10;
+    public function __toString(): string {
+        return "object";
+    }
+}
+function main()
+{
+    /*
+     * Passing non array values to 'arr1' argument of array_merge_recursive() and see
+     * that the function outputs proper warning messages wherever expected.
+    */
+    echo "*** Testing array_merge_recursive() : Passing non array values to \$arr1 argument ***\n";
+    //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");
+    // unexpected values to be passed to $arr1 argument
+    $arrays = 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,
+        // undefined data
+        /*21*/
+        @$undefined_var,
+        // unset data
+        /*22*/
+        @$unset_var,
+        // resource variable
+        /*23*/
+        $fp,
+        // object data
+        /*24*/
+        new A(),
+    );
+    // initialise the second argument
+    $arr2 = array(1, array("hello", 'world'));
+    // loop through each element of $arrays and check the behavior of array_merge_recursive()
+    $iterator = 1;
+    foreach ($arrays as $arr1) {
+        echo "\n-- Iteration {$iterator} --";
+        // with default argument
+        echo "\n-- With default argument --";
+        try {
+            var_dump(array_merge_recursive($arr1));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        // with more arguments
+        echo "-- With more arguments --";
+        try {
+            var_dump(array_merge_recursive($arr1, $arr2));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : Passing non array values to $arr1 argument ***
+
+-- Iteration 1 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, int given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, int given
+
+-- Iteration 2 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, int given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, int given
+
+-- Iteration 3 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, int given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, int given
+
+-- Iteration 4 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, int given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, int given
+
+-- Iteration 5 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, float given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, float given
+
+-- Iteration 6 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, float given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, float given
+
+-- Iteration 7 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, float given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, float given
+
+-- Iteration 8 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, float given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, float given
+
+-- Iteration 9 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, float given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, float given
+
+-- Iteration 10 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, null given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, null given
+
+-- Iteration 11 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, null given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, null given
+
+-- Iteration 12 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, true given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, true given
+
+-- Iteration 13 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, false given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, false given
+
+-- Iteration 14 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, true given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, true given
+
+-- Iteration 15 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, false given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, false given
+
+-- Iteration 16 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, string given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, string given
+
+-- Iteration 17 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, string given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, string given
+
+-- Iteration 18 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, string given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, string given
+
+-- Iteration 19 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, string given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, string given
+
+-- Iteration 20 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, string given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, string given
+
+-- Iteration 21 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, null given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, null given
+
+-- Iteration 22 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, null given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, null given
+
+-- Iteration 23 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, resource given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, resource given
+
+-- Iteration 24 --
+-- With default argument --array_merge_recursive(): Argument #1 must be of type array, A given
+-- With more arguments --array_merge_recursive(): Argument #1 must be of type array, A given
+Done
diff --git a/tests/std/array/array_merge_recursive_variation10.phpt b/tests/std/array/array_merge_recursive_variation10.phpt
new file mode 100644
index 00000000..7f03779c
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation10.phpt
@@ -0,0 +1,169 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - two dimensional arrays
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_merge_recursive() by passing
+ * two dimensional arrays for $arr1 argument.
+*/
+
+echo "*** Testing array_merge_recursive() : two dimensional array for \$arr1 argument ***\n";
+
+// initialize the 2-d array
+$arr1 = array(
+  array(1, 2, 3, 1),
+  "array" => array("hello", "world", "str1" => "hello", "str2" => 'world'),
+  array(1 => "one", 2 => "two", "one", 'two'),
+  array(1, 2, 3, 1)
+);
+
+// initialize the second argument
+$arr2 = array(1, "hello", "array" => array("hello", 'world'));
+
+echo "-- Passing the entire 2-d array --\n";
+echo "-- With default argument --\n";
+var_dump( array_merge_recursive($arr1) );
+echo "-- With more arguments --\n";
+var_dump( array_merge_recursive($arr1, $arr2) );
+
+echo "-- Passing the sub-array --\n";
+echo "-- With default argument --\n";
+var_dump( array_merge_recursive($arr1["array"]) );
+echo "-- With more arguments --\n";
+var_dump( array_merge_recursive($arr1["array"], $arr2["array"]) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : two dimensional array for $arr1 argument ***
+-- Passing the entire 2-d array --
+-- With default argument --
+array(4) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(1)
+  }
+  ["array"]=>
+  array(4) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+    ["str1"]=>
+    string(5) "hello"
+    ["str2"]=>
+    string(5) "world"
+  }
+  [1]=>
+  array(4) {
+    [1]=>
+    string(3) "one"
+    [2]=>
+    string(3) "two"
+    [3]=>
+    string(3) "one"
+    [4]=>
+    string(3) "two"
+  }
+  [2]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(1)
+  }
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(1)
+  }
+  ["array"]=>
+  array(6) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+    ["str1"]=>
+    string(5) "hello"
+    ["str2"]=>
+    string(5) "world"
+    [2]=>
+    string(5) "hello"
+    [3]=>
+    string(5) "world"
+  }
+  [1]=>
+  array(4) {
+    [1]=>
+    string(3) "one"
+    [2]=>
+    string(3) "two"
+    [3]=>
+    string(3) "one"
+    [4]=>
+    string(3) "two"
+  }
+  [2]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(1)
+  }
+  [3]=>
+  int(1)
+  [4]=>
+  string(5) "hello"
+}
+-- Passing the sub-array --
+-- With default argument --
+array(4) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+  ["str1"]=>
+  string(5) "hello"
+  ["str2"]=>
+  string(5) "world"
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+  ["str1"]=>
+  string(5) "hello"
+  ["str2"]=>
+  string(5) "world"
+  [2]=>
+  string(5) "hello"
+  [3]=>
+  string(5) "world"
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_variation2.phpt b/tests/std/array/array_merge_recursive_variation2.phpt
new file mode 100644
index 00000000..ff656dc8
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation2.phpt
@@ -0,0 +1,148 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - unexpected values for $arr2 argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+class A
+{
+    //  public $var = 10;
+    public function __toString(): string {
+        return "object";
+    }
+}
+function main()
+{
+    /*
+     * Passing non array values to 'arr2' argument of array_merge_recursive() and see
+     * that the function outputs proper warning messages wherever expected.
+    */
+    echo "*** Testing array_merge_recursive() : Passing non array values to \$arr2 argument ***\n";
+    // initialise the first argument
+    $arr1 = array(1, array("hello", 'world'));
+    //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");
+    // unexpected values to be passed to $arr2 argument
+    $arrays = 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,
+        // undefined data
+        /*21*/
+        @$undefined_var,
+        // unset data
+        /*22*/
+        @$unset_var,
+        // resource variable
+        /*23*/
+        $fp,
+        // object data
+        /*24*/
+        new A(),
+    );
+    // loop through each element of $arrays and check the behavior of array_merge_recursive()
+    $iterator = 1;
+    foreach ($arrays as $arr2) {
+        echo "\n-- Iteration {$iterator} --";
+        try {
+            var_dump(array_merge_recursive($arr1, $arr2));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : Passing non array values to $arr2 argument ***
+
+-- Iteration 1 --array_merge_recursive(): Argument #2 must be of type array, int given
+
+-- Iteration 2 --array_merge_recursive(): Argument #2 must be of type array, int given
+
+-- Iteration 3 --array_merge_recursive(): Argument #2 must be of type array, int given
+
+-- Iteration 4 --array_merge_recursive(): Argument #2 must be of type array, int given
+
+-- Iteration 5 --array_merge_recursive(): Argument #2 must be of type array, float given
+
+-- Iteration 6 --array_merge_recursive(): Argument #2 must be of type array, float given
+
+-- Iteration 7 --array_merge_recursive(): Argument #2 must be of type array, float given
+
+-- Iteration 8 --array_merge_recursive(): Argument #2 must be of type array, float given
+
+-- Iteration 9 --array_merge_recursive(): Argument #2 must be of type array, float given
+
+-- Iteration 10 --array_merge_recursive(): Argument #2 must be of type array, null given
+
+-- Iteration 11 --array_merge_recursive(): Argument #2 must be of type array, null given
+
+-- Iteration 12 --array_merge_recursive(): Argument #2 must be of type array, true given
+
+-- Iteration 13 --array_merge_recursive(): Argument #2 must be of type array, false given
+
+-- Iteration 14 --array_merge_recursive(): Argument #2 must be of type array, true given
+
+-- Iteration 15 --array_merge_recursive(): Argument #2 must be of type array, false given
+
+-- Iteration 16 --array_merge_recursive(): Argument #2 must be of type array, string given
+
+-- Iteration 17 --array_merge_recursive(): Argument #2 must be of type array, string given
+
+-- Iteration 18 --array_merge_recursive(): Argument #2 must be of type array, string given
+
+-- Iteration 19 --array_merge_recursive(): Argument #2 must be of type array, string given
+
+-- Iteration 20 --array_merge_recursive(): Argument #2 must be of type array, string given
+
+-- Iteration 21 --array_merge_recursive(): Argument #2 must be of type array, null given
+
+-- Iteration 22 --array_merge_recursive(): Argument #2 must be of type array, null given
+
+-- Iteration 23 --array_merge_recursive(): Argument #2 must be of type array, resource given
+
+-- Iteration 24 --array_merge_recursive(): Argument #2 must be of type array, A given
+Done
diff --git a/tests/std/array/array_merge_recursive_variation3.phpt b/tests/std/array/array_merge_recursive_variation3.phpt
new file mode 100644
index 00000000..8e1ff9f5
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation3.phpt
@@ -0,0 +1,758 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - different arrays for 'arr1' argument
+--SKIPIF--
+<?php die("skip AOT array_merge numeric key reindexing differs from PHP"); ?>
+--FILE--
+<?php
+/*
+* Passing different arrays to $arr1 argument and testing whether
+* array_merge_recursive() behaves in an expected way.
+*/
+
+echo "*** Testing array_merge_recursive() : Passing different arrays to \$arr1 argument ***\n";
+
+/* Different heredoc strings */
+
+// 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 $arr1 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", "\[\]\!\@\#\$\%\^\&\*\(\)\{\}"),  // with double quoted strings
+       array('a\v\f', 'aaaa\r', 'b', '\[\]\!\@\#\$\%\^\&\*\(\)\{\}'),  // with single quoted strings
+       array("h1" => $blank_line, "h2" => $multiline_string, "h3" => $diff_whitespaces),  // with heredocs
+
+       // associative arrays
+/*9*/  array(1 => "one", 2 => "two"),  // explicit numeric keys, string values
+       array("one" => 1, "two" => 2, "1" => 1 ),  // string keys & numeric values
+       array( 1 => 10, 2 => 20, 4 => 40),  // explicit numeric keys and numeric values
+       array( "one" => "ten", "two" => "twenty"),  // 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 containing embedded arrays
+/*15*/ array("str1", "array" => array("hello", 'world'), array(1, 2))
+);
+
+// initialise the second argument
+$arr2 = array( 1 => "one", 2, "string" => "hello", "array" => array("a", "b", "c"));
+
+// loop through each sub array of $arrays and check the behavior of array_merge_recursive()
+$iterator = 1;
+foreach($arrays as $arr1) {
+  echo "-- Iteration $iterator --\n";
+
+  // with default argument
+  echo "-- With default argument --\n";
+  var_dump( array_merge_recursive($arr1) );
+
+  // with more arguments
+  echo "-- With more arguments --\n";
+  var_dump( array_merge_recursive($arr1, $arr2) );
+
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : Passing different arrays to $arr1 argument ***
+-- Iteration 1 --
+-- With default argument --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 2 --
+-- With default argument --
+array(2) {
+  [0]=>
+  float(1.1)
+  [1]=>
+  float(2.2)
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  float(1.1)
+  [1]=>
+  float(2.2)
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 3 --
+-- With default argument --
+array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 4 --
+-- With default argument --
+array(0) {
+}
+-- With more arguments --
+array(4) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 5 --
+-- With default argument --
+array(1) {
+  [0]=>
+  NULL
+}
+-- With more arguments --
+array(5) {
+  [0]=>
+  NULL
+  [1]=>
+  string(3) "one"
+  [2]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 6 --
+-- With default argument --
+array(4) {
+  [0]=>
+  string(3) "a"
+  [1]=>
+  string(5) "aaaa
"
+  [2]=>
+  string(1) "b"
+  [3]=>
+  string(27) "\[\]\!\@\#$\%\^\&\*\(\)\{\}"
+}
+-- With more arguments --
+array(8) {
+  [0]=>
+  string(3) "a"
+  [1]=>
+  string(5) "aaaa
"
+  [2]=>
+  string(1) "b"
+  [3]=>
+  string(27) "\[\]\!\@\#$\%\^\&\*\(\)\{\}"
+  [4]=>
+  string(3) "one"
+  [5]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 7 --
+-- With default argument --
+array(4) {
+  [0]=>
+  string(5) "a\v\f"
+  [1]=>
+  string(6) "aaaa\r"
+  [2]=>
+  string(1) "b"
+  [3]=>
+  string(28) "\[\]\!\@\#\$\%\^\&\*\(\)\{\}"
+}
+-- With more arguments --
+array(8) {
+  [0]=>
+  string(5) "a\v\f"
+  [1]=>
+  string(6) "aaaa\r"
+  [2]=>
+  string(1) "b"
+  [3]=>
+  string(28) "\[\]\!\@\#\$\%\^\&\*\(\)\{\}"
+  [4]=>
+  string(3) "one"
+  [5]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 8 --
+-- With default argument --
+array(3) {
+  ["h1"]=>
+  string(1) "
+"
+  ["h2"]=>
+  string(88) "hello world
+The quick brown fox jumped over;
+the lazy dog
+This is a double quoted string"
+  ["h3"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+}
+-- With more arguments --
+array(7) {
+  ["h1"]=>
+  string(1) "
+"
+  ["h2"]=>
+  string(88) "hello world
+The quick brown fox jumped over;
+the lazy dog
+This is a double quoted string"
+  ["h3"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 9 --
+-- With default argument --
+array(2) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 10 --
+-- With default argument --
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [0]=>
+  int(1)
+}
+-- With more arguments --
+array(7) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "one"
+  [2]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 11 --
+-- With default argument --
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(20)
+  [2]=>
+  int(40)
+}
+-- With more arguments --
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(20)
+  [2]=>
+  int(40)
+  [3]=>
+  string(3) "one"
+  [4]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 12 --
+-- With default argument --
+array(2) {
+  ["one"]=>
+  string(3) "ten"
+  ["two"]=>
+  string(6) "twenty"
+}
+-- With more arguments --
+array(6) {
+  ["one"]=>
+  string(3) "ten"
+  ["two"]=>
+  string(6) "twenty"
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 13 --
+-- With default argument --
+array(3) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(4) "four"
+}
+-- With more arguments --
+array(7) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(4) "four"
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 14 --
+-- With default argument --
+array(3) {
+  [""]=>
+  string(4) "null"
+  ["NULL"]=>
+  NULL
+  ["null"]=>
+  NULL
+}
+-- With more arguments --
+array(7) {
+  [""]=>
+  string(4) "null"
+  ["NULL"]=>
+  NULL
+  ["null"]=>
+  NULL
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 15 --
+-- With default argument --
+array(4) {
+  [0]=>
+  string(4) "true"
+  [1]=>
+  string(5) "false"
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+}
+-- With more arguments --
+array(8) {
+  [0]=>
+  string(4) "true"
+  [1]=>
+  string(5) "false"
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 16 --
+-- With default argument --
+array(3) {
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+  ["emptys"]=>
+  string(0) ""
+}
+-- With more arguments --
+array(7) {
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+  ["emptys"]=>
+  string(0) ""
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 17 --
+-- With default argument --
+array(6) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+  [4]=>
+  bool(false)
+  [5]=>
+  bool(true)
+}
+-- With more arguments --
+array(10) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+  [4]=>
+  bool(false)
+  [5]=>
+  bool(true)
+  [6]=>
+  string(3) "one"
+  [7]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 18 --
+-- With default argument --
+array(3) {
+  [""]=>
+  int(4)
+  [0]=>
+  int(5)
+  [1]=>
+  int(6)
+}
+-- With more arguments --
+array(7) {
+  [""]=>
+  int(4)
+  [0]=>
+  int(5)
+  [1]=>
+  int(6)
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 19 --
+-- With default argument --
+array(3) {
+  [0]=>
+  string(4) "str1"
+  ["array"]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  string(4) "str1"
+  ["array"]=>
+  array(5) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+    [2]=>
+    string(1) "a"
+    [3]=>
+    string(1) "b"
+    [4]=>
+    string(1) "c"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_variation4.phpt b/tests/std/array/array_merge_recursive_variation4.phpt
new file mode 100644
index 00000000..ebdeed23
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation4.phpt
@@ -0,0 +1,330 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - associative array with different keys
+--SKIPIF--
+<?php die("skip AOT array_merge numeric key reindexing differs from PHP"); ?>
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Testing the functionality of array_merge_recursive() by passing different
+     * associative arrays having different keys to $arr1 argument.
+    */
+    echo "*** Testing array_merge_recursive() : assoc. array with diff. keys to \$arr1 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 associative arrays to be passed to $arr1 argument
+    $arrays = array(
+        /*1*/
+        // arrays with integer keys
+        array(0 => "0", 1 => array(1 => "one")),
+        array(1 => "1", 2 => array(1 => "one", 2 => "two", 3 => 1, 4 => "4")),
+        // arrays with string keys
+        /*5*/
+        array('\tHello' => array("hello", 'world'), '\v\fworld' => 2.2, 'pen\n' => 111),
+        array("\tHello" => array("hello", 'world'), "\v\fworld" => 2.2, "pen\n" => 111),
+        array("hello", $heredoc => array("heredoc", 'string'), "string"),
+        // array with object, unset variable and resource variable
+        /*8*/
+        array(@$unset_var => array("unset"), $fp => 'resource', 11, "hello"),
+    );
+    // initialise the second array
+    $arr2 = array(1 => "one", 2, "string" => "hello", "array" => array("a", "b", "c"));
+    // loop through each sub array of $arrays and check the behavior of array_merge_recursive()
+    $iterator = 1;
+    foreach ($arrays as $arr1) {
+        echo "-- Iteration {$iterator} --\n";
+        // with default argument
+        echo "-- With default argument --\n";
+        var_dump(array_merge_recursive($arr1));
+        // with more arguments
+        echo "-- With more arguments --\n";
+        var_dump(array_merge_recursive($arr1, $arr2));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_merge_recursive() : assoc. array with diff. keys to $arr1 argument ***
+
+Warning: Resource ID#%d used as offset, casting to integer (%d) in %s on line %d
+-- Iteration 1 --
+-- With default argument --
+array(2) {
+  [0]=>
+  string(1) "0"
+  [1]=>
+  array(1) {
+    [1]=>
+    string(3) "one"
+  }
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  string(1) "0"
+  [1]=>
+  array(1) {
+    [1]=>
+    string(3) "one"
+  }
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 2 --
+-- With default argument --
+array(2) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  array(4) {
+    [1]=>
+    string(3) "one"
+    [2]=>
+    string(3) "two"
+    [3]=>
+    int(1)
+    [4]=>
+    string(1) "4"
+  }
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  array(4) {
+    [1]=>
+    string(3) "one"
+    [2]=>
+    string(3) "two"
+    [3]=>
+    int(1)
+    [4]=>
+    string(1) "4"
+  }
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 3 --
+-- With default argument --
+array(3) {
+  ["\tHello"]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+  ["\v\fworld"]=>
+  float(2.2)
+  ["pen\n"]=>
+  int(111)
+}
+-- With more arguments --
+array(7) {
+  ["\tHello"]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+  ["\v\fworld"]=>
+  float(2.2)
+  ["pen\n"]=>
+  int(111)
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 4 --
+-- With default argument --
+array(3) {
+  ["	Hello"]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+  ["world"]=>
+  float(2.2)
+  ["pen
+"]=>
+  int(111)
+}
+-- With more arguments --
+array(7) {
+  ["	Hello"]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+  ["world"]=>
+  float(2.2)
+  ["pen
+"]=>
+  int(111)
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 5 --
+-- With default argument --
+array(3) {
+  [0]=>
+  string(5) "hello"
+  ["Hello world"]=>
+  array(2) {
+    [0]=>
+    string(7) "heredoc"
+    [1]=>
+    string(6) "string"
+  }
+  [1]=>
+  string(6) "string"
+}
+-- With more arguments --
+array(7) {
+  [0]=>
+  string(5) "hello"
+  ["Hello world"]=>
+  array(2) {
+    [0]=>
+    string(7) "heredoc"
+    [1]=>
+    string(6) "string"
+  }
+  [1]=>
+  string(6) "string"
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 6 --
+-- With default argument --
+array(4) {
+  [""]=>
+  array(1) {
+    [0]=>
+    string(5) "unset"
+  }
+  [0]=>
+  string(8) "resource"
+  [1]=>
+  int(11)
+  [2]=>
+  string(5) "hello"
+}
+-- With more arguments --
+array(8) {
+  [""]=>
+  array(1) {
+    [0]=>
+    string(5) "unset"
+  }
+  [0]=>
+  string(8) "resource"
+  [1]=>
+  int(11)
+  [2]=>
+  string(5) "hello"
+  [3]=>
+  string(3) "one"
+  [4]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_variation5.phpt b/tests/std/array/array_merge_recursive_variation5.phpt
new file mode 100644
index 00000000..b6425c87
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation5.phpt
@@ -0,0 +1,392 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - associative array with different values
+--SKIPIF--
+<?php die("skip AOT array_merge numeric key reindexing differs from PHP"); ?>
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Testing the functionality of array_merge_recursive() by passing different
+     * associative arrays having different values to $arr1 argument.
+    */
+    echo "*** Testing array_merge_recursive() : assoc. array with diff. values to \$arr1 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 associative arrays to be passed to $arr1 argument
+    $arrays = array(
+        // arrays with integer values
+        /*1*/
+        array('0' => 0, '1' => 0),
+        array("one" => 1, 'two' => 2, "three" => 1, 4 => 1),
+        // arrays with float values
+        /*3*/
+        array("f1" => 2.3333, "f2" => 2.3333, "f3" => array(1.1, 2.22)),
+        array("f1" => 1.2, 'f2' => 3.33, 3 => 4.89999922839999, 'f4' => array(1.2, 'f4' => 1.2)),
+        // arrays with string values
+        /*5*/
+        array(111 => "\tHello", "array" => "col\tor", 2 => "\v\fworld", 3 => "\tHello"),
+        array(111 => '\tHello', 'array' => 'col\tor', 2 => '\v\fworld', 3 => '\tHello'),
+        array(1 => "hello", "string" => $heredoc, $heredoc),
+        // array with object, unset variable and resource variable
+        /*8*/
+        array(11 => new classA(), "string" => @$unset_var, "resource" => $fp, new classA(), $fp),
+    );
+    // initialise the second array
+    $arr2 = array(1 => "one", 2, "string" => "hello", "array" => array("a", "b", "c"));
+    // loop through each sub array of $arrays and check the behavior of array_merge_recursive()
+    $iterator = 1;
+    foreach ($arrays as $arr1) {
+        echo "-- Iteration {$iterator} --\n";
+        // with default argument
+        echo "-- With default argument --\n";
+        var_dump(array_merge_recursive($arr1));
+        // with more arguments
+        echo "-- With more arguments --\n";
+        var_dump(array_merge_recursive($arr1, $arr2));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_merge_recursive() : assoc. array with diff. values to $arr1 argument ***
+-- Iteration 1 --
+-- With default argument --
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(0)
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(0)
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 2 --
+-- With default argument --
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(1)
+  [0]=>
+  int(1)
+}
+-- With more arguments --
+array(8) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(1)
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "one"
+  [2]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 3 --
+-- With default argument --
+array(3) {
+  ["f1"]=>
+  float(2.3333)
+  ["f2"]=>
+  float(2.3333)
+  ["f3"]=>
+  array(2) {
+    [0]=>
+    float(1.1)
+    [1]=>
+    float(2.22)
+  }
+}
+-- With more arguments --
+array(7) {
+  ["f1"]=>
+  float(2.3333)
+  ["f2"]=>
+  float(2.3333)
+  ["f3"]=>
+  array(2) {
+    [0]=>
+    float(1.1)
+    [1]=>
+    float(2.22)
+  }
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 4 --
+-- With default argument --
+array(4) {
+  ["f1"]=>
+  float(1.2)
+  ["f2"]=>
+  float(3.33)
+  [0]=>
+  float(4.89999922839999)
+  ["f4"]=>
+  array(2) {
+    [0]=>
+    float(1.2)
+    ["f4"]=>
+    float(1.2)
+  }
+}
+-- With more arguments --
+array(8) {
+  ["f1"]=>
+  float(1.2)
+  ["f2"]=>
+  float(3.33)
+  [0]=>
+  float(4.89999922839999)
+  ["f4"]=>
+  array(2) {
+    [0]=>
+    float(1.2)
+    ["f4"]=>
+    float(1.2)
+  }
+  [1]=>
+  string(3) "one"
+  [2]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 5 --
+-- With default argument --
+array(4) {
+  [0]=>
+  string(6) "	Hello"
+  ["array"]=>
+  string(6) "col	or"
+  [1]=>
+  string(7) "world"
+  [2]=>
+  string(6) "	Hello"
+}
+-- With more arguments --
+array(7) {
+  [0]=>
+  string(6) "	Hello"
+  ["array"]=>
+  array(4) {
+    [0]=>
+    string(6) "col	or"
+    [1]=>
+    string(1) "a"
+    [2]=>
+    string(1) "b"
+    [3]=>
+    string(1) "c"
+  }
+  [1]=>
+  string(7) "world"
+  [2]=>
+  string(6) "	Hello"
+  [3]=>
+  string(3) "one"
+  [4]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+}
+-- Iteration 6 --
+-- With default argument --
+array(4) {
+  [0]=>
+  string(7) "\tHello"
+  ["array"]=>
+  string(7) "col\tor"
+  [1]=>
+  string(9) "\v\fworld"
+  [2]=>
+  string(7) "\tHello"
+}
+-- With more arguments --
+array(7) {
+  [0]=>
+  string(7) "\tHello"
+  ["array"]=>
+  array(4) {
+    [0]=>
+    string(7) "col\tor"
+    [1]=>
+    string(1) "a"
+    [2]=>
+    string(1) "b"
+    [3]=>
+    string(1) "c"
+  }
+  [1]=>
+  string(9) "\v\fworld"
+  [2]=>
+  string(7) "\tHello"
+  [3]=>
+  string(3) "one"
+  [4]=>
+  int(2)
+  ["string"]=>
+  string(5) "hello"
+}
+-- Iteration 7 --
+-- With default argument --
+array(3) {
+  [0]=>
+  string(5) "hello"
+  ["string"]=>
+  string(11) "Hello world"
+  [1]=>
+  string(11) "Hello world"
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  string(5) "hello"
+  ["string"]=>
+  array(2) {
+    [0]=>
+    string(11) "Hello world"
+    [1]=>
+    string(5) "hello"
+  }
+  [1]=>
+  string(11) "Hello world"
+  [2]=>
+  string(3) "one"
+  [3]=>
+  int(2)
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+-- Iteration 8 --
+-- With default argument --
+array(5) {
+  [0]=>
+  object(classA)#%d (0) {
+  }
+  ["string"]=>
+  NULL
+  ["resource"]=>
+  resource(%d) of type (stream)
+  [1]=>
+  object(classA)#%d (0) {
+  }
+  [2]=>
+  resource(%d) of type (stream)
+}
+-- With more arguments --
+array(8) {
+  [0]=>
+  object(classA)#%d (0) {
+  }
+  ["string"]=>
+  array(2) {
+    [0]=>
+    NULL
+    [1]=>
+    string(5) "hello"
+  }
+  ["resource"]=>
+  resource(%d) of type (stream)
+  [1]=>
+  object(classA)#%d (0) {
+  }
+  [2]=>
+  resource(%d) of type (stream)
+  [3]=>
+  string(3) "one"
+  [4]=>
+  int(2)
+  ["array"]=>
+  array(3) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(1) "b"
+    [2]=>
+    string(1) "c"
+  }
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_variation6.phpt b/tests/std/array/array_merge_recursive_variation6.phpt
new file mode 100644
index 00000000..9540a6cf
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation6.phpt
@@ -0,0 +1,108 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - array with duplicate keys
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_merge_recursive() by passing
+ * array having duplicate keys.
+*/
+
+echo "*** Testing array_merge_recursive() : array with duplicate keys for \$arr1 argument ***\n";
+
+/* initialize the array having duplicate keys */
+// array with numeric keys
+$arr1_numeric_key = array( 1 => "one", 2 => "two", 2 => array(1, 2), 3 => "three", 1 => array("duplicate", 'strings'));
+// array with string keys
+$arr1_string_key = array("str1" => "hello", "str2" => 111, "str1" => "world", "str2" => 111.111);
+
+// initialize the second argument
+$arr2 = array("one", "str1" => "two", array("one", "two"));
+
+echo "-- With default argument --\n";
+var_dump( array_merge_recursive($arr1_numeric_key) );
+var_dump( array_merge_recursive($arr1_string_key) );
+
+echo "-- With more arguments --\n";
+var_dump( array_merge_recursive($arr1_numeric_key, $arr2) );
+var_dump( array_merge_recursive($arr1_string_key, $arr2) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : array with duplicate keys for $arr1 argument ***
+-- With default argument --
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(9) "duplicate"
+    [1]=>
+    string(7) "strings"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  string(5) "three"
+}
+array(2) {
+  ["str1"]=>
+  string(5) "world"
+  ["str2"]=>
+  float(111.111)
+}
+-- With more arguments --
+array(6) {
+  [0]=>
+  array(2) {
+    [0]=>
+    string(9) "duplicate"
+    [1]=>
+    string(7) "strings"
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  string(5) "three"
+  [3]=>
+  string(3) "one"
+  ["str1"]=>
+  string(3) "two"
+  [4]=>
+  array(2) {
+    [0]=>
+    string(3) "one"
+    [1]=>
+    string(3) "two"
+  }
+}
+array(4) {
+  ["str1"]=>
+  array(2) {
+    [0]=>
+    string(5) "world"
+    [1]=>
+    string(3) "two"
+  }
+  ["str2"]=>
+  float(111.111)
+  [0]=>
+  string(3) "one"
+  [1]=>
+  array(2) {
+    [0]=>
+    string(3) "one"
+    [1]=>
+    string(3) "two"
+  }
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_variation7.phpt b/tests/std/array/array_merge_recursive_variation7.phpt
new file mode 100644
index 00000000..e1e5c951
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation7.phpt
@@ -0,0 +1,79 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - array with reference variables
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_merge_recursive() by passing
+ * array having reference variables.
+*/
+
+echo "*** Testing array_merge_recursive() : array with reference variables for \$arr1 argument ***\n";
+
+$value1 = 10;
+$value2 = "hello";
+$value3 = 0;
+$value4 = &$value2;
+
+// input array containing elements as reference variables
+$arr1 = array(
+  0 => 0,
+  1 => &$value4,
+  2 => &$value2,
+  3 => "hello",
+  4 => &$value3,
+  $value4 => &$value2
+);
+
+// initialize the second argument
+$arr2 = array($value4 => "hello", &$value2);
+
+echo "-- With default argument --\n";
+var_dump( array_merge_recursive($arr1) );
+
+echo "-- With more arguments --\n";
+var_dump( array_merge_recursive($arr1, $arr2) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : array with reference variables for $arr1 argument ***
+-- With default argument --
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  &string(5) "hello"
+  [2]=>
+  &string(5) "hello"
+  [3]=>
+  string(5) "hello"
+  [4]=>
+  &int(0)
+  ["hello"]=>
+  &string(5) "hello"
+}
+-- With more arguments --
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  &string(5) "hello"
+  [2]=>
+  &string(5) "hello"
+  [3]=>
+  string(5) "hello"
+  [4]=>
+  &int(0)
+  ["hello"]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "hello"
+  }
+  [5]=>
+  &string(5) "hello"
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_variation8.phpt b/tests/std/array/array_merge_recursive_variation8.phpt
new file mode 100644
index 00000000..bd41e57e
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation8.phpt
@@ -0,0 +1,68 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - binary safe checking
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_merge_recursive() by passing an array having binary values.
+*/
+
+echo "*** Testing array_merge_recursive() : array with binary data for \$arr1 argument ***\n";
+
+// array with binary values
+$arr1 = array(b"1", b"hello" => "hello", b"world", "str1" => b"hello", "str2" => "world");
+
+// initialize the second argument
+$arr2 = array(b"str1" => b"binary", b"hello" => "binary", b"str2" => b"binary");
+
+echo "-- With default argument --\n";
+var_dump( array_merge_recursive($arr1) );
+
+echo "-- With more arguments --\n";
+var_dump( array_merge_recursive($arr1, $arr2) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : array with binary data for $arr1 argument ***
+-- With default argument --
+array(5) {
+  [0]=>
+  string(1) "1"
+  ["hello"]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+  ["str1"]=>
+  string(5) "hello"
+  ["str2"]=>
+  string(5) "world"
+}
+-- With more arguments --
+array(5) {
+  [0]=>
+  string(1) "1"
+  ["hello"]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(6) "binary"
+  }
+  [1]=>
+  string(5) "world"
+  ["str1"]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(6) "binary"
+  }
+  ["str2"]=>
+  array(2) {
+    [0]=>
+    string(5) "world"
+    [1]=>
+    string(6) "binary"
+  }
+}
+Done
diff --git a/tests/std/array/array_merge_recursive_variation9.phpt b/tests/std/array/array_merge_recursive_variation9.phpt
new file mode 100644
index 00000000..ff12e86b
--- /dev/null
+++ b/tests/std/array/array_merge_recursive_variation9.phpt
@@ -0,0 +1,112 @@
+--TEST--
+Test array_merge_recursive() function : usage variations - common key and value(Bug#43559)
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_merge_recursive() by passing
+ * arrays having common key and value.
+*/
+
+echo "*** Testing array_merge_recursive() : arrays with common key and value ***\n";
+
+/* initialize the array having duplicate values */
+
+// integer values
+$arr1 = array("a" => 1, "b" => 2);
+$arr2 = array("b" => 2, "c" => 4);
+echo "-- Integer values --\n";
+var_dump( array_merge_recursive($arr1, $arr2) );
+
+// float values
+$arr1 = array("a" => 1.1, "b" => 2.2);
+$arr2 = array("b" => 2.2, "c" => 3.3);
+echo "-- Float values --\n";
+var_dump( array_merge_recursive($arr1, $arr2) );
+
+// string values
+$arr1 = array("a" => "hello", "b" => "world");
+$arr2 = array("b" => "world", "c" => "string");
+echo "-- String values --\n";
+var_dump( array_merge_recursive($arr1, $arr2) );
+
+// boolean values
+$arr1 = array("a" => true, "b" => false);
+$arr2 = array("b" => false);
+echo "-- Boolean values --\n";
+var_dump( array_merge_recursive($arr1, $arr2) );
+
+// null values
+$arr1 = array( "a" => NULL);
+$arr2 = array( "a" => NULL);
+echo "-- Null values --\n";
+var_dump( array_merge_recursive($arr1, $arr2) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge_recursive() : arrays with common key and value ***
+-- Integer values --
+array(3) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  array(2) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(2)
+  }
+  ["c"]=>
+  int(4)
+}
+-- Float values --
+array(3) {
+  ["a"]=>
+  float(1.1)
+  ["b"]=>
+  array(2) {
+    [0]=>
+    float(2.2)
+    [1]=>
+    float(2.2)
+  }
+  ["c"]=>
+  float(3.3)
+}
+-- String values --
+array(3) {
+  ["a"]=>
+  string(5) "hello"
+  ["b"]=>
+  array(2) {
+    [0]=>
+    string(5) "world"
+    [1]=>
+    string(5) "world"
+  }
+  ["c"]=>
+  string(6) "string"
+}
+-- Boolean values --
+array(2) {
+  ["a"]=>
+  bool(true)
+  ["b"]=>
+  array(2) {
+    [0]=>
+    bool(false)
+    [1]=>
+    bool(false)
+  }
+}
+-- Null values --
+array(1) {
+  ["a"]=>
+  array(2) {
+    [0]=>
+    NULL
+    [1]=>
+    NULL
+  }
+}
+Done
diff --git a/tests/std/array/array_merge_replace_recursive_refs.phpt b/tests/std/array/array_merge_replace_recursive_refs.phpt
new file mode 100644
index 00000000..ac8be2ba
--- /dev/null
+++ b/tests/std/array/array_merge_replace_recursive_refs.phpt
@@ -0,0 +1,38 @@
+--TEST--
+array_merge/replace_recursive() should unwrap references with rc=1
+--FILE--
+<?php
+
+$x = 24;
+$arr1 = [[42]];
+$arr2 = [[&$x]];
+unset($x);
+$arr3 = array_replace_recursive($arr1, $arr2);
+$arr2[0][0] = 12;
+var_dump($arr3);
+
+unset($arr1, $arr2, $arr3);
+
+$x = 24;
+$arr1 = [42];
+$arr2 = [&$x];
+unset($x);
+$arr3 = array_merge_recursive($arr1, $arr2);
+$arr2[0] = 12;
+var_dump($arr3);
+
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(24)
+  }
+}
+array(2) {
+  [0]=>
+  int(42)
+  [1]=>
+  int(24)
+}
diff --git a/tests/std/array/array_merge_variation1.phpt b/tests/std/array/array_merge_variation1.phpt
new file mode 100644
index 00000000..0b98797a
--- /dev/null
+++ b/tests/std/array/array_merge_variation1.phpt
@@ -0,0 +1,102 @@
+--TEST--
+Test array_merge() function : usage variations - Pass different data types to $arr1 arg
+--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 different data types as $arr1 argument to test behaviour
+     */
+    echo "*** Testing array_merge() : usage variations ***\n";
+    // Initialise function arguments not being substituted
+    $arr2 = array(1, 2);
+    //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");
+    // unexpected values to be passed to $arr1 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*/
+        "",
+        '',
+        array(),
+        // string data
+        /*19*/
+        "string",
+        'string',
+        $heredoc,
+        // object data
+        /*22*/
+        new classA(),
+        // undefined data
+        /*23*/
+        @$undefined_var,
+        // unset data
+        /*24*/
+        @$unset_var,
+        // resource variable
+        /*25*/
+        $fp,
+    );
+    // loop through each element of $inputs to check the behavior of array_merge()
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "\n-- Iteration {$iterator} --\n";
+        var_dump(array_merge($input, $arr2));
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_merge() : usage variations ***
+
+-- Iteration 1 --
+
+Fatal error: Uncaught TypeError: array_merge(): Argument #1 must be of type array, int given in %s:%d
+Stack trace:
+#0 %s(%d): array_merge(0, Array)
+#1 {main}
+  thrown in %s on line %d
diff --git a/tests/std/array/array_merge_variation10.phpt b/tests/std/array/array_merge_variation10.phpt
new file mode 100644
index 00000000..1877cece
--- /dev/null
+++ b/tests/std/array/array_merge_variation10.phpt
@@ -0,0 +1,64 @@
+--TEST--
+Test array_merge() function : usage variations - position of internal array pointer
+--FILE--
+<?php
+/*
+ * Check the position of the internal array pointer after calling array_merge().
+ * This test is also passing more than two arguments to array_merge().
+ */
+
+echo "*** Testing array_merge() : usage variations ***\n";
+
+$arr1 = array ('zero', 'one', 'two');
+$arr2 = array ('zero', 'un', 'deux');
+$arr3 = array ('null', 'eins', 'zwei');
+
+echo "\n-- Call array_merge() --\n";
+var_dump($result = array_merge($arr1, $arr2, $arr3));
+
+echo "\n-- Position of Internal Pointer in Result: --\n";
+echo key($result) . " => " . current($result) . "\n";
+
+echo "\n-- Position of Internal Pointer in Original Array: --\n";
+echo "\$arr1: ";
+echo key($arr1) . " => " . current ($arr1) . "\n";
+echo "\$arr2: ";
+echo key($arr2) . " => " . current ($arr2) . "\n";
+echo "\$arr3: ";
+echo key($arr3) . " => " . current ($arr3) . "\n";
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge() : usage variations ***
+
+-- Call array_merge() --
+array(9) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(4) "zero"
+  [4]=>
+  string(2) "un"
+  [5]=>
+  string(4) "deux"
+  [6]=>
+  string(4) "null"
+  [7]=>
+  string(4) "eins"
+  [8]=>
+  string(4) "zwei"
+}
+
+-- Position of Internal Pointer in Result: --
+0 => zero
+
+-- Position of Internal Pointer in Original Array: --
+$arr1: 0 => zero
+$arr2: 0 => zero
+$arr3: 0 => null
+Done
diff --git a/tests/std/array/array_merge_variation2.phpt b/tests/std/array/array_merge_variation2.phpt
new file mode 100644
index 00000000..b1657957
--- /dev/null
+++ b/tests/std/array/array_merge_variation2.phpt
@@ -0,0 +1,179 @@
+--TEST--
+Test array_merge() function : usage variations - Pass different data types as $arr2 arg
+--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 different data types as $arr2 argument to array_merge() to test behaviour
+     */
+    echo "*** Testing array_merge() : usage variations ***\n";
+    // Initialise function arguments not being substituted
+    $arr1 = array(1, 2);
+    //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");
+    // unexpected values to be passed to $arr2 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*/
+        "",
+        '',
+        array(),
+        // string data
+        /*19*/
+        "string",
+        'string',
+        $heredoc,
+        // object data
+        /*22*/
+        new classA(),
+        // undefined data
+        /*23*/
+        @$undefined_var,
+        // unset data
+        /*24*/
+        @$unset_var,
+        // resource variable
+        /*25*/
+        $fp,
+    );
+    // loop through each element of $inputs to check the behavior of array_merge()
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "\n-- Iteration {$iterator} --\n";
+        try {
+            var_dump(array_merge($arr1, $input));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_merge() : usage variations ***
+
+-- Iteration 1 --
+array_merge(): Argument #2 must be of type array, int given
+
+-- Iteration 2 --
+array_merge(): Argument #2 must be of type array, int given
+
+-- Iteration 3 --
+array_merge(): Argument #2 must be of type array, int given
+
+-- Iteration 4 --
+array_merge(): Argument #2 must be of type array, int given
+
+-- Iteration 5 --
+array_merge(): Argument #2 must be of type array, float given
+
+-- Iteration 6 --
+array_merge(): Argument #2 must be of type array, float given
+
+-- Iteration 7 --
+array_merge(): Argument #2 must be of type array, float given
+
+-- Iteration 8 --
+array_merge(): Argument #2 must be of type array, float given
+
+-- Iteration 9 --
+array_merge(): Argument #2 must be of type array, float given
+
+-- Iteration 10 --
+array_merge(): Argument #2 must be of type array, null given
+
+-- Iteration 11 --
+array_merge(): Argument #2 must be of type array, null given
+
+-- Iteration 12 --
+array_merge(): Argument #2 must be of type array, true given
+
+-- Iteration 13 --
+array_merge(): Argument #2 must be of type array, false given
+
+-- Iteration 14 --
+array_merge(): Argument #2 must be of type array, true given
+
+-- Iteration 15 --
+array_merge(): Argument #2 must be of type array, false given
+
+-- Iteration 16 --
+array_merge(): Argument #2 must be of type array, string given
+
+-- Iteration 17 --
+array_merge(): Argument #2 must be of type array, string given
+
+-- Iteration 18 --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+-- Iteration 19 --
+array_merge(): Argument #2 must be of type array, string given
+
+-- Iteration 20 --
+array_merge(): Argument #2 must be of type array, string given
+
+-- Iteration 21 --
+array_merge(): Argument #2 must be of type array, string given
+
+-- Iteration 22 --
+array_merge(): Argument #2 must be of type array, classA given
+
+-- Iteration 23 --
+array_merge(): Argument #2 must be of type array, null given
+
+-- Iteration 24 --
+array_merge(): Argument #2 must be of type array, null given
+
+-- Iteration 25 --
+array_merge(): Argument #2 must be of type array, resource given
+Done
diff --git a/tests/std/array/array_merge_variation3.phpt b/tests/std/array/array_merge_variation3.phpt
new file mode 100644
index 00000000..64154540
--- /dev/null
+++ b/tests/std/array/array_merge_variation3.phpt
@@ -0,0 +1,336 @@
+--TEST--
+Test array_merge() function : usage variations - arrays of diff. 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()
+{
+    /*
+     * Pass arrays of different data types to test how array_merge adds them
+     * onto an existing array
+     */
+    echo "*** Testing array_merge() : usage variations ***\n";
+    // Initialise function arguments not being substituted
+    $arr = array(1, 2);
+    //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");
+    // arrays of different data types to be passed as $input
+    $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 string' => array("", ''),
+        /*6*/
+        'empty array' => array(),
+        // string data
+        /*7*/
+        'string' => array("string", 'string', $heredoc),
+        // object data
+        /*8*/
+        'object' => array(new classA()),
+        // undefined data
+        /*9*/
+        'undefined' => array(@$undefined_var),
+        // unset data
+        /*10*/
+        'unset' => array(@$unset_var),
+        // resource variable
+        /*11*/
+        'resource' => array($fp),
+    );
+    // loop through each element of $inputs to check the behavior of array_merge
+    $iterator = 1;
+    foreach ($inputs as $key => $input) {
+        echo "\n-- Iteration {$iterator}: {$key} data --\n";
+        var_dump(array_merge($input, $arr));
+        var_dump(array_merge($arr, $input));
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_merge() : usage variations ***
+
+-- Iteration 1: int data --
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(12345)
+  [3]=>
+  int(-2345)
+  [4]=>
+  int(1)
+  [5]=>
+  int(2)
+}
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(0)
+  [3]=>
+  int(1)
+  [4]=>
+  int(12345)
+  [5]=>
+  int(-2345)
+}
+
+-- Iteration 2: float data --
+array(7) {
+  [0]=>
+  float(10.5)
+  [1]=>
+  float(-10.5)
+  [2]=>
+  float(123456789000)
+  [3]=>
+  float(1.23456789E-9)
+  [4]=>
+  float(0.5)
+  [5]=>
+  int(1)
+  [6]=>
+  int(2)
+}
+array(7) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  float(10.5)
+  [3]=>
+  float(-10.5)
+  [4]=>
+  float(123456789000)
+  [5]=>
+  float(1.23456789E-9)
+  [6]=>
+  float(0.5)
+}
+
+-- Iteration 3: null data --
+array(4) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+}
+
+-- Iteration 4: bool data --
+array(6) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(false)
+  [4]=>
+  int(1)
+  [5]=>
+  int(2)
+}
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(false)
+  [4]=>
+  bool(true)
+  [5]=>
+  bool(false)
+}
+
+-- Iteration 5: empty string data --
+array(4) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(0) ""
+  [3]=>
+  string(0) ""
+}
+
+-- Iteration 6: empty array data --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+
+-- Iteration 7: string data --
+array(5) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(6) "string"
+  [2]=>
+  string(11) "hello world"
+  [3]=>
+  int(1)
+  [4]=>
+  int(2)
+}
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(6) "string"
+  [3]=>
+  string(6) "string"
+  [4]=>
+  string(11) "hello world"
+}
+
+-- Iteration 8: object data --
+array(3) {
+  [0]=>
+  object(classA)#%d (0) {
+  }
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  object(classA)#%d (0) {
+  }
+}
+
+-- Iteration 9: undefined data --
+array(3) {
+  [0]=>
+  NULL
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  NULL
+}
+
+-- Iteration 10: unset data --
+array(3) {
+  [0]=>
+  NULL
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  NULL
+}
+
+-- Iteration 11: resource data --
+array(3) {
+  [0]=>
+  resource(%d) of type (stream)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  resource(%d) of type (stream)
+}
+Done
diff --git a/tests/std/array/array_merge_variation4.phpt b/tests/std/array/array_merge_variation4.phpt
new file mode 100644
index 00000000..4fa12783
--- /dev/null
+++ b/tests/std/array/array_merge_variation4.phpt
@@ -0,0 +1,308 @@
+--TEST--
+Test array_merge() function : usage variations - Diff. data types as array keys
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Pass an array with different data types as keys to test how array_merge
+ * adds it onto an existing array
+ */
+
+echo "*** Testing array_merge() : usage variations ***\n";
+
+// Initialise function arguments not being substituted
+$arr = array ('one' => 1, 'two' => 2);
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// heredoc string
+$heredoc = <<<EOT
+hello world
+EOT;
+
+// arrays with keys as different data types to be passed as $input
+$inputs = array(
+
+       // int data
+/*1*/  'int' => array(
+       0 => 'zero',
+       1 => 'one',
+       12345 => 'positive',
+       -2345 => 'negative',
+       ),
+
+       // null data
+/*4*/  'null uppercase' => array(
+       NULL => 'null 1',
+       ),
+
+/*5*/  'null lowercase' => array(
+       null => 'null 2',
+       ),
+
+       // boolean data
+/*6*/ 'bool lowercase' => array(
+       true => 'lowert',
+       false => 'lowerf',
+       ),
+
+/*7*/  'bool uppercase' => array(
+       TRUE => 'uppert',
+       FALSE => 'upperf',
+       ),
+
+       // empty data
+/*8*/ 'empty double quotes' => array(
+       "" => 'emptyd',
+       ),
+
+/*9*/  'empty single quotes' => array(
+       '' => 'emptys',
+       ),
+
+       // string data
+/*10*/ 'string' => array(
+       "stringd" => 'stringd',
+       'strings' => 'strings',
+       $heredoc => 'stringh',
+       ),
+
+       // undefined data
+/*11*/ 'undefined' => array(
+       @$undefined_var => 'undefined',
+       ),
+
+       // unset data
+/*12*/ 'unset' => array(
+       @$unset_var => 'unset',
+       ),
+);
+
+// loop through each element of $inputs to check the behavior of array_merge
+$iterator = 1;
+foreach($inputs as $key => $input) {
+  echo "\n-- Iteration $iterator: $key data --\n";
+  var_dump( array_merge($input, $arr) );
+  var_dump( array_merge($arr, $input) );
+  $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge() : usage variations ***
+
+-- Iteration 1: int data --
+array(6) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(8) "positive"
+  [3]=>
+  string(8) "negative"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(6) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(8) "positive"
+  [3]=>
+  string(8) "negative"
+}
+
+-- Iteration 2: null uppercase data --
+array(3) {
+  [""]=>
+  string(6) "null 1"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [""]=>
+  string(6) "null 1"
+}
+
+-- Iteration 3: null lowercase data --
+array(3) {
+  [""]=>
+  string(6) "null 2"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [""]=>
+  string(6) "null 2"
+}
+
+-- Iteration 4: bool lowercase data --
+array(4) {
+  [0]=>
+  string(6) "lowert"
+  [1]=>
+  string(6) "lowerf"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [0]=>
+  string(6) "lowert"
+  [1]=>
+  string(6) "lowerf"
+}
+
+-- Iteration 5: bool uppercase data --
+array(4) {
+  [0]=>
+  string(6) "uppert"
+  [1]=>
+  string(6) "upperf"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(4) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [0]=>
+  string(6) "uppert"
+  [1]=>
+  string(6) "upperf"
+}
+
+-- Iteration 6: empty double quotes data --
+array(3) {
+  [""]=>
+  string(6) "emptyd"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [""]=>
+  string(6) "emptyd"
+}
+
+-- Iteration 7: empty single quotes data --
+array(3) {
+  [""]=>
+  string(6) "emptys"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [""]=>
+  string(6) "emptys"
+}
+
+-- Iteration 8: string data --
+array(5) {
+  ["stringd"]=>
+  string(7) "stringd"
+  ["strings"]=>
+  string(7) "strings"
+  ["hello world"]=>
+  string(7) "stringh"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(5) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["stringd"]=>
+  string(7) "stringd"
+  ["strings"]=>
+  string(7) "strings"
+  ["hello world"]=>
+  string(7) "stringh"
+}
+
+-- Iteration 9: undefined data --
+array(3) {
+  [""]=>
+  string(9) "undefined"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [""]=>
+  string(9) "undefined"
+}
+
+-- Iteration 10: unset data --
+array(3) {
+  [""]=>
+  string(5) "unset"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+array(3) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  [""]=>
+  string(5) "unset"
+}
+Done
diff --git a/tests/std/array/array_merge_variation5.phpt b/tests/std/array/array_merge_variation5.phpt
new file mode 100644
index 00000000..5ef9699d
--- /dev/null
+++ b/tests/std/array/array_merge_variation5.phpt
@@ -0,0 +1,57 @@
+--TEST--
+Test array_merge() function : usage variations - numeric keys
+--SKIPIF--
+<?php die("skip AOT array_merge numeric key reindexing differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * Pass array_merge() arrays with only numeric keys to test behaviour.
+ * $arr2 contains a duplicate element to $arr1.
+ */
+
+echo "*** Testing array_merge() : usage variations ***\n";
+
+//numeric keys
+$arr1 = array('zero', 'one', 'two', 'three');
+$arr2 = array(1 => 'one', 20 => 'twenty', 30 => 'thirty');
+
+var_dump(array_merge($arr1, $arr2));
+var_dump(array_merge($arr2, $arr1));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge() : usage variations ***
+array(7) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+  [4]=>
+  string(3) "one"
+  [5]=>
+  string(6) "twenty"
+  [6]=>
+  string(6) "thirty"
+}
+array(7) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(6) "twenty"
+  [2]=>
+  string(6) "thirty"
+  [3]=>
+  string(4) "zero"
+  [4]=>
+  string(3) "one"
+  [5]=>
+  string(3) "two"
+  [6]=>
+  string(5) "three"
+}
+Done
diff --git a/tests/std/array/array_merge_variation6.phpt b/tests/std/array/array_merge_variation6.phpt
new file mode 100644
index 00000000..b2297883
--- /dev/null
+++ b/tests/std/array/array_merge_variation6.phpt
@@ -0,0 +1,47 @@
+--TEST--
+Test array_merge() function : usage variations - string keys
+--FILE--
+<?php
+/*
+ * Pass array_merge arrays with string keys to test behaviour.
+ * $arr2 has a duplicate key to $arr1
+ */
+
+echo "*** Testing array_merge() : usage variations ***\n";
+
+//string keys
+$arr1 = array('zero' => 'zero', 'one' => 'un', 'two' => 'deux');
+$arr2 = array('zero' => 'zero', 'un' => 'eins', 'deux' => 'zwei');
+
+var_dump(array_merge($arr1, $arr2));
+var_dump(array_merge($arr2, $arr1));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge() : usage variations ***
+array(5) {
+  ["zero"]=>
+  string(4) "zero"
+  ["one"]=>
+  string(2) "un"
+  ["two"]=>
+  string(4) "deux"
+  ["un"]=>
+  string(4) "eins"
+  ["deux"]=>
+  string(4) "zwei"
+}
+array(5) {
+  ["zero"]=>
+  string(4) "zero"
+  ["un"]=>
+  string(4) "eins"
+  ["deux"]=>
+  string(4) "zwei"
+  ["one"]=>
+  string(2) "un"
+  ["two"]=>
+  string(4) "deux"
+}
+Done
diff --git a/tests/std/array/array_merge_variation7.phpt b/tests/std/array/array_merge_variation7.phpt
new file mode 100644
index 00000000..d0d4f53b
--- /dev/null
+++ b/tests/std/array/array_merge_variation7.phpt
@@ -0,0 +1,61 @@
+--TEST--
+Test array_merge() function : usage variations - Mixed keys
+--SKIPIF--
+<?php die("skip AOT array_merge numeric key reindexing differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * Pass array_merge() arrays with mixed keys to test how it attaches them to
+ * existing arrays
+ */
+
+echo "*** Testing array_merge() : usage variations ***\n";
+
+//mixed keys
+$arr1 = array('zero', 20 => 'twenty', 'thirty' => 30, true => 'bool');
+$arr2 = array(0, 1, 2, null => 'null', 0 => 'float');
+
+var_dump(array_merge($arr1, $arr2));
+var_dump(array_merge($arr2, $arr1));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge() : usage variations ***
+array(8) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(6) "twenty"
+  ["thirty"]=>
+  int(30)
+  [2]=>
+  string(4) "bool"
+  [3]=>
+  string(5) "float"
+  [4]=>
+  int(1)
+  [5]=>
+  int(2)
+  [""]=>
+  string(4) "null"
+}
+array(8) {
+  [0]=>
+  string(5) "float"
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [""]=>
+  string(4) "null"
+  [3]=>
+  string(4) "zero"
+  [4]=>
+  string(6) "twenty"
+  ["thirty"]=>
+  int(30)
+  [5]=>
+  string(4) "bool"
+}
+Done
diff --git a/tests/std/array/array_merge_variation8.phpt b/tests/std/array/array_merge_variation8.phpt
new file mode 100644
index 00000000..e4dbeba2
--- /dev/null
+++ b/tests/std/array/array_merge_variation8.phpt
@@ -0,0 +1,68 @@
+--TEST--
+Test array_merge() function : usage variations - multi-dimensional arrays
+--FILE--
+<?php
+/*
+ * Test array_merge() with multi-dimensional arrays
+ */
+
+echo "*** Testing array_merge() : usage variations ***\n";
+
+$arr1 = array('zero', 'one', 'two', array(0));
+$arr2 = array(1, 2, 3);
+
+echo "\n-- Merge a two-dimensional and a one-dimensional array --\n";
+var_dump(array_merge($arr1, $arr2));
+
+echo "\n-- Merge an array and a sub-array --\n";
+var_dump(array_merge($arr1[3], $arr2));
+var_dump(array_merge($arr2, $arr1[3]));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge() : usage variations ***
+
+-- Merge a two-dimensional and a one-dimensional array --
+array(7) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [4]=>
+  int(1)
+  [5]=>
+  int(2)
+  [6]=>
+  int(3)
+}
+
+-- Merge an array and a sub-array --
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(0)
+}
+Done
diff --git a/tests/std/array/array_merge_variation9.phpt b/tests/std/array/array_merge_variation9.phpt
new file mode 100644
index 00000000..a615298e
--- /dev/null
+++ b/tests/std/array/array_merge_variation9.phpt
@@ -0,0 +1,95 @@
+--TEST--
+Test array_merge() function : usage variations - referenced variables
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+/* Test array_merge() when:
+ * 1. Passed an array made up of referenced variables
+ * 2. Passed an array as the first argument and a reference to that array as the second.
+ */
+
+echo "*** Testing array_merge() : usage variations ***\n";
+
+$val1 = 'foo';
+$val2 = 'bar';
+$val3 = 'baz';
+
+$arr1 = array(&$val1, &$val2, &$val3);
+$arr2 = array('key1' => 'val1', 'key2' => 'val2', 'key3' => 'val3');
+
+echo "\n-- Merge an array made up of referenced variables to an assoc. array --\n";
+var_dump(array_merge($arr1, $arr2));
+var_dump(array_merge($arr2, $arr1));
+
+$val2 = 'hello world';
+
+echo "\n-- Change \$val2 --\n";
+var_dump(array_merge($arr1, $arr2));
+var_dump(array_merge($arr2, $arr1));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_merge() : usage variations ***
+
+-- Merge an array made up of referenced variables to an assoc. array --
+array(6) {
+  [0]=>
+  &string(3) "foo"
+  [1]=>
+  &string(3) "bar"
+  [2]=>
+  &string(3) "baz"
+  ["key1"]=>
+  string(4) "val1"
+  ["key2"]=>
+  string(4) "val2"
+  ["key3"]=>
+  string(4) "val3"
+}
+array(6) {
+  ["key1"]=>
+  string(4) "val1"
+  ["key2"]=>
+  string(4) "val2"
+  ["key3"]=>
+  string(4) "val3"
+  [0]=>
+  &string(3) "foo"
+  [1]=>
+  &string(3) "bar"
+  [2]=>
+  &string(3) "baz"
+}
+
+-- Change $val2 --
+array(6) {
+  [0]=>
+  &string(3) "foo"
+  [1]=>
+  &string(11) "hello world"
+  [2]=>
+  &string(3) "baz"
+  ["key1"]=>
+  string(4) "val1"
+  ["key2"]=>
+  string(4) "val2"
+  ["key3"]=>
+  string(4) "val3"
+}
+array(6) {
+  ["key1"]=>
+  string(4) "val1"
+  ["key2"]=>
+  string(4) "val2"
+  ["key3"]=>
+  string(4) "val3"
+  [0]=>
+  &string(3) "foo"
+  [1]=>
+  &string(11) "hello world"
+  [2]=>
+  &string(3) "baz"
+}
+Done
diff --git a/tests/std/array/array_multisort_basic1.phpt b/tests/std/array/array_multisort_basic1.phpt
new file mode 100644
index 00000000..f73c6d32
--- /dev/null
+++ b/tests/std/array/array_multisort_basic1.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Test array_multisort() function : basic functionality
+--SKIPIF--
+--FILE--
+<?php
+echo "*** Testing array_multisort() : basic functionality ***\n";
+
+// Initialise all required variables
+$ar1 = array("row1" => 2, "row2" => 1, "row3" => 1);
+$ar2 = array("row1" => 2, "row2" => "aa", "row3" => "1");
+
+echo "\n-- Testing array_multisort() function with all normal arguments --\n";
+var_dump( array_multisort($ar1, SORT_ASC, SORT_REGULAR, $ar2, SORT_DESC, SORT_STRING) );
+var_dump($ar1, $ar2);
+
+echo "\n-- Testing array_multisort() function with one argument --\n";
+var_dump( array_multisort($ar2) );
+var_dump($ar2);
+
+
+?>
+--EXPECT--
+*** Testing array_multisort() : basic functionality ***
+
+-- Testing array_multisort() function with all normal arguments --
+bool(true)
+array(3) {
+  ["row2"]=>
+  int(1)
+  ["row3"]=>
+  int(1)
+  ["row1"]=>
+  int(2)
+}
+array(3) {
+  ["row2"]=>
+  string(2) "aa"
+  ["row3"]=>
+  string(1) "1"
+  ["row1"]=>
+  int(2)
+}
+
+-- Testing array_multisort() function with one argument --
+bool(true)
+array(3) {
+  ["row3"]=>
+  string(1) "1"
+  ["row1"]=>
+  int(2)
+  ["row2"]=>
+  string(2) "aa"
+}
diff --git a/tests/std/array/array_multisort_basic2.phpt b/tests/std/array/array_multisort_basic2.phpt
new file mode 100644
index 00000000..9c13589b
--- /dev/null
+++ b/tests/std/array/array_multisort_basic2.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Test array_multisort() function : basic functionality
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : basic functionality - renumbering of numeric keys ***\n";
+
+// Initialise all required variables
+$ar1 = array( "strkey" => 2,  1,  9 => 1);
+$ar2 = array( 2, "aa" , "1");
+
+echo "\n-- Testing array_multisort() function with all normal arguments --\n";
+var_dump( array_multisort($ar1, SORT_ASC, SORT_REGULAR, $ar2, SORT_ASC, SORT_NUMERIC) );
+var_dump($ar1, $ar2);
+
+?>
+--EXPECT--
+*** Testing array_multisort() : basic functionality - renumbering of numeric keys ***
+
+-- Testing array_multisort() function with all normal arguments --
+bool(true)
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  ["strkey"]=>
+  int(2)
+}
+array(3) {
+  [0]=>
+  string(2) "aa"
+  [1]=>
+  string(1) "1"
+  [2]=>
+  int(2)
+}
diff --git a/tests/std/array/array_multisort_case.phpt b/tests/std/array/array_multisort_case.phpt
new file mode 100644
index 00000000..cc619df3
--- /dev/null
+++ b/tests/std/array/array_multisort_case.phpt
@@ -0,0 +1,67 @@
+--TEST--
+Test array_multisort() function : case-sensitive
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : case-sensitive\n";
+
+$a = array(
+    'Second',
+    'First.1',
+    'First.2',
+    'First.3',
+    'Twentieth',
+    'Tenth',
+    'Third',
+);
+
+$b = array(
+    '2 a',
+    '1 bb 1',
+    '1 bB 2',
+    '1 BB 3',
+    '20 c',
+    '10 d',
+    '3 e',
+);
+
+array_multisort($b, SORT_STRING, $a);
+
+var_dump($a, $b);
+
+?>
+--EXPECT--
+*** Testing array_multisort() : case-sensitive
+array(7) {
+  [0]=>
+  string(7) "First.3"
+  [1]=>
+  string(7) "First.2"
+  [2]=>
+  string(7) "First.1"
+  [3]=>
+  string(5) "Tenth"
+  [4]=>
+  string(6) "Second"
+  [5]=>
+  string(9) "Twentieth"
+  [6]=>
+  string(5) "Third"
+}
+array(7) {
+  [0]=>
+  string(6) "1 BB 3"
+  [1]=>
+  string(6) "1 bB 2"
+  [2]=>
+  string(6) "1 bb 1"
+  [3]=>
+  string(4) "10 d"
+  [4]=>
+  string(3) "2 a"
+  [5]=>
+  string(4) "20 c"
+  [6]=>
+  string(3) "3 e"
+}
diff --git a/tests/std/array/array_multisort_error.phpt b/tests/std/array/array_multisort_error.phpt
new file mode 100644
index 00000000..d184b2ac
--- /dev/null
+++ b/tests/std/array/array_multisort_error.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Test array_multisort() function : error conditions
+--SKIPIF--
+--FILE--
+<?php
+echo "*** Testing array_multisort() : error conditions ***\n";
+
+echo "\n-- Testing array_multisort() function with repeated flags --\n";
+$ar1 = array(1);
+try {
+    var_dump( array_multisort($ar1, SORT_ASC, SORT_ASC) );
+} catch (\TypeError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo "\n-- Testing array_multisort() function with repeated flags --\n";
+$ar1 = array(1);
+try {
+    var_dump( array_multisort($ar1, SORT_STRING, SORT_NUMERIC) );
+} catch (\TypeError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+?>
+--EXPECT--
+*** Testing array_multisort() : error conditions ***
+
+-- Testing array_multisort() function with repeated flags --
+array_multisort(): Argument #3 must be an array or a sort flag that has not already been specified
+
+-- Testing array_multisort() function with repeated flags --
+array_multisort(): Argument #3 must be an array or a sort flag that has not already been specified
diff --git a/tests/std/array/array_multisort_incase.phpt b/tests/std/array/array_multisort_incase.phpt
new file mode 100644
index 00000000..043432c7
--- /dev/null
+++ b/tests/std/array/array_multisort_incase.phpt
@@ -0,0 +1,67 @@
+--TEST--
+Test array_multisort() function : case-insensitive
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : case-insensitive\n";
+
+$a = array(
+    'Second',
+    'First.1',
+    'First.2',
+    'First.3',
+    'Twentieth',
+    'Tenth',
+    'Third',
+);
+
+$b = array(
+    '2 a',
+    '1 bb 1',
+    '1 bB 2',
+    '1 BB 3',
+    '20 c',
+    '10 d',
+    '3 e',
+);
+
+array_multisort($b, SORT_STRING | SORT_FLAG_CASE, $a);
+
+var_dump($a, $b);
+
+?>
+--EXPECT--
+*** Testing array_multisort() : case-insensitive
+array(7) {
+  [0]=>
+  string(7) "First.1"
+  [1]=>
+  string(7) "First.2"
+  [2]=>
+  string(7) "First.3"
+  [3]=>
+  string(5) "Tenth"
+  [4]=>
+  string(6) "Second"
+  [5]=>
+  string(9) "Twentieth"
+  [6]=>
+  string(5) "Third"
+}
+array(7) {
+  [0]=>
+  string(6) "1 bb 1"
+  [1]=>
+  string(6) "1 bB 2"
+  [2]=>
+  string(6) "1 BB 3"
+  [3]=>
+  string(4) "10 d"
+  [4]=>
+  string(3) "2 a"
+  [5]=>
+  string(4) "20 c"
+  [6]=>
+  string(3) "3 e"
+}
diff --git a/tests/std/array/array_multisort_natural.phpt b/tests/std/array/array_multisort_natural.phpt
new file mode 100644
index 00000000..1295a83c
--- /dev/null
+++ b/tests/std/array/array_multisort_natural.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_multisort() function : natural sorting
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : natural sorting\n";
+
+$a = array(
+    'Second',
+    'First',
+    'Twentieth',
+    'Tenth',
+    'Third',
+);
+
+$b = array(
+    '2 a',
+    '1 b',
+    '20 c',
+    '10 d',
+    '3 e',
+);
+
+array_multisort($b, SORT_NATURAL, $a);
+
+var_dump($a, $b);
+
+?>
+--EXPECT--
+*** Testing array_multisort() : natural sorting
+array(5) {
+  [0]=>
+  string(5) "First"
+  [1]=>
+  string(6) "Second"
+  [2]=>
+  string(5) "Third"
+  [3]=>
+  string(5) "Tenth"
+  [4]=>
+  string(9) "Twentieth"
+}
+array(5) {
+  [0]=>
+  string(3) "1 b"
+  [1]=>
+  string(3) "2 a"
+  [2]=>
+  string(3) "3 e"
+  [3]=>
+  string(4) "10 d"
+  [4]=>
+  string(4) "20 c"
+}
diff --git a/tests/std/array/array_multisort_natural_case.phpt b/tests/std/array/array_multisort_natural_case.phpt
new file mode 100644
index 00000000..d7192342
--- /dev/null
+++ b/tests/std/array/array_multisort_natural_case.phpt
@@ -0,0 +1,67 @@
+--TEST--
+Test array_multisort() function : natural sorting case-sensitive
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : natural sorting case-sensitive\n";
+
+$a = array(
+    'Second',
+    'First.1',
+    'First.2',
+    'First.3',
+    'Twentieth',
+    'Tenth',
+    'Third',
+);
+
+$b = array(
+    '2 a',
+    '1 bb 1',
+    '1 bB 2',
+    '1 BB 3',
+    '20 c',
+    '10 d',
+    '3 e',
+);
+
+array_multisort($b, SORT_NATURAL, $a);
+
+var_dump($a, $b);
+
+?>
+--EXPECT--
+*** Testing array_multisort() : natural sorting case-sensitive
+array(7) {
+  [0]=>
+  string(7) "First.3"
+  [1]=>
+  string(7) "First.2"
+  [2]=>
+  string(7) "First.1"
+  [3]=>
+  string(6) "Second"
+  [4]=>
+  string(5) "Third"
+  [5]=>
+  string(5) "Tenth"
+  [6]=>
+  string(9) "Twentieth"
+}
+array(7) {
+  [0]=>
+  string(6) "1 BB 3"
+  [1]=>
+  string(6) "1 bB 2"
+  [2]=>
+  string(6) "1 bb 1"
+  [3]=>
+  string(3) "2 a"
+  [4]=>
+  string(3) "3 e"
+  [5]=>
+  string(4) "10 d"
+  [6]=>
+  string(4) "20 c"
+}
diff --git a/tests/std/array/array_multisort_natural_incase.phpt b/tests/std/array/array_multisort_natural_incase.phpt
new file mode 100644
index 00000000..a73516b9
--- /dev/null
+++ b/tests/std/array/array_multisort_natural_incase.phpt
@@ -0,0 +1,67 @@
+--TEST--
+Test array_multisort() function : natural sorting case-insensitive
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : natural sorting case-insensitive\n";
+
+$a = array(
+    'Second',
+    'First.1',
+    'First.2',
+    'First.3',
+    'Twentieth',
+    'Tenth',
+    'Third',
+);
+
+$b = array(
+    '2 a',
+    '1 bb 1',
+    '1 bB 2',
+    '1 BB 3',
+    '20 c',
+    '10 d',
+    '3 e',
+);
+
+array_multisort($b, SORT_NATURAL | SORT_FLAG_CASE, $a);
+
+var_dump($a, $b);
+
+?>
+--EXPECT--
+*** Testing array_multisort() : natural sorting case-insensitive
+array(7) {
+  [0]=>
+  string(7) "First.1"
+  [1]=>
+  string(7) "First.2"
+  [2]=>
+  string(7) "First.3"
+  [3]=>
+  string(6) "Second"
+  [4]=>
+  string(5) "Third"
+  [5]=>
+  string(5) "Tenth"
+  [6]=>
+  string(9) "Twentieth"
+}
+array(7) {
+  [0]=>
+  string(6) "1 bb 1"
+  [1]=>
+  string(6) "1 bB 2"
+  [2]=>
+  string(6) "1 BB 3"
+  [3]=>
+  string(3) "2 a"
+  [4]=>
+  string(3) "3 e"
+  [5]=>
+  string(4) "10 d"
+  [6]=>
+  string(4) "20 c"
+}
diff --git a/tests/std/array/array_multisort_stability.phpt b/tests/std/array/array_multisort_stability.phpt
new file mode 100644
index 00000000..67814254
--- /dev/null
+++ b/tests/std/array/array_multisort_stability.phpt
@@ -0,0 +1,15 @@
+--TEST--
+array_multisort() is stable
+--FILE--
+<?php
+
+// Something of a dummy example where 0 and '0' are used as equal elements.
+
+$ary1 = array_fill(0, 100, 0);
+$origAry2 = $ary2 = array_merge(...array_fill(0, 50, [0, '0']));
+array_multisort($ary1, $ary2);
+var_dump($ary2 === $origAry2);
+
+?>
+--EXPECT--
+bool(true)
diff --git a/tests/std/array/array_multisort_variation1.phpt b/tests/std/array/array_multisort_variation1.phpt
new file mode 100644
index 00000000..5e69c985
--- /dev/null
+++ b/tests/std/array/array_multisort_variation1.phpt
@@ -0,0 +1,167 @@
+--TEST--
+Test array_multisort() function : usage variation
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// Define error handler
+function test_error_handler($err_no, $err_msg, $filename, $linenum)
+{
+    if (error_reporting() & $err_no) {
+        // report non-silenced errors
+        echo "Error: {$err_no} - {$err_msg}, {$filename}({$linenum})\n";
+    }
+}
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_multisort() : usage variation ***\n";
+    set_error_handler('test_error_handler');
+    $ar2 = array(1, 2);
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for ar1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_multisort($value));
+        } catch (\ValueError|\TypeError $e) {
+            echo $e->getMessage() . "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_multisort() : usage variation ***
+
+--int 0--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag that has not already been specified
+
+--int 1--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag that has not already been specified
+
+--int 12345--
+array_multisort(): Argument #1 ($array) must be a valid sort flag
+
+--int -12345--
+array_multisort(): Argument #1 ($array) must be a valid sort flag
+
+--float 10.5--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--float -10.5--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--float 12.3456789000e10--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--float -12.3456789000e10--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--float .5--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--uppercase NULL--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--lowercase null--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--lowercase true--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--lowercase false--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--uppercase TRUE--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--uppercase FALSE--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--empty string DQ--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--empty string SQ--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--string DQ--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--string SQ--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--mixed case string--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--heredoc--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--instance of classWithToString--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--instance of classWithoutToString--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--undefined var--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+
+--unset var--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
diff --git a/tests/std/array/array_multisort_variation10.phpt b/tests/std/array/array_multisort_variation10.phpt
new file mode 100644
index 00000000..6d61ae04
--- /dev/null
+++ b/tests/std/array/array_multisort_variation10.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Test array_multisort() function : usage variation - testing with anonymous array arguments
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : Testing with anonymous arguments ***\n";
+
+var_dump(array_multisort(array(1,3,2,4)));
+
+?>
+--EXPECT--
+*** Testing array_multisort() : Testing with anonymous arguments ***
+bool(true)
diff --git a/tests/std/array/array_multisort_variation11.phpt b/tests/std/array/array_multisort_variation11.phpt
new file mode 100644
index 00000000..a3565022
--- /dev/null
+++ b/tests/std/array/array_multisort_variation11.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Test array_multisort() function : usage variation - testing with empty array
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : Testing with empty array ***\n";
+
+var_dump(array_multisort(array()));
+
+?>
+--EXPECT--
+*** Testing array_multisort() : Testing with empty array ***
+bool(true)
diff --git a/tests/std/array/array_multisort_variation2.phpt b/tests/std/array/array_multisort_variation2.phpt
new file mode 100644
index 00000000..eab827e4
--- /dev/null
+++ b/tests/std/array/array_multisort_variation2.phpt
@@ -0,0 +1,186 @@
+--TEST--
+Test array_multisort() function : usage variation
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// Define error handler
+function test_error_handler($err_no, $err_msg, $filename, $linenum)
+{
+    if (error_reporting() & $err_no) {
+        // report non-silenced errors
+        echo "Error: {$err_no} - {$err_msg}, {$filename}({$linenum})\n";
+    }
+}
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_multisort() : usage variation ***\n";
+    set_error_handler('test_error_handler');
+    // Initialise function arguments not being substituted (if any)
+    $ar1 = array(1, 2);
+    $ar2 = array(1, 2);
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+        // array data
+        'empty array' => array(),
+        'int indexed array' => $index_array,
+        'associative array' => $assoc_array,
+        'nested arrays' => array('foo', $index_array, $assoc_array),
+        // 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,
+    );
+    // loop through each element of the array for SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_NATURAL|SORT_FLAG_CASE]]
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_multisort($ar1, $value));
+        } catch (\ValueError|\TypeError $e) {
+            echo $e->getMessage() . "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_multisort() : usage variation ***
+
+--int 0--
+bool(true)
+
+--int 1--
+bool(true)
+
+--int 12345--
+array_multisort(): Argument #2 must be a valid sort flag
+
+--int -12345--
+array_multisort(): Argument #2 must be a valid sort flag
+
+--float 10.5--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--float -10.5--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--float 12.3456789000e10--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--float -12.3456789000e10--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--float .5--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--empty array--
+Array sizes are inconsistent
+
+--int indexed array--
+Array sizes are inconsistent
+
+--associative array--
+bool(true)
+
+--nested arrays--
+Array sizes are inconsistent
+
+--uppercase NULL--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--lowercase null--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--lowercase true--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--lowercase false--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--uppercase TRUE--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--uppercase FALSE--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--empty string DQ--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--empty string SQ--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--string DQ--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--string SQ--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--mixed case string--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--heredoc--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--instance of classWithToString--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--instance of classWithoutToString--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--undefined var--
+array_multisort(): Argument #2 must be an array or a sort flag
+
+--unset var--
+array_multisort(): Argument #2 must be an array or a sort flag
diff --git a/tests/std/array/array_multisort_variation3.phpt b/tests/std/array/array_multisort_variation3.phpt
new file mode 100644
index 00000000..f345b44a
--- /dev/null
+++ b/tests/std/array/array_multisort_variation3.phpt
@@ -0,0 +1,168 @@
+--TEST--
+Test array_multisort() function : usage variation
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// Define error handler
+function test_error_handler($err_no, $err_msg, $filename, $linenum)
+{
+    if (error_reporting() & $err_no) {
+        // report non-silenced errors
+        echo "Error: {$err_no} - {$err_msg}, {$filename}({$linenum})\n";
+    }
+}
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_multisort() : usage variation ***\n";
+    set_error_handler('test_error_handler');
+    // Initialise function arguments not being substituted (if any)
+    $ar1 = array(1, 2);
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for ar2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_multisort($ar1, SORT_REGULAR, $value));
+        } catch (\ValueError|\TypeError $e) {
+            echo $e->getMessage() . "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_multisort() : usage variation ***
+
+--int 0--
+array_multisort(): Argument #3 must be an array or a sort flag that has not already been specified
+
+--int 1--
+array_multisort(): Argument #3 must be an array or a sort flag that has not already been specified
+
+--int 12345--
+array_multisort(): Argument #3 must be a valid sort flag
+
+--int -12345--
+array_multisort(): Argument #3 must be a valid sort flag
+
+--float 10.5--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--float -10.5--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--float 12.3456789000e10--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--float -12.3456789000e10--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--float .5--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--uppercase NULL--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--lowercase null--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--lowercase true--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--lowercase false--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--uppercase TRUE--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--uppercase FALSE--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--empty string DQ--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--empty string SQ--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--string DQ--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--string SQ--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--mixed case string--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--heredoc--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--instance of classWithToString--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--instance of classWithoutToString--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--undefined var--
+array_multisort(): Argument #3 must be an array or a sort flag
+
+--unset var--
+array_multisort(): Argument #3 must be an array or a sort flag
diff --git a/tests/std/array/array_multisort_variation4.phpt b/tests/std/array/array_multisort_variation4.phpt
new file mode 100644
index 00000000..6f88dda2
--- /dev/null
+++ b/tests/std/array/array_multisort_variation4.phpt
@@ -0,0 +1,52 @@
+--TEST--
+Test array_multisort() function : usage variation - testing with multiple array arguments
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : Testing  with multiple array arguments ***\n";
+
+$arr1 = array (4,3,3,3);
+$arr2 = array (9,3,2,2);
+$arr3 = array (9,9,2,1);
+
+var_dump(array_multisort($arr1, $arr2, $arr3));
+
+var_dump($arr1);
+var_dump($arr2);
+var_dump($arr3);
+
+?>
+--EXPECT--
+*** Testing array_multisort() : Testing  with multiple array arguments ***
+bool(true)
+array(4) {
+  [0]=>
+  int(3)
+  [1]=>
+  int(3)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+}
+array(4) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(9)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(9)
+  [3]=>
+  int(9)
+}
diff --git a/tests/std/array/array_multisort_variation5.phpt b/tests/std/array/array_multisort_variation5.phpt
new file mode 100644
index 00000000..088e4628
--- /dev/null
+++ b/tests/std/array/array_multisort_variation5.phpt
@@ -0,0 +1,47 @@
+--TEST--
+Test array_multisort() function : usage variation - testing with multiple array arguments
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : Testing  all array sort specifiers ***\n";
+
+$ar = array( 2, "aa" , "1");
+
+array_multisort($ar, SORT_REGULAR, SORT_ASC);
+var_dump($ar);
+
+array_multisort($ar, SORT_STRING, SORT_ASC);
+var_dump($ar);
+
+array_multisort($ar, SORT_NUMERIC, SORT_ASC);
+var_dump($ar);
+
+
+?>
+--EXPECT--
+*** Testing array_multisort() : Testing  all array sort specifiers ***
+array(3) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  int(2)
+  [2]=>
+  string(2) "aa"
+}
+array(3) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  int(2)
+  [2]=>
+  string(2) "aa"
+}
+array(3) {
+  [0]=>
+  string(2) "aa"
+  [1]=>
+  string(1) "1"
+  [2]=>
+  int(2)
+}
diff --git a/tests/std/array/array_multisort_variation6.phpt b/tests/std/array/array_multisort_variation6.phpt
new file mode 100644
index 00000000..3528e7e4
--- /dev/null
+++ b/tests/std/array/array_multisort_variation6.phpt
@@ -0,0 +1,47 @@
+--TEST--
+Test array_multisort() function : usage variation - testing with multiple array arguments
+--SKIPIF--
+
+--FILE--
+<?php
+echo "*** Testing array_multisort() : Testing  all array sort specifiers ***\n";
+
+$ar = array( 2, "aa" , "1");
+
+array_multisort($ar, SORT_REGULAR, SORT_DESC);
+var_dump($ar);
+
+array_multisort($ar, SORT_STRING, SORT_DESC);
+var_dump($ar);
+
+array_multisort($ar, SORT_NUMERIC, SORT_DESC);
+var_dump($ar);
+
+
+?>
+--EXPECT--
+*** Testing array_multisort() : Testing  all array sort specifiers ***
+array(3) {
+  [0]=>
+  string(2) "aa"
+  [1]=>
+  int(2)
+  [2]=>
+  string(1) "1"
+}
+array(3) {
+  [0]=>
+  string(2) "aa"
+  [1]=>
+  int(2)
+  [2]=>
+  string(1) "1"
+}
+array(3) {
+  [0]=>
+  int(2)
+  [1]=>
+  string(1) "1"
+  [2]=>
+  string(2) "aa"
+}
diff --git a/tests/std/array/array_multisort_variation7.phpt b/tests/std/array/array_multisort_variation7.phpt
new file mode 100644
index 00000000..a584182c
--- /dev/null
+++ b/tests/std/array/array_multisort_variation7.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_multisort() function : usage variation - test sort order of all types
+--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_multisort() : usage variation  - test sort order of all types***\n";
+    $inputs = array('int 0' => 0, 'float -10.5' => -10.5, array(), 'uppercase NULL' => NULL, 'lowercase true' => true, 'empty string DQ' => "", 'string DQ' => "string", 'instance of classWithToString' => new classWithToString(), 'instance of classWithoutToString' => new classWithoutToString(), 'undefined var' => @$undefined_var);
+    var_dump(array_multisort($inputs));
+    var_dump($inputs);
+}
+?>
+--EXPECT--
+*** Testing array_multisort() : usage variation  - test sort order of all types***
+bool(true)
+array(10) {
+  ["float -10.5"]=>
+  float(-10.5)
+  ["int 0"]=>
+  int(0)
+  [0]=>
+  array(0) {
+  }
+  ["uppercase NULL"]=>
+  NULL
+  ["empty string DQ"]=>
+  string(0) ""
+  ["undefined var"]=>
+  NULL
+  ["lowercase true"]=>
+  bool(true)
+  ["instance of classWithToString"]=>
+  object(classWithToString)#1 (0) {
+  }
+  ["string DQ"]=>
+  string(6) "string"
+  ["instance of classWithoutToString"]=>
+  object(classWithoutToString)#2 (0) {
+  }
+}
diff --git a/tests/std/array/array_multisort_variation8.phpt b/tests/std/array/array_multisort_variation8.phpt
new file mode 100644
index 00000000..5213010c
--- /dev/null
+++ b/tests/std/array/array_multisort_variation8.phpt
@@ -0,0 +1,58 @@
+--TEST--
+Test array_multisort() function : usage variation - test sort order of all types
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// Define error handler
+function test_error_handler($err_no, $err_msg, $filename, $linenum)
+{
+    // We're testing sort order not errors so ignore.
+}
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_multisort() : usage variation  - test sort order of all types***\n";
+    set_error_handler('test_error_handler');
+    $inputs = array('int 0' => 0, 'float -10.5' => -10.5, array(), 'uppercase NULL' => NULL, 'lowercase true' => true, 'empty string DQ' => "", 'string DQ' => "string", 'instance of classWithToString' => new classWithToString(), 'undefined var' => @$undefined_var);
+    var_dump(array_multisort($inputs, SORT_STRING));
+    var_dump($inputs);
+}
+?>
+--EXPECT--
+*** Testing array_multisort() : usage variation  - test sort order of all types***
+bool(true)
+array(9) {
+  ["uppercase NULL"]=>
+  NULL
+  ["empty string DQ"]=>
+  string(0) ""
+  ["undefined var"]=>
+  NULL
+  ["float -10.5"]=>
+  float(-10.5)
+  ["int 0"]=>
+  int(0)
+  ["lowercase true"]=>
+  bool(true)
+  [0]=>
+  array(0) {
+  }
+  ["instance of classWithToString"]=>
+  object(classWithToString)#1 (0) {
+  }
+  ["string DQ"]=>
+  string(6) "string"
+}
diff --git a/tests/std/array/array_multisort_variation9.phpt b/tests/std/array/array_multisort_variation9.phpt
new file mode 100644
index 00000000..d19d6cbe
--- /dev/null
+++ b/tests/std/array/array_multisort_variation9.phpt
@@ -0,0 +1,63 @@
+--TEST--
+Test array_multisort() function : usage variation - test sort order of all types
+--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_multisort() : usage variation  - test sort order of all types***\n";
+    $inputs = array('int 0' => 0, 'float -10.5' => -10.5, array(), 'uppercase NULL' => NULL, 'lowercase true' => true, 'empty string DQ' => "", 'string DQ' => "string", 'instance of classWithToString' => new classWithToString(), 'instance of classWithoutToString' => new classWithoutToString(), 'undefined var' => @$undefined_var);
+    var_dump(array_multisort($inputs, SORT_NUMERIC));
+    var_dump($inputs);
+}
+?>
+--EXPECTF--
+*** Testing array_multisort() : usage variation  - test sort order of all types***
+
+Warning: Object of class classWithToString could not be converted to float in %s on line %d
+
+Warning: Object of class classWithToString could not be converted to float in %s on line %d
+
+Warning: Object of class classWithoutToString could not be converted to float in %s on line %d
+
+Warning: Object of class classWithoutToString could not be converted to float in %s on line %d
+bool(true)
+array(10) {
+  ["float -10.5"]=>
+  float(-10.5)
+  ["int 0"]=>
+  int(0)
+  [0]=>
+  array(0) {
+  }
+  ["uppercase NULL"]=>
+  NULL
+  ["empty string DQ"]=>
+  string(0) ""
+  ["string DQ"]=>
+  string(6) "string"
+  ["undefined var"]=>
+  NULL
+  ["lowercase true"]=>
+  bool(true)
+  ["instance of classWithToString"]=>
+  object(classWithToString)#1 (0) {
+  }
+  ["instance of classWithoutToString"]=>
+  object(classWithoutToString)#2 (0) {
+  }
+}
diff --git a/tests/std/array/array_next_error1.phpt b/tests/std/array/array_next_error1.phpt
new file mode 100644
index 00000000..13911b89
--- /dev/null
+++ b/tests/std/array/array_next_error1.phpt
@@ -0,0 +1,18 @@
+--TEST--
+next - ensure warning is received when passing an indirect temporary.
+--SKIPIF--
+<?php die("skip AOT next() error handling differs from PHP"); ?>
+--FILE--
+<?php
+function f()
+{
+    return array(1, 2);
+}
+function main()
+{
+    var_dump(next(f()));
+}
+?>
+--EXPECTF--
+Notice: Only variables should be passed by reference in %s on line %d
+int(2)
diff --git a/tests/std/array/array_next_error2.phpt b/tests/std/array/array_next_error2.phpt
new file mode 100644
index 00000000..68789be6
--- /dev/null
+++ b/tests/std/array/array_next_error2.phpt
@@ -0,0 +1,20 @@
+--TEST--
+next - ensure we cannot pass a temporary
+--SKIPIF--
+<?php die("skip AOT next() error handling differs from PHP"); ?>
+--FILE--
+<?php
+function f()
+{
+    return array(1, 2);
+}
+function main()
+{
+    var_dump(next(array(1, 2)));
+}
+?>
+--EXPECTF--
+Fatal error: Uncaught Error: next(): Argument #1 ($array) could not be passed by reference in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d
diff --git a/tests/std/array/array_pad.phpt b/tests/std/array/array_pad.phpt
new file mode 100644
index 00000000..67cb4234
--- /dev/null
+++ b/tests/std/array/array_pad.phpt
@@ -0,0 +1,80 @@
+--TEST--
+array_pad() tests
+--FILE--
+<?php
+
+var_dump(array_pad(array(), 1, 0));
+
+var_dump(array_pad(array(), 0, 0));
+var_dump(array_pad(array(), -1, 0));
+var_dump(array_pad(array("", -1, 2.0), 5, 0));
+var_dump(array_pad(array("", -1, 2.0), 5, array()));
+var_dump(array_pad(array("", -1, 2.0), 2, array()));
+var_dump(array_pad(array("", -1, 2.0), -3, array()));
+var_dump(array_pad(array("", -1, 2.0), -4, array()));
+
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  int(0)
+}
+array(0) {
+}
+array(1) {
+  [0]=>
+  int(0)
+}
+array(5) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  int(-1)
+  [2]=>
+  float(2)
+  [3]=>
+  int(0)
+  [4]=>
+  int(0)
+}
+array(5) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  int(-1)
+  [2]=>
+  float(2)
+  [3]=>
+  array(0) {
+  }
+  [4]=>
+  array(0) {
+  }
+}
+array(3) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  int(-1)
+  [2]=>
+  float(2)
+}
+array(3) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  int(-1)
+  [2]=>
+  float(2)
+}
+array(4) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  string(0) ""
+  [2]=>
+  int(-1)
+  [3]=>
+  float(2)
+}
diff --git a/tests/std/array/array_pad_too_large_padding.phpt b/tests/std/array/array_pad_too_large_padding.phpt
new file mode 100644
index 00000000..41c25fd7
--- /dev/null
+++ b/tests/std/array/array_pad_too_large_padding.phpt
@@ -0,0 +1,21 @@
+--TEST--
+array_pad() with too large padding should fail
+--FILE--
+<?php
+function test($length)
+{
+    try {
+        var_dump(array_pad(array("", -1, 2.0), $length, 0));
+    } catch (\ValueError $e) {
+        echo $e->getMessage() . "\n";
+    }
+}
+function main()
+{
+    test(PHP_INT_MIN);
+    test(PHP_INT_MAX);
+}
+?>
+--EXPECT--
+array_pad(): Argument #2 ($length) must not exceed the maximum allowed array size
+array_pad(): Argument #2 ($length) must not exceed the maximum allowed array size
diff --git a/tests/std/array/array_pad_variation3.phpt b/tests/std/array/array_pad_variation3.phpt
new file mode 100644
index 00000000..fe2f7236
--- /dev/null
+++ b/tests/std/array/array_pad_variation3.phpt
@@ -0,0 +1,864 @@
+--TEST--
+Test array_pad() function : usage variations - possible values for 'pad_value' 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()
+{
+    /*
+    * Testing array_pad() function for expected behavior by passing
+    * different possible values for $pad_value argument.
+    * $input and $pad_size arguments take fixed value.
+    */
+    echo "*** Testing array_pad() : possible values for \$pad_value argument ***\n";
+    // Initialise $input and $pad_size argument
+    $input = array(1, 2);
+    $pad_size = 4;
+    //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");
+    // get a reference variable
+    $value = "hello";
+    $reference =& $value;
+    // different values to be passed to $pad_value argument
+    $pad_values = array(
+        // int data
+        /*1*/
+        0,
+        1,
+        12345,
+        -2345,
+        // float data
+        /*5*/
+        10.5,
+        -10.5,
+        123456789000.0,
+        1.23456789E-9,
+        0.5,
+        // array data
+        /*10*/
+        array(),
+        array(0),
+        array(1),
+        array(1, 2),
+        array('color' => 'red', 'item' => 'pen'),
+        // null data
+        /*15*/
+        NULL,
+        null,
+        // boolean data
+        /*17*/
+        true,
+        false,
+        TRUE,
+        FALSE,
+        // empty data
+        /*21*/
+        "",
+        '',
+        // string data
+        /*23*/
+        "string",
+        'string',
+        $heredoc,
+        // strings with different white spaces
+        /*26*/
+        "\v\fHello\t world!! \rstring\n",
+        '\v\fHello\t world!! \rstring\n',
+        // object data
+        /*28*/
+        new classA(),
+        // undefined data
+        /*29*/
+        @$undefined_var,
+        // unset data
+        /*30*/
+        @$unset_var,
+        // resource variable
+        /*31*/
+        $fp,
+        // reference variable
+        /*32*/
+        $reference,
+    );
+    // loop through each element of $pad_values to check the behavior of array_pad()
+    $iterator = 1;
+    foreach ($pad_values as $pad_value) {
+        echo "-- Iteration {$iterator} --\n";
+        var_dump(array_pad($input, $pad_size, $pad_value));
+        // positive 'pad_size'
+        var_dump(array_pad($input, -$pad_size, $pad_value));
+        // negative 'pad_size'
+        $iterator++;
+    }
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_pad() : possible values for $pad_value argument ***
+-- Iteration 1 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(0)
+  [3]=>
+  int(0)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(0)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 2 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(1)
+  [3]=>
+  int(1)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 3 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(12345)
+  [3]=>
+  int(12345)
+}
+array(4) {
+  [0]=>
+  int(12345)
+  [1]=>
+  int(12345)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 4 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(-2345)
+  [3]=>
+  int(-2345)
+}
+array(4) {
+  [0]=>
+  int(-2345)
+  [1]=>
+  int(-2345)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 5 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  float(10.5)
+  [3]=>
+  float(10.5)
+}
+array(4) {
+  [0]=>
+  float(10.5)
+  [1]=>
+  float(10.5)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 6 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  float(-10.5)
+  [3]=>
+  float(-10.5)
+}
+array(4) {
+  [0]=>
+  float(-10.5)
+  [1]=>
+  float(-10.5)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 7 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  float(123456789000)
+  [3]=>
+  float(123456789000)
+}
+array(4) {
+  [0]=>
+  float(123456789000)
+  [1]=>
+  float(123456789000)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 8 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  float(1.23456789E-9)
+  [3]=>
+  float(1.23456789E-9)
+}
+array(4) {
+  [0]=>
+  float(1.23456789E-9)
+  [1]=>
+  float(1.23456789E-9)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 9 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  float(0.5)
+  [3]=>
+  float(0.5)
+}
+array(4) {
+  [0]=>
+  float(0.5)
+  [1]=>
+  float(0.5)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 10 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  array(0) {
+  }
+  [3]=>
+  array(0) {
+  }
+}
+array(4) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(0) {
+  }
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 11 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+}
+array(4) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 12 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+array(4) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 13 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [3]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+}
+array(4) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 14 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+  [3]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+}
+array(4) {
+  [0]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+  [1]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 15 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+}
+array(4) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 16 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+}
+array(4) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 17 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+array(4) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(true)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 18 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  bool(false)
+  [3]=>
+  bool(false)
+}
+array(4) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(false)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 19 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+array(4) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(true)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 20 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  bool(false)
+  [3]=>
+  bool(false)
+}
+array(4) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(false)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 21 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(0) ""
+  [3]=>
+  string(0) ""
+}
+array(4) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 22 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(0) ""
+  [3]=>
+  string(0) ""
+}
+array(4) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 23 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(6) "string"
+  [3]=>
+  string(6) "string"
+}
+array(4) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(6) "string"
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 24 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(6) "string"
+  [3]=>
+  string(6) "string"
+}
+array(4) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(6) "string"
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 25 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(11) "hello world"
+  [3]=>
+  string(11) "hello world"
+}
+array(4) {
+  [0]=>
+  string(11) "hello world"
+  [1]=>
+  string(11) "hello world"
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 26 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(25) "Hello	 world!! 
string
+"
+  [3]=>
+  string(25) "Hello	 world!! 
string
+"
+}
+array(4) {
+  [0]=>
+  string(25) "Hello	 world!! 
string
+"
+  [1]=>
+  string(25) "Hello	 world!! 
string
+"
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 27 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(30) "\v\fHello\t world!! \rstring\n"
+  [3]=>
+  string(30) "\v\fHello\t world!! \rstring\n"
+}
+array(4) {
+  [0]=>
+  string(30) "\v\fHello\t world!! \rstring\n"
+  [1]=>
+  string(30) "\v\fHello\t world!! \rstring\n"
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 28 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  object(classA)#%d (0) {
+  }
+  [3]=>
+  object(classA)#%d (0) {
+  }
+}
+array(4) {
+  [0]=>
+  object(classA)#%d (0) {
+  }
+  [1]=>
+  object(classA)#%d (0) {
+  }
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 29 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+}
+array(4) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 30 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+}
+array(4) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 31 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  resource(%d) of type (stream)
+  [3]=>
+  resource(%d) of type (stream)
+}
+array(4) {
+  [0]=>
+  resource(%d) of type (stream)
+  [1]=>
+  resource(%d) of type (stream)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+-- Iteration 32 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(5) "hello"
+  [3]=>
+  string(5) "hello"
+}
+array(4) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/array_pad_variation4.phpt b/tests/std/array/array_pad_variation4.phpt
new file mode 100644
index 00000000..0c7c6534
--- /dev/null
+++ b/tests/std/array/array_pad_variation4.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_pad() function : usage variations - binary safe checking
+--FILE--
+<?php
+/*
+* Passing binary values to $pad_value argument and testing whether
+* array_pad() behaves in an expected way with the other arguments passed to the function.
+* The $input and $pad_size arguments passed are fixed values.
+*/
+
+echo "*** Testing array_pad() : Passing binary values to \$pad_value argument ***\n";
+
+// initialize the $input and $pad_size argument
+$input = array(1, 2, 3);
+$pad_size = 6;
+
+// initialize $pad_value with reference variable
+$binary = b"hello";
+
+var_dump( array_pad($input, $pad_size, $binary) );  // positive 'pad_size'
+var_dump( array_pad($input, -$pad_size, $binary) );  // negative 'pad_size'
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_pad() : Passing binary values to $pad_value argument ***
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  string(5) "hello"
+  [4]=>
+  string(5) "hello"
+  [5]=>
+  string(5) "hello"
+}
+array(6) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "hello"
+  [3]=>
+  int(1)
+  [4]=>
+  int(2)
+  [5]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/array_pad_variation5.phpt b/tests/std/array/array_pad_variation5.phpt
new file mode 100644
index 00000000..40df2bf2
--- /dev/null
+++ b/tests/std/array/array_pad_variation5.phpt
@@ -0,0 +1,135 @@
+--TEST--
+Test array_pad() function : usage variations - two dimensional array for 'pad_value' argument
+--FILE--
+<?php
+/*
+* Passing two dimensional array to $pad_value argument and testing whether
+* array_pad() behaves in an expected way with the other arguments passed to the function.
+* The $input and $pad_size arguments passed are fixed values.
+*/
+
+echo "*** Testing array_pad() : Passing 2-d array to \$pad_value argument ***\n";
+
+// initialize the $input and $pad_size argument
+$input = array(1, 2, 3);
+$pad_size = 5;
+
+// initialize $pad_value
+$pad_value = array (
+  array(1),
+  array("hello", 'world'),
+  array("one" => 1, 'two' => 2)
+);
+
+var_dump( array_pad($input, $pad_size, $pad_value) );  // positive 'pad_value'
+var_dump( array_pad($input, -$pad_size, $pad_value) );  // negative 'pad_value'
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_pad() : Passing 2-d array to $pad_value argument ***
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  array(3) {
+    [0]=>
+    array(1) {
+      [0]=>
+      int(1)
+    }
+    [1]=>
+    array(2) {
+      [0]=>
+      string(5) "hello"
+      [1]=>
+      string(5) "world"
+    }
+    [2]=>
+    array(2) {
+      ["one"]=>
+      int(1)
+      ["two"]=>
+      int(2)
+    }
+  }
+  [4]=>
+  array(3) {
+    [0]=>
+    array(1) {
+      [0]=>
+      int(1)
+    }
+    [1]=>
+    array(2) {
+      [0]=>
+      string(5) "hello"
+      [1]=>
+      string(5) "world"
+    }
+    [2]=>
+    array(2) {
+      ["one"]=>
+      int(1)
+      ["two"]=>
+      int(2)
+    }
+  }
+}
+array(5) {
+  [0]=>
+  array(3) {
+    [0]=>
+    array(1) {
+      [0]=>
+      int(1)
+    }
+    [1]=>
+    array(2) {
+      [0]=>
+      string(5) "hello"
+      [1]=>
+      string(5) "world"
+    }
+    [2]=>
+    array(2) {
+      ["one"]=>
+      int(1)
+      ["two"]=>
+      int(2)
+    }
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    array(1) {
+      [0]=>
+      int(1)
+    }
+    [1]=>
+    array(2) {
+      [0]=>
+      string(5) "hello"
+      [1]=>
+      string(5) "world"
+    }
+    [2]=>
+    array(2) {
+      ["one"]=>
+      int(1)
+      ["two"]=>
+      int(2)
+    }
+  }
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+  [4]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/array_pad_variation6.phpt b/tests/std/array/array_pad_variation6.phpt
new file mode 100644
index 00000000..7c12baa8
--- /dev/null
+++ b/tests/std/array/array_pad_variation6.phpt
@@ -0,0 +1,665 @@
+--TEST--
+Test array_pad() function : usage variations - different arrays for 'input' argument
+--SKIPIF--
+<?php die("skip AOT array_pad behavior differs for mixed types"); ?>
+--FILE--
+<?php
+/*
+* Passing different arrays to $input argument and testing whether
+* array_pad() behaves in an expected way with the other arguments passed to the function.
+* The $pad_size and $pad_value arguments passed are fixed values.
+*/
+
+echo "*** Testing array_pad() : Passing different arrays to \$input argument ***\n";
+
+/* Different heredoc strings */
+
+// heredoc with blank line
+$blank_line = <<<EOT
+
+
+EOT;
+
+// heredoc with multiline string
+$multiline_string = <<<EOT
+hello world
+The big 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;
+
+// different arrays to be passed to $input argument
+$inputs = 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\tbbb", "\[\]\!\@\#\$\%\^\&\*\(\)\{\}"),  // with double quoted strings
+       array('a\v\f', 'aaaa\r', 'b\tbbb', '\[\]\!\@\#\$\%\^\&\*\(\)\{\}'),  // 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)
+);
+
+// initialize the $pad_size and $pad_value arguments
+$pad_size = 6;
+$pad_value = "HELLO";
+
+// loop through each sub-array within $inputs to check the behavior of array_pad()
+$iterator = 1;
+foreach($inputs as $input) {
+  echo "-- Iteration $iterator --\n";
+  var_dump( array_pad($input, $pad_size, $pad_value) );  // positive 'pad_size'
+  var_dump( array_pad($input, -$pad_size, $pad_value) );  // negative 'pad_size'
+  $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_pad() : Passing different arrays to $input argument ***
+-- Iteration 1 --
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  int(1)
+  [5]=>
+  int(2)
+}
+-- Iteration 2 --
+array(6) {
+  [0]=>
+  float(1.1)
+  [1]=>
+  float(2.2)
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  float(1.1)
+  [5]=>
+  float(2.2)
+}
+-- Iteration 3 --
+array(6) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  bool(false)
+  [5]=>
+  bool(true)
+}
+-- Iteration 4 --
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+-- Iteration 5 --
+array(6) {
+  [0]=>
+  NULL
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  NULL
+}
+-- Iteration 6 --
+array(6) {
+  [0]=>
+  string(3) "a"
+  [1]=>
+  string(5) "aaaa
"
+  [2]=>
+  string(5) "b	bbb"
+  [3]=>
+  string(27) "\[\]\!\@\#$\%\^\&\*\(\)\{\}"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(3) "a"
+  [3]=>
+  string(5) "aaaa
"
+  [4]=>
+  string(5) "b	bbb"
+  [5]=>
+  string(27) "\[\]\!\@\#$\%\^\&\*\(\)\{\}"
+}
+-- Iteration 7 --
+array(6) {
+  [0]=>
+  string(5) "a\v\f"
+  [1]=>
+  string(6) "aaaa\r"
+  [2]=>
+  string(6) "b\tbbb"
+  [3]=>
+  string(28) "\[\]\!\@\#\$\%\^\&\*\(\)\{\}"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "a\v\f"
+  [3]=>
+  string(6) "aaaa\r"
+  [4]=>
+  string(6) "b\tbbb"
+  [5]=>
+  string(28) "\[\]\!\@\#\$\%\^\&\*\(\)\{\}"
+}
+-- Iteration 8 --
+array(6) {
+  ["h1"]=>
+  string(1) "
+"
+  ["h2"]=>
+  string(86) "hello world
+The big brown fox jumped over;
+the lazy dog
+This is a double quoted string"
+  ["h3"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+  [0]=>
+  string(90) "11 < 12. 123 >22
+'single quoted string'
+"double quoted string"
+2222 != 1111.	 0000 = 0000
+"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  ["h1"]=>
+  string(1) "
+"
+  ["h2"]=>
+  string(86) "hello world
+The big brown fox jumped over;
+the lazy dog
+This is a double quoted string"
+  ["h3"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+  [2]=>
+  string(90) "11 < 12. 123 >22
+'single quoted string'
+"double quoted string"
+2222 != 1111.	 0000 = 0000
+"
+}
+-- Iteration 9 --
+array(6) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  string(5) "three"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(3) "one"
+  [4]=>
+  string(3) "two"
+  [5]=>
+  string(5) "three"
+}
+-- Iteration 10 --
+array(6) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+}
+-- Iteration 11 --
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(20)
+  [2]=>
+  int(40)
+  [3]=>
+  int(30)
+  [4]=>
+  string(5) "HELLO"
+  [5]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  int(10)
+  [3]=>
+  int(20)
+  [4]=>
+  int(40)
+  [5]=>
+  int(30)
+}
+-- Iteration 12 --
+array(6) {
+  ["one"]=>
+  string(3) "ten"
+  ["two"]=>
+  string(6) "twenty"
+  ["three"]=>
+  string(6) "thirty"
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  ["one"]=>
+  string(3) "ten"
+  ["two"]=>
+  string(6) "twenty"
+  ["three"]=>
+  string(6) "thirty"
+}
+-- Iteration 13 --
+array(6) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(4) "four"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  ["one"]=>
+  int(1)
+  [3]=>
+  string(3) "two"
+  [4]=>
+  string(4) "four"
+}
+-- Iteration 14 --
+array(6) {
+  [""]=>
+  string(4) "null"
+  ["NULL"]=>
+  NULL
+  ["null"]=>
+  NULL
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [""]=>
+  string(4) "null"
+  ["NULL"]=>
+  NULL
+  ["null"]=>
+  NULL
+}
+-- Iteration 15 --
+array(6) {
+  [0]=>
+  string(4) "true"
+  [1]=>
+  string(5) "false"
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(4) "true"
+  [3]=>
+  string(5) "false"
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+}
+-- Iteration 16 --
+array(6) {
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+  ["emptys"]=>
+  string(0) ""
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+  ["emptys"]=>
+  string(0) ""
+}
+-- Iteration 17 --
+array(6) {
+  [1]=>
+  string(0) ""
+  [2]=>
+  string(0) ""
+  [3]=>
+  NULL
+  [4]=>
+  NULL
+  [5]=>
+  bool(false)
+  [6]=>
+  bool(true)
+}
+array(6) {
+  [1]=>
+  string(0) ""
+  [2]=>
+  string(0) ""
+  [3]=>
+  NULL
+  [4]=>
+  NULL
+  [5]=>
+  bool(false)
+  [6]=>
+  bool(true)
+}
+-- Iteration 18 --
+array(6) {
+  [""]=>
+  int(4)
+  [0]=>
+  int(5)
+  [1]=>
+  int(6)
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [""]=>
+  int(4)
+  [3]=>
+  int(5)
+  [4]=>
+  int(6)
+}
+-- Iteration 19 --
+array(6) {
+  ["One"]=>
+  int(10)
+  ["two"]=>
+  int(20)
+  ["three"]=>
+  int(3)
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+}
+array(6) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  ["One"]=>
+  int(10)
+  ["two"]=>
+  int(20)
+  ["three"]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/array_pad_variation7.phpt b/tests/std/array/array_pad_variation7.phpt
new file mode 100644
index 00000000..06f2bfa6
--- /dev/null
+++ b/tests/std/array/array_pad_variation7.phpt
@@ -0,0 +1,122 @@
+--TEST--
+Test array_pad() function : usage variations - two dimensional array for 'input' argument
+--FILE--
+<?php
+/*
+* Passing two dimensional array to $input argument and testing whether
+* array_pad() behaves in an expected way with the other arguments passed to the function.
+* The $pad_size and $pad_value arguments passed are fixed values.
+*/
+
+echo "*** Testing array_pad() : Passing 2-D array to \$input argument ***\n";
+
+// initialize the 2-d array
+$input = array (
+  array(1, 2, 3),
+  array("hello", 'world'),
+  array("one" => 1, "two" => 2)
+);
+
+// initialize the $pad_size and $pad_value arguments
+$pad_size = 5;
+$pad_value = "HELLO";
+
+// entire 2-d array
+echo "-- Entire 2-d array for \$input argument --\n";
+var_dump( array_pad($input, $pad_size, $pad_value) );  // positive 'pad_size'
+var_dump( array_pad($input, -$pad_size, $pad_value) );  // negative 'pad_size'
+
+// sub array
+echo "-- Sub array for \$input argument --\n";
+var_dump( array_pad($input[1], $pad_size, $pad_value) );  // positive 'pad_size'
+var_dump( array_pad($input[1], -$pad_size, $pad_value) );  // negative 'pad_size'
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_pad() : Passing 2-D array to $input argument ***
+-- Entire 2-d array for $input argument --
+array(5) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+  [2]=>
+  array(2) {
+    ["one"]=>
+    int(1)
+    ["two"]=>
+    int(2)
+  }
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+}
+array(5) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [3]=>
+  array(2) {
+    [0]=>
+    string(5) "hello"
+    [1]=>
+    string(5) "world"
+  }
+  [4]=>
+  array(2) {
+    ["one"]=>
+    int(1)
+    ["two"]=>
+    int(2)
+  }
+}
+-- Sub array for $input argument --
+array(5) {
+  [0]=>
+  string(5) "hello"
+  [1]=>
+  string(5) "world"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "HELLO"
+  [4]=>
+  string(5) "HELLO"
+}
+array(5) {
+  [0]=>
+  string(5) "HELLO"
+  [1]=>
+  string(5) "HELLO"
+  [2]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "hello"
+  [4]=>
+  string(5) "world"
+}
+Done
diff --git a/tests/std/array/array_pop.phpt b/tests/std/array/array_pop.phpt
new file mode 100644
index 00000000..fb0c74b0
--- /dev/null
+++ b/tests/std/array/array_pop.phpt
@@ -0,0 +1,277 @@
+--TEST--
+Test array_pop() function
+--SKIPIF--
+<?php die("skip AOT array_pop behavior differs for mixed-type arrays"); ?>
+--FILE--
+<?php
+
+$empty_array = array();
+$number = 5;
+$str = "abc";
+
+
+/* Various combinations of arrays to be used for the test */
+$mixed_array = array(
+  array(),
+  array( 1,2,3,4,5,6,7,8,9 ),
+  array( "One", "_Two", "Three", "Four", "Five" ),
+  array( 6, "six", 7, "seven", 8, "eight", 9, "nine" ),
+  array( "a" => "aaa", "A" => "AAA", "c" => "ccc", "d" => "ddd", "e" => "eee" ),
+  array( "1" => "one", "2" => "two", "3" => "three", "4" => "four", "5" => "five" ),
+  array( 1 => "one", 2 => "two", 3 => 7, 4 => "four", 5 => "five" ),
+  array( "f" => "fff", "1" => "one", 4 => 6, "" => "blank", 2 => "float", "F" => "FFF",
+         "blank" => "", 3 => 3.7, 5 => 7, 6 => 8.6, '5' => "Five", "4name" => "jonny", "a" => NULL, NULL => 3 ),
+  array( 12, "name", 'age', '45' ),
+  array( array("oNe", "tWo", 4), array(10, 20, 30, 40, 50), array() ),
+  array( "one" => 1, "one" => 2, "three" => 3, 3, 4, 3 => 33, 4 => 44, 5, 6,
+          5 => 57, "5.4" => 554, "5.7" => 557 )
+);
+
+/* Loop to test normal functionality with different arrays inputs */
+echo "\n*** Normal testing with various array inputs ***\n";
+
+$counter = 1;
+foreach( $mixed_array as $sub_array )
+{
+ echo "\n-- Input Array for Iteration $counter is --\n";
+ var_dump( $sub_array );
+ echo "\nOutput after Pop is :\n";
+ var_dump( array_pop($sub_array) );
+ $counter++;
+}
+
+echo"\nDone";
+?>
+--EXPECT--
+*** Normal testing with various array inputs ***
+
+-- Input Array for Iteration 1 is --
+array(0) {
+}
+
+Output after Pop is :
+NULL
+
+-- Input Array for Iteration 2 is --
+array(9) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+}
+
+Output after Pop is :
+int(9)
+
+-- Input Array for Iteration 3 is --
+array(5) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(4) "_Two"
+  [2]=>
+  string(5) "Three"
+  [3]=>
+  string(4) "Four"
+  [4]=>
+  string(4) "Five"
+}
+
+Output after Pop is :
+string(4) "Five"
+
+-- Input Array for Iteration 4 is --
+array(8) {
+  [0]=>
+  int(6)
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+  [3]=>
+  string(5) "seven"
+  [4]=>
+  int(8)
+  [5]=>
+  string(5) "eight"
+  [6]=>
+  int(9)
+  [7]=>
+  string(4) "nine"
+}
+
+Output after Pop is :
+string(4) "nine"
+
+-- Input Array for Iteration 5 is --
+array(5) {
+  ["a"]=>
+  string(3) "aaa"
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+  ["d"]=>
+  string(3) "ddd"
+  ["e"]=>
+  string(3) "eee"
+}
+
+Output after Pop is :
+string(3) "eee"
+
+-- Input Array for Iteration 6 is --
+array(5) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+
+Output after Pop is :
+string(4) "five"
+
+-- Input Array for Iteration 7 is --
+array(5) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  int(7)
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+
+Output after Pop is :
+string(4) "five"
+
+-- Input Array for Iteration 8 is --
+array(12) {
+  ["f"]=>
+  string(3) "fff"
+  [1]=>
+  string(3) "one"
+  [4]=>
+  int(6)
+  [""]=>
+  int(3)
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+  [3]=>
+  float(3.7)
+  [5]=>
+  string(4) "Five"
+  [6]=>
+  float(8.6)
+  ["4name"]=>
+  string(5) "jonny"
+  ["a"]=>
+  NULL
+}
+
+Output after Pop is :
+NULL
+
+-- Input Array for Iteration 9 is --
+array(4) {
+  [0]=>
+  int(12)
+  [1]=>
+  string(4) "name"
+  [2]=>
+  string(3) "age"
+  [3]=>
+  string(2) "45"
+}
+
+Output after Pop is :
+string(2) "45"
+
+-- Input Array for Iteration 10 is --
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(3) "oNe"
+    [1]=>
+    string(3) "tWo"
+    [2]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [2]=>
+  array(0) {
+  }
+}
+
+Output after Pop is :
+array(0) {
+}
+
+-- Input Array for Iteration 11 is --
+array(10) {
+  ["one"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [0]=>
+  int(3)
+  [1]=>
+  int(4)
+  [3]=>
+  int(33)
+  [4]=>
+  int(44)
+  [5]=>
+  int(57)
+  [6]=>
+  int(6)
+  ["5.4"]=>
+  int(554)
+  ["5.7"]=>
+  int(557)
+}
+
+Output after Pop is :
+int(557)
+
+Done
diff --git a/tests/std/array/array_pop_variation.phpt b/tests/std/array/array_pop_variation.phpt
new file mode 100644
index 00000000..af8b0cc0
--- /dev/null
+++ b/tests/std/array/array_pop_variation.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_pop() function (variation)
+--FILE--
+<?php
+
+/* Various combinations of arrays to be used for the test */
+$mixed_array = array(
+  array(),
+  array( 1,2,3,4,5,6,7,8,9 ),
+  array( "One", "_Two", "Three", "Four", "Five" ),
+  array( 6, "six", 7, "seven", 8, "eight", 9, "nine" ),
+  array( "a" => "aaa", "A" => "AAA", "c" => "ccc", "d" => "ddd", "e" => "eee" ),
+  array( "1" => "one", "2" => "two", "3" => "three", "4" => "four", "5" => "five" ),
+  array( 1 => "one", 2 => "two", 3 => 7, 4 => "four", 5 => "five" ),
+  array( "f" => "fff", "1" => "one", 4 => 6, "" => "blank", 2 => "float", "F" => "FFF",
+         "blank" => "", 3 => 3.7, 5 => 7, 6 => 8.6, '5' => "Five", "4name" => "jonny", "a" => NULL, NULL => 3 ),
+  array( 12, "name", 'age', '45' ),
+  array( array("oNe", "tWo", 4), array(10, 20, 30, 40, 50), array() ),
+  array( "one" => 1, "one" => 2, "three" => 3, 3, 4, 3 => 33, 4 => 44, 5, 6,
+          5 => 57, "5.4" => 554, "5.7" => 557 )
+);
+
+echo"\n*** Checking for internal array pointer being reset when pop is called ***\n";
+
+echo "\nCurrent Element is : ";
+var_dump( current($mixed_array[1]) );
+
+echo "\nNext Element is : ";
+var_dump( next($mixed_array[1]) );
+
+echo "\nNext Element is : ";
+var_dump( next($mixed_array[1]) );
+
+echo "\nPOPed Element is : ";
+var_dump( array_pop($mixed_array[1]) );
+
+echo "\nCurrent Element after POP operation is: ";
+var_dump( current($mixed_array[1]) );
+
+echo"\nDone";
+?>
+--EXPECT--
+*** Checking for internal array pointer being reset when pop is called ***
+
+Current Element is : int(1)
+
+Next Element is : int(2)
+
+Next Element is : int(3)
+
+POPed Element is : int(9)
+
+Current Element after POP operation is: int(1)
+
+Done
diff --git a/tests/std/array/array_product_empty_array.phpt b/tests/std/array/array_product_empty_array.phpt
new file mode 100644
index 00000000..714030d1
--- /dev/null
+++ b/tests/std/array/array_product_empty_array.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Test array_product() function with empty array
+--FILE--
+<?php
+$input = [];
+
+echo "array_product() version:\n";
+var_dump(array_product($input));
+
+echo "array_reduce() version:\n";
+var_dump(array_reduce($input, fn($carry, $value) => $carry * $value, 1));
+?>
+--EXPECT--
+array_product() version:
+int(1)
+array_reduce() version:
+int(1)
diff --git a/tests/std/array/array_product_objects_operation_no_cast.phpt b/tests/std/array/array_product_objects_operation_no_cast.phpt
new file mode 100644
index 00000000..7f4af375
--- /dev/null
+++ b/tests/std/array/array_product_objects_operation_no_cast.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Test array_product() function with objects that implement addition but not castable to numeric type
+--EXTENSIONS--
+zend_test
+--FILE--
+<?php
+$input = [new DoOperationNoCast(25), new DoOperationNoCast(6), new DoOperationNoCast(10)];
+
+echo "array_product() version:\n";
+var_dump(array_product($input));
+
+echo "array_reduce() version:\n";
+var_dump(array_reduce($input, fn($carry, $value) => $carry * $value, 1));
+?>
+--EXPECTF--
+array_product() version:
+
+Warning: array_product(): Multiplication is not supported on type DoOperationNoCast in %s on line %d
+
+Warning: array_product(): Multiplication is not supported on type DoOperationNoCast in %s on line %d
+
+Warning: array_product(): Multiplication is not supported on type DoOperationNoCast in %s on line %d
+int(1)
+array_reduce() version:
+object(DoOperationNoCast)#5 (1) {
+  ["val":"DoOperationNoCast":private]=>
+  int(1500)
+}
diff --git a/tests/std/array/array_product_variation1.phpt b/tests/std/array/array_product_variation1.phpt
new file mode 100644
index 00000000..ad92aa11
--- /dev/null
+++ b/tests/std/array/array_product_variation1.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Test array_product() function : variation
+--FILE--
+<?php
+class A
+{
+    static function help()
+    {
+        echo "hello\n";
+    }
+}
+function main()
+{
+    echo "*** Testing array_product() : variation - using non numeric values ***\n";
+    $types = array("boolean (true)" => true, "boolean (false)" => false, "string" => "hello", "numeric string" => "12", "resource" => STDERR, "object" => new A(), "null" => null, "array" => array(3, 2));
+    foreach ($types as $desc => $type) {
+        echo $desc, "\n";
+        var_dump(array_product([1, $type]));
+        echo "\n";
+    }
+}
+?>
+--EXPECTF--
+*** Testing array_product() : variation - using non numeric values ***
+boolean (true)
+int(1)
+
+boolean (false)
+int(0)
+
+string
+
+Warning:%S Multiplication is not supported on type string in %s on line %d
+int(0)
+
+numeric string
+int(12)
+
+resource
+
+Warning:%S Multiplication is not supported on type resource in %s on line %d
+int(3)
+
+object
+
+Warning:%S Multiplication is not supported on type A in %s on line %d
+int(1)
+
+null
+int(0)
+
+array
+
+Warning:%S Multiplication is not supported on type array in %s on line %d
+int(1)
+
diff --git a/tests/std/array/array_product_variation2.phpt b/tests/std/array/array_product_variation2.phpt
new file mode 100644
index 00000000..167e46ec
--- /dev/null
+++ b/tests/std/array/array_product_variation2.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Test array_product() function : variation
+--FILE--
+<?php
+echo "*** Testing array_product() : variations ***\n";
+
+echo "\n-- Testing array_product() function with a keyed array array --\n";
+var_dump( array_product(array("bob" => 2, "janet" => 5)) );
+?>
+--EXPECT--
+*** Testing array_product() : variations ***
+
+-- Testing array_product() function with a keyed array array --
+int(10)
diff --git a/tests/std/array/array_product_variation3.phpt b/tests/std/array/array_product_variation3.phpt
new file mode 100644
index 00000000..03c7da17
--- /dev/null
+++ b/tests/std/array/array_product_variation3.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Test array_product() function : variation
+--FILE--
+<?php
+echo "*** Testing array_product() : variations - negative numbers***\n";
+
+echo "\n-- Testing array_product() function with one negative number --\n";
+var_dump( array_product(array(-2)) );
+
+echo "\n-- Testing array_product() function with two negative numbers --\n";
+var_dump( array_product(array(-2, -3)) );
+
+echo "\n-- Testing array_product() function with three negative numbers --\n";
+var_dump( array_product(array(-2, -3, -4)) );
+
+echo "\n-- Testing array_product() function with negative floats --\n";
+var_dump( array_product(array(-1.5)));
+
+echo "\n-- Testing array_product() function with negative floats --\n";
+var_dump( array_product(array(-99999999.9, 99999999.1)));
+
+
+?>
+--EXPECT--
+*** Testing array_product() : variations - negative numbers***
+
+-- Testing array_product() function with one negative number --
+int(-2)
+
+-- Testing array_product() function with two negative numbers --
+int(6)
+
+-- Testing array_product() function with three negative numbers --
+int(-24)
+
+-- Testing array_product() function with negative floats --
+float(-1.5)
+
+-- Testing array_product() function with negative floats --
+float(-9999999900000000)
diff --git a/tests/std/array/array_product_variation4.phpt b/tests/std/array/array_product_variation4.phpt
new file mode 100644
index 00000000..c142cea6
--- /dev/null
+++ b/tests/std/array/array_product_variation4.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Test array_product() function : variation
+--FILE--
+<?php
+echo "*** Testing array_product() : variations ***\n";
+
+echo "\n-- Testing array_product() function with a very large array --\n";
+
+$array = array();
+
+for ($i = 0; $i < 999; $i++) {
+  $array[] = 999;
+}
+
+var_dump( array_product($array) );
+?>
+--EXPECT--
+*** Testing array_product() : variations ***
+
+-- Testing array_product() function with a very large array --
+float(INF)
diff --git a/tests/std/array/array_product_variation5.phpt b/tests/std/array/array_product_variation5.phpt
new file mode 100644
index 00000000..557c2b33
--- /dev/null
+++ b/tests/std/array/array_product_variation5.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Test array_product() function: resources in array
+--FILE--
+<?php
+$input = [10, STDERR /* Should get casted to 3 as an integer */];
+
+echo "array_product() version:\n";
+var_dump(array_product($input));
+
+echo "array_reduce() version:\n";
+try {
+    var_dump(array_reduce($input, fn($carry, $value) => $carry * $value, 1));
+} catch (TypeError $e) {
+    echo $e->getMessage();
+}
+?>
+--EXPECTF--
+array_product() version:
+
+Warning:%S Multiplication is not supported on type resource in %s on line %d
+int(30)
+array_reduce() version:
+Unsupported operand types: int * resource%S
+%a
diff --git a/tests/std/array/array_product_variation6.phpt b/tests/std/array/array_product_variation6.phpt
new file mode 100644
index 00000000..6526197c
--- /dev/null
+++ b/tests/std/array/array_product_variation6.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Test array_product() function with objects castable to numeric type
+--EXTENSIONS--
+gmp
+--FILE--
+<?php
+$input = [gmp_init(25), gmp_init(6)];
+
+echo "array_product() version:\n";
+var_dump(array_product($input));
+
+echo "array_reduce() version:\n";
+var_dump(array_reduce($input, fn($carry, $value) => $carry * $value, 1));
+?>
+--EXPECT--
+array_product() version:
+int(150)
+array_reduce() version:
+object(GMP)#5 (1) {
+  ["num"]=>
+  string(3) "150"
+}
diff --git a/tests/std/array/array_push.phpt b/tests/std/array/array_push.phpt
new file mode 100644
index 00000000..32fcf0d3
--- /dev/null
+++ b/tests/std/array/array_push.phpt
@@ -0,0 +1,320 @@
+--TEST--
+Test array_push() function
+--SKIPIF--
+<?php die("skip AOT array_push behavior differs for mixed-type arrays"); ?>
+--FILE--
+<?php
+
+$empty_array = array();
+$number = 5;
+$str = "abc";
+
+
+/* Various combinations of arrays to be used for the test */
+$mixed_array = array(
+  array(),
+  array( 1,2,3,4,5,6,7,8,9 ),
+  array( "One", "_Two", "Three", "Four", "Five" ),
+  array( 6, "six", 7, "seven", 8, "eight", 9, "nine" ),
+  array( "a" => "aaa", "A" => "AAA", "c" => "ccc", "d" => "ddd", "e" => "eee" ),
+  array( "1" => "one", "2" => "two", "3" => "three", "4" => "four", "5" => "five" ),
+  array( 1 => "one", 2 => "two", 3 => 7, 4 => "four", 5 => "five" ),
+  array( "f" => "fff", "1" => "one", 4 => 6, "" => "blank", 2 => "float", "F" => "FFF",
+         "blank" => "", 3 => 3.7, 5 => 7, 6 => 8.6, '5' => "Five", "4name" => "jonny", "a" => NULL, NULL => 3 ),
+  array( 12, "name", 'age', '45' ),
+  array( array("oNe", "tWo", 4), array(10, 20, 30, 40, 50), array() ),
+  array( "one" => 1, "one" => 2, "three" => 3, 3, 4, 3 => 33, 4 => 44, 5, 6,
+          5 => 57, "5.4" => 554, "5.7" => 557 )
+);
+
+/* Error Conditions */
+echo "\n*** Testing Edge Conditions ***\n";
+
+/* Invalid Number of arguments */
+var_dump( array_push($mixed_array[1],1,2) );
+
+/* Empty Array as argument */
+var_dump( array_push($empty_array, 2) );
+
+
+/* Loop to test normal functionality with different arrays inputs */
+echo "\n*** Testing with various array inputs ***\n";
+
+$counter = 1;
+foreach( $mixed_array as $sub_array )
+{
+ echo "\n-- Input Array for Iteration $counter is --\n";
+ var_dump( $sub_array );
+ echo "\nOutput after push is :\n";
+ var_dump( array_push($sub_array, 22, "abc") );
+ $counter++;
+}
+
+/* Checking for return value and the new array formed from push operation */
+echo "\n*** Checking for return value and the new array formed from push operation ***\n";
+var_dump( array_push($mixed_array[2], 22, 33, "44") );
+var_dump( $mixed_array[2] );
+
+echo"\nDone";
+?>
+--EXPECT--
+*** Testing Edge Conditions ***
+int(11)
+int(1)
+
+*** Testing with various array inputs ***
+
+-- Input Array for Iteration 1 is --
+array(0) {
+}
+
+Output after push is :
+int(2)
+
+-- Input Array for Iteration 2 is --
+array(11) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+  [9]=>
+  int(1)
+  [10]=>
+  int(2)
+}
+
+Output after push is :
+int(13)
+
+-- Input Array for Iteration 3 is --
+array(5) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(4) "_Two"
+  [2]=>
+  string(5) "Three"
+  [3]=>
+  string(4) "Four"
+  [4]=>
+  string(4) "Five"
+}
+
+Output after push is :
+int(7)
+
+-- Input Array for Iteration 4 is --
+array(8) {
+  [0]=>
+  int(6)
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+  [3]=>
+  string(5) "seven"
+  [4]=>
+  int(8)
+  [5]=>
+  string(5) "eight"
+  [6]=>
+  int(9)
+  [7]=>
+  string(4) "nine"
+}
+
+Output after push is :
+int(10)
+
+-- Input Array for Iteration 5 is --
+array(5) {
+  ["a"]=>
+  string(3) "aaa"
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+  ["d"]=>
+  string(3) "ddd"
+  ["e"]=>
+  string(3) "eee"
+}
+
+Output after push is :
+int(7)
+
+-- Input Array for Iteration 6 is --
+array(5) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+
+Output after push is :
+int(7)
+
+-- Input Array for Iteration 7 is --
+array(5) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  int(7)
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+
+Output after push is :
+int(7)
+
+-- Input Array for Iteration 8 is --
+array(12) {
+  ["f"]=>
+  string(3) "fff"
+  [1]=>
+  string(3) "one"
+  [4]=>
+  int(6)
+  [""]=>
+  int(3)
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+  [3]=>
+  float(3.7)
+  [5]=>
+  string(4) "Five"
+  [6]=>
+  float(8.6)
+  ["4name"]=>
+  string(5) "jonny"
+  ["a"]=>
+  NULL
+}
+
+Output after push is :
+int(14)
+
+-- Input Array for Iteration 9 is --
+array(4) {
+  [0]=>
+  int(12)
+  [1]=>
+  string(4) "name"
+  [2]=>
+  string(3) "age"
+  [3]=>
+  string(2) "45"
+}
+
+Output after push is :
+int(6)
+
+-- Input Array for Iteration 10 is --
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(3) "oNe"
+    [1]=>
+    string(3) "tWo"
+    [2]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [2]=>
+  array(0) {
+  }
+}
+
+Output after push is :
+int(5)
+
+-- Input Array for Iteration 11 is --
+array(10) {
+  ["one"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [0]=>
+  int(3)
+  [1]=>
+  int(4)
+  [3]=>
+  int(33)
+  [4]=>
+  int(44)
+  [5]=>
+  int(57)
+  [6]=>
+  int(6)
+  ["5.4"]=>
+  int(554)
+  ["5.7"]=>
+  int(557)
+}
+
+Output after push is :
+int(12)
+
+*** Checking for return value and the new array formed from push operation ***
+int(8)
+array(8) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(4) "_Two"
+  [2]=>
+  string(5) "Three"
+  [3]=>
+  string(4) "Four"
+  [4]=>
+  string(4) "Five"
+  [5]=>
+  int(22)
+  [6]=>
+  int(33)
+  [7]=>
+  string(2) "44"
+}
+
+Done
diff --git a/tests/std/array/array_push_basic.phpt b/tests/std/array/array_push_basic.phpt
new file mode 100644
index 00000000..c0d66b70
--- /dev/null
+++ b/tests/std/array/array_push_basic.phpt
@@ -0,0 +1,57 @@
+--TEST--
+Test array_push() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of array_push with indexed and associative arrays
+ */
+
+echo "*** Testing array_push() : basic functionality ***\n";
+
+$array = array ('zero', 'one', 'two');
+$var1 = 'three';
+$var2 = 'four';
+
+echo "\n-- Push values onto an indexed array --\n";
+var_dump(array_push($array, $var1, $var2));
+var_dump($array);
+
+$array_assoc = array ('one' => 'un', 'two' => 'deux');
+
+echo "\n-- Push values onto an associative array --\n";
+var_dump(array_push($array_assoc, $var1, $var2));
+var_dump($array_assoc);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_push() : basic functionality ***
+
+-- Push values onto an indexed array --
+int(5)
+array(5) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+  [4]=>
+  string(4) "four"
+}
+
+-- Push values onto an associative array --
+int(4)
+array(4) {
+  ["one"]=>
+  string(2) "un"
+  ["two"]=>
+  string(4) "deux"
+  [0]=>
+  string(5) "three"
+  [1]=>
+  string(4) "four"
+}
+Done
diff --git a/tests/std/array/array_push_empty.phpt b/tests/std/array/array_push_empty.phpt
new file mode 100644
index 00000000..1c7f935a
--- /dev/null
+++ b/tests/std/array/array_push_empty.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Test array_push() function : push empty set to the array
+--FILE--
+<?php
+$array = [1,2,3];
+$values = [];
+
+var_dump( array_push($array) );
+var_dump( array_push($array, ...$values) );
+var_dump( $array );
+
+echo "Done";
+?>
+--EXPECT--
+int(3)
+int(3)
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/array_push_error2.phpt b/tests/std/array/array_push_error2.phpt
new file mode 100644
index 00000000..0ed0af6e
--- /dev/null
+++ b/tests/std/array/array_push_error2.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Test array_push() function : error conditions - max int value as key
+--FILE--
+<?php
+/*
+ * Use PHP's maximum integer value as array key
+ * then try and push new elements onto the array
+ */
+
+echo "*** Testing array_push() : error conditions ***\n";
+
+$array = array(PHP_INT_MAX => 'max');
+try {
+    var_dump(array_push($array, 'new'));
+} catch (\Error $e) {
+    echo $e->getMessage() . "\n";
+}
+var_dump($array);
+
+?>
+--EXPECTF--
+*** Testing array_push() : error conditions ***
+Cannot add element to the array as the next element is already occupied
+array(1) {
+  [%d]=>
+  string(3) "max"
+}
diff --git a/tests/std/array/array_push_variation2.phpt b/tests/std/array/array_push_variation2.phpt
new file mode 100644
index 00000000..6533a67e
--- /dev/null
+++ b/tests/std/array/array_push_variation2.phpt
@@ -0,0 +1,171 @@
+--TEST--
+Test array_push() function : usage variations - Pass different data types as $var arg
+--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 different data types as $var argument to array_push to test behaviour
+     */
+    echo "*** Testing array_push() : usage variations ***\n";
+    // Initialise function arguments not being substituted
+    $stack = array(1, 2);
+    //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");
+    // unexpected values to be passed to $var 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*/
+        "",
+        '',
+        array(),
+        // string data
+        /*19*/
+        "string",
+        'string',
+        $heredoc,
+        // object data
+        /*22*/
+        new classA(),
+        // undefined data
+        /*23*/
+        @$undefined_var,
+        // unset data
+        /*24*/
+        @$unset_var,
+        // resource variable
+        /*25*/
+        $fp,
+    );
+    // loop through each element of $inputs to check the behavior of array_push()
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "\n-- Iteration {$iterator} --\n";
+        $temp_array = $stack;
+        var_dump(array_push($temp_array, $input));
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_push() : usage variations ***
+
+-- Iteration 1 --
+int(3)
+
+-- Iteration 2 --
+int(3)
+
+-- Iteration 3 --
+int(3)
+
+-- Iteration 4 --
+int(3)
+
+-- Iteration 5 --
+int(3)
+
+-- Iteration 6 --
+int(3)
+
+-- Iteration 7 --
+int(3)
+
+-- Iteration 8 --
+int(3)
+
+-- Iteration 9 --
+int(3)
+
+-- Iteration 10 --
+int(3)
+
+-- Iteration 11 --
+int(3)
+
+-- Iteration 12 --
+int(3)
+
+-- Iteration 13 --
+int(3)
+
+-- Iteration 14 --
+int(3)
+
+-- Iteration 15 --
+int(3)
+
+-- Iteration 16 --
+int(3)
+
+-- Iteration 17 --
+int(3)
+
+-- Iteration 18 --
+int(3)
+
+-- Iteration 19 --
+int(3)
+
+-- Iteration 20 --
+int(3)
+
+-- Iteration 21 --
+int(3)
+
+-- Iteration 22 --
+int(3)
+
+-- Iteration 23 --
+int(3)
+
+-- Iteration 24 --
+int(3)
+
+-- Iteration 25 --
+int(3)
+Done
diff --git a/tests/std/array/array_push_variation3.phpt b/tests/std/array/array_push_variation3.phpt
new file mode 100644
index 00000000..4ce4e7d9
--- /dev/null
+++ b/tests/std/array/array_push_variation3.phpt
@@ -0,0 +1,65 @@
+--TEST--
+Test array_push() function : usage variations - multidimensional arrays
+--FILE--
+<?php
+/*
+ * Test array_push when passed:
+ * 1. an array as $var arg
+ * 2. as sub-array as $stack arg
+ */
+
+echo "*** Testing array_push() : usage variations ***\n";
+
+echo "\n-- Pass array as \$var argument --\n";
+$array = array(1, 2, 3);
+$sub_array = array('one', 'two');
+var_dump(array_push($array, $sub_array));
+var_dump($array);
+
+echo "\n-- Pass sub-array as \$stack argument --\n";
+var_dump(array_push($array[3], 'a'));
+var_dump($array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_push() : usage variations ***
+
+-- Pass array as $var argument --
+int(4)
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  array(2) {
+    [0]=>
+    string(3) "one"
+    [1]=>
+    string(3) "two"
+  }
+}
+
+-- Pass sub-array as $stack argument --
+int(3)
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  array(3) {
+    [0]=>
+    string(3) "one"
+    [1]=>
+    string(3) "two"
+    [2]=>
+    string(1) "a"
+  }
+}
+Done
diff --git a/tests/std/array/array_push_variation5.phpt b/tests/std/array/array_push_variation5.phpt
new file mode 100644
index 00000000..32e541ef
--- /dev/null
+++ b/tests/std/array/array_push_variation5.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Test array_push() function : usage variations - position of internal array pointer
+--FILE--
+<?php
+/*
+ * Check the position of the internal array pointer after calling array_push()
+ */
+
+echo "*** Testing array_push() : usage variations ***\n";
+
+$stack = array ('one' => 'un', 'two' => 'deux');
+$var0 = 'zero';
+
+echo "\n-- Call array_push() --\n";
+var_dump($result = array_push($stack, $var0));
+
+echo "\n-- Position of Internal Pointer in Original Array: --\n";
+echo key($stack) . " => " . current ($stack) . "\n";
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_push() : usage variations ***
+
+-- Call array_push() --
+int(3)
+
+-- Position of Internal Pointer in Original Array: --
+one => un
+Done
diff --git a/tests/std/array/array_push_variation6.phpt b/tests/std/array/array_push_variation6.phpt
new file mode 100644
index 00000000..b5ebbb3c
--- /dev/null
+++ b/tests/std/array/array_push_variation6.phpt
@@ -0,0 +1,138 @@
+--TEST--
+Test array_push() function : usage variations - array keys are different data types
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Pass array_push arrays where the keys are different data types.
+ */
+
+echo "*** Testing array_push() : usage variations ***\n";
+
+// Initialise function arguments not being substituted
+$var = 'value';
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// heredoc string
+$heredoc = <<<EOT
+hello world
+EOT;
+
+// arrays of different data types as keys to be passed to $stack 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_push()
+$iterator = 1;
+foreach($inputs as $key => $input) {
+  echo "\n-- Iteration $iterator : $key data --\n";
+  echo "Before : ";
+  var_dump(count($input));
+  echo "After  : ";
+  var_dump( array_push($input, $var) );
+  $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_push() : usage variations ***
+
+-- Iteration 1 : int data --
+Before : int(4)
+After  : int(5)
+
+-- Iteration 2 : null uppercase data --
+Before : int(1)
+After  : int(2)
+
+-- Iteration 3 : null lowercase data --
+Before : int(1)
+After  : int(2)
+
+-- Iteration 4 : bool lowercase data --
+Before : int(2)
+After  : int(3)
+
+-- Iteration 5 : bool uppercase data --
+Before : int(2)
+After  : int(3)
+
+-- Iteration 6 : empty double quotes data --
+Before : int(1)
+After  : int(2)
+
+-- Iteration 7 : empty single quotes data --
+Before : int(1)
+After  : int(2)
+
+-- Iteration 8 : string data --
+Before : int(3)
+After  : int(4)
+
+-- Iteration 9 : undefined data --
+Before : int(1)
+After  : int(2)
+
+-- Iteration 10 : unset data --
+Before : int(1)
+After  : int(2)
+Done
diff --git a/tests/std/array/array_rand.phpt b/tests/std/array/array_rand.phpt
new file mode 100644
index 00000000..24f6966b
--- /dev/null
+++ b/tests/std/array/array_rand.phpt
@@ -0,0 +1,59 @@
+--TEST--
+array_rand() tests
+--FILE--
+<?php
+
+try {
+    var_dump(array_rand(array()));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(array_rand(array(), 0));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(array_rand(array(1,2,3), 0));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(array_rand(array(1,2,3), -1));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(array_rand(array(1,2,3), 10));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+var_dump(array_rand(array(1,2,3), 3));
+var_dump(array_rand(array(1,2,3), 2));
+
+?>
+--EXPECTF--
+array_rand(): Argument #1 ($array) must not be empty
+array_rand(): Argument #1 ($array) must not be empty
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+array(2) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+}
diff --git a/tests/std/array/array_rand_basic1.phpt b/tests/std/array/array_rand_basic1.phpt
new file mode 100644
index 00000000..0f2d79df
--- /dev/null
+++ b/tests/std/array/array_rand_basic1.phpt
@@ -0,0 +1,47 @@
+--TEST--
+Test array_rand() function : basic functionality - array with default keys
+--FILE--
+<?php
+/*
+ * Test array_rand() when array with default keys is passed to 'input' argument
+*/
+
+echo "*** Testing array_rand() : array with default keys ***\n";
+
+
+// Initialise the 'input' and 'num_req' variables
+$input = array(10, 20, 30, 40, 50, 60, 70);
+$num_req = 6;
+
+// Calling array_rand() with optional argument
+echo"\n-- with all default and optional arguments --\n";
+var_dump( array_rand($input,$num_req) );
+
+// Calling array_rand() with default arguments
+echo"\n-- with default argument --\n";
+var_dump( array_rand($input) );
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_rand() : array with default keys ***
+
+-- with all default and optional arguments --
+array(%d) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+  [3]=>
+  int(%d)
+  [4]=>
+  int(%d)
+  [5]=>
+  int(%d)
+}
+
+-- with default argument --
+int(%d)
+Done
diff --git a/tests/std/array/array_rand_basic2.phpt b/tests/std/array/array_rand_basic2.phpt
new file mode 100644
index 00000000..747cb562
--- /dev/null
+++ b/tests/std/array/array_rand_basic2.phpt
@@ -0,0 +1,52 @@
+--TEST--
+Test array_rand() function : basic functionality - with associative array for 'input' argument
+--FILE--
+<?php
+/*
+ * Test array_rand() when associative array is passed to 'input' argument
+*/
+
+echo "*** Testing array_rand() : with associative array ***\n";
+
+
+// Initialise the 'input' and 'num_req' variables
+$input = array(
+  'one' => 1, 'two' => 2, 'three' => 3,
+  'FoUr' => 'four', '#5' => 5, 'SIX' => 'six',
+  "seven" => 7, "#8" => "eight", "nine" => "NINE"
+);
+
+$num_req = 6;
+
+// Calling array_rand() with optional argument
+echo"\n-- with all default and optional arguments --\n";
+var_dump( array_rand($input,$num_req) );
+
+// Calling array_rand() with default arguments
+echo"\n-- with default argument --\n";
+var_dump( array_rand($input) );
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_rand() : with associative array ***
+
+-- with all default and optional arguments --
+array(6) {
+  [0]=>
+  string(%d) "%s"
+  [1]=>
+  string(%d) "%s"
+  [2]=>
+  string(%d) "%s"
+  [3]=>
+  string(%d) "%s"
+  [4]=>
+  string(%d) "%s"
+  [5]=>
+  string(%d) "%s"
+}
+
+-- with default argument --
+string(%d) "%s"
+Done
diff --git a/tests/std/array/array_rand_variation3.phpt b/tests/std/array/array_rand_variation3.phpt
new file mode 100644
index 00000000..34f2db6e
--- /dev/null
+++ b/tests/std/array/array_rand_variation3.phpt
@@ -0,0 +1,144 @@
+--TEST--
+Test array_rand() function : usage variation - with MultiDimensional array
+--FILE--
+<?php
+/*
+* Test behaviour of array_rand() function when multi-dimensional array
+* is passed to 'input' argument
+*/
+
+echo "*** Testing array_rand() : with multi-dimensional array ***\n";
+
+// initialise the multi-dimensional array
+$input = array(
+       // array with int values
+/*1*/  array(1, 2, 0, -0, -1, -2),
+
+       // array with float values
+       array(1.23, -1.23, 0.34, -0.34, 0e2, 2e-3, -2e2, -40e-2),
+
+       // array with single quoted strings
+/*3*/  array('one', '123numbers', 'hello\tworld', 'hello world\0', '12.34floatnum'),
+
+       // array with double quoted strings
+       array("one","123numbers", "hello\tworld", "hello world\0", "12.34floatnum"),
+
+       // array with bool values
+/*5*/  array(true, TRUE, FALSE, false, TrUe, FaLsE),
+
+       // array with hexa values
+       array(0x123, -0x123, 0xabc, 0xABC, 0xab),
+
+       // array with null values
+/*7*/  array(null, NULL, "\0", Null, NuLl)
+
+);
+
+// initialise 'num_req' variable
+$num_req = 3;
+
+// calling array_rand() function with multi-dimensional array
+var_dump( array_rand($input, $num_req) );
+
+// looping to test array_rand() with each sub-array in the multi-dimensional array
+echo "\n*** Testing array_rand() with arrays having different types of values ***\n";
+$counter = 1;
+foreach($input as $arr) {
+  echo "\n-- Iteration $counter --\n";
+  var_dump( array_rand($arr) );  // with default arguments
+  var_dump( array_rand($arr, 3) );  // with default as well as optional arguments
+  $counter++;
+}
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_rand() : with multi-dimensional array ***
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+*** Testing array_rand() with arrays having different types of values ***
+
+-- Iteration 1 --
+int(%d)
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 2 --
+int(%d)
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 3 --
+int(%d)
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 4 --
+int(%d)
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 5 --
+int(%d)
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 6 --
+int(%d)
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 7 --
+int(%d)
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+Done
diff --git a/tests/std/array/array_rand_variation4.phpt b/tests/std/array/array_rand_variation4.phpt
new file mode 100644
index 00000000..c7d90783
--- /dev/null
+++ b/tests/std/array/array_rand_variation4.phpt
@@ -0,0 +1,163 @@
+--TEST--
+Test array_rand() function : usage variation - with associative arrays for 'input' parameter
+--SKIPIF--
+<?php die("skip AOT array_rand differs from PHP (random order)"); ?>
+--FILE--
+<?php
+/*
+* Test behaviour of array_rand() function when associative array is passed to
+* the 'input' parameter in the function call
+*/
+
+echo "*** Testing array_rand() : with associative arrays ***\n";
+
+// initialise associative arrays
+$asso_arrays = array(
+
+       // array with numeric keys
+/*1*/  array(1 => 'one', 2 => 2, 1234567890 => 'big', -1 => 'negative key',
+             0 => "zero key"),
+
+       // array with string keys
+       array('one' => 1, "two" => 2.0, "three" => 'three',
+             '12twelve' => 12.00, "" => 'empty string', " " => "space key"),
+
+       // array with hexa values as keys
+/*3*/  array(0xabc => 2748, 0x12f => '303', 0xff => "255", -0xff => "-255"),
+
+       // array with octal values as keys
+       array(0123 => 83, 012 => 10, 010 => "8", -034 => "-28", 0012 => '10'),
+
+       // array with bool values as keys
+       array(TRUE => '1', true => true, TrUe => "TRUE",
+             FALSE => '0', false => false, FaLsE => "FALSE"),
+
+       // array with special chars as keys
+/*6*/  array('##' => "key1", '&$r' => 'key2', '!' => "key3", '<>' =>'key4',
+             "NULL" => 'key5', "\n" => 'newline as key',
+             "\t" => "tab as key", "'" => 'single quote as key',
+             '"' => 'double quote as key', "\0" => "null char as key")
+);
+
+/* looping to test array_rand() function with different arrays having
+ * different types of keys
+*/
+$counter = 1;
+foreach($asso_arrays as $input) {
+  echo "\n-- Iteration $counter --\n";
+
+  // with default argument
+  echo"\nWith default argument\n";
+  var_dump( array_rand($input) );
+
+  // with default and optional arguments
+  echo"\nWith num_req = 1\n";
+  var_dump( array_rand($input, 1) );  // with $num_req=1
+  echo"\nWith num_req = 2\n";
+  var_dump( array_rand($input, 2) );  // with $num_req=2
+
+  $counter++;
+}  // end of for loop
+
+
+echo "Done";
+?>
+--EXPECTREGEX--
+\*\*\* Testing array_rand\(\) : with associative arrays \*\*\*
+
+-- Iteration 1 --
+
+With default argument
+int\([012-][12.e]*[23e]*[34]*[5]*[6]*[7]*[8]*[9]*[0]*\)
+
+With num_req = 1
+int\([012-][12.e]*[23e]*[34]*[5]*[6]*[7]*[8]*[9]*[0]*\)
+
+With num_req = 2
+array\(2\) {
+  \[0\]=>
+  int\([012-][12.e]*[23e]*[34]*[5]*[6]*[7]*[8]*[9]*[0]*\)
+  \[1\]=>
+  int\([012-][12.e]*[23e]*[34]*[5]*[6]*[7]*[8]*[9]*[0]*\)
+}
+
+-- Iteration 2 --
+
+With default argument
+string\([0-9]*\) "[ot1 ]*[hnw2]*[eort]*[ew]*[e]*[l]*[v]*[e]*"
+
+With num_req = 1
+string\([0-9]*\) "[ot1 ]*[hnw2]*[eort]*[ew]*[e]*[l]*[v]*[e]*"
+
+With num_req = 2
+array\(2\) {
+  \[0\]=>
+  string\([0-9]*\) "[ot1 ]*[hnw2]*[eort]*[ew]*[e]*[l]*[v]*[e]*"
+  \[1\]=>
+  string\([0-9]*\) "[ot1 ]*[hnw2]*[eort]*[ew]*[e]*[l]*[v]*[e]*"
+}
+
+-- Iteration 3 --
+
+With default argument
+int\([23-]*[2570]*[345]*[58]*\)
+
+With num_req = 1
+int\([23-]*[2570]*[345]*[58]*\)
+
+With num_req = 2
+array\(2\) {
+  \[0\]=>
+  int\([23-]*[2570]*[345]*[58]*\)
+  \[1\]=>
+  int\([23-]*[2570]*[345]*[58]*\)
+}
+
+-- Iteration 4 --
+
+With default argument
+int\([18-]*[023]*[8]*\)
+
+With num_req = 1
+int\([18-]*[023]*[8]*\)
+
+With num_req = 2
+array\(2\) {
+  \[0\]=>
+  int\([18-]*[023]*[8]*\)
+  \[1\]=>
+  int\([18-]*[023]*[8]*\)
+}
+
+-- Iteration 5 --
+
+With default argument
+int\([01]\)
+
+With num_req = 1
+int\([01]\)
+
+With num_req = 2
+array\(2\) {
+  \[0\]=>
+  int\([01]\)
+  \[1\]=>
+  int\([01]\)
+}
+
+-- Iteration 6 --
+
+With default argument
+string\([0-9]*\) "[#&!N  <\n\t'"\0]*[U#$>]*[rL]*[L]*"
+
+With num_req = 1
+string\([0-9]*\) "[#&!N  <\n\t'"\0]*[U#$>]*[rL]*[L]*"
+
+With num_req = 2
+array\(2\) {
+  \[0\]=>
+  string\([0-9]*\) "[#&!N  <\n\t'"\0]*[U#$>]*[rL]*[L]*"
+  \[1\]=>
+  string\([0-9]*\) "[#&!N  <\n\t'"\0]*[U#$>]*[rL]*[L]*"
+}
+Done
diff --git a/tests/std/array/array_rand_variation5.phpt b/tests/std/array/array_rand_variation5.phpt
new file mode 100644
index 00000000..57f5ee03
--- /dev/null
+++ b/tests/std/array/array_rand_variation5.phpt
@@ -0,0 +1,76 @@
+--TEST--
+Test array_rand() function : usage variation - invalid values for 'req_num' parameter
+--FILE--
+<?php
+/*
+* Test behaviour of array_rand() function when associative array and
+* various invalid values are passed to the 'input' and 'req_num'
+* parameters respectively
+*/
+
+echo "*** Testing array_rand() : with invalid values for 'req_num' ***\n";
+
+// initialise associative arrays
+$input = array(
+  1 => 'one',
+  0xabc => 2748, 0x12f => '303', 0xff => "255",
+  0123 => 83, 012 => 10, 010 => "8"
+);
+
+// Testing array_rand() function with various invalid 'req_num' values
+// with valid num_req values
+echo"\n-- With default num_req value --\n";
+var_dump( array_rand($input) );  // with default $num_req value
+echo"\n-- With num_req = 1 --\n";
+var_dump( array_rand($input, 1) );  // with valid $num_req value
+
+// with invalid num_req value
+echo"\n-- With num_req = 0 --\n";
+try {
+    var_dump( array_rand($input, 0) );  // with $num_req=0
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo"\n-- With num_req = -1 --\n";
+try {
+    var_dump( array_rand($input, -1) );  // with $num_req=-1
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo"\n-- With num_req = -2 --\n";
+try {
+    var_dump( array_rand($input, -2) );  // with $num_req=-2
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo"\n-- With num_req more than number of members in 'input' array --\n";
+try {
+    var_dump( array_rand($input, 13) );  // with $num_req=13
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+?>
+--EXPECTF--
+*** Testing array_rand() : with invalid values for 'req_num' ***
+
+-- With default num_req value --
+int(%d)
+
+-- With num_req = 1 --
+int(%d)
+
+-- With num_req = 0 --
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
+
+-- With num_req = -1 --
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
+
+-- With num_req = -2 --
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
+
+-- With num_req more than number of members in 'input' array --
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
diff --git a/tests/std/array/array_rand_variation6.phpt b/tests/std/array/array_rand_variation6.phpt
new file mode 100644
index 00000000..e8113fc1
--- /dev/null
+++ b/tests/std/array/array_rand_variation6.phpt
@@ -0,0 +1,98 @@
+--TEST--
+Test array_rand() function : usage variation - with heredoc string as key in the 'input' array
+--FILE--
+<?php
+/*
+* Test behaviour of array_rand() when keys of the 'input' array is heredoc string
+*/
+
+echo "*** Testing array_rand() : with keys of input array as heredoc strings ***\n";
+
+// defining different heredoc strings
+$empty_heredoc = <<<EOT
+EOT;
+
+$heredoc_with_newline = <<<EOT
+\n
+EOT;
+
+$heredoc_with_characters = <<<EOT
+first line of heredoc string
+second line of heredoc string
+third line of heredocstring
+EOT;
+
+$heredoc_with_newline_and_tabs = <<<EOT
+hello\tworld\nhello\nworld\n
+EOT;
+
+$heredoc_with_alphanumerics = <<<EOT
+hello123world456
+1234hello\t1234
+EOT;
+
+$heredoc_with_embedded_nulls = <<<EOT
+hello\0world\0hello
+\0hello\0
+EOT;
+
+$input = array(
+  $empty_heredoc => "heredoc1",
+  $heredoc_with_newline => "heredoc2",
+  $heredoc_with_characters => "heredoc3",
+  $heredoc_with_newline_and_tabs => "heredoc3",
+  $heredoc_with_alphanumerics => "heredoc4",
+  $heredoc_with_embedded_nulls => "heredoc5"
+);
+
+// Test array_rand() function with different valid 'req_num' values
+echo "\n-- with default parameters --\n";
+var_dump( array_rand($input) );
+
+echo "\n-- with num_req = 1 --\n";
+var_dump( array_rand($input, 1) );
+
+echo "\n-- with num_req = 3 --\n";
+var_dump( array_rand($input, 3) );
+
+echo "\n-- with num_req = 6 --\n";
+var_dump( array_rand($input, 6) );
+
+
+echo "Done";
+?>
+--EXPECTREGEX--
+\*\*\* Testing array_rand\(\) : with keys of input array as heredoc strings \*\*\*
+
+-- with default parameters --
+string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+
+-- with num_req = 1 --
+string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+
+-- with num_req = 3 --
+array\(3\) {
+  \[0\]=>
+  string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+  \[1\]=>
+  string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+  \[2\]=>
+  string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+}
+
+-- with num_req = 6 --
+array\(6\) {
+  \[0\]=>
+  string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+  \[1\]=>
+  string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+  \[2\]=>
+  string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+  \[3\]=>
+  string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+  \[4\]=>
+  string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+  \[5\]=>
+  string\([0-9]*\) "[a-z \n \t \0 0-9  ]*"
+}
+Done
diff --git a/tests/std/array/array_reduce.phpt b/tests/std/array/array_reduce.phpt
new file mode 100644
index 00000000..f3e9c021
--- /dev/null
+++ b/tests/std/array/array_reduce.phpt
@@ -0,0 +1,90 @@
+--TEST--
+Test array_reduce() function
+--INI--
+precision=14
+--SKIPIF--
+<?php die("skip AOT array_reduce type handling differs from PHP"); ?>
+--FILE--
+<?php
+function reduce_int($w, $v)
+{
+    return $w + strlen($v);
+}
+function reduce_float($w, $v)
+{
+    return $w + strlen($v) / 10;
+}
+function reduce_string($w, $v)
+{
+    return $w . $v;
+}
+function reduce_array($w, $v)
+{
+    $w[$v]++;
+    return $w;
+}
+function reduce_null($w, $v)
+{
+    return $w . $v;
+}
+function main()
+{
+    $array = array('foo', 'foo', 'bar', 'qux', 'qux', 'quux');
+    echo "\n*** Testing array_reduce() to integer ***\n";
+    $initial = 42;
+    var_dump(array_reduce($array, 'reduce_int', $initial), $initial);
+    echo "\n*** Testing array_reduce() to float ***\n";
+    $initial = 4.2;
+    var_dump(array_reduce($array, 'reduce_float', $initial), $initial);
+    echo "\n*** Testing array_reduce() to string ***\n";
+    $initial = 'quux';
+    var_dump(array_reduce($array, 'reduce_string', $initial), $initial);
+    echo "\n*** Testing array_reduce() to array ***\n";
+    $initial = array('foo' => 42, 'bar' => 17, 'qux' => -2, 'quux' => 0);
+    var_dump(array_reduce($array, 'reduce_array', $initial), $initial);
+    echo "\n*** Testing array_reduce() to null ***\n";
+    $initial = null;
+    var_dump(array_reduce($array, 'reduce_null', $initial), $initial);
+    echo "\nDone";
+}
+?>
+--EXPECT--
+*** Testing array_reduce() to integer ***
+int(61)
+int(42)
+
+*** Testing array_reduce() to float ***
+float(6.1)
+float(4.2)
+
+*** Testing array_reduce() to string ***
+string(23) "quuxfoofoobarquxquxquux"
+string(4) "quux"
+
+*** Testing array_reduce() to array ***
+array(4) {
+  ["foo"]=>
+  int(44)
+  ["bar"]=>
+  int(18)
+  ["qux"]=>
+  int(0)
+  ["quux"]=>
+  int(1)
+}
+array(4) {
+  ["foo"]=>
+  int(42)
+  ["bar"]=>
+  int(17)
+  ["qux"]=>
+  int(-2)
+  ["quux"]=>
+  int(0)
+}
+
+*** Testing array_reduce() to null ***
+string(19) "foofoobarquxquxquux"
+NULL
+
+Done
diff --git a/tests/std/array/array_reduce_return_by_ref.phpt b/tests/std/array/array_reduce_return_by_ref.phpt
new file mode 100644
index 00000000..8da7018c
--- /dev/null
+++ b/tests/std/array/array_reduce_return_by_ref.phpt
@@ -0,0 +1,11 @@
+--TEST--
+Return by reference from array_reduce() callback
+--FILE--
+<?php
+$array = [1, 2];
+var_dump(array_reduce($array, function &($a, $b) {
+    return $b;
+}, 0));
+?>
+--EXPECT--
+int(2)
diff --git a/tests/std/array/array_reduce_variation1.phpt b/tests/std/array/array_reduce_variation1.phpt
new file mode 100644
index 00000000..97ed759e
--- /dev/null
+++ b/tests/std/array/array_reduce_variation1.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Test array_reduce() function : variation
+--SKIPIF--
+<?php die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function oneArg($v)
+{
+    return $v;
+}
+function threeArgs($v, $w, $x)
+{
+    return $v + $w + $x;
+}
+function main()
+{
+    echo "*** Testing array_reduce() : variation ***\n";
+    $array = array(1);
+    echo "\n--- Testing with a callback with too few parameters ---\n";
+    var_dump(array_reduce($array, "oneArg", 2));
+    echo "\n--- Testing with a callback with too many parameters ---\n";
+    try {
+        var_dump(array_reduce($array, "threeArgs", 2));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+}
+?>
+--EXPECT--
+*** Testing array_reduce() : variation ***
+
+--- Testing with a callback with too few parameters ---
+int(2)
+
+--- Testing with a callback with too many parameters ---
+Exception: Too few arguments to function threeArgs(), 2 passed and exactly 3 expected
diff --git a/tests/std/array/array_reduce_variation3.phpt b/tests/std/array/array_reduce_variation3.phpt
new file mode 100644
index 00000000..4cc6d011
--- /dev/null
+++ b/tests/std/array/array_reduce_variation3.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Test array_reduce() function : variation - object callbacks
+--FILE--
+<?php
+class A
+{
+    static function adder($a, $b)
+    {
+        return $a + $b;
+    }
+    public function adder2($a, $b)
+    {
+        return $a + $b;
+    }
+}
+function main()
+{
+    echo "*** Testing array_reduce() : variation - object callbacks ***\n";
+    $array = array(1);
+    echo "\n--- Static method callback ---\n";
+    var_dump(array_reduce($array, array("A", "adder")));
+    echo "\n--- Instance method callback ---\n";
+    var_dump(array_reduce($array, array(new A(), "adder2")));
+}
+?>
+--EXPECT--
+*** Testing array_reduce() : variation - object callbacks ***
+
+--- Static method callback ---
+int(1)
+
+--- Instance method callback ---
+int(1)
diff --git a/tests/std/array/array_replace.phpt b/tests/std/array/array_replace.phpt
new file mode 100644
index 00000000..c3edba00
--- /dev/null
+++ b/tests/std/array/array_replace.phpt
@@ -0,0 +1,114 @@
+--TEST--
+Test array_replace and array_replace_recursive
+--FILE--
+<?php
+
+$array1 = array(
+    0 => 'dontclobber',
+    '1' => 'unclobbered',
+    'test2' => 0.0,
+    'test3' => array(
+        'testarray2' => true,
+        1 => array(
+            'testsubarray1' => 'dontclobber2',
+            'testsubarray2' => 'dontclobber3',
+    ),
+    ),
+);
+
+$array2 = array(
+    1 => 'clobbered',
+    'test3' => array(
+        'testarray2' => false,
+    ),
+    'test4' => array(
+        'clobbered3' => array(0, 1, 2),
+    ),
+);
+
+$array3 = array(array(array(array())));
+
+$array4 = array();
+$array4[] = &$array4;
+
+echo " -- Testing array_replace() --\n";
+$data = array_replace($array1, $array2);
+
+var_dump($data);
+
+echo " -- Testing array_replace_recursive() --\n";
+$data = array_replace_recursive($array1, $array2);
+
+var_dump($data);
+
+echo " -- Testing array_replace_recursive() w/ endless recusrsion --\n";
+try {
+    $data = array_replace_recursive($array3, $array4);
+    var_dump($data);
+} catch (\Error $e) {
+    echo $e->getMessage() . "\n";
+}
+
+?>
+--EXPECT--
+ -- Testing array_replace() --
+array(5) {
+  [0]=>
+  string(11) "dontclobber"
+  [1]=>
+  string(9) "clobbered"
+  ["test2"]=>
+  float(0)
+  ["test3"]=>
+  array(1) {
+    ["testarray2"]=>
+    bool(false)
+  }
+  ["test4"]=>
+  array(1) {
+    ["clobbered3"]=>
+    array(3) {
+      [0]=>
+      int(0)
+      [1]=>
+      int(1)
+      [2]=>
+      int(2)
+    }
+  }
+}
+ -- Testing array_replace_recursive() --
+array(5) {
+  [0]=>
+  string(11) "dontclobber"
+  [1]=>
+  string(9) "clobbered"
+  ["test2"]=>
+  float(0)
+  ["test3"]=>
+  array(2) {
+    ["testarray2"]=>
+    bool(false)
+    [1]=>
+    array(2) {
+      ["testsubarray1"]=>
+      string(12) "dontclobber2"
+      ["testsubarray2"]=>
+      string(12) "dontclobber3"
+    }
+  }
+  ["test4"]=>
+  array(1) {
+    ["clobbered3"]=>
+    array(3) {
+      [0]=>
+      int(0)
+      [1]=>
+      int(1)
+      [2]=>
+      int(2)
+    }
+  }
+}
+ -- Testing array_replace_recursive() w/ endless recusrsion --
+Recursion detected
diff --git a/tests/std/array/array_replace_merge_recursive_ref.phpt b/tests/std/array/array_replace_merge_recursive_ref.phpt
new file mode 100644
index 00000000..e8d4f8e0
--- /dev/null
+++ b/tests/std/array/array_replace_merge_recursive_ref.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Test array_(replace|merge)_recursive with references
+--FILE--
+<?php
+
+$one = [1];
+$two = [42];
+$arr1 = ['k' => &$one];
+$arr2 = ['k' => &$two];
+var_dump(current($one), current($two));
+array_replace_recursive($arr1, $arr2);
+var_dump(current($one), current($two));
+
+$one = [1];
+$two = [42];
+$arr1 = ['k' => &$one];
+$arr2 = ['k' => &$two];
+var_dump(current($one), current($two));
+array_merge_recursive($arr1, $arr2);
+var_dump(current($one), current($two));
+
+?>
+--EXPECT--
+int(1)
+int(42)
+int(1)
+int(42)
+int(1)
+int(42)
+int(1)
+int(42)
diff --git a/tests/std/array/array_reverse_basic1.phpt b/tests/std/array/array_reverse_basic1.phpt
new file mode 100644
index 00000000..6f7197d8
--- /dev/null
+++ b/tests/std/array/array_reverse_basic1.phpt
@@ -0,0 +1,67 @@
+--TEST--
+Test array_reverse() function : basic functionality - simple array for 'array' argument
+--FILE--
+<?php
+/*
+ * Testing array_reverse() by giving a simple array for $array argument
+*/
+
+echo "*** Testing array_reverse() : basic functionality ***\n";
+
+// Initialise the array
+$array = array("a", "green", "red", 'blue', 10, 13.33);
+
+// Calling array_reverse() with default arguments
+var_dump( array_reverse($array) );
+
+// Calling array_reverse() with all possible arguments
+var_dump( array_reverse($array, true) );  // expects the keys to be preserved
+var_dump( array_reverse($array, false) );  // expects the keys not to be preserved
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_reverse() : basic functionality ***
+array(6) {
+  [0]=>
+  float(13.33)
+  [1]=>
+  int(10)
+  [2]=>
+  string(4) "blue"
+  [3]=>
+  string(3) "red"
+  [4]=>
+  string(5) "green"
+  [5]=>
+  string(1) "a"
+}
+array(6) {
+  [5]=>
+  float(13.33)
+  [4]=>
+  int(10)
+  [3]=>
+  string(4) "blue"
+  [2]=>
+  string(3) "red"
+  [1]=>
+  string(5) "green"
+  [0]=>
+  string(1) "a"
+}
+array(6) {
+  [0]=>
+  float(13.33)
+  [1]=>
+  int(10)
+  [2]=>
+  string(4) "blue"
+  [3]=>
+  string(3) "red"
+  [4]=>
+  string(5) "green"
+  [5]=>
+  string(1) "a"
+}
+Done
diff --git a/tests/std/array/array_reverse_basic2.phpt b/tests/std/array/array_reverse_basic2.phpt
new file mode 100644
index 00000000..c10c12b0
--- /dev/null
+++ b/tests/std/array/array_reverse_basic2.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_reverse() function : basic functionality - associative array for 'array' argument
+--FILE--
+<?php
+/*
+ * Testing array_reverse() with associative array for $array argument
+*/
+
+echo "*** Testing array_reverse() : basic functionality ***\n";
+
+// Initialise the array
+$array = array("a" => "hello", 123 => "number", 'string' => 'blue', "10" => 13.33);
+
+// Calling array_reverse() with default arguments
+var_dump( array_reverse($array) );
+
+// Calling array_reverse() with all possible arguments
+var_dump( array_reverse($array, true) );  // expects the keys to be preserved
+var_dump( array_reverse($array, false) );  // expects the keys not to be preserved
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_reverse() : basic functionality ***
+array(4) {
+  [0]=>
+  float(13.33)
+  ["string"]=>
+  string(4) "blue"
+  [1]=>
+  string(6) "number"
+  ["a"]=>
+  string(5) "hello"
+}
+array(4) {
+  [10]=>
+  float(13.33)
+  ["string"]=>
+  string(4) "blue"
+  [123]=>
+  string(6) "number"
+  ["a"]=>
+  string(5) "hello"
+}
+array(4) {
+  [0]=>
+  float(13.33)
+  ["string"]=>
+  string(4) "blue"
+  [1]=>
+  string(6) "number"
+  ["a"]=>
+  string(5) "hello"
+}
+Done
diff --git a/tests/std/array/array_reverse_variation3.phpt b/tests/std/array/array_reverse_variation3.phpt
new file mode 100644
index 00000000..78299e68
--- /dev/null
+++ b/tests/std/array/array_reverse_variation3.phpt
@@ -0,0 +1,605 @@
+--TEST--
+Test array_reverse() function : usage variations - different array values for 'array' argument
+--SKIPIF--
+<?php die("skip AOT empty string key handling differs from PHP"); ?>
+--FILE--
+<?php
+//get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Testing the functionality of array_reverse() by giving
+     * different array values for $array argument
+    */
+    echo "*** Testing array_reverse() : usage variations ***\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;
+    $arrays = array(
+        /*1*/
+        array(1, 2),
+        // array with default keys and numeric values
+        array(1.1, 2.2),
+        // array with default keys & float values
+        array(array(2), array(1)),
+        // sub arrays
+        array(false, true),
+        // array with default keys and boolean values
+        array(),
+        // empty array
+        array(NULL),
+        // array with NULL
+        array("a", "aaaa", "b", "bbbb", "c", "ccccc"),
+        // associative arrays
+        /*8*/
+        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
+        /*13*/
+        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
+        /*18*/
+        array("One" => 1, "two" => 2, "One" => 10, "two" => 20, "three" => 3),
+    );
+    // loop through the various elements of $arrays to test array_reverse()
+    $iterator = 1;
+    foreach ($arrays as $array) {
+        echo "-- Iteration {$iterator} --\n";
+        // with default argument
+        echo "- with default argument -\n";
+        var_dump(array_reverse($array));
+        // with all possible arguments
+        echo "- with \$preserve keys = true -\n";
+        var_dump(array_reverse($array, true));
+        echo "- with \$preserve_keys = false -\n";
+        var_dump(array_reverse($array, false));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_reverse() : usage variations ***
+-- Iteration 1 --
+- with default argument -
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(1)
+}
+- with $preserve keys = true -
+array(2) {
+  [1]=>
+  int(2)
+  [0]=>
+  int(1)
+}
+- with $preserve_keys = false -
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(1)
+}
+-- Iteration 2 --
+- with default argument -
+array(2) {
+  [0]=>
+  float(2.2)
+  [1]=>
+  float(1.1)
+}
+- with $preserve keys = true -
+array(2) {
+  [1]=>
+  float(2.2)
+  [0]=>
+  float(1.1)
+}
+- with $preserve_keys = false -
+array(2) {
+  [0]=>
+  float(2.2)
+  [1]=>
+  float(1.1)
+}
+-- Iteration 3 --
+- with default argument -
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+- with $preserve keys = true -
+array(2) {
+  [1]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [0]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+- with $preserve_keys = false -
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+}
+-- Iteration 4 --
+- with default argument -
+array(2) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(false)
+}
+- with $preserve keys = true -
+array(2) {
+  [1]=>
+  bool(true)
+  [0]=>
+  bool(false)
+}
+- with $preserve_keys = false -
+array(2) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(false)
+}
+-- Iteration 5 --
+- with default argument -
+array(0) {
+}
+- with $preserve keys = true -
+array(0) {
+}
+- with $preserve_keys = false -
+array(0) {
+}
+-- Iteration 6 --
+- with default argument -
+array(1) {
+  [0]=>
+  NULL
+}
+- with $preserve keys = true -
+array(1) {
+  [0]=>
+  NULL
+}
+- with $preserve_keys = false -
+array(1) {
+  [0]=>
+  NULL
+}
+-- Iteration 7 --
+- with default argument -
+array(6) {
+  [0]=>
+  string(5) "ccccc"
+  [1]=>
+  string(1) "c"
+  [2]=>
+  string(4) "bbbb"
+  [3]=>
+  string(1) "b"
+  [4]=>
+  string(4) "aaaa"
+  [5]=>
+  string(1) "a"
+}
+- with $preserve keys = true -
+array(6) {
+  [5]=>
+  string(5) "ccccc"
+  [4]=>
+  string(1) "c"
+  [3]=>
+  string(4) "bbbb"
+  [2]=>
+  string(1) "b"
+  [1]=>
+  string(4) "aaaa"
+  [0]=>
+  string(1) "a"
+}
+- with $preserve_keys = false -
+array(6) {
+  [0]=>
+  string(5) "ccccc"
+  [1]=>
+  string(1) "c"
+  [2]=>
+  string(4) "bbbb"
+  [3]=>
+  string(1) "b"
+  [4]=>
+  string(4) "aaaa"
+  [5]=>
+  string(1) "a"
+}
+-- Iteration 8 --
+- with default argument -
+array(3) {
+  [0]=>
+  string(5) "three"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  string(3) "one"
+}
+- with $preserve keys = true -
+array(3) {
+  [3]=>
+  string(5) "three"
+  [2]=>
+  string(3) "two"
+  [1]=>
+  string(3) "one"
+}
+- with $preserve_keys = false -
+array(3) {
+  [0]=>
+  string(5) "three"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  string(3) "one"
+}
+-- Iteration 9 --
+- with default argument -
+array(3) {
+  ["three"]=>
+  int(3)
+  ["two"]=>
+  int(2)
+  ["one"]=>
+  int(1)
+}
+- with $preserve keys = true -
+array(3) {
+  ["three"]=>
+  int(3)
+  ["two"]=>
+  int(2)
+  ["one"]=>
+  int(1)
+}
+- with $preserve_keys = false -
+array(3) {
+  ["three"]=>
+  int(3)
+  ["two"]=>
+  int(2)
+  ["one"]=>
+  int(1)
+}
+-- Iteration 10 --
+- with default argument -
+array(4) {
+  [0]=>
+  int(30)
+  [1]=>
+  int(40)
+  [2]=>
+  int(20)
+  [3]=>
+  int(10)
+}
+- with $preserve keys = true -
+array(4) {
+  [3]=>
+  int(30)
+  [4]=>
+  int(40)
+  [2]=>
+  int(20)
+  [1]=>
+  int(10)
+}
+- with $preserve_keys = false -
+array(4) {
+  [0]=>
+  int(30)
+  [1]=>
+  int(40)
+  [2]=>
+  int(20)
+  [3]=>
+  int(10)
+}
+-- Iteration 11 --
+- with default argument -
+array(3) {
+  ["three"]=>
+  string(6) "thirty"
+  ["two"]=>
+  string(6) "twenty"
+  ["one"]=>
+  string(3) "ten"
+}
+- with $preserve keys = true -
+array(3) {
+  ["three"]=>
+  string(6) "thirty"
+  ["two"]=>
+  string(6) "twenty"
+  ["one"]=>
+  string(3) "ten"
+}
+- with $preserve_keys = false -
+array(3) {
+  ["three"]=>
+  string(6) "thirty"
+  ["two"]=>
+  string(6) "twenty"
+  ["one"]=>
+  string(3) "ten"
+}
+-- Iteration 12 --
+- with default argument -
+array(3) {
+  [0]=>
+  string(4) "four"
+  [1]=>
+  string(3) "two"
+  ["one"]=>
+  int(1)
+}
+- with $preserve keys = true -
+array(3) {
+  [4]=>
+  string(4) "four"
+  [2]=>
+  string(3) "two"
+  ["one"]=>
+  int(1)
+}
+- with $preserve_keys = false -
+array(3) {
+  [0]=>
+  string(4) "four"
+  [1]=>
+  string(3) "two"
+  ["one"]=>
+  int(1)
+}
+-- Iteration 13 --
+- with default argument -
+array(3) {
+  ["null"]=>
+  NULL
+  ["NULL"]=>
+  NULL
+  [""]=>
+  string(4) "null"
+}
+- with $preserve keys = true -
+array(3) {
+  ["null"]=>
+  NULL
+  ["NULL"]=>
+  NULL
+  [""]=>
+  string(4) "null"
+}
+- with $preserve_keys = false -
+array(3) {
+  ["null"]=>
+  NULL
+  ["NULL"]=>
+  NULL
+  [""]=>
+  string(4) "null"
+}
+-- Iteration 14 --
+- with default argument -
+array(4) {
+  ["true"]=>
+  bool(true)
+  ["false"]=>
+  bool(false)
+  [0]=>
+  string(5) "false"
+  [1]=>
+  string(4) "true"
+}
+- with $preserve keys = true -
+array(4) {
+  ["true"]=>
+  bool(true)
+  ["false"]=>
+  bool(false)
+  [0]=>
+  string(5) "false"
+  [1]=>
+  string(4) "true"
+}
+- with $preserve_keys = false -
+array(4) {
+  ["true"]=>
+  bool(true)
+  ["false"]=>
+  bool(false)
+  [0]=>
+  string(5) "false"
+  [1]=>
+  string(4) "true"
+}
+-- Iteration 15 --
+- with default argument -
+array(3) {
+  ["emptys"]=>
+  string(0) ""
+  ["emptyd"]=>
+  string(0) ""
+  [""]=>
+  string(6) "emptys"
+}
+- with $preserve keys = true -
+array(3) {
+  ["emptys"]=>
+  string(0) ""
+  ["emptyd"]=>
+  string(0) ""
+  [""]=>
+  string(6) "emptys"
+}
+- with $preserve_keys = false -
+array(3) {
+  ["emptys"]=>
+  string(0) ""
+  ["emptyd"]=>
+  string(0) ""
+  [""]=>
+  string(6) "emptys"
+}
+-- Iteration 16 --
+- with default argument -
+array(6) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(false)
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+  [4]=>
+  string(0) ""
+  [5]=>
+  string(0) ""
+}
+- with $preserve keys = true -
+array(6) {
+  [6]=>
+  bool(true)
+  [5]=>
+  bool(false)
+  [4]=>
+  NULL
+  [3]=>
+  NULL
+  [2]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+}
+- with $preserve_keys = false -
+array(6) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(false)
+  [2]=>
+  NULL
+  [3]=>
+  NULL
+  [4]=>
+  string(0) ""
+  [5]=>
+  string(0) ""
+}
+-- Iteration 17 --
+- with default argument -
+array(3) {
+  [0]=>
+  int(6)
+  [1]=>
+  int(5)
+  [""]=>
+  int(4)
+}
+- with $preserve keys = true -
+array(3) {
+  [1]=>
+  int(6)
+  [0]=>
+  int(5)
+  [""]=>
+  int(4)
+}
+- with $preserve_keys = false -
+array(3) {
+  [0]=>
+  int(6)
+  [1]=>
+  int(5)
+  [""]=>
+  int(4)
+}
+-- Iteration 18 --
+- with default argument -
+array(3) {
+  ["three"]=>
+  int(3)
+  ["two"]=>
+  int(20)
+  ["One"]=>
+  int(10)
+}
+- with $preserve keys = true -
+array(3) {
+  ["three"]=>
+  int(3)
+  ["two"]=>
+  int(20)
+  ["One"]=>
+  int(10)
+}
+- with $preserve_keys = false -
+array(3) {
+  ["three"]=>
+  int(3)
+  ["two"]=>
+  int(20)
+  ["One"]=>
+  int(10)
+}
+Done
diff --git a/tests/std/array/array_reverse_variation4.phpt b/tests/std/array/array_reverse_variation4.phpt
new file mode 100644
index 00000000..1e367884
--- /dev/null
+++ b/tests/std/array/array_reverse_variation4.phpt
@@ -0,0 +1,317 @@
+--TEST--
+Test array_reverse() function : usage variations - assoc. array with diff. keys for 'array' argument
+--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_reverse() by giving associative arrays with different
+     * keys for $array argument
+    */
+    echo "*** Testing array_reverse() : usage variations ***\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;
+    // initializing the array
+    $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
+        array("\tHello" => 111, "re\td" => "color", "\v\fworld" => 2.2, "pen\n" => 33),
+        /*8*/
+        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
+        array(@$unset_var => "hello", $fp => 'resource'),
+        // array with mixed values
+        /*11*/
+        array('hello' => 1, "fruit" => 2.2, $fp => 'resource', 133 => "int", @$unset_var => "unset", $heredoc => "heredoc"),
+    );
+    // loop through the various elements of $arrays to test array_reverse()
+    $iterator = 1;
+    foreach ($arrays as $array) {
+        echo "-- Iteration {$iterator} --\n";
+        // with default argument
+        echo "- default argument -\n";
+        var_dump(array_reverse($array));
+        // with $preserve_keys argument
+        echo "- \$preserve keys = true -\n";
+        var_dump(array_reverse($array, true));
+        echo "- \$preserve_keys = false -\n";
+        var_dump(array_reverse($array, false));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_reverse() : usage variations ***
+
+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 --
+- default argument -
+array(0) {
+}
+- $preserve keys = true -
+array(0) {
+}
+- $preserve_keys = false -
+array(0) {
+}
+-- Iteration 2 --
+- default argument -
+array(1) {
+  [0]=>
+  string(1) "0"
+}
+- $preserve keys = true -
+array(1) {
+  [0]=>
+  string(1) "0"
+}
+- $preserve_keys = false -
+array(1) {
+  [0]=>
+  string(1) "0"
+}
+-- Iteration 3 --
+- default argument -
+array(1) {
+  [0]=>
+  string(1) "1"
+}
+- $preserve keys = true -
+array(1) {
+  [1]=>
+  string(1) "1"
+}
+- $preserve_keys = false -
+array(1) {
+  [0]=>
+  string(1) "1"
+}
+-- Iteration 4 --
+- default argument -
+array(4) {
+  [0]=>
+  string(1) "4"
+  [1]=>
+  string(1) "3"
+  [2]=>
+  string(1) "2"
+  [3]=>
+  string(1) "1"
+}
+- $preserve keys = true -
+array(4) {
+  [4]=>
+  string(1) "4"
+  [3]=>
+  string(1) "3"
+  [2]=>
+  string(1) "2"
+  [1]=>
+  string(1) "1"
+}
+- $preserve_keys = false -
+array(4) {
+  [0]=>
+  string(1) "4"
+  [1]=>
+  string(1) "3"
+  [2]=>
+  string(1) "2"
+  [3]=>
+  string(1) "1"
+}
+-- Iteration 5 --
+- default argument -
+array(4) {
+  ["pen
+"]=>
+  int(33)
+  ["world"]=>
+  float(2.2)
+  ["re	d"]=>
+  string(5) "color"
+  ["	Hello"]=>
+  int(111)
+}
+- $preserve keys = true -
+array(4) {
+  ["pen
+"]=>
+  int(33)
+  ["world"]=>
+  float(2.2)
+  ["re	d"]=>
+  string(5) "color"
+  ["	Hello"]=>
+  int(111)
+}
+- $preserve_keys = false -
+array(4) {
+  ["pen
+"]=>
+  int(33)
+  ["world"]=>
+  float(2.2)
+  ["re	d"]=>
+  string(5) "color"
+  ["	Hello"]=>
+  int(111)
+}
+-- Iteration 6 --
+- default argument -
+array(4) {
+  ["pen
+"]=>
+  int(33)
+  ["world"]=>
+  float(2.2)
+  ["re	d"]=>
+  string(5) "color"
+  ["	Hello"]=>
+  int(111)
+}
+- $preserve keys = true -
+array(4) {
+  ["pen
+"]=>
+  int(33)
+  ["world"]=>
+  float(2.2)
+  ["re	d"]=>
+  string(5) "color"
+  ["	Hello"]=>
+  int(111)
+}
+- $preserve_keys = false -
+array(4) {
+  ["pen
+"]=>
+  int(33)
+  ["world"]=>
+  float(2.2)
+  ["re	d"]=>
+  string(5) "color"
+  ["	Hello"]=>
+  int(111)
+}
+-- Iteration 7 --
+- default argument -
+array(2) {
+  ["Hello world"]=>
+  string(6) "string"
+  [0]=>
+  string(5) "hello"
+}
+- $preserve keys = true -
+array(2) {
+  ["Hello world"]=>
+  string(6) "string"
+  [0]=>
+  string(5) "hello"
+}
+- $preserve_keys = false -
+array(2) {
+  ["Hello world"]=>
+  string(6) "string"
+  [0]=>
+  string(5) "hello"
+}
+-- Iteration 8 --
+- default argument -
+array(2) {
+  [0]=>
+  string(8) "resource"
+  [""]=>
+  string(5) "hello"
+}
+- $preserve keys = true -
+array(2) {
+  [5]=>
+  string(8) "resource"
+  [""]=>
+  string(5) "hello"
+}
+- $preserve_keys = false -
+array(2) {
+  [0]=>
+  string(8) "resource"
+  [""]=>
+  string(5) "hello"
+}
+-- Iteration 9 --
+- default argument -
+array(6) {
+  ["Hello world"]=>
+  string(7) "heredoc"
+  [""]=>
+  string(5) "unset"
+  [0]=>
+  string(3) "int"
+  [1]=>
+  string(8) "resource"
+  ["fruit"]=>
+  float(2.2)
+  ["hello"]=>
+  int(1)
+}
+- $preserve keys = true -
+array(6) {
+  ["Hello world"]=>
+  string(7) "heredoc"
+  [""]=>
+  string(5) "unset"
+  [133]=>
+  string(3) "int"
+  [5]=>
+  string(8) "resource"
+  ["fruit"]=>
+  float(2.2)
+  ["hello"]=>
+  int(1)
+}
+- $preserve_keys = false -
+array(6) {
+  ["Hello world"]=>
+  string(7) "heredoc"
+  [""]=>
+  string(5) "unset"
+  [0]=>
+  string(3) "int"
+  [1]=>
+  string(8) "resource"
+  ["fruit"]=>
+  float(2.2)
+  ["hello"]=>
+  int(1)
+}
+Done
diff --git a/tests/std/array/array_reverse_variation5.phpt b/tests/std/array/array_reverse_variation5.phpt
new file mode 100644
index 00000000..25425e07
--- /dev/null
+++ b/tests/std/array/array_reverse_variation5.phpt
@@ -0,0 +1,389 @@
+--TEST--
+Test array_reverse() function : usage variations - assoc. array with diff. value for 'array' argument
+--INI--
+precision=12
+--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_reverse() by giving associative arrays with different
+     * values for $array argument
+    */
+    echo "*** Testing array_reverse() : usage variations ***\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;
+    // initializing the 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.333333),
+        // arrays with string values
+        array(111 => "\tHello", "red" => "col\tor", 2 => "\v\fworld", 3 => "pen\n"),
+        /*8*/
+        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
+        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 the various elements of $arrays to test array_reverse()
+    $iterator = 1;
+    foreach ($arrays as $array) {
+        echo "-- Iteration {$iterator} --\n";
+        // with default argument
+        echo "- default argument -\n";
+        var_dump(array_reverse($array));
+        // with $preserve_keys argument
+        echo "- \$preserve keys = true -\n";
+        var_dump(array_reverse($array, true));
+        echo "- \$preserve_keys = false -\n";
+        var_dump(array_reverse($array, false));
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_reverse() : usage variations ***
+-- Iteration 1 --
+- default argument -
+array(0) {
+}
+- $preserve keys = true -
+array(0) {
+}
+- $preserve_keys = false -
+array(0) {
+}
+-- Iteration 2 --
+- default argument -
+array(1) {
+  [0]=>
+  int(0)
+}
+- $preserve keys = true -
+array(1) {
+  [0]=>
+  int(0)
+}
+- $preserve_keys = false -
+array(1) {
+  [0]=>
+  int(0)
+}
+-- Iteration 3 --
+- default argument -
+array(1) {
+  [0]=>
+  int(1)
+}
+- $preserve keys = true -
+array(1) {
+  [1]=>
+  int(1)
+}
+- $preserve_keys = false -
+array(1) {
+  [0]=>
+  int(1)
+}
+-- Iteration 4 --
+- default argument -
+array(4) {
+  [0]=>
+  int(4)
+  ["three"]=>
+  int(3)
+  ["two"]=>
+  int(2)
+  ["one"]=>
+  int(1)
+}
+- $preserve keys = true -
+array(4) {
+  [4]=>
+  int(4)
+  ["three"]=>
+  int(3)
+  ["two"]=>
+  int(2)
+  ["one"]=>
+  int(1)
+}
+- $preserve_keys = false -
+array(4) {
+  [0]=>
+  int(4)
+  ["three"]=>
+  int(3)
+  ["two"]=>
+  int(2)
+  ["one"]=>
+  int(1)
+}
+-- Iteration 5 --
+- default argument -
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+- $preserve keys = true -
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+- $preserve_keys = false -
+array(1) {
+  ["float"]=>
+  float(2.3333)
+}
+-- Iteration 6 --
+- default argument -
+array(4) {
+  ["f4"]=>
+  float(33333333.333333)
+  [0]=>
+  float(4.89999922839999)
+  ["f2"]=>
+  float(3.33)
+  ["f1"]=>
+  float(1.2)
+}
+- $preserve keys = true -
+array(4) {
+  ["f4"]=>
+  float(33333333.333333)
+  [3]=>
+  float(4.89999922839999)
+  ["f2"]=>
+  float(3.33)
+  ["f1"]=>
+  float(1.2)
+}
+- $preserve_keys = false -
+array(4) {
+  ["f4"]=>
+  float(33333333.333333)
+  [0]=>
+  float(4.89999922839999)
+  ["f2"]=>
+  float(3.33)
+  ["f1"]=>
+  float(1.2)
+}
+-- Iteration 7 --
+- default argument -
+array(4) {
+  [0]=>
+  string(4) "pen
+"
+  [1]=>
+  string(7) "world"
+  ["red"]=>
+  string(6) "col	or"
+  [2]=>
+  string(6) "	Hello"
+}
+- $preserve keys = true -
+array(4) {
+  [3]=>
+  string(4) "pen
+"
+  [2]=>
+  string(7) "world"
+  ["red"]=>
+  string(6) "col	or"
+  [111]=>
+  string(6) "	Hello"
+}
+- $preserve_keys = false -
+array(4) {
+  [0]=>
+  string(4) "pen
+"
+  [1]=>
+  string(7) "world"
+  ["red"]=>
+  string(6) "col	or"
+  [2]=>
+  string(6) "	Hello"
+}
+-- Iteration 8 --
+- default argument -
+array(4) {
+  [0]=>
+  string(5) "pen\n"
+  [1]=>
+  string(9) "\v\fworld"
+  ["red"]=>
+  string(7) "col\tor"
+  [2]=>
+  string(7) "\tHello"
+}
+- $preserve keys = true -
+array(4) {
+  [3]=>
+  string(5) "pen\n"
+  [2]=>
+  string(9) "\v\fworld"
+  ["red"]=>
+  string(7) "col\tor"
+  [111]=>
+  string(7) "\tHello"
+}
+- $preserve_keys = false -
+array(4) {
+  [0]=>
+  string(5) "pen\n"
+  [1]=>
+  string(9) "\v\fworld"
+  ["red"]=>
+  string(7) "col\tor"
+  [2]=>
+  string(7) "\tHello"
+}
+-- Iteration 9 --
+- default argument -
+array(2) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+  [0]=>
+  string(5) "hello"
+}
+- $preserve keys = true -
+array(2) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+  [1]=>
+  string(5) "hello"
+}
+- $preserve_keys = false -
+array(2) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+  [0]=>
+  string(5) "hello"
+}
+-- Iteration 10 --
+- default argument -
+array(3) {
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["unset"]=>
+  NULL
+  [0]=>
+  object(classA)#%d (0) {
+  }
+}
+- $preserve keys = true -
+array(3) {
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["unset"]=>
+  NULL
+  [11]=>
+  object(classA)#%d (0) {
+  }
+}
+- $preserve_keys = false -
+array(3) {
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["unset"]=>
+  NULL
+  [0]=>
+  object(classA)#%d (0) {
+  }
+}
+-- Iteration 11 --
+- default argument -
+array(8) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+  ["unset"]=>
+  NULL
+  ["float"]=>
+  float(444.432)
+  ["int"]=>
+  int(133)
+  ["resource"]=>
+  resource(%d) of type (stream)
+  [0]=>
+  string(5) "fruit"
+  [1]=>
+  object(classA)#%d (0) {
+  }
+  [2]=>
+  string(5) "hello"
+}
+- $preserve keys = true -
+array(8) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+  ["unset"]=>
+  NULL
+  ["float"]=>
+  float(444.432)
+  ["int"]=>
+  int(133)
+  ["resource"]=>
+  resource(%d) of type (stream)
+  [222]=>
+  string(5) "fruit"
+  [2]=>
+  object(classA)#%d (0) {
+  }
+  [1]=>
+  string(5) "hello"
+}
+- $preserve_keys = false -
+array(8) {
+  ["heredoc"]=>
+  string(11) "Hello world"
+  ["unset"]=>
+  NULL
+  ["float"]=>
+  float(444.432)
+  ["int"]=>
+  int(133)
+  ["resource"]=>
+  resource(%d) of type (stream)
+  [0]=>
+  string(5) "fruit"
+  [1]=>
+  object(classA)#%d (0) {
+  }
+  [2]=>
+  string(5) "hello"
+}
+Done
diff --git a/tests/std/array/array_reverse_variation6.phpt b/tests/std/array/array_reverse_variation6.phpt
new file mode 100644
index 00000000..8ad3451d
--- /dev/null
+++ b/tests/std/array/array_reverse_variation6.phpt
@@ -0,0 +1,204 @@
+--TEST--
+Test array_reverse() function : usage variations - two dimensional arrays for 'array' argument
+--FILE--
+<?php
+/*
+ * testing the functionality of array_reverse() by giving 2-D arrays for $array argument
+*/
+
+echo "*** Testing array_reverse() : usage variations ***\n";
+
+// Initializing the 2-d arrays
+$two_dimensional_array = array(
+
+  // associative array
+  array('color' => 'red', 'item' => 'pen', 'place' => 'LA'),
+
+   // numeric array
+   array(1, 2, 3, 4, 5),
+
+   // combination of numeric and associative arrays
+   array('a' => 'green', 'red', 'brown', 33, 88, 'orange', 'item' => 'ball')
+);
+
+// calling array_reverse() with various types of 2-d arrays
+// with default arguments
+echo "-- with default argument --\n";
+var_dump( array_reverse($two_dimensional_array) );  // whole array
+var_dump( array_reverse($two_dimensional_array[1]) );  // sub array
+
+// with $preserve_keys argument
+echo "-- with all possible arguments --\n";
+// whole array
+var_dump( array_reverse($two_dimensional_array, true) );
+var_dump( array_reverse($two_dimensional_array, false) );
+// sub array
+var_dump( array_reverse($two_dimensional_array[1], true) );
+var_dump( array_reverse($two_dimensional_array[1], false) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_reverse() : usage variations ***
+-- with default argument --
+array(3) {
+  [0]=>
+  array(7) {
+    ["a"]=>
+    string(5) "green"
+    [0]=>
+    string(3) "red"
+    [1]=>
+    string(5) "brown"
+    [2]=>
+    int(33)
+    [3]=>
+    int(88)
+    [4]=>
+    string(6) "orange"
+    ["item"]=>
+    string(4) "ball"
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [2]=>
+  array(3) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+    ["place"]=>
+    string(2) "LA"
+  }
+}
+array(5) {
+  [0]=>
+  int(5)
+  [1]=>
+  int(4)
+  [2]=>
+  int(3)
+  [3]=>
+  int(2)
+  [4]=>
+  int(1)
+}
+-- with all possible arguments --
+array(3) {
+  [2]=>
+  array(7) {
+    ["a"]=>
+    string(5) "green"
+    [0]=>
+    string(3) "red"
+    [1]=>
+    string(5) "brown"
+    [2]=>
+    int(33)
+    [3]=>
+    int(88)
+    [4]=>
+    string(6) "orange"
+    ["item"]=>
+    string(4) "ball"
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [0]=>
+  array(3) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+    ["place"]=>
+    string(2) "LA"
+  }
+}
+array(3) {
+  [0]=>
+  array(7) {
+    ["a"]=>
+    string(5) "green"
+    [0]=>
+    string(3) "red"
+    [1]=>
+    string(5) "brown"
+    [2]=>
+    int(33)
+    [3]=>
+    int(88)
+    [4]=>
+    string(6) "orange"
+    ["item"]=>
+    string(4) "ball"
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [2]=>
+  array(3) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+    ["place"]=>
+    string(2) "LA"
+  }
+}
+array(5) {
+  [4]=>
+  int(5)
+  [3]=>
+  int(4)
+  [2]=>
+  int(3)
+  [1]=>
+  int(2)
+  [0]=>
+  int(1)
+}
+array(5) {
+  [0]=>
+  int(5)
+  [1]=>
+  int(4)
+  [2]=>
+  int(3)
+  [3]=>
+  int(2)
+  [4]=>
+  int(1)
+}
+Done
diff --git a/tests/std/array/array_search.phpt b/tests/std/array/array_search.phpt
new file mode 100644
index 00000000..6219efd3
--- /dev/null
+++ b/tests/std/array/array_search.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test array_search()/in_array()
+--FILE--
+<?php
+
+$arr1 = array('a','b','c');
+$arr2 = array();
+$arr3 = array('c','key'=>'d');
+$arr4 = array("a\0b"=>'e','key'=>'d', 'f');
+
+var_dump(in_array(123, $arr2));
+var_dump(in_array(123, $arr1));
+var_dump(array_search(123, $arr1));
+var_dump(in_array('a', $arr1));
+var_dump(array_search('a', $arr1));
+var_dump(array_search('e', $arr4));
+var_dump(array_search('d', $arr4));
+
+echo "Done\n";
+?>
+--EXPECTF--
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+int(0)
+string(3) "a%0b"
+string(3) "key"
+Done
diff --git a/tests/std/array/array_search1.phpt b/tests/std/array/array_search1.phpt
new file mode 100644
index 00000000..33d9c75d
--- /dev/null
+++ b/tests/std/array/array_search1.phpt
@@ -0,0 +1,28 @@
+--TEST--
+array_search() tests
+--FILE--
+<?php
+
+$a = array(1=>0, 2=>1, 4=>3, "a"=>"b", "c"=>"d");
+
+var_dump(array_search("a",$a));
+var_dump(array_search("0",$a, true));
+var_dump(array_search("0",$a));
+var_dump(array_search(0,$a));
+var_dump(array_search(1,$a));
+var_dump(array_search("d",$a, true));
+var_dump(array_search("d",$a));
+var_dump(array_search(-1,$a, true));
+
+echo "Done\n";
+?>
+--EXPECT--
+bool(false)
+bool(false)
+int(1)
+int(1)
+int(2)
+string(1) "c"
+string(1) "c"
+bool(false)
+Done
diff --git a/tests/std/array/array_search_variation1.phpt b/tests/std/array/array_search_variation1.phpt
new file mode 100644
index 00000000..a2838810
--- /dev/null
+++ b/tests/std/array/array_search_variation1.phpt
@@ -0,0 +1,635 @@
+--TEST--
+Test array_search() function : usage variations - different needle values
+--FILE--
+<?php
+/* Test array_search() with different possible needle values */
+
+echo "*** Testing array_search() with different needle values ***\n";
+$arrays = array (
+  array(0),
+  array("a" => "A", 2 => "B", "C" => 3, 4 => 4, "one" => 1, "" => NULL, "b", "ab", "abcd"),
+  array(4, array(1, 2 => 3), "one" => 1, "5" => 5 ),
+  array(-1, -2, -3, -4, -2.989888, "-0.005" => "neg0.005", 2 => "float2", "-.9" => -.9),
+  array(TRUE, FALSE),
+  array("", array()),
+  array("abcd\x00abcd\x00abcd"),
+  array("abcd\tabcd\nabcd\rabcd\0abcdefghij")
+);
+
+$array_compare = array (
+  4,
+  "4",
+  4.00,
+  "b",
+  "5",
+  -2,
+  -2.0,
+  -2.98989,
+  "-.9",
+  "True",
+  "",
+  array(),
+  NULL,
+  "ab",
+  "abcd",
+  0.0,
+  -0,
+  "abcd\x00abcd\x00abcd"
+);
+/* loop to check if elements in $array_compare exist in $arrays
+   using array_search() */
+$counter = 1;
+foreach($arrays as $array) {
+  foreach($array_compare as $compare) {
+    echo "-- Iteration $counter --\n";
+    //strict option OFF
+    var_dump(array_search($compare,$array));
+    //strict option ON
+    var_dump(array_search($compare,$array,TRUE));
+    //strict option OFF
+    var_dump(array_search($compare,$array,FALSE));
+    $counter++;
+ }
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing array_search() with different needle values ***
+-- Iteration 1 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 2 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 3 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 4 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 5 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 6 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 7 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 8 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 9 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 10 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 11 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 12 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 13 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 14 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 15 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 16 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 17 --
+int(0)
+int(0)
+int(0)
+-- Iteration 18 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 19 --
+int(4)
+int(4)
+int(4)
+-- Iteration 20 --
+int(4)
+bool(false)
+int(4)
+-- Iteration 21 --
+int(4)
+bool(false)
+int(4)
+-- Iteration 22 --
+int(5)
+int(5)
+int(5)
+-- Iteration 23 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 24 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 25 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 26 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 27 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 28 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 29 --
+string(0) ""
+bool(false)
+string(0) ""
+-- Iteration 30 --
+string(0) ""
+bool(false)
+string(0) ""
+-- Iteration 31 --
+string(0) ""
+string(0) ""
+string(0) ""
+-- Iteration 32 --
+int(6)
+int(6)
+int(6)
+-- Iteration 33 --
+int(7)
+int(7)
+int(7)
+-- Iteration 34 --
+string(0) ""
+bool(false)
+string(0) ""
+-- Iteration 35 --
+string(0) ""
+bool(false)
+string(0) ""
+-- Iteration 36 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 37 --
+int(0)
+int(0)
+int(0)
+-- Iteration 38 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 39 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 40 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 41 --
+int(5)
+bool(false)
+int(5)
+-- Iteration 42 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 43 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 44 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 45 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 46 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 47 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 48 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 49 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 50 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 51 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 52 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 53 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 54 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 55 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 56 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 57 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 58 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 59 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 60 --
+int(1)
+int(1)
+int(1)
+-- Iteration 61 --
+int(1)
+bool(false)
+int(1)
+-- Iteration 62 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 63 --
+string(3) "-.9"
+bool(false)
+string(3) "-.9"
+-- Iteration 64 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 65 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 66 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 67 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 68 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 69 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 70 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 71 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 72 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 73 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 74 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 75 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 76 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 77 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 78 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 79 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 80 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 81 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 82 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 83 --
+int(1)
+bool(false)
+int(1)
+-- Iteration 84 --
+int(1)
+bool(false)
+int(1)
+-- Iteration 85 --
+int(1)
+bool(false)
+int(1)
+-- Iteration 86 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 87 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 88 --
+int(1)
+bool(false)
+int(1)
+-- Iteration 89 --
+int(1)
+bool(false)
+int(1)
+-- Iteration 90 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 91 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 92 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 93 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 94 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 95 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 96 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 97 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 98 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 99 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 100 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 101 --
+int(0)
+int(0)
+int(0)
+-- Iteration 102 --
+int(1)
+int(1)
+int(1)
+-- Iteration 103 --
+int(0)
+bool(false)
+int(0)
+-- Iteration 104 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 105 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 106 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 107 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 108 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 109 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 110 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 111 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 112 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 113 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 114 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 115 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 116 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 117 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 118 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 119 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 120 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 121 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 122 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 123 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 124 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 125 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 126 --
+int(0)
+int(0)
+int(0)
+-- Iteration 127 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 128 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 129 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 130 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 131 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 132 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 133 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 134 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 135 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 136 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 137 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 138 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 139 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 140 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 141 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 142 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 143 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 144 --
+bool(false)
+bool(false)
+bool(false)
+Done
diff --git a/tests/std/array/array_search_variation2.phpt b/tests/std/array/array_search_variation2.phpt
new file mode 100644
index 00000000..83c3a925
--- /dev/null
+++ b/tests/std/array/array_search_variation2.phpt
@@ -0,0 +1,98 @@
+--TEST--
+Test array_search() function : usage variations - different haystack values
+--SKIPIF--
+<?php die("skip AOT array search differs from PHP for resources/objects"); ?>
+--FILE--
+<?php
+/* Test array_search() with different possible haystack values */
+
+echo "*** Testing array_search() with different haystack values ***\n";
+
+$misc_array = array (
+  'a',
+  'key' =>'d',
+  3,
+  ".001" =>-67,
+  "-.051" =>"k",
+  0 =>"-.08",
+  "e" =>"5",
+  "y" =>NULL,
+  NULL =>"",
+  0,
+  TRUE,
+  FALSE,
+  -27.39999999999,
+  " ",
+  "abcd\x00abcd\x00\abcd\x00abcdefghij",
+  "abcd\nabcd\tabcd\rabcd\0abcd"
+);
+$array_type = array(TRUE, FALSE, 1, 0, -1, "1", "0", "-1", NULL, array(), "PHP", "");
+/* loop to do loose and strict type check of elements in
+   $array_type on elements in $misc_array using array_search();
+   checking PHP type comparison tables
+*/
+$counter = 1;
+foreach($array_type as $type) {
+  echo "-- Iteration $counter --\n";
+  //loose type checking
+  var_dump( array_search($type,$misc_array ) );
+  //strict type checking
+  var_dump( array_search($type,$misc_array,true) );
+  //loose type checking
+  var_dump( array_search($type,$misc_array,false) );
+  $counter++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing array_search() with different haystack values ***
+-- Iteration 1 --
+int(0)
+int(3)
+int(0)
+-- Iteration 2 --
+string(1) "y"
+int(4)
+string(1) "y"
+-- Iteration 3 --
+int(3)
+bool(false)
+int(3)
+-- Iteration 4 --
+string(1) "y"
+int(2)
+string(1) "y"
+-- Iteration 5 --
+int(3)
+bool(false)
+int(3)
+-- Iteration 6 --
+int(3)
+bool(false)
+int(3)
+-- Iteration 7 --
+int(2)
+bool(false)
+int(2)
+-- Iteration 8 --
+int(3)
+bool(false)
+int(3)
+-- Iteration 9 --
+string(1) "y"
+string(1) "y"
+string(1) "y"
+-- Iteration 10 --
+string(1) "y"
+bool(false)
+string(1) "y"
+-- Iteration 11 --
+int(3)
+bool(false)
+int(3)
+-- Iteration 12 --
+string(1) "y"
+string(0) ""
+string(1) "y"
+Done
diff --git a/tests/std/array/array_search_variation3.phpt b/tests/std/array/array_search_variation3.phpt
new file mode 100644
index 00000000..674e9916
--- /dev/null
+++ b/tests/std/array/array_search_variation3.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_search() function : usage variations - haystack as sub-array/object
+--SKIPIF--
+<?php die("skip AOT array search differs from PHP for resources/objects"); ?>
+--FILE--
+<?php
+class array_search_check
+{
+    public $array_var = array(1 => "one", "two" => 2, 3 => 3);
+    public function foo()
+    {
+        echo "Public function\n";
+    }
+}
+function main()
+{
+    /* checking for sub-arrays with array_search() */
+    echo "*** Testing sub-arrays with array_search() ***\n";
+    $sub_array = array("one", array(1, 2 => "two", "three" => 3), 4 => "four", "five" => 5, array('', 'i'));
+    var_dump(array_search("four", $sub_array));
+    //checking for element in a sub-array
+    var_dump(array_search(3, $sub_array[1]));
+    var_dump(array_search(array('', 'i'), $sub_array));
+    /* checking for objects in array_search() */
+    echo "\n*** Testing objects with array_search() ***\n";
+    $array_search_obj = new array_search_check();
+    //creating new object
+    //error: as wrong datatype for second argument
+    try {
+        var_dump(array_search("array_var", $array_search_obj));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    //error: as wrong datatype for second argument
+    try {
+        var_dump(array_search("foo", $array_search_obj));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    //element found as "one" exists in array $array_var
+    var_dump(array_search("one", $array_search_obj->array_var));
+    echo "Done\n";
+}
+?>
+--EXPECT--
+*** Testing sub-arrays with array_search() ***
+int(4)
+string(5) "three"
+int(5)
+
+*** Testing objects with array_search() ***
+array_search(): Argument #2 ($haystack) must be of type array, array_search_check given
+array_search(): Argument #2 ($haystack) must be of type array, array_search_check given
+int(1)
+Done
diff --git a/tests/std/array/array_search_variation4.phpt b/tests/std/array/array_search_variation4.phpt
new file mode 100644
index 00000000..fa5cdf62
--- /dev/null
+++ b/tests/std/array/array_search_variation4.phpt
@@ -0,0 +1,68 @@
+--TEST--
+Test array_search() function : usage variations - haystack as resource/multi dimensional array
+--FILE--
+<?php
+/* checking for Resources */
+echo "*** Testing resource type with array_search() ***\n";
+//file type resource
+$file_handle = fopen(__FILE__, "r");
+
+//directory type resource
+$dir_handle = opendir( __DIR__ );
+
+//store resources in array for comparison.
+$resources = array($file_handle, $dir_handle);
+
+// search for resource type in the resource array
+var_dump( array_search($file_handle, $resources, true) );
+//checking for (int) type resource
+var_dump( array_search((int)$dir_handle, $resources, true) );
+
+/* Miscellenous input check  */
+echo "\n*** Testing miscelleneos inputs with array_search() ***\n";
+//matching "Good" in array(0,"hello"), result:true in loose type check
+var_dump( array_search("Good", array(0,"hello")) );
+//false in strict mode
+var_dump( array_search("Good", array(0,"hello"), TRUE) );
+
+//matching integer 0 in array("this"), result:true in loose type check
+var_dump( array_search(0, array("this")) );
+// false in strict mode
+var_dump( array_search(0, array("this")),TRUE );
+
+//matching string "this" in array(0), result:true in loose type check
+var_dump( array_search("this", array(0)) );
+// false in stric mode
+var_dump( array_search("this", array(0), TRUE) );
+
+//checking for type FALSE in multidimensional array with loose checking, result:false in loose type check
+var_dump( array_search(FALSE,
+                   array("a"=> TRUE, "b"=> TRUE,
+                         array("c"=> TRUE, "d"=>TRUE)
+                        )
+                  )
+        );
+
+//matching string having integer in beginning, result:true in loose type check
+var_dump( array_search('123abc', array(123)) );
+var_dump( array_search('123abc', array(123), TRUE) ); // false in strict mode
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing resource type with array_search() ***
+int(0)
+bool(false)
+
+*** Testing miscelleneos inputs with array_search() ***
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+Done
diff --git a/tests/std/array/array_shift_basic.phpt b/tests/std/array/array_shift_basic.phpt
new file mode 100644
index 00000000..ad0d70ea
--- /dev/null
+++ b/tests/std/array/array_shift_basic.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Test array_shift() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of array_shift()
+ */
+
+echo "*** Testing array_shift() : basic functionality ***\n";
+
+$array = array('zero', 'one', '3' => 'three', 'four' => 4);
+echo "\n-- Before shift: --\n";
+var_dump($array);
+
+echo "\n-- After shift: --\n";
+echo "Returned value:\t";
+var_dump(array_shift($array));
+echo "New array:\n";
+var_dump($array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_shift() : basic functionality ***
+
+-- Before shift: --
+array(4) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [3]=>
+  string(5) "three"
+  ["four"]=>
+  int(4)
+}
+
+-- After shift: --
+Returned value:	string(4) "zero"
+New array:
+array(3) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(5) "three"
+  ["four"]=>
+  int(4)
+}
+Done
diff --git a/tests/std/array/array_shift_variation2.phpt b/tests/std/array/array_shift_variation2.phpt
new file mode 100644
index 00000000..0ab7708b
--- /dev/null
+++ b/tests/std/array/array_shift_variation2.phpt
@@ -0,0 +1,165 @@
+--TEST--
+Test array_shift() function : usage variations - Pass arrays of 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()
+{
+    /*
+     * Pass arrays where values are of one data type to test behaviour of array_shift()
+     */
+    echo "*** Testing array_shift() : usage variations ***\n";
+    //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");
+    // arrays of different data types to be passed to $stack 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 string' => array("", ''),
+        /*6*/
+        'empty array' => array(),
+        // string data
+        /*7*/
+        'string' => array("string", 'string', $heredoc),
+        // object data
+        /*8*/
+        'object' => array(new classA()),
+        // undefined data
+        /*9*/
+        'undefined' => array(@$undefined_var),
+        // unset data
+        /*10*/
+        'unset' => array(@$unset_var),
+        // resource variable
+        /*11*/
+        'resource' => array($fp),
+    );
+    // loop through each element of $inputs to check the behavior of array_shift
+    $iterator = 1;
+    foreach ($inputs as $key => $input) {
+        echo "\n-- Iteration {$iterator}: {$key} data --\n";
+        var_dump(array_shift($input));
+        var_dump($input);
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_shift() : usage variations ***
+
+-- Iteration 1: int data --
+int(0)
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(12345)
+  [2]=>
+  int(-2345)
+}
+
+-- Iteration 2: float data --
+float(10.5)
+array(4) {
+  [0]=>
+  float(-10.5)
+  [1]=>
+  float(123456789000)
+  [2]=>
+  float(1.23456789E-9)
+  [3]=>
+  float(0.5)
+}
+
+-- Iteration 3: null data --
+NULL
+array(1) {
+  [0]=>
+  NULL
+}
+
+-- Iteration 4: bool data --
+bool(true)
+array(3) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+  [2]=>
+  bool(false)
+}
+
+-- Iteration 5: empty string data --
+string(0) ""
+array(1) {
+  [0]=>
+  string(0) ""
+}
+
+-- Iteration 6: empty array data --
+NULL
+array(0) {
+}
+
+-- Iteration 7: string data --
+string(6) "string"
+array(2) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(11) "hello world"
+}
+
+-- Iteration 8: object data --
+object(classA)#%d (0) {
+}
+array(0) {
+}
+
+-- Iteration 9: undefined data --
+NULL
+array(0) {
+}
+
+-- Iteration 10: unset data --
+NULL
+array(0) {
+}
+
+-- Iteration 11: resource data --
+resource(%d) of type (stream)
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_shift_variation3.phpt b/tests/std/array/array_shift_variation3.phpt
new file mode 100644
index 00000000..a33626b8
--- /dev/null
+++ b/tests/std/array/array_shift_variation3.phpt
@@ -0,0 +1,160 @@
+--TEST--
+Test array_shift() function : usage variations - Pass array with 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 test how array_shift() re-assigns keys
+ */
+
+echo "*** Testing array_shift() : usage variations ***\n";
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// heredoc string
+$heredoc = <<<EOT
+hello world
+EOT;
+
+// unexpected values to be passed to $stack argument
+$inputs = array(
+
+       // int data
+/*1*/  'int' => array(
+       0 => 'zero',
+       1 => 'one',
+       12345 => 'positive',
+       -2345 => 'negative',
+       ),
+
+       // null data
+/*4*/  'null uppercase' => array(
+       NULL => 'null 1',
+       ),
+
+/*5*/  'null lowercase' => array(
+       null => 'null 2',
+       ),
+
+       // boolean data
+/*6*/  'bool lowercase' => array(
+       true => 'lowert',
+       false => 'lowerf',
+       ),
+
+/*7*/  'bool uppercase' => array(
+       TRUE => 'uppert',
+       FALSE => 'upperf',
+       ),
+
+       // empty data
+/*8*/  'empty double quotes' => array(
+       "" => 'emptyd',
+       ),
+
+/*9*/  'empty single quotes' => array(
+       '' => 'emptys',
+       ),
+
+       // string data
+/*10*/ 'string' => array(
+       "stringd" => 'stringd',
+       'strings' => 'strings',
+       $heredoc => 'stringh',
+       ),
+
+       // undefined data
+/*11*/ 'undefined' => array(
+       @$undefined_var => 'undefined',
+       ),
+
+       // unset data
+/*12*/ 'unset' => array(
+       @$unset_var => 'unset',
+       ),
+);
+
+// loop through each element of $inputs to check the behavior of array_shift()
+$iterator = 1;
+foreach($inputs as $key => $input) {
+  echo "\n-- Iteration $iterator : $key data --\n";
+  var_dump( array_shift($input) );
+  var_dump($input);
+  $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_shift() : usage variations ***
+
+-- Iteration 1 : int data --
+string(4) "zero"
+array(3) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(8) "positive"
+  [2]=>
+  string(8) "negative"
+}
+
+-- Iteration 2 : null uppercase data --
+string(6) "null 1"
+array(0) {
+}
+
+-- Iteration 3 : null lowercase data --
+string(6) "null 2"
+array(0) {
+}
+
+-- Iteration 4 : bool lowercase data --
+string(6) "lowert"
+array(1) {
+  [0]=>
+  string(6) "lowerf"
+}
+
+-- Iteration 5 : bool uppercase data --
+string(6) "uppert"
+array(1) {
+  [0]=>
+  string(6) "upperf"
+}
+
+-- Iteration 6 : empty double quotes data --
+string(6) "emptyd"
+array(0) {
+}
+
+-- Iteration 7 : empty single quotes data --
+string(6) "emptys"
+array(0) {
+}
+
+-- Iteration 8 : string data --
+string(7) "stringd"
+array(2) {
+  ["strings"]=>
+  string(7) "strings"
+  ["hello world"]=>
+  string(7) "stringh"
+}
+
+-- Iteration 9 : undefined data --
+string(9) "undefined"
+array(0) {
+}
+
+-- Iteration 10 : unset data --
+string(5) "unset"
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_shift_variation4.phpt b/tests/std/array/array_shift_variation4.phpt
new file mode 100644
index 00000000..34c15055
--- /dev/null
+++ b/tests/std/array/array_shift_variation4.phpt
@@ -0,0 +1,104 @@
+--TEST--
+Test array_shift() function : usage variations - multi-dimensional arrays
+--FILE--
+<?php
+/*
+ * Test popping elements from a sub-array and popping an array from an array
+ */
+
+echo "*** Testing array_shift() : usage variations ***\n";
+
+$stack_first = array(array(1, 2, 3), 'one', 'two');
+$stack_last = array ('zero', 'one', array (1, 2, 3));
+echo "\n-- Before shift: --\n";
+echo "---- \$stack_first:\n";
+var_dump($stack_first);
+echo "---- \$stack_last:\n";
+var_dump($stack_last);
+
+echo "\n-- After shift: --\n";
+echo "---- Pop array from array:\n";
+echo "Returned value:\t";
+var_dump(array_shift($stack_first));
+echo "New array:\n";
+var_dump($stack_first);
+
+echo "---- Pop element from array within array:\n";
+echo "Returned value:\t";
+var_dump(array_shift($stack_last[2]));
+echo "New array:\n";
+var_dump($stack_last);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_shift() : usage variations ***
+
+-- Before shift: --
+---- $stack_first:
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+---- $stack_last:
+array(3) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+
+-- After shift: --
+---- Pop array from array:
+Returned value:	array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+New array:
+array(2) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+}
+---- Pop element from array within array:
+Returned value:	int(1)
+New array:
+array(3) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  array(2) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(3)
+  }
+}
+Done
diff --git a/tests/std/array/array_shift_variation5.phpt b/tests/std/array/array_shift_variation5.phpt
new file mode 100644
index 00000000..0ba29b62
--- /dev/null
+++ b/tests/std/array/array_shift_variation5.phpt
@@ -0,0 +1,42 @@
+--TEST--
+Test array_shift() function : usage variations - call recursively
+--SKIPIF--
+<?php die("skip AOT array_shift recursive behavior differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * Use the result of one call to array_shift
+ * as the $stack argument of another call to array_shift()
+ * When done in one statement causes strict error messages.
+ */
+
+echo "*** Testing array_shift() : usage variations ***\n";
+
+$stack = array ( array ( array ('zero', 'one', 'two'), 'un', 'deux'), 'eins', 'zwei');
+
+// not following strict standards
+echo "\n-- Incorrect Method: --\n";
+var_dump(array_shift(array_shift(array_shift($stack))));
+
+$stack = array (array( array('zero', 'one', 'two'), 'un', 'deux'), 'eins', 'zwei');
+// correct way of doing above:
+echo "\n-- Correct Method: --\n";
+$result1 = array_shift($stack);
+$result2 = array_shift($result1);
+var_dump(array_shift($result2));
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_shift() : usage variations ***
+
+-- Incorrect Method: --
+
+Notice: Only variables should be passed by reference in %s on line %d
+
+Notice: Only variables should be passed by reference in %s on line %d
+string(4) "zero"
+
+-- Correct Method: --
+string(4) "zero"
+Done
diff --git a/tests/std/array/array_shift_variation6.phpt b/tests/std/array/array_shift_variation6.phpt
new file mode 100644
index 00000000..1f554887
--- /dev/null
+++ b/tests/std/array/array_shift_variation6.phpt
@@ -0,0 +1,80 @@
+--TEST--
+Test array_shift() function : usage variations - Referenced arrays
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+/*
+ * Test how array_shift when passed:
+ * 1. a variable that is referenced to an array
+ * 2. an array that contains a referenced array
+ */
+
+echo "*** Testing array_shift() : usage variations ***\n";
+
+echo "\n-- Variable is referenced array --\n";
+$original_array = array('zero', 'one', 'two');
+$copied_array = &$original_array;
+
+echo "Result: ";
+var_dump(array_shift($copied_array));
+echo "\n\$original_array:\n";
+var_dump($original_array);
+echo "\n\$copied_array:\n";
+var_dump($copied_array);
+
+echo "\n-- Element is referenced array --\n";
+$new_array = array (&$copied_array, 1, 'two');
+echo "Result: ";
+var_dump(array_shift($new_array[0]));
+echo "\n\$new_array:\n";
+var_dump($new_array);
+echo "\n\$copied_array\n";
+var_dump($copied_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_shift() : usage variations ***
+
+-- Variable is referenced array --
+Result: string(4) "zero"
+
+$original_array:
+array(2) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+}
+
+$copied_array:
+array(2) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+}
+
+-- Element is referenced array --
+Result: string(3) "one"
+
+$new_array:
+array(3) {
+  [0]=>
+  &array(1) {
+    [0]=>
+    string(3) "two"
+  }
+  [1]=>
+  int(1)
+  [2]=>
+  string(3) "two"
+}
+
+$copied_array
+array(1) {
+  [0]=>
+  string(3) "two"
+}
+Done
diff --git a/tests/std/array/array_shift_variation7.phpt b/tests/std/array/array_shift_variation7.phpt
new file mode 100644
index 00000000..257047be
--- /dev/null
+++ b/tests/std/array/array_shift_variation7.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test array_shift() function : usage variations - position of internal pointer
+--FILE--
+<?php
+/*
+ * Test that the internal pointer is reset after calling array_shift()
+ */
+
+echo "*** Testing array_shift() : usage variations ***\n";
+
+$stack = array ('one' => 'un', 'two' => 'deux');
+
+echo "\n-- Call array_shift() --\n";
+var_dump($result = array_shift($stack));
+
+echo "\n-- Position of Internal Pointer in Passed Array: --\n";
+echo key($stack) . " => " . current ($stack) . "\n";
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_shift() : usage variations ***
+
+-- Call array_shift() --
+string(2) "un"
+
+-- Position of Internal Pointer in Passed Array: --
+two => deux
+Done
diff --git a/tests/std/array/array_shift_variation8.phpt b/tests/std/array/array_shift_variation8.phpt
new file mode 100644
index 00000000..16bcecc1
--- /dev/null
+++ b/tests/std/array/array_shift_variation8.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Test array_shift() function : usage variations - maintaining referenced elements
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference assignment in this context");
+?>
+
+--FILE--
+<?php
+/*
+ * From a comment left by Traps on 09-Jul-2007 on the array_shift documentation page:
+ * For those that may be trying to use array_shift() with an array containing references
+ * (e.g. working with linked node trees), beware that array_shift() may not work as you expect:
+ * it will return a *copy* of the first element of the array,
+ * and not the element itself, so your reference will be lost.
+ * The solution is to reference the first element before removing it with array_shift():
+ */
+
+echo "*** Testing array_shift() : usage variations ***\n";
+
+// using only array_shift:
+echo "\n-- Reference result of array_shift: --\n";
+$a = 1;
+$array = array(&$a);
+$b =& array_shift($array);
+$b = 2;
+echo "a = $a, b = $b\n";
+
+// solution: referencing the first element first:
+echo "\n-- Reference first element before array_shift: --\n";
+$a = 1;
+$array = array(&$a);
+$b =& $array[0];
+array_shift($array);
+$b = 2;
+echo "a = $a, b = $b\n";
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_shift() : usage variations ***
+
+-- Reference result of array_shift: --
+
+Notice: Only variables should be assigned by reference in %s on line %d
+a = 1, b = 2
+
+-- Reference first element before array_shift: --
+a = 2, b = 2
+Done
diff --git a/tests/std/array/array_shuffle_basic.phpt b/tests/std/array/array_shuffle_basic.phpt
new file mode 100644
index 00000000..65d2f11d
--- /dev/null
+++ b/tests/std/array/array_shuffle_basic.phpt
@@ -0,0 +1,98 @@
+--TEST--
+array_shuffle(): Test return type and value for expected input
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+$numbers = range(1, 20);
+echo "*** testing array_shuffle  \n";
+$a = array();
+var_dump(shuffle($a));
+var_dump($a);
+$a = array(1);
+var_dump(shuffle($a));
+var_dump($a);
+$a = array(2 => 1);
+var_dump(shuffle($a));
+var_dump($a);
+$a = array("a" => 1);
+var_dump(shuffle($a));
+var_dump($a);
+$a = array(array(1, 2, 3));
+var_dump(shuffle($a));
+var_dump($a);
+$a = array(1, 1, 1, 1);
+var_dump(shuffle($a));
+var_dump($a);
+$arr1 = array(5 => 1, 6 => 2, 7 => 3, 8 => 9);
+$arr2 = array(5 => 1, 6 => 2, 7 => 3, 8 => 9);
+shuffle($arr1);
+echo "this should be 0->...." . count(array_diff($arr1, $arr2)) . "\n";
+echo "this should be 4->...." . count(array_intersect($arr1, $arr2)) . "\n";
+$bigarray = range(1, 400);
+shuffle($bigarray);
+echo "this should be 400->...." . count($bigarray) . "\n";
+echo "*** testing pass by reference  \n";
+$original = $bigarray;
+shuffle($bigarray);
+$diffarray = array_diff_assoc($original, $bigarray);
+if (count($diffarray) < 350) {
+    // with 400 entries, the probability that 50 entries or more get the same
+    // key-> value association should be so close to zero it wont happen in the lifetime of the
+    // universe.
+    echo "shuffled array seems to be similar to original\n";
+    var_dump($original);
+    var_dump($bigarray);
+} else {
+    echo "test passed \n";
+}
+?>
+--EXPECT--
+*** testing array_shuffle  
+bool(true)
+array(0) {
+}
+bool(true)
+array(1) {
+  [0]=>
+  int(1)
+}
+bool(true)
+array(1) {
+  [0]=>
+  int(1)
+}
+bool(true)
+array(1) {
+  [0]=>
+  int(1)
+}
+bool(true)
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+bool(true)
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [2]=>
+  int(1)
+  [3]=>
+  int(1)
+}
+this should be 0->....0
+this should be 4->....4
+this should be 400->....400
+*** testing pass by reference  
+test passed 
diff --git a/tests/std/array/array_slice.phpt b/tests/std/array/array_slice.phpt
new file mode 100644
index 00000000..f12f6d62
--- /dev/null
+++ b/tests/std/array/array_slice.phpt
@@ -0,0 +1,1419 @@
+--TEST--
+Testing array_slice() function
+--FILE--
+<?php
+
+$var_array = array(
+                   array(),
+                   array(1,2,3,4,5,6,7,8,9),
+                   array("One", "Two", "Three", "Four", "Five"),
+                   array(6, "six", 7, "seven", 8, "eight", 9, "nine"),
+                   array( "a" => "aaa", "A" => "AAA", "c" => "ccc", "d" => "ddd", "e" => "eee"),
+                   array("1" => "one", "2" => "two", "3" => "three", "4" => "four", "5" => "five"),
+                   array(1 => "one", 2 => "two", 3 => 7, 4 => "four", 5 => "five"),
+                   array("f" => "fff", "1" => "one", 4 => 6, "" => "blank", 2 => "float", "F" => "FFF",
+                         "blank" => "", 3 => 3.7, 5 => 7, 6 => 8.6, '5' => "Five"),
+                   array(12, "name", 'age', '45'),
+                   array( array("oNe", "tWo", 4), array(10, 20, 30, 40, 50), array())
+                 );
+
+$num = 4;
+$str = "john";
+
+$counter = 1;
+foreach ($var_array as $sub_array)
+{
+  /* variations with two arguments */
+  /* offset values >, < and = 0    */
+
+  echo"\n*** Iteration ".$counter." ***\n";
+  echo"\n*** Variation with first two Arguments ***\n";
+  var_dump ( array_slice($sub_array, 1) );
+  var_dump ( array_slice($sub_array, 0) );
+  var_dump ( array_slice($sub_array, -2) );
+
+  /* variations with three arguments */
+  /* offset value variations with length values  */
+  echo"\n*** Variation with first three Arguments ***\n";
+  var_dump ( array_slice($sub_array, 1, 3) );
+  var_dump ( array_slice($sub_array, 1, 0) );
+  var_dump ( array_slice($sub_array, 1, -3) );
+  var_dump ( array_slice($sub_array, 0, 3) );
+  var_dump ( array_slice($sub_array, 0, 0) );
+  var_dump ( array_slice($sub_array, 0, -3) );
+  var_dump ( array_slice($sub_array, -2, 3) );
+  var_dump ( array_slice($sub_array, -2, 0 ) );
+  var_dump ( array_slice($sub_array, -2, -3) );
+
+  /* variations with four arguments */
+  /* offset value, length value and preserve_key values variation */
+  echo"\n*** Variation with first two arguments with preserve_key value TRUE ***\n";
+  var_dump ( array_slice($sub_array, 1, 3, true) );
+  var_dump ( array_slice($sub_array, 1, 0, true) );
+  var_dump ( array_slice($sub_array, 1, -3, true) );
+  var_dump ( array_slice($sub_array, 0, 3, true) );
+  var_dump ( array_slice($sub_array, 0, 0, true) );
+  var_dump ( array_slice($sub_array, 0, -3, true) );
+  var_dump ( array_slice($sub_array, -2, 3, true) );
+  var_dump ( array_slice($sub_array, -2, 0, true) );
+  var_dump ( array_slice($sub_array, -2, -3, true) );
+  $counter++;
+}
+
+  /* variation of offset and length to point to same element */
+  echo"\n*** Typical Variation of offset and length  Arguments ***\n";
+  var_dump (array_slice($var_array[2], 1, -3, true) );
+  var_dump (array_slice($var_array[2], 1, -3, false) );
+  var_dump (array_slice($var_array[2], -3, -2, true) );
+  var_dump (array_slice($var_array[2], -3, -2, false) );
+
+?>
+--EXPECT--
+*** Iteration 1 ***
+
+*** Variation with first two Arguments ***
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first three Arguments ***
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Iteration 2 ***
+
+*** Variation with first two Arguments ***
+array(8) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+  [4]=>
+  int(6)
+  [5]=>
+  int(7)
+  [6]=>
+  int(8)
+  [7]=>
+  int(9)
+}
+array(9) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+}
+array(2) {
+  [0]=>
+  int(8)
+  [1]=>
+  int(9)
+}
+
+*** Variation with first three Arguments ***
+array(3) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+  [2]=>
+  int(4)
+}
+array(0) {
+}
+array(5) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+  [4]=>
+  int(6)
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(0) {
+}
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+}
+array(2) {
+  [0]=>
+  int(8)
+  [1]=>
+  int(9)
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(3) {
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+}
+array(0) {
+}
+array(5) {
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(0) {
+}
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+}
+array(2) {
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Iteration 3 ***
+
+*** Variation with first two Arguments ***
+array(4) {
+  [0]=>
+  string(3) "Two"
+  [1]=>
+  string(5) "Three"
+  [2]=>
+  string(4) "Four"
+  [3]=>
+  string(4) "Five"
+}
+array(5) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(3) "Two"
+  [2]=>
+  string(5) "Three"
+  [3]=>
+  string(4) "Four"
+  [4]=>
+  string(4) "Five"
+}
+array(2) {
+  [0]=>
+  string(4) "Four"
+  [1]=>
+  string(4) "Five"
+}
+
+*** Variation with first three Arguments ***
+array(3) {
+  [0]=>
+  string(3) "Two"
+  [1]=>
+  string(5) "Three"
+  [2]=>
+  string(4) "Four"
+}
+array(0) {
+}
+array(1) {
+  [0]=>
+  string(3) "Two"
+}
+array(3) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(3) "Two"
+  [2]=>
+  string(5) "Three"
+}
+array(0) {
+}
+array(2) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(3) "Two"
+}
+array(2) {
+  [0]=>
+  string(4) "Four"
+  [1]=>
+  string(4) "Five"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(3) {
+  [1]=>
+  string(3) "Two"
+  [2]=>
+  string(5) "Three"
+  [3]=>
+  string(4) "Four"
+}
+array(0) {
+}
+array(1) {
+  [1]=>
+  string(3) "Two"
+}
+array(3) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(3) "Two"
+  [2]=>
+  string(5) "Three"
+}
+array(0) {
+}
+array(2) {
+  [0]=>
+  string(3) "One"
+  [1]=>
+  string(3) "Two"
+}
+array(2) {
+  [3]=>
+  string(4) "Four"
+  [4]=>
+  string(4) "Five"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Iteration 4 ***
+
+*** Variation with first two Arguments ***
+array(7) {
+  [0]=>
+  string(3) "six"
+  [1]=>
+  int(7)
+  [2]=>
+  string(5) "seven"
+  [3]=>
+  int(8)
+  [4]=>
+  string(5) "eight"
+  [5]=>
+  int(9)
+  [6]=>
+  string(4) "nine"
+}
+array(8) {
+  [0]=>
+  int(6)
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+  [3]=>
+  string(5) "seven"
+  [4]=>
+  int(8)
+  [5]=>
+  string(5) "eight"
+  [6]=>
+  int(9)
+  [7]=>
+  string(4) "nine"
+}
+array(2) {
+  [0]=>
+  int(9)
+  [1]=>
+  string(4) "nine"
+}
+
+*** Variation with first three Arguments ***
+array(3) {
+  [0]=>
+  string(3) "six"
+  [1]=>
+  int(7)
+  [2]=>
+  string(5) "seven"
+}
+array(0) {
+}
+array(4) {
+  [0]=>
+  string(3) "six"
+  [1]=>
+  int(7)
+  [2]=>
+  string(5) "seven"
+  [3]=>
+  int(8)
+}
+array(3) {
+  [0]=>
+  int(6)
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+}
+array(0) {
+}
+array(5) {
+  [0]=>
+  int(6)
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+  [3]=>
+  string(5) "seven"
+  [4]=>
+  int(8)
+}
+array(2) {
+  [0]=>
+  int(9)
+  [1]=>
+  string(4) "nine"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(3) {
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+  [3]=>
+  string(5) "seven"
+}
+array(0) {
+}
+array(4) {
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+  [3]=>
+  string(5) "seven"
+  [4]=>
+  int(8)
+}
+array(3) {
+  [0]=>
+  int(6)
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+}
+array(0) {
+}
+array(5) {
+  [0]=>
+  int(6)
+  [1]=>
+  string(3) "six"
+  [2]=>
+  int(7)
+  [3]=>
+  string(5) "seven"
+  [4]=>
+  int(8)
+}
+array(2) {
+  [6]=>
+  int(9)
+  [7]=>
+  string(4) "nine"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Iteration 5 ***
+
+*** Variation with first two Arguments ***
+array(4) {
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+  ["d"]=>
+  string(3) "ddd"
+  ["e"]=>
+  string(3) "eee"
+}
+array(5) {
+  ["a"]=>
+  string(3) "aaa"
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+  ["d"]=>
+  string(3) "ddd"
+  ["e"]=>
+  string(3) "eee"
+}
+array(2) {
+  ["d"]=>
+  string(3) "ddd"
+  ["e"]=>
+  string(3) "eee"
+}
+
+*** Variation with first three Arguments ***
+array(3) {
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+  ["d"]=>
+  string(3) "ddd"
+}
+array(0) {
+}
+array(1) {
+  ["A"]=>
+  string(3) "AAA"
+}
+array(3) {
+  ["a"]=>
+  string(3) "aaa"
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+}
+array(0) {
+}
+array(2) {
+  ["a"]=>
+  string(3) "aaa"
+  ["A"]=>
+  string(3) "AAA"
+}
+array(2) {
+  ["d"]=>
+  string(3) "ddd"
+  ["e"]=>
+  string(3) "eee"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(3) {
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+  ["d"]=>
+  string(3) "ddd"
+}
+array(0) {
+}
+array(1) {
+  ["A"]=>
+  string(3) "AAA"
+}
+array(3) {
+  ["a"]=>
+  string(3) "aaa"
+  ["A"]=>
+  string(3) "AAA"
+  ["c"]=>
+  string(3) "ccc"
+}
+array(0) {
+}
+array(2) {
+  ["a"]=>
+  string(3) "aaa"
+  ["A"]=>
+  string(3) "AAA"
+}
+array(2) {
+  ["d"]=>
+  string(3) "ddd"
+  ["e"]=>
+  string(3) "eee"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Iteration 6 ***
+
+*** Variation with first two Arguments ***
+array(4) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "four"
+  [3]=>
+  string(4) "five"
+}
+array(5) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  string(5) "three"
+  [3]=>
+  string(4) "four"
+  [4]=>
+  string(4) "five"
+}
+array(2) {
+  [0]=>
+  string(4) "four"
+  [1]=>
+  string(4) "five"
+}
+
+*** Variation with first three Arguments ***
+array(3) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "four"
+}
+array(0) {
+}
+array(1) {
+  [0]=>
+  string(3) "two"
+}
+array(3) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  string(5) "three"
+}
+array(0) {
+}
+array(2) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+}
+array(2) {
+  [0]=>
+  string(4) "four"
+  [1]=>
+  string(4) "five"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(3) {
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+  [4]=>
+  string(4) "four"
+}
+array(0) {
+}
+array(1) {
+  [2]=>
+  string(3) "two"
+}
+array(3) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+}
+array(0) {
+}
+array(2) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+array(2) {
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Iteration 7 ***
+
+*** Variation with first two Arguments ***
+array(4) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  int(7)
+  [2]=>
+  string(4) "four"
+  [3]=>
+  string(4) "five"
+}
+array(5) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  int(7)
+  [3]=>
+  string(4) "four"
+  [4]=>
+  string(4) "five"
+}
+array(2) {
+  [0]=>
+  string(4) "four"
+  [1]=>
+  string(4) "five"
+}
+
+*** Variation with first three Arguments ***
+array(3) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  int(7)
+  [2]=>
+  string(4) "four"
+}
+array(0) {
+}
+array(1) {
+  [0]=>
+  string(3) "two"
+}
+array(3) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  int(7)
+}
+array(0) {
+}
+array(2) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+}
+array(2) {
+  [0]=>
+  string(4) "four"
+  [1]=>
+  string(4) "five"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(3) {
+  [2]=>
+  string(3) "two"
+  [3]=>
+  int(7)
+  [4]=>
+  string(4) "four"
+}
+array(0) {
+}
+array(1) {
+  [2]=>
+  string(3) "two"
+}
+array(3) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  int(7)
+}
+array(0) {
+}
+array(2) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+array(2) {
+  [4]=>
+  string(4) "four"
+  [5]=>
+  string(4) "five"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Iteration 8 ***
+
+*** Variation with first two Arguments ***
+array(9) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(6)
+  [""]=>
+  string(5) "blank"
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+  [3]=>
+  float(3.7)
+  [4]=>
+  string(4) "Five"
+  [5]=>
+  float(8.6)
+}
+array(10) {
+  ["f"]=>
+  string(3) "fff"
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(6)
+  [""]=>
+  string(5) "blank"
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+  [3]=>
+  float(3.7)
+  [4]=>
+  string(4) "Five"
+  [5]=>
+  float(8.6)
+}
+array(2) {
+  [0]=>
+  string(4) "Five"
+  [1]=>
+  float(8.6)
+}
+
+*** Variation with first three Arguments ***
+array(3) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(6)
+  [""]=>
+  string(5) "blank"
+}
+array(0) {
+}
+array(6) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(6)
+  [""]=>
+  string(5) "blank"
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+}
+array(3) {
+  ["f"]=>
+  string(3) "fff"
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(6)
+}
+array(0) {
+}
+array(7) {
+  ["f"]=>
+  string(3) "fff"
+  [0]=>
+  string(3) "one"
+  [1]=>
+  int(6)
+  [""]=>
+  string(5) "blank"
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+}
+array(2) {
+  [0]=>
+  string(4) "Five"
+  [1]=>
+  float(8.6)
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(3) {
+  [1]=>
+  string(3) "one"
+  [4]=>
+  int(6)
+  [""]=>
+  string(5) "blank"
+}
+array(0) {
+}
+array(6) {
+  [1]=>
+  string(3) "one"
+  [4]=>
+  int(6)
+  [""]=>
+  string(5) "blank"
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+}
+array(3) {
+  ["f"]=>
+  string(3) "fff"
+  [1]=>
+  string(3) "one"
+  [4]=>
+  int(6)
+}
+array(0) {
+}
+array(7) {
+  ["f"]=>
+  string(3) "fff"
+  [1]=>
+  string(3) "one"
+  [4]=>
+  int(6)
+  [""]=>
+  string(5) "blank"
+  [2]=>
+  string(5) "float"
+  ["F"]=>
+  string(3) "FFF"
+  ["blank"]=>
+  string(0) ""
+}
+array(2) {
+  [5]=>
+  string(4) "Five"
+  [6]=>
+  float(8.6)
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Iteration 9 ***
+
+*** Variation with first two Arguments ***
+array(3) {
+  [0]=>
+  string(4) "name"
+  [1]=>
+  string(3) "age"
+  [2]=>
+  string(2) "45"
+}
+array(4) {
+  [0]=>
+  int(12)
+  [1]=>
+  string(4) "name"
+  [2]=>
+  string(3) "age"
+  [3]=>
+  string(2) "45"
+}
+array(2) {
+  [0]=>
+  string(3) "age"
+  [1]=>
+  string(2) "45"
+}
+
+*** Variation with first three Arguments ***
+array(3) {
+  [0]=>
+  string(4) "name"
+  [1]=>
+  string(3) "age"
+  [2]=>
+  string(2) "45"
+}
+array(0) {
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  int(12)
+  [1]=>
+  string(4) "name"
+  [2]=>
+  string(3) "age"
+}
+array(0) {
+}
+array(1) {
+  [0]=>
+  int(12)
+}
+array(2) {
+  [0]=>
+  string(3) "age"
+  [1]=>
+  string(2) "45"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(3) {
+  [1]=>
+  string(4) "name"
+  [2]=>
+  string(3) "age"
+  [3]=>
+  string(2) "45"
+}
+array(0) {
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  int(12)
+  [1]=>
+  string(4) "name"
+  [2]=>
+  string(3) "age"
+}
+array(0) {
+}
+array(1) {
+  [0]=>
+  int(12)
+}
+array(2) {
+  [2]=>
+  string(3) "age"
+  [3]=>
+  string(2) "45"
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Iteration 10 ***
+
+*** Variation with first two Arguments ***
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [1]=>
+  array(0) {
+  }
+}
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(3) "oNe"
+    [1]=>
+    string(3) "tWo"
+    [2]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [2]=>
+  array(0) {
+  }
+}
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [1]=>
+  array(0) {
+  }
+}
+
+*** Variation with first three Arguments ***
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [1]=>
+  array(0) {
+  }
+}
+array(0) {
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(3) "oNe"
+    [1]=>
+    string(3) "tWo"
+    [2]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [2]=>
+  array(0) {
+  }
+}
+array(0) {
+}
+array(0) {
+}
+array(2) {
+  [0]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [1]=>
+  array(0) {
+  }
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Variation with first two arguments with preserve_key value TRUE ***
+array(2) {
+  [1]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [2]=>
+  array(0) {
+  }
+}
+array(0) {
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(3) "oNe"
+    [1]=>
+    string(3) "tWo"
+    [2]=>
+    int(4)
+  }
+  [1]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [2]=>
+  array(0) {
+  }
+}
+array(0) {
+}
+array(0) {
+}
+array(2) {
+  [1]=>
+  array(5) {
+    [0]=>
+    int(10)
+    [1]=>
+    int(20)
+    [2]=>
+    int(30)
+    [3]=>
+    int(40)
+    [4]=>
+    int(50)
+  }
+  [2]=>
+  array(0) {
+  }
+}
+array(0) {
+}
+array(0) {
+}
+
+*** Typical Variation of offset and length  Arguments ***
+array(1) {
+  [1]=>
+  string(3) "Two"
+}
+array(1) {
+  [0]=>
+  string(3) "Two"
+}
+array(1) {
+  [2]=>
+  string(5) "Three"
+}
+array(1) {
+  [0]=>
+  string(5) "Three"
+}
diff --git a/tests/std/array/array_slice_basic.phpt b/tests/std/array/array_slice_basic.phpt
new file mode 100644
index 00000000..b82e4cc4
--- /dev/null
+++ b/tests/std/array/array_slice_basic.phpt
@@ -0,0 +1,45 @@
+--TEST--
+Test array_slice() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of array_slice()
+ */
+
+echo "*** Testing array_slice() : basic functionality ***\n";
+
+
+$input = array('one' => 1, 'two' => 2, 3, 23 => 4);
+$offset = 2;
+$length = 2;
+$preserve_keys = true;
+
+// Calling array_slice() with all possible arguments
+echo "\n-- All arguments --\n";
+var_dump( array_slice($input, $offset, $length, $preserve_keys) );
+
+// Calling array_slice() with mandatory arguments
+echo "\n-- Mandatory arguments --\n";
+var_dump( array_slice($input, $offset) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_slice() : basic functionality ***
+
+-- All arguments --
+array(2) {
+  [0]=>
+  int(3)
+  [23]=>
+  int(4)
+}
+
+-- Mandatory arguments --
+array(2) {
+  [0]=>
+  int(3)
+  [1]=>
+  int(4)
+}
+Done
diff --git a/tests/std/array/array_slice_variation1.phpt b/tests/std/array/array_slice_variation1.phpt
new file mode 100644
index 00000000..b1d80d3f
--- /dev/null
+++ b/tests/std/array/array_slice_variation1.phpt
@@ -0,0 +1,66 @@
+--TEST--
+Test array_slice() - Third parameter (NULL vs 0)
+--FILE--
+<?php
+
+var_dump(array_slice(range(1, 3), 0, NULL, 1));
+var_dump(array_slice(range(1, 3), 0, 0, 1));
+var_dump(array_slice(range(1, 3), 0, NULL));
+var_dump(array_slice(range(1, 3), 0, 0));
+
+var_dump(array_slice(range(1, 3), -1, 0));
+var_dump(array_slice(range(1, 3), -1, 0, 1));
+var_dump(array_slice(range(1, 3), -1, NULL));
+var_dump(array_slice(range(1, 3), -1, NULL, 1));
+
+
+$a = 'foo';
+try {
+    var_dump(array_slice(range(1, 3), 0, $a));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump(array_slice(range(1, 3), 0, $a));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($a);
+
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(1) {
+  [0]=>
+  int(3)
+}
+array(1) {
+  [2]=>
+  int(3)
+}
+array_slice(): Argument #3 ($length) must be of type ?int, string given
+array_slice(): Argument #3 ($length) must be of type ?int, string given
+string(3) "foo"
diff --git a/tests/std/array/array_slice_variation10.phpt b/tests/std/array/array_slice_variation10.phpt
new file mode 100644
index 00000000..66be016b
--- /dev/null
+++ b/tests/std/array/array_slice_variation10.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Test array_slice() function : usage variations - position of internal array pointer
+--FILE--
+<?php
+/*
+ * Check position of internal array pointer after calling array_slice()
+ */
+
+echo "*** Testing array_slice() : usage variations ***\n";
+
+$input = array ('one' => 'un', 'two' => 'deux', 23 => 'twenty-three', 'zero');
+
+echo "\n-- Call array_slice() --\n";
+var_dump($result = array_slice($input, 2));
+
+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_slice() : usage variations ***
+
+-- Call array_slice() --
+array(2) {
+  [0]=>
+  string(12) "twenty-three"
+  [1]=>
+  string(4) "zero"
+}
+-- Position of Internal Pointer in Result: --
+0 => twenty-three
+
+-- Position of Internal Pointer in Original Array: --
+one => un
+Done
diff --git a/tests/std/array/array_slice_variation11.phpt b/tests/std/array/array_slice_variation11.phpt
new file mode 100644
index 00000000..b69f0174
--- /dev/null
+++ b/tests/std/array/array_slice_variation11.phpt
@@ -0,0 +1,99 @@
+--TEST--
+Test array_slice() function : usage variations - array has holes in buckets
+--FILE--
+<?php
+function dump_slice(array $input, $offsetToUnset, int $offset, int $length)
+{
+    unset($input[$offsetToUnset]);
+    var_dump(array_slice($input, $offset, $length));
+}
+function main()
+{
+    /*
+     * Check that results of array_slice are correct when there are holes in buckets caused by unset()
+     */
+    echo "*** Testing array_slice() : usage variations ***\n";
+    echo "\n-- Call array_slice() on array with string keys--\n";
+    $input = ['one' => 'un', 'two' => 'deux', 23 => 'twenty-three', 'zero'];
+    dump_slice($input, 'two', 0, 1);
+    dump_slice($input, 'two', 0, 2);
+    dump_slice($input, 'two', 0, 3);
+    dump_slice($input, 23, 1, 2);
+    echo "\n-- Call array_slice() on array with packed keys--\n";
+    $input = [10, 11, 12, 'thirteen'];
+    dump_slice($input, 0, 0, 1);
+    dump_slice($input, 1, 0, 1);
+    dump_slice($input, 1, 0, 3);
+    dump_slice($input, 1, -1, 1);
+    dump_slice($input, 1, 0, 3);
+    dump_slice($input, 1, -3, 3);
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_slice() : usage variations ***
+
+-- Call array_slice() on array with string keys--
+array(1) {
+  ["one"]=>
+  string(2) "un"
+}
+array(2) {
+  ["one"]=>
+  string(2) "un"
+  [0]=>
+  string(12) "twenty-three"
+}
+array(3) {
+  ["one"]=>
+  string(2) "un"
+  [0]=>
+  string(12) "twenty-three"
+  [1]=>
+  string(4) "zero"
+}
+array(2) {
+  ["two"]=>
+  string(4) "deux"
+  [0]=>
+  string(4) "zero"
+}
+
+-- Call array_slice() on array with packed keys--
+array(1) {
+  [0]=>
+  int(11)
+}
+array(1) {
+  [0]=>
+  int(10)
+}
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(12)
+  [2]=>
+  string(8) "thirteen"
+}
+array(1) {
+  [0]=>
+  string(8) "thirteen"
+}
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(12)
+  [2]=>
+  string(8) "thirteen"
+}
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(12)
+  [2]=>
+  string(8) "thirteen"
+}
+Done
diff --git a/tests/std/array/array_slice_variation5.phpt b/tests/std/array/array_slice_variation5.phpt
new file mode 100644
index 00000000..e2340695
--- /dev/null
+++ b/tests/std/array/array_slice_variation5.phpt
@@ -0,0 +1,185 @@
+--TEST--
+Test array_slice() function : usage variations - Pass different integers as $offset argument
+--FILE--
+<?php
+/*
+ * Pass different integers as $offset argument to test how array_slice() behaves
+ */
+
+echo "*** Testing array_slice() : usage variations ***\n";
+
+$input = array ('one' => 1, 2 => 'two', 'three', 9 => 'nine', 'ten' => 10);
+
+for ($i = -7; $i <= 7; $i++) {
+    echo "\n-- \$offset is $i --\n";
+    var_dump(array_slice($input, $i));
+}
+echo "\n-- \$offset is maximum integer value --\n";
+var_dump(array_slice($input, PHP_INT_MAX));
+
+echo "\n-- \$offset is minimum integer value --\n";
+var_dump(array_slice($input, -PHP_INT_MAX));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_slice() : usage variations ***
+
+-- $offset is -7 --
+array(5) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is -6 --
+array(5) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is -5 --
+array(5) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is -4 --
+array(4) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is -3 --
+array(3) {
+  [0]=>
+  string(5) "three"
+  [1]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is -2 --
+array(2) {
+  [0]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is -1 --
+array(1) {
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is 0 --
+array(5) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is 1 --
+array(4) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is 2 --
+array(3) {
+  [0]=>
+  string(5) "three"
+  [1]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is 3 --
+array(2) {
+  [0]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is 4 --
+array(1) {
+  ["ten"]=>
+  int(10)
+}
+
+-- $offset is 5 --
+array(0) {
+}
+
+-- $offset is 6 --
+array(0) {
+}
+
+-- $offset is 7 --
+array(0) {
+}
+
+-- $offset is maximum integer value --
+array(0) {
+}
+
+-- $offset is minimum integer value --
+array(5) {
+  ["one"]=>
+  int(1)
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+Done
diff --git a/tests/std/array/array_slice_variation6.phpt b/tests/std/array/array_slice_variation6.phpt
new file mode 100644
index 00000000..f6099e68
--- /dev/null
+++ b/tests/std/array/array_slice_variation6.phpt
@@ -0,0 +1,144 @@
+--TEST--
+Test array_slice() function : usage variations - pass different int values as $length arg
+--FILE--
+<?php
+/*
+ * Pass different integer values as $length argument to array_slice() to test behaviour
+ */
+
+echo "*** Testing array_slice() : usage variations ***\n";
+
+$input = array ('one' => 1, 2 => 'two', 'three', 9 => 'nine', 'ten' => 10);
+$offset = 1;
+
+for ($i = -6; $i <= 6; $i++) {
+    echo "\n-- \$length is $i --\n";
+    var_dump(array_slice($input, $offset, $i));
+}
+echo "\n-- \$length is maximum integer value --\n";
+var_dump(array_slice($input, $offset, PHP_INT_MAX));
+
+echo "\n-- \$length is minimum integer value --\n";
+var_dump(array_slice($input, $offset, -PHP_INT_MAX));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_slice() : usage variations ***
+
+-- $length is -6 --
+array(0) {
+}
+
+-- $length is -5 --
+array(0) {
+}
+
+-- $length is -4 --
+array(0) {
+}
+
+-- $length is -3 --
+array(1) {
+  [0]=>
+  string(3) "two"
+}
+
+-- $length is -2 --
+array(2) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+}
+
+-- $length is -1 --
+array(3) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+}
+
+-- $length is 0 --
+array(0) {
+}
+
+-- $length is 1 --
+array(1) {
+  [0]=>
+  string(3) "two"
+}
+
+-- $length is 2 --
+array(2) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+}
+
+-- $length is 3 --
+array(3) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+}
+
+-- $length is 4 --
+array(4) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $length is 5 --
+array(4) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $length is 6 --
+array(4) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $length is maximum integer value --
+array(4) {
+  [0]=>
+  string(3) "two"
+  [1]=>
+  string(5) "three"
+  [2]=>
+  string(4) "nine"
+  ["ten"]=>
+  int(10)
+}
+
+-- $length is minimum integer value --
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_slice_variation7.phpt b/tests/std/array/array_slice_variation7.phpt
new file mode 100644
index 00000000..58788bd9
--- /dev/null
+++ b/tests/std/array/array_slice_variation7.phpt
@@ -0,0 +1,251 @@
+--TEST--
+Test array_slice() function : usage variations - different data types as keys in an array
+--SKIPIF--
+<?php
+?>
+
+--FILE--
+<?php
+/*
+ * Pass different data types as keys in an array to array_slice()
+ * to test how $preserve_keys treats them
+ */
+
+echo "*** Testing array_slice() : usage variations ***\n";
+
+// Initialise function arguments not being substituted
+$offset = 0;
+$length = 10; // to ensure all elements are displayed
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+$undefined_var = null;
+
+// heredoc string
+$heredoc = <<<EOT
+hello world
+EOT;
+
+// arrays of different data types to be passed as $input
+$inputs = array(
+
+       // int data
+/*1*/  'int' => array(
+       0 => 'zero',
+       1 => 'one',
+       12345 => 'positive',
+       -2345 => 'negative',
+       ),
+
+       // null data
+/*4*/ 'null uppercase' => array(
+       NULL => 'null 1',
+       ),
+
+/*5*/  'null lowercase' => array(
+       null => 'null 2',
+       ),
+
+       // boolean data
+/*6*/ 'bool lowercase' => array(
+       true => 'lowert',
+       false => 'lowerf',
+       ),
+
+/*7*/  'bool uppercase' => array(
+       TRUE => 'uppert',
+       FALSE => 'upperf',
+       ),
+
+       // empty data
+/*8*/ 'empty double quotes' => array(
+       "" => 'emptyd',
+       ),
+
+/*9*/  'empty single quotes' => array(
+       '' => 'emptys',
+       ),
+
+       // string data
+/*10*/ 'string' => array(
+       "stringd" => 'stringd',
+       'strings' => 'strings',
+       $heredoc => 'stringh',
+       ),
+
+       // undefined data
+/*11*/ 'undefined' => array(
+       @$undefined_var => 'undefined',
+       ),
+
+       // unset data
+/*12*/ 'unset' => array(
+       @$unset_var => 'unset',
+       ),
+);
+
+// loop through each element of $inputs to check the behavior of array_slice()
+$iterator = 1;
+foreach($inputs as $type => $input) {
+  echo "\n-- Iteration $iterator : key type is $type --\n";
+  echo "\$preserve_keys = TRUE\n";
+  var_dump( array_slice($input, $offset, $length, true) );
+  echo "\$preserve_keys = FALSE\n";
+  var_dump( array_slice($input, $offset, $length, false) );
+  $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_slice() : usage variations ***
+
+-- Iteration 1 : key type is int --
+$preserve_keys = TRUE
+array(4) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [12345]=>
+  string(8) "positive"
+  [-2345]=>
+  string(8) "negative"
+}
+$preserve_keys = FALSE
+array(4) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(8) "positive"
+  [3]=>
+  string(8) "negative"
+}
+
+-- Iteration 2 : key type is null uppercase --
+$preserve_keys = TRUE
+array(1) {
+  [0]=>
+  string(6) "null 1"
+}
+$preserve_keys = FALSE
+array(1) {
+  [0]=>
+  string(6) "null 1"
+}
+
+-- Iteration 3 : key type is null lowercase --
+$preserve_keys = TRUE
+array(1) {
+  [0]=>
+  string(6) "null 2"
+}
+$preserve_keys = FALSE
+array(1) {
+  [0]=>
+  string(6) "null 2"
+}
+
+-- Iteration 4 : key type is bool lowercase --
+$preserve_keys = TRUE
+array(2) {
+  [1]=>
+  string(6) "lowert"
+  [0]=>
+  string(6) "lowerf"
+}
+$preserve_keys = FALSE
+array(2) {
+  [0]=>
+  string(6) "lowert"
+  [1]=>
+  string(6) "lowerf"
+}
+
+-- Iteration 5 : key type is bool uppercase --
+$preserve_keys = TRUE
+array(2) {
+  [1]=>
+  string(6) "uppert"
+  [0]=>
+  string(6) "upperf"
+}
+$preserve_keys = FALSE
+array(2) {
+  [0]=>
+  string(6) "uppert"
+  [1]=>
+  string(6) "upperf"
+}
+
+-- Iteration 6 : key type is empty double quotes --
+$preserve_keys = TRUE
+array(1) {
+  [""]=>
+  string(6) "emptyd"
+}
+$preserve_keys = FALSE
+array(1) {
+  [""]=>
+  string(6) "emptyd"
+}
+
+-- Iteration 7 : key type is empty single quotes --
+$preserve_keys = TRUE
+array(1) {
+  [""]=>
+  string(6) "emptys"
+}
+$preserve_keys = FALSE
+array(1) {
+  [""]=>
+  string(6) "emptys"
+}
+
+-- Iteration 8 : key type is string --
+$preserve_keys = TRUE
+array(3) {
+  ["stringd"]=>
+  string(7) "stringd"
+  ["strings"]=>
+  string(7) "strings"
+  ["hello world"]=>
+  string(7) "stringh"
+}
+$preserve_keys = FALSE
+array(3) {
+  ["stringd"]=>
+  string(7) "stringd"
+  ["strings"]=>
+  string(7) "strings"
+  ["hello world"]=>
+  string(7) "stringh"
+}
+
+-- Iteration 9 : key type is undefined --
+$preserve_keys = TRUE
+array(1) {
+  [0]=>
+  string(9) "undefined"
+}
+$preserve_keys = FALSE
+array(1) {
+  [0]=>
+  string(9) "undefined"
+}
+
+-- Iteration 10 : key type is unset --
+$preserve_keys = TRUE
+array(1) {
+  [""]=>
+  string(5) "unset"
+}
+$preserve_keys = FALSE
+array(1) {
+  [""]=>
+  string(5) "unset"
+}
+Done
diff --git a/tests/std/array/array_slice_variation8.phpt b/tests/std/array/array_slice_variation8.phpt
new file mode 100644
index 00000000..6e0e8f00
--- /dev/null
+++ b/tests/std/array/array_slice_variation8.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Test array_slice() function : usage variations - multidimensional arrays
+--FILE--
+<?php
+/*
+ * Test array_slice when passed
+ * 1. a two-dimensional array as $input argument
+ * 2. a sub-array as $input argument
+ */
+
+echo "*** Testing array_slice() : usage variations ***\n";
+
+$input = array ('zero', 'one', array('zero', 'un', 'deux'), 9 => 'nine');
+
+echo "\n-- Slice a two-dimensional array --\n";
+var_dump(array_slice($input, 1, 3));
+
+echo "\n-- \$input is a sub-array --\n";
+var_dump(array_slice($input[2], 1, 2));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_slice() : usage variations ***
+
+-- Slice a two-dimensional array --
+array(3) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  array(3) {
+    [0]=>
+    string(4) "zero"
+    [1]=>
+    string(2) "un"
+    [2]=>
+    string(4) "deux"
+  }
+  [2]=>
+  string(4) "nine"
+}
+
+-- $input is a sub-array --
+array(2) {
+  [0]=>
+  string(2) "un"
+  [1]=>
+  string(4) "deux"
+}
+Done
diff --git a/tests/std/array/array_slice_variation9.phpt b/tests/std/array/array_slice_variation9.phpt
new file mode 100644
index 00000000..436ee467
--- /dev/null
+++ b/tests/std/array/array_slice_variation9.phpt
@@ -0,0 +1,46 @@
+--TEST--
+Test array_slice() function : usage variations - referenced variables
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+/*
+ * Test array_slice() when:
+ * 1. Passed an array of referenced variables
+ * 2. $input argument is passed by reference
+ */
+
+echo "*** Testing array_slice() : usage variations ***\n";
+
+$val1 = 'one';
+$val2 = 'two';
+$val3 = 'three';
+
+echo "\n-- Array of referenced variables (\$preserve_keys = default) --\n";
+$input = array(3 => &$val1, 2 => &$val2, 1 => &$val3);
+var_dump(array_slice($input, 1, 2));
+
+echo "-- Change \$val2 (\$preserve_keys = TRUE) --\n";
+$val2 = 'hello, world';
+var_dump(array_slice($input, 1, 2, true));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_slice() : usage variations ***
+
+-- Array of referenced variables ($preserve_keys = default) --
+array(2) {
+  [0]=>
+  &string(3) "two"
+  [1]=>
+  &string(5) "three"
+}
+-- Change $val2 ($preserve_keys = TRUE) --
+array(2) {
+  [2]=>
+  &string(12) "hello, world"
+  [1]=>
+  &string(5) "three"
+}
+Done
diff --git a/tests/std/array/array_splice_basic.phpt b/tests/std/array/array_splice_basic.phpt
new file mode 100644
index 00000000..6396ca75
--- /dev/null
+++ b/tests/std/array/array_splice_basic.phpt
@@ -0,0 +1,135 @@
+--TEST--
+Test array_splice(): basic functionality
+--FILE--
+<?php
+/*
+ * Function is implemented in ext/standard/array.c
+*/
+
+echo "*** Testing array_splice() basic operations ***\n";
+echo "test truncation \n";
+$input = array("red", "green", "blue", "yellow");
+var_dump (array_splice($input, 2));
+var_dump ($input);
+// $input is now array("red", "green")
+
+echo "test truncation with null length \n";
+$input = array("red", "green", "blue", "yellow");
+var_dump (array_splice($input, 2, null));
+var_dump ($input);
+// $input is now array("red", "green")
+
+echo "test removing entries from the middle \n";
+$input = array("red", "green", "blue", "yellow");
+var_dump (array_splice($input, 1, -1));
+var_dump ($input);
+// $input is now array("red", "yellow")
+
+echo "test substitution at end \n";
+$input = array("red", "green", "blue", "yellow");
+var_dump (array_splice($input, 1, count($input), "orange"));
+var_dump ($input);
+// $input is now array("red", "orange")
+
+$input = array("red", "green", "blue", "yellow");
+var_dump (array_splice($input, -1, 1, array("black", "maroon")));
+var_dump ($input);
+// $input is now array("red", "green",
+//          "blue", "black", "maroon")
+
+echo "test insertion \n";
+$input = array("red", "green", "blue", "yellow");
+var_dump (array_splice($input, 3, 0, "purple"));
+var_dump ($input);
+// $input is now array("red", "green",
+//          "blue", "purple", "yellow");
+
+
+?>
+--EXPECT--
+*** Testing array_splice() basic operations ***
+test truncation 
+array(2) {
+  [0]=>
+  string(4) "blue"
+  [1]=>
+  string(6) "yellow"
+}
+array(2) {
+  [0]=>
+  string(3) "red"
+  [1]=>
+  string(5) "green"
+}
+test truncation with null length 
+array(2) {
+  [0]=>
+  string(4) "blue"
+  [1]=>
+  string(6) "yellow"
+}
+array(2) {
+  [0]=>
+  string(3) "red"
+  [1]=>
+  string(5) "green"
+}
+test removing entries from the middle 
+array(2) {
+  [0]=>
+  string(5) "green"
+  [1]=>
+  string(4) "blue"
+}
+array(2) {
+  [0]=>
+  string(3) "red"
+  [1]=>
+  string(6) "yellow"
+}
+test substitution at end 
+array(3) {
+  [0]=>
+  string(5) "green"
+  [1]=>
+  string(4) "blue"
+  [2]=>
+  string(6) "yellow"
+}
+array(2) {
+  [0]=>
+  string(3) "red"
+  [1]=>
+  string(6) "orange"
+}
+array(1) {
+  [0]=>
+  string(6) "yellow"
+}
+array(5) {
+  [0]=>
+  string(3) "red"
+  [1]=>
+  string(5) "green"
+  [2]=>
+  string(4) "blue"
+  [3]=>
+  string(5) "black"
+  [4]=>
+  string(6) "maroon"
+}
+test insertion 
+array(0) {
+}
+array(5) {
+  [0]=>
+  string(3) "red"
+  [1]=>
+  string(5) "green"
+  [2]=>
+  string(4) "blue"
+  [3]=>
+  string(6) "purple"
+  [4]=>
+  string(6) "yellow"
+}
diff --git a/tests/std/array/array_splice_variation1.phpt b/tests/std/array/array_splice_variation1.phpt
new file mode 100644
index 00000000..ab13d75e
--- /dev/null
+++ b/tests/std/array/array_splice_variation1.phpt
@@ -0,0 +1,113 @@
+--TEST--
+Test array_splice() function : usage variations - references
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support dynamic array access");
+?>
+
+--FILE--
+<?php
+/*
+ * Function is implemented in ext/standard/array.c
+*/
+
+
+echo "test behaviour when input array is in a reference set\n";
+
+$input_array=array (array(1,2));
+$input_array[]=&$input_array[0];
+var_dump (array_splice ($input_array[0],1,1));
+var_dump ($input_array);
+
+echo "Test behaviour of input arrays containing references \n";
+/*
+ *  There are three regions to test:, before cut, the cut and after the cut.
+ *  For reach we check a plain value, a reference value with integer key and a
+ *  reference value with a string key.
+ */
+$numbers=array(0,1,2,3,4,5,6,7,8,9,10,11,12);
+$input_array=array(0,1,&$numbers[2],"three"=>&$numbers[3],4,&$numbers[5],"six"=>&$numbers[6],7,&$numbers[8],"nine"=>&$numbers[9]);
+var_dump (array_splice ($input_array,4,3));
+var_dump ($input_array);
+
+echo "Test behaviour of replacement array containing references \n";
+
+$three=3;
+$four=4;
+$input_array=array (0,1,2);
+$b=array(&$three,"fourkey"=>&$four);
+array_splice ($input_array,-1,1,$b);
+var_dump ($input_array);
+
+echo "Test behaviour of replacement which is part of reference set \n";
+
+$int=3;
+$input_array=array (1,2);
+$b=&$int;
+
+array_splice ($input_array,-1,1,$b);
+var_dump ($input_array);
+echo "Done\n";
+?>
+--EXPECT--
+test behaviour when input array is in a reference set
+array(1) {
+  [0]=>
+  int(2)
+}
+array(2) {
+  [0]=>
+  &array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  &array(1) {
+    [0]=>
+    int(1)
+  }
+}
+Test behaviour of input arrays containing references 
+array(3) {
+  [0]=>
+  int(4)
+  [1]=>
+  &int(5)
+  ["six"]=>
+  &int(6)
+}
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  &int(2)
+  ["three"]=>
+  &int(3)
+  [3]=>
+  int(7)
+  [4]=>
+  &int(8)
+  ["nine"]=>
+  &int(9)
+}
+Test behaviour of replacement array containing references 
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  &int(3)
+  [3]=>
+  &int(4)
+}
+Test behaviour of replacement which is part of reference set 
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/array_splice_variation3.phpt b/tests/std/array/array_splice_variation3.phpt
new file mode 100644
index 00000000..d456cdb5
--- /dev/null
+++ b/tests/std/array/array_splice_variation3.phpt
@@ -0,0 +1,844 @@
+--TEST--
+Test array_splice() function : usage variations - lengths and offsets
+--FILE--
+<?php
+function test_splice($offset, $length)
+{
+    echo "  - No replacement\n";
+    $input_array = array(0, 1, 2, 3, 4, 5);
+    var_dump(array_splice($input_array, $offset, $length));
+    var_dump($input_array);
+    echo "  - With replacement\n";
+    $input_array = array(0, 1, 2, 3, 4, 5);
+    var_dump(array_splice($input_array, $offset, $length, array("A", "B", "C")));
+    var_dump($input_array);
+}
+function main()
+{
+    /*
+     * Function is implemented in ext/standard/array.c
+    */
+    echo "*** array_splice() function : usage variations - lengths and offsets\n";
+    echo "absolute offset - absolute length - cut from beginning\n";
+    test_splice(0, 2);
+    echo "absolute offset - absolute length - cut from middle\n";
+    test_splice(2, 2);
+    echo "absolute offset - absolute length - cut from end\n";
+    test_splice(4, 2);
+    echo "absolute offset - absolute length - attempt to cut past end\n";
+    test_splice(4, 4);
+    echo "absolute offset - absolute length - cut everything\n";
+    test_splice(0, 7);
+    echo "absolute offset - absolute length - cut nothing\n";
+    test_splice(3, 0);
+    echo "absolute offset - relative length - cut from beginning\n";
+    test_splice(0, -4);
+    echo "absolute offset - relative length - cut from middle\n";
+    test_splice(2, -2);
+    echo "absolute offset - relative length - attempt to cut form before beginning \n";
+    test_splice(0, -7);
+    echo "absolute offset - relative length - cut nothing\n";
+    test_splice(2, -7);
+    echo "relative offset - absolute length - cut from beginning\n";
+    test_splice(-6, 2);
+    echo "relative offset - absolute length - cut from middle\n";
+    test_splice(-4, 2);
+    echo "relative offset - absolute length - cut from end\n";
+    test_splice(-2, 2);
+    echo "relative offset - absolute length - attempt to cut past end\n";
+    test_splice(-2, 4);
+    echo "relative offset - absolute length - cut everything\n";
+    test_splice(-6, 6);
+    echo "relative offset - absolute length - cut nothing\n";
+    test_splice(-6, 0);
+    echo "relative offset - relative length - cut from beginning\n";
+    test_splice(-6, -4);
+    echo "relative offset - relative length - cut from middle\n";
+    test_splice(-4, -2);
+    echo "relative offset - relative length - cut nothing\n";
+    test_splice(-4, -7);
+    echo "Done\n";
+}
+?>
+--EXPECT--
+*** array_splice() function : usage variations - lengths and offsets
+absolute offset - absolute length - cut from beginning
+  - No replacement
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(4) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(7) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+  [2]=>
+  string(1) "C"
+  [3]=>
+  int(2)
+  [4]=>
+  int(3)
+  [5]=>
+  int(4)
+  [6]=>
+  int(5)
+}
+absolute offset - absolute length - cut from middle
+  - No replacement
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  string(1) "A"
+  [3]=>
+  string(1) "B"
+  [4]=>
+  string(1) "C"
+  [5]=>
+  int(4)
+  [6]=>
+  int(5)
+}
+absolute offset - absolute length - cut from end
+  - No replacement
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  string(1) "A"
+  [5]=>
+  string(1) "B"
+  [6]=>
+  string(1) "C"
+}
+absolute offset - absolute length - attempt to cut past end
+  - No replacement
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  string(1) "A"
+  [5]=>
+  string(1) "B"
+  [6]=>
+  string(1) "C"
+}
+absolute offset - absolute length - cut everything
+  - No replacement
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+array(0) {
+}
+  - With replacement
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+array(3) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+  [2]=>
+  string(1) "C"
+}
+absolute offset - absolute length - cut nothing
+  - No replacement
+array(0) {
+}
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+  - With replacement
+array(0) {
+}
+array(9) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  string(1) "A"
+  [4]=>
+  string(1) "B"
+  [5]=>
+  string(1) "C"
+  [6]=>
+  int(3)
+  [7]=>
+  int(4)
+  [8]=>
+  int(5)
+}
+absolute offset - relative length - cut from beginning
+  - No replacement
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(4) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(7) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+  [2]=>
+  string(1) "C"
+  [3]=>
+  int(2)
+  [4]=>
+  int(3)
+  [5]=>
+  int(4)
+  [6]=>
+  int(5)
+}
+absolute offset - relative length - cut from middle
+  - No replacement
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  string(1) "A"
+  [3]=>
+  string(1) "B"
+  [4]=>
+  string(1) "C"
+  [5]=>
+  int(4)
+  [6]=>
+  int(5)
+}
+absolute offset - relative length - attempt to cut form before beginning 
+  - No replacement
+array(0) {
+}
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+  - With replacement
+array(0) {
+}
+array(9) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+  [2]=>
+  string(1) "C"
+  [3]=>
+  int(0)
+  [4]=>
+  int(1)
+  [5]=>
+  int(2)
+  [6]=>
+  int(3)
+  [7]=>
+  int(4)
+  [8]=>
+  int(5)
+}
+absolute offset - relative length - cut nothing
+  - No replacement
+array(0) {
+}
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+  - With replacement
+array(0) {
+}
+array(9) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  string(1) "A"
+  [3]=>
+  string(1) "B"
+  [4]=>
+  string(1) "C"
+  [5]=>
+  int(2)
+  [6]=>
+  int(3)
+  [7]=>
+  int(4)
+  [8]=>
+  int(5)
+}
+relative offset - absolute length - cut from beginning
+  - No replacement
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(4) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(7) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+  [2]=>
+  string(1) "C"
+  [3]=>
+  int(2)
+  [4]=>
+  int(3)
+  [5]=>
+  int(4)
+  [6]=>
+  int(5)
+}
+relative offset - absolute length - cut from middle
+  - No replacement
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  string(1) "A"
+  [3]=>
+  string(1) "B"
+  [4]=>
+  string(1) "C"
+  [5]=>
+  int(4)
+  [6]=>
+  int(5)
+}
+relative offset - absolute length - cut from end
+  - No replacement
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  string(1) "A"
+  [5]=>
+  string(1) "B"
+  [6]=>
+  string(1) "C"
+}
+relative offset - absolute length - attempt to cut past end
+  - No replacement
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  string(1) "A"
+  [5]=>
+  string(1) "B"
+  [6]=>
+  string(1) "C"
+}
+relative offset - absolute length - cut everything
+  - No replacement
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+array(0) {
+}
+  - With replacement
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+array(3) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+  [2]=>
+  string(1) "C"
+}
+relative offset - absolute length - cut nothing
+  - No replacement
+array(0) {
+}
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+  - With replacement
+array(0) {
+}
+array(9) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+  [2]=>
+  string(1) "C"
+  [3]=>
+  int(0)
+  [4]=>
+  int(1)
+  [5]=>
+  int(2)
+  [6]=>
+  int(3)
+  [7]=>
+  int(4)
+  [8]=>
+  int(5)
+}
+relative offset - relative length - cut from beginning
+  - No replacement
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(4) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(7) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+  [2]=>
+  string(1) "C"
+  [3]=>
+  int(2)
+  [4]=>
+  int(3)
+  [5]=>
+  int(4)
+  [6]=>
+  int(5)
+}
+relative offset - relative length - cut from middle
+  - No replacement
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(4)
+  [3]=>
+  int(5)
+}
+  - With replacement
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  string(1) "A"
+  [3]=>
+  string(1) "B"
+  [4]=>
+  string(1) "C"
+  [5]=>
+  int(4)
+  [6]=>
+  int(5)
+}
+relative offset - relative length - cut nothing
+  - No replacement
+array(0) {
+}
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+  - With replacement
+array(0) {
+}
+array(9) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  string(1) "A"
+  [3]=>
+  string(1) "B"
+  [4]=>
+  string(1) "C"
+  [5]=>
+  int(2)
+  [6]=>
+  int(3)
+  [7]=>
+  int(4)
+  [8]=>
+  int(5)
+}
+Done
diff --git a/tests/std/array/array_splice_variation4.phpt b/tests/std/array/array_splice_variation4.phpt
new file mode 100644
index 00000000..6742b2ff
--- /dev/null
+++ b/tests/std/array/array_splice_variation4.phpt
@@ -0,0 +1,66 @@
+--TEST--
+Test array_splice() function : usage variations - non array replacement values
+--FILE--
+<?php
+/*
+ * Function is implemented in ext/standard/array.c
+*/
+function test_splice($replacement)
+{
+    $input_array = array(0, 1);
+    var_dump(array_splice($input_array, 2, 0, $replacement));
+    var_dump($input_array);
+}
+function main()
+{
+    test_splice(2);
+    test_splice(2.1);
+    test_splice(true);
+    //file type resource
+    $file_handle = fopen(__FILE__, "r");
+    test_splice($file_handle);
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+array(0) {
+}
+array(3) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.1)
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  bool(true)
+}
+array(0) {
+}
+array(3) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  resource(%d) of type (stream)
+}
+Done
diff --git a/tests/std/array/array_sum.phpt b/tests/std/array/array_sum.phpt
new file mode 100644
index 00000000..9ba80beb
--- /dev/null
+++ b/tests/std/array/array_sum.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Test array_sum()
+--INI--
+precision=14
+memory_limit=128M
+--FILE--
+<?php
+$i = 0;
+while ($i++ < 1000) {
+    $a[] = $i;
+    $b[] = (string)$i;
+}
+$s1 = array_sum($a);
+$s2 = array_sum($b);
+var_dump($s1, $s2);
+
+$j = 0;
+while ($j++ < 100000) {
+    $c[] = $j;
+    $d[] = (string) $j;
+}
+$s3 = array_sum($c);
+$s4 = array_sum($d);
+var_dump($s3, $s4);
+?>
+--EXPECTF--
+int(500500)
+int(500500)
+%st(5000050000)
+%st(5000050000)
diff --git a/tests/std/array/array_sum_basic.phpt b/tests/std/array/array_sum_basic.phpt
new file mode 100644
index 00000000..7a7b13e9
--- /dev/null
+++ b/tests/std/array/array_sum_basic.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Test array_sum() function : basic functionality
+--FILE--
+<?php
+echo "*** Testing array_sum() : basic functionality ***\n";
+
+// array with integer values
+$input = array(1, 2, 3, 4, 5);
+echo "-- array_sum() with integer array entries --\n";
+var_dump( array_sum($input) );
+
+// array with float values
+$input = array(1.0, 2.2, 3.4, 4.6);
+echo "-- array_sum() with float array entries --\n";
+var_dump( array_sum($input) );
+
+// array with integer and float values
+$input = array(1, 2.3, 4, 0.6, 10);
+echo "-- array_sum() with integer/float array entries --\n";
+var_dump( array_sum($input) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_sum() : basic functionality ***
+-- array_sum() with integer array entries --
+int(15)
+-- array_sum() with float array entries --
+float(11.2)
+-- array_sum() with integer/float array entries --
+float(17.9)
+Done
diff --git a/tests/std/array/array_sum_empty_array.phpt b/tests/std/array/array_sum_empty_array.phpt
new file mode 100644
index 00000000..17c80ce4
--- /dev/null
+++ b/tests/std/array/array_sum_empty_array.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Test array_sum() function with empty array
+--FILE--
+<?php
+$input = [];
+
+echo "array_sum() version:\n";
+var_dump(array_sum($input));
+
+echo "array_reduce() version:\n";
+var_dump(array_reduce($input, fn($carry, $value) => $carry + $value, 0));
+?>
+--EXPECT--
+array_sum() version:
+int(0)
+array_reduce() version:
+int(0)
diff --git a/tests/std/array/array_sum_objects_operation_no_cast.phpt b/tests/std/array/array_sum_objects_operation_no_cast.phpt
new file mode 100644
index 00000000..d89b44ae
--- /dev/null
+++ b/tests/std/array/array_sum_objects_operation_no_cast.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Test array_sum() function with objects that implement addition but not castable to numeric type
+--EXTENSIONS--
+zend_test
+--FILE--
+<?php
+$input = [new DoOperationNoCast(25), new DoOperationNoCast(6)];
+
+echo "array_sum() version:\n";
+var_dump(array_sum($input));
+
+echo "array_reduce() version:\n";
+var_dump(array_reduce($input, fn($carry, $value) => $carry + $value, 0));
+?>
+--EXPECTF--
+array_sum() version:
+
+Warning: array_sum(): Addition is not supported on type DoOperationNoCast in %s on line %d
+
+Warning: array_sum(): Addition is not supported on type DoOperationNoCast in %s on line %d
+int(0)
+array_reduce() version:
+object(DoOperationNoCast)#5 (1) {
+  ["val":"DoOperationNoCast":private]=>
+  int(31)
+}
diff --git a/tests/std/array/array_sum_objects_operation_no_cast_FFI.phpt b/tests/std/array/array_sum_objects_operation_no_cast_FFI.phpt
new file mode 100644
index 00000000..a43f27b1
--- /dev/null
+++ b/tests/std/array/array_sum_objects_operation_no_cast_FFI.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test array_sum() function with objects that implement addition but not castable to numeric type
+--EXTENSIONS--
+ffi
+--FILE--
+<?php
+
+$x = FFI::cdef()->new("int[2]");
+$x[0] = 10;
+$x[1] = 25;
+
+$input = [$x, 1];
+
+echo "array_sum() version:\n";
+var_dump(array_sum($input));
+
+echo "array_reduce() version:\n";
+var_dump(array_reduce($input, fn($carry, $value) => $carry + $value, 0));
+?>
+--EXPECTF--
+array_sum() version:
+
+Warning: array_sum(): Addition is not supported on type FFI\CData in %s on line %d
+int(1)
+array_reduce() version:
+object(FFI\CData:int32_t*)#4 (1) {
+  [0]=>
+  int(25)
+}
diff --git a/tests/std/array/array_sum_on_reference.phpt b/tests/std/array/array_sum_on_reference.phpt
new file mode 100644
index 00000000..a11da5fd
--- /dev/null
+++ b/tests/std/array/array_sum_on_reference.phpt
@@ -0,0 +1,15 @@
+--TEST--
+array_sum() on array with references
+--FILE--
+<?php
+
+$n = "10";
+$n .= "0";
+$nums = [&$n, 100];
+var_dump(array_sum($nums));
+var_dump($n);
+
+?>
+--EXPECT--
+int(200)
+string(3) "100"
diff --git a/tests/std/array/array_sum_variation2.phpt b/tests/std/array/array_sum_variation2.phpt
new file mode 100644
index 00000000..a4cf7d74
--- /dev/null
+++ b/tests/std/array/array_sum_variation2.phpt
@@ -0,0 +1,44 @@
+--TEST--
+Test array_sum() function : usage variations - array with different integer value
+--FILE--
+<?php
+/*
+* Testing array_sum() with different types of integer arrays containing data of following type:
+*  integer, octal, hexadecimal, maximum and minimum integer values & mixed of all integers
+*/
+
+echo "*** Testing array_sum() : different integer array ***\n";
+
+// Int array
+$int_values = array(3, 2, 100, 150, 25, 350, 0, -3, -1200);
+echo "-- Sum of Integer array --\n";
+var_dump( array_sum($int_values) );
+
+// Octal array
+$octal_values = array(056, 023, 00, 015, -045, 01, -07);
+echo "-- Sum of Octal array --\n";
+var_dump( array_sum($octal_values) );
+
+// Hexadecimal array
+$hex_values = array(0xAE, 0x2B, 0X10, -0xCF, 0X12, -0XF2);
+echo "-- Sum of Hex array --\n";
+var_dump( array_sum($hex_values) );
+
+// Mixed values int, octal & hex
+$mixed_int_value = array(2, 5, -1, 054, 0X3E, 0, -014, -0x2A);
+echo "-- Sum of mixed integer values --\n";
+var_dump( array_sum($mixed_int_value) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_sum() : different integer array ***
+-- Sum of Integer array --
+int(-573)
+-- Sum of Octal array --
+int(35)
+-- Sum of Hex array --
+int(-198)
+-- Sum of mixed integer values --
+int(58)
+Done
diff --git a/tests/std/array/array_sum_variation3.phpt b/tests/std/array/array_sum_variation3.phpt
new file mode 100644
index 00000000..3cb8bc7d
--- /dev/null
+++ b/tests/std/array/array_sum_variation3.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Test array_sum() function : usage variations - array with different float values
+--FILE--
+<?php
+/*
+ * sum of array containing different float values
+*/
+
+echo "*** Testing array_sum() : array with different float values ***\n";
+
+// Simple float array
+$float_input = array( 1.1, 2.3, 0.0, 0.5, -2.3, -0.8, .5);
+echo "-- simple float array --\n";
+var_dump( array_sum($float_input) );
+
+// float array with scientific notations
+$float_input = array( 1.2e2, 23.4e3, -4.1e2, 0.2e2, 2.1e-2, .5e3);
+echo "-- float array with scientific notations e and E --\n";
+var_dump( array_sum($float_input) );
+$float_input = array( 1.2E2, 23.4E3, -4.1E2, 0.2E2, 2.1E-2, .5E3);
+var_dump( array_sum($float_input) );
+
+// Mixed float array
+$float_input = array(
+  1.2,
+  0.5
+  -5.8,
+  6.334,
+  -0.65,
+  1.2e3,
+  -2.3e2,
+  5.56E3,
+  -3.82E-2
+);
+echo "-- Mixed float array --\n";
+var_dump( array_sum($float_input) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_sum() : array with different float values ***
+-- simple float array --
+float(1.3)
+-- float array with scientific notations e and E --
+float(23630.021)
+float(23630.021)
+-- Mixed float array --
+float(6531.5458)
+Done
diff --git a/tests/std/array/array_sum_variation4.phpt b/tests/std/array/array_sum_variation4.phpt
new file mode 100644
index 00000000..22c72ad1
--- /dev/null
+++ b/tests/std/array/array_sum_variation4.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test array_sum() function : usage variations - array with duplicate values
+--FILE--
+<?php
+/*
+* Checking array_sum() with integer and float array containing duplicate values
+*/
+
+echo "*** Testing array_sum() : array with duplicate values ***\n";
+
+// integer array with duplicate values
+$int_input = array( 2, 5, 7, 5, 0, -4, 2, 100);
+echo "-- With integer array --\n";
+var_dump( array_sum($int_input) );
+
+// float array with duplicate values
+$float_input = array( 2.3, 1.9, -4.1, 0.5, 1.9, -4.1, 3.6, 0.5);
+echo "-- With float array --\n";
+var_dump( array_sum($float_input) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_sum() : array with duplicate values ***
+-- With integer array --
+int(117)
+-- With float array --
+float(2.5)
+Done
diff --git a/tests/std/array/array_sum_variation5.phpt b/tests/std/array/array_sum_variation5.phpt
new file mode 100644
index 00000000..f38f4507
--- /dev/null
+++ b/tests/std/array/array_sum_variation5.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Test array_sum() function : usage variations - array with reference variables as elements
+--FILE--
+<?php
+/*
+* Testing array_sum() with 'input' having reference variables as elements
+*/
+
+echo "*** Testing array_sum() : array with elements as reference ***\n";
+
+$value1 = -5;
+$value2 = 100;
+$value3 = 0;
+$value4 = &$value1;
+
+// input array containing elements as reference variables
+$input = array(
+  0 => 10,
+  1 => &$value4,
+  2 => &$value2,
+  3 => 200,
+  4 => &$value3,
+);
+
+var_dump( array_sum($input) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_sum() : array with elements as reference ***
+int(305)
+Done
diff --git a/tests/std/array/array_sum_variation6.phpt b/tests/std/array/array_sum_variation6.phpt
new file mode 100644
index 00000000..e0739ec1
--- /dev/null
+++ b/tests/std/array/array_sum_variation6.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Test array_sum() function : usage variations - associative array
+--FILE--
+<?php
+/*
+* Testing array_sum() with associative array as 'input' argument
+*/
+
+echo "*** Testing array_sum() : with associative array ***\n";
+
+// array with numeric keys
+$input = array(0 => 1, 1 => 10, 2 => 0, 3 => -2, 4 => 23.56);
+echo "-- with numeric keys --\n";
+var_dump( array_sum($input) );
+
+// array with string keys
+$input = array('a' => 20, "b" => 50, 'c' => 0, 'd' => -30, "e" => 100);
+echo "-- with string keys --\n";
+var_dump( array_sum($input) );
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_sum() : with associative array ***
+-- with numeric keys --
+float(32.56)
+-- with string keys --
+int(140)
+Done
diff --git a/tests/std/array/array_sum_variation7.phpt b/tests/std/array/array_sum_variation7.phpt
new file mode 100644
index 00000000..224d0d0a
--- /dev/null
+++ b/tests/std/array/array_sum_variation7.phpt
@@ -0,0 +1,110 @@
+--TEST--
+Test array_sum() function : usage variations - 'input' array with unexpected values as array element
+--SKIPIF--
+<?php
+?>
+--FILE--
+<?php
+/*
+* Testing array_sum() with array having other than numeric entries
+*    strings, bool, null, subarrays & objects
+*/
+
+class MyClass
+{
+  public $value;
+  public function __construct($value)
+  {
+    $this->value = $value;
+  }
+}
+
+function main() {
+echo "*** Testing array_sum() : array with unexpected entries ***\n";
+
+// string array
+$input = array('Apple', 'Banana', 'Carrot', 'Mango', 'Orange');
+echo "-- array with string values --\n";
+var_dump( array_sum($input) );
+
+// bool array
+$input = array( true, true, false, true, false);
+echo "-- array with bool values --\n";
+var_dump( array_sum($input) );
+
+// array with null entry
+$input = array(null, NULL);
+echo "-- array with null values --\n";
+var_dump( array_sum($input) );
+
+// array with subarray
+$input = array(
+  array(1, 2),
+  array(),
+  array(0)
+);
+echo "-- array with subarrays --\n";
+var_dump( array_sum($input) );
+
+// array of objects
+$input = array(
+  new MyClass(2),
+  new MyClass(5),
+  new MyClass(10),
+  new MyClass(0)
+);
+echo "-- array with object values --\n";
+var_dump( array_sum($input) );
+
+// Mixed values
+$input = array( 5, -8, 7.2, -1.2, "10", "apple", 'Mango', true, false, null, NULL, array( array(1,2), array(0), array()));
+echo "-- array with mixed values --\n";
+var_dump( array_sum($input) );
+echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_sum() : array with unexpected entries ***
+-- array with string values --
+
+%s: Addition is not supported on type string in %s on line %d
+
+%s: Addition is not supported on type string in %s on line %d
+
+%s: Addition is not supported on type string in %s on line %d
+
+%s: Addition is not supported on type string in %s on line %d
+
+%s: Addition is not supported on type string in %s on line %d
+int(0)
+-- array with bool values --
+int(3)
+-- array with null values --
+int(0)
+-- array with subarrays --
+
+%s: Addition is not supported on type array in %s on line %d
+
+%s: Addition is not supported on type array in %s on line %d
+
+%s: Addition is not supported on type array in %s on line %d
+int(0)
+-- array with object values --
+
+%s: Addition is not supported on type MyClass in %s on line %d
+
+%s: Addition is not supported on type MyClass in %s on line %d
+
+%s: Addition is not supported on type MyClass in %s on line %d
+
+%s: Addition is not supported on type MyClass in %s on line %d
+int(0)
+-- array with mixed values --
+
+%s: Addition is not supported on type string in %s on line %d
+
+%s: Addition is not supported on type string in %s on line %d
+
+%s: Addition is not supported on type array in %s on line %d
+float(14)
+Done
diff --git a/tests/std/array/array_sum_variation8.phpt b/tests/std/array/array_sum_variation8.phpt
new file mode 100644
index 00000000..21ff8fcf
--- /dev/null
+++ b/tests/std/array/array_sum_variation8.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Test array_sum() function: resources in array
+--FILE--
+<?php
+$input = [10, STDERR /* Should get casted to 3 as an integer */];
+
+echo "array_sum() version:\n";
+var_dump(array_sum($input));
+
+echo "array_reduce() version:\n";
+try {
+    var_dump(array_reduce($input, fn($carry, $value) => $carry + $value, 0));
+} catch (TypeError $e) {
+    echo $e->getMessage();
+}
+?>
+--EXPECTF--
+array_sum() version:
+
+Warning:%S Addition is not supported on type resource in %s on line %d
+int(13)
+array_reduce() version:
+Unsupported operand types: int + resource%S
+%a
diff --git a/tests/std/array/array_sum_variation9.phpt b/tests/std/array/array_sum_variation9.phpt
new file mode 100644
index 00000000..61af56b2
--- /dev/null
+++ b/tests/std/array/array_sum_variation9.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Test array_sum() function with objects castable to numeric type
+--EXTENSIONS--
+gmp
+--FILE--
+<?php
+$input = [gmp_init(25), gmp_init(6)];
+
+echo "array_sum() version:\n";
+var_dump(array_sum($input));
+
+echo "array_reduce() version:\n";
+var_dump(array_reduce($input, fn($carry, $value) => $carry + $value, 0));
+?>
+--EXPECT--
+array_sum() version:
+int(31)
+array_reduce() version:
+object(GMP)#5 (1) {
+  ["num"]=>
+  string(2) "31"
+}
diff --git a/tests/std/array/array_udiff_assoc_basic.phpt b/tests/std/array/array_udiff_assoc_basic.phpt
new file mode 100644
index 00000000..293ff402
--- /dev/null
+++ b/tests/std/array/array_udiff_assoc_basic.phpt
@@ -0,0 +1,48 @@
+--TEST--
+array_udiff_assoc(): Test return type and value for expected input
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+class cr
+{
+    private $priv_member;
+    function __construct($val)
+    {
+        $this->priv_member = $val;
+    }
+    static function comp_func_cr($a, $b)
+    {
+        if ($a->priv_member === $b->priv_member) {
+            return 0;
+        }
+        return $a->priv_member > $b->priv_member ? 1 : -1;
+    }
+}
+function main()
+{
+    $a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1 => new cr(4), 2 => new cr(-15));
+    $b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1 => new cr(4), 2 => new cr(-15));
+    $result = array_udiff_assoc($a, $b, array("cr", "comp_func_cr"));
+    var_dump($result);
+}
+?>
+--EXPECTF--
+array(3) {
+  ["0.1"]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(9)
+  }
+  ["0.5"]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(12)
+  }
+  [0]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(23)
+  }
+}
diff --git a/tests/std/array/array_udiff_assoc_variation.phpt b/tests/std/array/array_udiff_assoc_variation.phpt
new file mode 100644
index 00000000..02afa572
--- /dev/null
+++ b/tests/std/array/array_udiff_assoc_variation.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test array_udiff_assoc() function : variation
+--SKIPIF--
+--FILE--
+<?php
+echo "*** Testing array_udiff_assoc() : variation - testing with multiple array arguments ***\n";
+
+include(__DIR__.'/compare_function.inc');
+$key_compare_function = 'compare_function';
+
+// Initialise all required variables
+$arr1 = array("one" => "one", "02" => "two", '3' => "three", "four", "0.5" => 5, 6 => 6, "seven" => "07");
+$arr2 = array("one" => "one", "02" => "two", '3' => "three");
+$arr3 = array("four", "0.5" => "five", 6 => 6, "seven" => 7);
+$arr4 = array("four", "0.5" => "five", 6 => 6, "seven" => 7);
+
+
+var_dump( array_udiff_assoc($arr1, $arr2, $arr3, $arr4, $key_compare_function) );
+
+
+?>
+--EXPECT--
+*** Testing array_udiff_assoc() : variation - testing with multiple array arguments ***
+array(2) {
+  [4]=>
+  string(4) "four"
+  ["0.5"]=>
+  int(5)
+}
diff --git a/tests/std/array/array_udiff_assoc_variation1.phpt b/tests/std/array/array_udiff_assoc_variation1.phpt
new file mode 100644
index 00000000..1fd8eabb
--- /dev/null
+++ b/tests/std/array/array_udiff_assoc_variation1.phpt
@@ -0,0 +1,161 @@
+--TEST--
+Test array_udiff_assoc() function : usage variation
+--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_udiff_assoc() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array2 = array(1, 2);
+    include 'compare_function.inc';
+    $key_comp_func = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_udiff_assoc($value, $array2, $key_comp_func));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_udiff_assoc() : usage variation ***
+
+--int 0--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_udiff_assoc(): Argument #1 ($array) must be of type array, null given
diff --git a/tests/std/array/array_udiff_assoc_variation2.phpt b/tests/std/array/array_udiff_assoc_variation2.phpt
new file mode 100644
index 00000000..b155ff4a
--- /dev/null
+++ b/tests/std/array/array_udiff_assoc_variation2.phpt
@@ -0,0 +1,161 @@
+--TEST--
+Test array_udiff_assoc() function : usage variation
+--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_udiff_assoc() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array1 = array(1, 2);
+    include 'compare_function.inc';
+    $key_comp_func = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_udiff_assoc($array1, $value, $key_comp_func));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_udiff_assoc() : usage variation ***
+
+--int 0--
+array_udiff_assoc(): Argument #2 must be of type array, int given
+
+--int 1--
+array_udiff_assoc(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_udiff_assoc(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_udiff_assoc(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_udiff_assoc(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_udiff_assoc(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_udiff_assoc(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_udiff_assoc(): Argument #2 must be of type array, float given
+
+--float .5--
+array_udiff_assoc(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_udiff_assoc(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_udiff_assoc(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_udiff_assoc(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_udiff_assoc(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_udiff_assoc(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_udiff_assoc(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_udiff_assoc(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_udiff_assoc(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_udiff_assoc(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_udiff_assoc(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_udiff_assoc(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_udiff_assoc(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_udiff_assoc(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_udiff_assoc(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_udiff_assoc(): Argument #2 must be of type array, null given
+
+--unset var--
+array_udiff_assoc(): Argument #2 must be of type array, null given
diff --git a/tests/std/array/array_udiff_assoc_variation5.phpt b/tests/std/array/array_udiff_assoc_variation5.phpt
new file mode 100644
index 00000000..3ce2c6cf
--- /dev/null
+++ b/tests/std/array/array_udiff_assoc_variation5.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Test array_udiff_assoc() function : usage variation - incorrect comparison functions
+--SKIPIF--
+<?php //die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function incorrect_return_value($val1, $val2)
+{
+    return array(1);
+}
+function too_many_parameters($val1, $val2)
+{
+    return 1;
+}
+function too_few_parameters($val1, $val2)
+{
+    return 1;
+}
+function main()
+{
+    echo "*** Testing array_udiff_assoc() : usage variation - differing comparison functions***\n";
+    $arr1 = array(1);
+    $arr2 = array(1, 2);
+    echo "\n-- comparison function with an incorrect return value --\n";
+    var_dump(array_udiff_assoc($arr1, $arr2, 'incorrect_return_value'));
+    echo "\n-- comparison function taking too many parameters --\n";
+    try {
+        var_dump(array_udiff_assoc($arr1, $arr2, 'too_many_parameters'));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "\n-- comparison function taking too few parameters --\n";
+    var_dump(array_udiff_assoc($arr1, $arr2, 'too_few_parameters'));
+}
+?>
+--EXPECT--
+*** Testing array_udiff_assoc() : usage variation - differing comparison functions***
+
+-- comparison function with an incorrect return value --
+array(1) {
+  [0]=>
+  int(1)
+}
+
+-- comparison function taking too many parameters --
+array(1) {
+  [0]=>
+  int(1)
+}
+
+-- comparison function taking too few parameters --
+array(1) {
+  [0]=>
+  int(1)
+}
diff --git a/tests/std/array/array_udiff_basic.phpt b/tests/std/array/array_udiff_basic.phpt
new file mode 100644
index 00000000..cbac87a8
--- /dev/null
+++ b/tests/std/array/array_udiff_basic.phpt
@@ -0,0 +1,43 @@
+--TEST--
+array_udiff():Test return type and value for expected input
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+class cr
+{
+    private $priv_member;
+    function __construct($val)
+    {
+        $this->priv_member = $val;
+    }
+    static function comp_func_cr($a, $b)
+    {
+        if ($a->priv_member === $b->priv_member) {
+            return 0;
+        }
+        return $a->priv_member > $b->priv_member ? 1 : -1;
+    }
+}
+function main()
+{
+    $a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1 => new cr(4), 2 => new cr(-15));
+    $b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1 => new cr(4), 2 => new cr(-15));
+    $result = array_udiff($a, $b, array("cr", "comp_func_cr"));
+    var_dump($result);
+}
+?>
+--EXPECTF--
+array(2) {
+  ["0.5"]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(12)
+  }
+  [0]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(23)
+  }
+}
diff --git a/tests/std/array/array_udiff_uassoc_basic.phpt b/tests/std/array/array_udiff_uassoc_basic.phpt
new file mode 100644
index 00000000..cbe99767
--- /dev/null
+++ b/tests/std/array/array_udiff_uassoc_basic.phpt
@@ -0,0 +1,55 @@
+--TEST--
+array_udiff_uassoc(): Test return type and value for expected input
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+class cr
+{
+    private $priv_member;
+    function __construct($val)
+    {
+        $this->priv_member = $val;
+    }
+    static function comp_func_cr($a, $b)
+    {
+        if ($a->priv_member === $b->priv_member) {
+            return 0;
+        }
+        return $a->priv_member > $b->priv_member ? 1 : -1;
+    }
+    static function comp_func_key($a, $b)
+    {
+        if ($a === $b) {
+            return 0;
+        }
+        return $a > $b ? 1 : -1;
+    }
+}
+function main()
+{
+    $a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1 => new cr(4), 2 => new cr(-15));
+    $b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1 => new cr(4), 2 => new cr(-15));
+    $result = array_udiff_uassoc($a, $b, array("cr", "comp_func_cr"), array("cr", "comp_func_key"));
+    var_dump($result);
+}
+?>
+--EXPECTF--
+array(3) {
+  ["0.1"]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(9)
+  }
+  ["0.5"]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(12)
+  }
+  [0]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(23)
+  }
+}
diff --git a/tests/std/array/array_udiff_uassoc_variation1.phpt b/tests/std/array/array_udiff_uassoc_variation1.phpt
new file mode 100644
index 00000000..15436670
--- /dev/null
+++ b/tests/std/array/array_udiff_uassoc_variation1.phpt
@@ -0,0 +1,160 @@
+--TEST--
+Test array_udiff_uassoc() function : usage variation
+--SKIPIF--
+<?php
+?>
+
+--FILE--
+<?php
+// define some classes
+class classWithToString
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+class classWithoutToString
+{
+}
+function main()
+{
+    echo "*** Testing array_udiff_uassoc() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array2 = array(1, 2);
+    include __DIR__ . '/compare_function.inc';
+    $data_comp_func = 'compare_function';
+    $key_comp_func = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    $undefined_var = null;
+    // 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,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_udiff_uassoc($value, $array2, $data_comp_func, $key_comp_func));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_udiff_uassoc() : usage variation ***
+
+--int 0--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_udiff_uassoc(): Argument #1 ($array) must be of type array, null given
+
diff --git a/tests/std/array/array_udiff_uassoc_variation2.phpt b/tests/std/array/array_udiff_uassoc_variation2.phpt
new file mode 100644
index 00000000..4aa546e9
--- /dev/null
+++ b/tests/std/array/array_udiff_uassoc_variation2.phpt
@@ -0,0 +1,162 @@
+--TEST--
+Test array_udiff_uassoc() function : usage variation
+--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_udiff_uassoc() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array1 = array(1, 2);
+    include 'compare_function.inc';
+    $data_comp_func = 'compare_function';
+    $key_comp_func = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_udiff_uassoc($array1, $value, $data_comp_func, $key_comp_func));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_udiff_uassoc() : usage variation ***
+
+--int 0--
+array_udiff_uassoc(): Argument #2 must be of type array, int given
+
+--int 1--
+array_udiff_uassoc(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_udiff_uassoc(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_udiff_uassoc(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_udiff_uassoc(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_udiff_uassoc(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_udiff_uassoc(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_udiff_uassoc(): Argument #2 must be of type array, float given
+
+--float .5--
+array_udiff_uassoc(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_udiff_uassoc(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_udiff_uassoc(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_udiff_uassoc(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_udiff_uassoc(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_udiff_uassoc(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_udiff_uassoc(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_udiff_uassoc(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_udiff_uassoc(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_udiff_uassoc(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_udiff_uassoc(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_udiff_uassoc(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_udiff_uassoc(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_udiff_uassoc(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_udiff_uassoc(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_udiff_uassoc(): Argument #2 must be of type array, null given
+
+--unset var--
+array_udiff_uassoc(): Argument #2 must be of type array, null given
diff --git a/tests/std/array/array_udiff_uassoc_variation6.phpt b/tests/std/array/array_udiff_uassoc_variation6.phpt
new file mode 100644
index 00000000..38a26896
--- /dev/null
+++ b/tests/std/array/array_udiff_uassoc_variation6.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Test array_udiff_uassoc() function : usage variation
+--SKIPIF--
+<?php //die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function incorrect_return_value($val1, $val2)
+{
+    return array(1);
+}
+function too_many_parameters($val1, $val2)
+{
+    return 1;
+}
+function too_few_parameters($val1, $val2)
+{
+    return 1;
+}
+function main()
+{
+    echo "*** Testing array_udiff_uassoc() : usage variation - differing comparison functions***\n";
+    $arr1 = array(1);
+    $arr2 = array(1);
+    echo "\n-- comparison function with an incorrect return value --\n";
+    var_dump(array_udiff_uassoc($arr1, $arr2, 'incorrect_return_value', 'incorrect_return_value'));
+    echo "\n-- comparison function taking too many parameters --\n";
+    try {
+        var_dump(array_udiff_uassoc($arr1, $arr2, 'too_many_parameters', 'too_many_parameters'));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "\n-- comparison function taking too few parameters --\n";
+    var_dump(array_udiff_uassoc($arr1, $arr2, 'too_few_parameters', 'too_few_parameters'));
+}
+?>
+--EXPECT--
+*** Testing array_udiff_uassoc() : usage variation - differing comparison functions***
+
+-- comparison function with an incorrect return value --
+array(1) {
+  [0]=>
+  int(1)
+}
+
+-- comparison function taking too many parameters --
+array(1) {
+  [0]=>
+  int(1)
+}
+
+-- comparison function taking too few parameters --
+array(1) {
+  [0]=>
+  int(1)
+}
diff --git a/tests/std/array/array_udiff_variation1.phpt b/tests/std/array/array_udiff_variation1.phpt
new file mode 100644
index 00000000..927d5200
--- /dev/null
+++ b/tests/std/array/array_udiff_variation1.phpt
@@ -0,0 +1,161 @@
+--TEST--
+Test array_udiff() function : usage variation
+--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_udiff() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array2 = array(1, 2);
+    include 'compare_function.inc';
+    $data_comp_func = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_udiff($value, $array2, $data_comp_func));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_udiff() : usage variation ***
+
+--int 0--
+array_udiff(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_udiff(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_udiff(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_udiff(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_udiff(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_udiff(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_udiff(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_udiff(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_udiff(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_udiff(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_udiff(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_udiff(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_udiff(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_udiff(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_udiff(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_udiff(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_udiff(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_udiff(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_udiff(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_udiff(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_udiff(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_udiff(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_udiff(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_udiff(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_udiff(): Argument #1 ($array) must be of type array, null given
diff --git a/tests/std/array/array_udiff_variation2.phpt b/tests/std/array/array_udiff_variation2.phpt
new file mode 100644
index 00000000..0035949f
--- /dev/null
+++ b/tests/std/array/array_udiff_variation2.phpt
@@ -0,0 +1,161 @@
+--TEST--
+Test array_udiff() function : usage variation
+--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_udiff() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array1 = array(1, 2);
+    include 'compare_function.inc';
+    $data_comp_func = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_udiff($array1, $value, $data_comp_func));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_udiff() : usage variation ***
+
+--int 0--
+array_udiff(): Argument #2 must be of type array, int given
+
+--int 1--
+array_udiff(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_udiff(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_udiff(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_udiff(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_udiff(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_udiff(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_udiff(): Argument #2 must be of type array, float given
+
+--float .5--
+array_udiff(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_udiff(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_udiff(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_udiff(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_udiff(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_udiff(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_udiff(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_udiff(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_udiff(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_udiff(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_udiff(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_udiff(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_udiff(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_udiff(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_udiff(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_udiff(): Argument #2 must be of type array, null given
+
+--unset var--
+array_udiff(): Argument #2 must be of type array, null given
diff --git a/tests/std/array/array_udiff_variation5.phpt b/tests/std/array/array_udiff_variation5.phpt
new file mode 100644
index 00000000..21a58df8
--- /dev/null
+++ b/tests/std/array/array_udiff_variation5.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Test array_udiff() function : usage variation
+--SKIPIF--
+<?php //die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function incorrect_return_value($val1, $val2)
+{
+    return array(1);
+}
+function too_many_parameters($val1, $val2)
+{
+    return 0;
+}
+function too_few_parameters($val1, $val2)
+{
+    return 0;
+}
+function main()
+{
+    echo "*** Testing array_udiff() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $arr1 = array(1);
+    $arr2 = array(1);
+    echo "\n-- comparison function with an incorrect return value --\n";
+    var_dump(array_udiff($arr1, $arr2, 'incorrect_return_value'));
+    echo "\n-- comparison function taking too many parameters --\n";
+    try {
+        var_dump(array_udiff($arr1, $arr2, 'too_many_parameters'));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "\n-- comparison function taking too few parameters --\n";
+    var_dump(array_udiff($arr1, $arr2, 'too_few_parameters'));
+}
+?>
+--EXPECT--
+*** Testing array_udiff() : usage variation ***
+
+-- comparison function with an incorrect return value --
+array(1) {
+  [0]=>
+  int(1)
+}
+
+-- comparison function taking too many parameters --
+array(0) {
+}
+
+-- comparison function taking too few parameters --
+array(0) {
+}
diff --git a/tests/std/array/array_uintersect_assoc_basic.phpt b/tests/std/array/array_uintersect_assoc_basic.phpt
new file mode 100644
index 00000000..0b8e6b5f
--- /dev/null
+++ b/tests/std/array/array_uintersect_assoc_basic.phpt
@@ -0,0 +1,43 @@
+--TEST--
+array_uintersect_assoc(): Test return type and value for expected input
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+class cr
+{
+    private $priv_member;
+    function __construct($val)
+    {
+        $this->priv_member = $val;
+    }
+    static function comp_func_cr($a, $b)
+    {
+        if ($a->priv_member === $b->priv_member) {
+            return 0;
+        }
+        return $a->priv_member > $b->priv_member ? 1 : -1;
+    }
+}
+function main()
+{
+    $a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1 => new cr(4), 2 => new cr(-15));
+    $b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1 => new cr(4), 2 => new cr(-15));
+    $result = array_uintersect_assoc($a, $b, array("cr", "comp_func_cr"));
+    var_dump($result);
+}
+?>
+--EXPECTF--
+array(2) {
+  [1]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(4)
+  }
+  [2]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(-15)
+  }
+}
diff --git a/tests/std/array/array_uintersect_assoc_basic2.phpt b/tests/std/array/array_uintersect_assoc_basic2.phpt
new file mode 100644
index 00000000..47bb916e
--- /dev/null
+++ b/tests/std/array/array_uintersect_assoc_basic2.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test array_uintersect_assoc() function : basic functionality - testing with multiple array arguments
+--SKIPIF--
+--FILE--
+<?php
+echo "*** Testing array_uintersect_assoc() : basic functionality - testing with multiple array arguments ***\n";
+
+include(__DIR__.'/compare_function.inc');
+$data_compare_function = 'compare_function';
+
+// Initialise all required variables
+$arr1 = array("one" => "one", "02" => "two", '3' => "three", "four", "0.5" => 5, 0 => 6, "0x7" => "seven");
+$arr2 = array("one" => "one", "02" => "two", '3' => "three");
+$arr3 = array("one" => "one", '3' => "three", "0.5" => 5);
+$arr4 = array("one" => "one", '3' => "three", "0.5" => 5);
+
+
+var_dump( array_uintersect_assoc($arr1, $arr2, $arr3, $arr4, $data_compare_function) );
+
+
+?>
+--EXPECT--
+*** Testing array_uintersect_assoc() : basic functionality - testing with multiple array arguments ***
+array(2) {
+  ["one"]=>
+  string(3) "one"
+  [3]=>
+  string(5) "three"
+}
diff --git a/tests/std/array/array_uintersect_assoc_variation1.phpt b/tests/std/array/array_uintersect_assoc_variation1.phpt
new file mode 100644
index 00000000..1f70e037
--- /dev/null
+++ b/tests/std/array/array_uintersect_assoc_variation1.phpt
@@ -0,0 +1,161 @@
+--TEST--
+Test array_uintersect_assoc() function : usage variation
+--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_uintersect_assoc() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array2 = array(1, 2);
+    include 'compare_function.inc';
+    $data_compare_function = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_uintersect_assoc($value, $array2, $data_compare_function));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_uintersect_assoc() : usage variation ***
+
+--int 0--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_uintersect_assoc(): Argument #1 ($array) must be of type array, null given
diff --git a/tests/std/array/array_uintersect_assoc_variation2.phpt b/tests/std/array/array_uintersect_assoc_variation2.phpt
new file mode 100644
index 00000000..ccef8840
--- /dev/null
+++ b/tests/std/array/array_uintersect_assoc_variation2.phpt
@@ -0,0 +1,161 @@
+--TEST--
+Test array_uintersect_assoc() function : usage variation
+--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_uintersect_assoc() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array1 = array(1, 2);
+    include 'compare_function.inc';
+    $data_compare_function = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_uintersect_assoc($array1, $value, $data_compare_function));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_uintersect_assoc() : usage variation ***
+
+--int 0--
+array_uintersect_assoc(): Argument #2 must be of type array, int given
+
+--int 1--
+array_uintersect_assoc(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_uintersect_assoc(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_uintersect_assoc(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_uintersect_assoc(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_uintersect_assoc(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_uintersect_assoc(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_uintersect_assoc(): Argument #2 must be of type array, float given
+
+--float .5--
+array_uintersect_assoc(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_uintersect_assoc(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_uintersect_assoc(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_uintersect_assoc(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_uintersect_assoc(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_uintersect_assoc(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_uintersect_assoc(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_uintersect_assoc(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_uintersect_assoc(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_uintersect_assoc(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_uintersect_assoc(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_uintersect_assoc(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_uintersect_assoc(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_uintersect_assoc(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_uintersect_assoc(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_uintersect_assoc(): Argument #2 must be of type array, null given
+
+--unset var--
+array_uintersect_assoc(): Argument #2 must be of type array, null given
diff --git a/tests/std/array/array_uintersect_assoc_variation5.phpt b/tests/std/array/array_uintersect_assoc_variation5.phpt
new file mode 100644
index 00000000..94fefc47
--- /dev/null
+++ b/tests/std/array/array_uintersect_assoc_variation5.phpt
@@ -0,0 +1,51 @@
+--TEST--
+Test array_uintersect_assoc() function : usage variation - differing comparison functions
+--SKIPIF--
+<?php //die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function incorrect_return_value($val1, $val2)
+{
+    return array(1);
+}
+function too_many_parameters($val1, $val2)
+{
+    return 1;
+}
+function too_few_parameters($val1, $val2)
+{
+    return 1;
+}
+function main()
+{
+    echo "*** Testing array_uintersect_assoc() : usage variation - differing comparison functions***\n";
+    $arr1 = array(1);
+    $arr2 = array(1, 2);
+    echo "\n-- comparison function with an incorrect return value --\n";
+    var_dump(array_uintersect_assoc($arr1, $arr2, 'incorrect_return_value'));
+    echo "\n-- comparison function taking too many parameters --\n";
+    try {
+        var_dump(array_uintersect_assoc($arr1, $arr2, 'too_many_parameters'));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "\n-- comparison function taking too few parameters --\n";
+    var_dump(array_uintersect_assoc($arr1, $arr2, 'too_few_parameters'));
+}
+?>
+--EXPECT--
+*** Testing array_uintersect_assoc() : usage variation - differing comparison functions***
+
+-- comparison function with an incorrect return value --
+array(0) {
+}
+
+-- comparison function taking too many parameters --
+array(0) {
+}
+
+-- comparison function taking too few parameters --
+array(0) {
+}
+
diff --git a/tests/std/array/array_uintersect_basic.phpt b/tests/std/array/array_uintersect_basic.phpt
new file mode 100644
index 00000000..7444cc07
--- /dev/null
+++ b/tests/std/array/array_uintersect_basic.phpt
@@ -0,0 +1,48 @@
+--TEST--
+array_uintersect(): Test return type and value for expected input
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+class cr
+{
+    private $priv_member;
+    function __construct($val)
+    {
+        $this->priv_member = $val;
+    }
+    static function comp_func_cr($a, $b)
+    {
+        if ($a->priv_member === $b->priv_member) {
+            return 0;
+        }
+        return $a->priv_member > $b->priv_member ? 1 : -1;
+    }
+}
+function main()
+{
+    $a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1 => new cr(4), 2 => new cr(-15));
+    $b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1 => new cr(4), 2 => new cr(-15));
+    $result = array_uintersect($a, $b, array("cr", "comp_func_cr"));
+    var_dump($result);
+}
+?>
+--EXPECTF--
+array(3) {
+  ["0.1"]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(9)
+  }
+  [1]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(4)
+  }
+  [2]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(-15)
+  }
+}
diff --git a/tests/std/array/array_uintersect_uassoc_basic.phpt b/tests/std/array/array_uintersect_uassoc_basic.phpt
new file mode 100644
index 00000000..8f4e3afd
--- /dev/null
+++ b/tests/std/array/array_uintersect_uassoc_basic.phpt
@@ -0,0 +1,50 @@
+--TEST--
+array_uintersect_uassoc(): Test return type and value for expected input
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+class cr
+{
+    private $priv_member;
+    function __construct($val)
+    {
+        $this->priv_member = $val;
+    }
+    static function comp_func_cr($a, $b)
+    {
+        if ($a->priv_member === $b->priv_member) {
+            return 0;
+        }
+        return $a->priv_member > $b->priv_member ? 1 : -1;
+    }
+    static function comp_func_key($a, $b)
+    {
+        if ($a === $b) {
+            return 0;
+        }
+        return $a > $b ? 1 : -1;
+    }
+}
+function main()
+{
+    $a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1 => new cr(4), 2 => new cr(-15));
+    $b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1 => new cr(4), 2 => new cr(-15));
+    $result = array_uintersect_uassoc($a, $b, array("cr", "comp_func_cr"), array("cr", "comp_func_key"));
+    var_dump($result);
+}
+?>
+--EXPECTF--
+array(2) {
+  [1]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(4)
+  }
+  [2]=>
+  object(cr)#%d (1) {
+    ["priv_member":"cr":private]=>
+    int(-15)
+  }
+}
diff --git a/tests/std/array/array_uintersect_uassoc_variation1.phpt b/tests/std/array/array_uintersect_uassoc_variation1.phpt
new file mode 100644
index 00000000..9478f908
--- /dev/null
+++ b/tests/std/array/array_uintersect_uassoc_variation1.phpt
@@ -0,0 +1,162 @@
+--TEST--
+Test array_uintersect_uassoc() function : usage variation
+--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_uintersect_uassoc() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array2 = array(1, 2);
+    include 'compare_function.inc';
+    $data_compare_func = 'compare_function';
+    $key_compare_func = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_uintersect_uassoc($value, $array2, $data_compare_func, $key_compare_func));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_uintersect_uassoc() : usage variation ***
+
+--int 0--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_uintersect_uassoc(): Argument #1 ($array) must be of type array, null given
diff --git a/tests/std/array/array_uintersect_uassoc_variation2.phpt b/tests/std/array/array_uintersect_uassoc_variation2.phpt
new file mode 100644
index 00000000..85793cd1
--- /dev/null
+++ b/tests/std/array/array_uintersect_uassoc_variation2.phpt
@@ -0,0 +1,162 @@
+--TEST--
+Test array_uintersect_uassoc() function : usage variation
+--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_uintersect_uassoc() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array1 = array(1, 2);
+    include 'compare_function.inc';
+    $data_compare_func = 'compare_function';
+    $key_compare_func = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_uintersect_uassoc($array1, $value, $data_compare_func, $key_compare_func));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_uintersect_uassoc() : usage variation ***
+
+--int 0--
+array_uintersect_uassoc(): Argument #2 must be of type array, int given
+
+--int 1--
+array_uintersect_uassoc(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_uintersect_uassoc(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_uintersect_uassoc(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_uintersect_uassoc(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_uintersect_uassoc(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_uintersect_uassoc(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_uintersect_uassoc(): Argument #2 must be of type array, float given
+
+--float .5--
+array_uintersect_uassoc(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_uintersect_uassoc(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_uintersect_uassoc(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_uintersect_uassoc(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_uintersect_uassoc(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_uintersect_uassoc(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_uintersect_uassoc(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_uintersect_uassoc(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_uintersect_uassoc(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_uintersect_uassoc(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_uintersect_uassoc(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_uintersect_uassoc(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_uintersect_uassoc(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_uintersect_uassoc(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_uintersect_uassoc(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_uintersect_uassoc(): Argument #2 must be of type array, null given
+
+--unset var--
+array_uintersect_uassoc(): Argument #2 must be of type array, null given
diff --git a/tests/std/array/array_uintersect_uassoc_variation6.phpt b/tests/std/array/array_uintersect_uassoc_variation6.phpt
new file mode 100644
index 00000000..54d4ecfb
--- /dev/null
+++ b/tests/std/array/array_uintersect_uassoc_variation6.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Test array_uintersect_uassoc() function : usage variation - incorrect callbacks
+--SKIPIF--
+<?php //die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function incorrect_return_value($val1, $val2)
+{
+    return array(1);
+}
+function too_many_parameters($val1, $val2)
+{
+    return 1;
+}
+function too_few_parameters($val1, $val2)
+{
+    return 1;
+}
+function main()
+{
+    echo "*** Testing array_uintersect_uassoc() : usage variation - incorrect callbacks ***\n";
+    $arr1 = array(1);
+    $arr2 = array(1, 2);
+    echo "\n-- comparison function with an incorrect return value --\n";
+    var_dump(array_uintersect_uassoc($arr1, $arr2, 'incorrect_return_value', 'incorrect_return_value'));
+    echo "\n-- comparison function taking too many parameters --\n";
+    try {
+        var_dump(array_uintersect_uassoc($arr1, $arr2, 'too_many_parameters', 'too_many_parameters'));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "\n-- comparison function taking too few parameters --\n";
+    var_dump(array_uintersect_uassoc($arr1, $arr2, 'too_few_parameters', 'too_few_parameters'));
+}
+?>
+--EXPECT--
+*** Testing array_uintersect_uassoc() : usage variation - incorrect callbacks ***
+
+-- comparison function with an incorrect return value --
+array(0) {
+}
+
+-- comparison function taking too many parameters --
+array(0) {
+}
+
+-- comparison function taking too few parameters --
+array(0) {
+}
diff --git a/tests/std/array/array_uintersect_variation1.phpt b/tests/std/array/array_uintersect_variation1.phpt
new file mode 100644
index 00000000..f482c7a9
--- /dev/null
+++ b/tests/std/array/array_uintersect_variation1.phpt
@@ -0,0 +1,161 @@
+--TEST--
+Test array_uintersect() function : usage variation
+--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_uintersect() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array2 = array(1, 2);
+    include 'compare_function.inc';
+    $data_compare_function = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array1
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_uintersect($value, $array2, $data_compare_function));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_uintersect() : usage variation ***
+
+--int 0--
+array_uintersect(): Argument #1 ($array) must be of type array, int given
+
+--int 1--
+array_uintersect(): Argument #1 ($array) must be of type array, int given
+
+--int 12345--
+array_uintersect(): Argument #1 ($array) must be of type array, int given
+
+--int -12345--
+array_uintersect(): Argument #1 ($array) must be of type array, int given
+
+--float 10.5--
+array_uintersect(): Argument #1 ($array) must be of type array, float given
+
+--float -10.5--
+array_uintersect(): Argument #1 ($array) must be of type array, float given
+
+--float 12.3456789000e10--
+array_uintersect(): Argument #1 ($array) must be of type array, float given
+
+--float -12.3456789000e10--
+array_uintersect(): Argument #1 ($array) must be of type array, float given
+
+--float .5--
+array_uintersect(): Argument #1 ($array) must be of type array, float given
+
+--uppercase NULL--
+array_uintersect(): Argument #1 ($array) must be of type array, null given
+
+--lowercase null--
+array_uintersect(): Argument #1 ($array) must be of type array, null given
+
+--lowercase true--
+array_uintersect(): Argument #1 ($array) must be of type array, true given
+
+--lowercase false--
+array_uintersect(): Argument #1 ($array) must be of type array, false given
+
+--uppercase TRUE--
+array_uintersect(): Argument #1 ($array) must be of type array, true given
+
+--uppercase FALSE--
+array_uintersect(): Argument #1 ($array) must be of type array, false given
+
+--empty string DQ--
+array_uintersect(): Argument #1 ($array) must be of type array, string given
+
+--empty string SQ--
+array_uintersect(): Argument #1 ($array) must be of type array, string given
+
+--string DQ--
+array_uintersect(): Argument #1 ($array) must be of type array, string given
+
+--string SQ--
+array_uintersect(): Argument #1 ($array) must be of type array, string given
+
+--mixed case string--
+array_uintersect(): Argument #1 ($array) must be of type array, string given
+
+--heredoc--
+array_uintersect(): Argument #1 ($array) must be of type array, string given
+
+--instance of classWithToString--
+array_uintersect(): Argument #1 ($array) must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_uintersect(): Argument #1 ($array) must be of type array, classWithoutToString given
+
+--undefined var--
+array_uintersect(): Argument #1 ($array) must be of type array, null given
+
+--unset var--
+array_uintersect(): Argument #1 ($array) must be of type array, null given
diff --git a/tests/std/array/array_uintersect_variation2.phpt b/tests/std/array/array_uintersect_variation2.phpt
new file mode 100644
index 00000000..6076204d
--- /dev/null
+++ b/tests/std/array/array_uintersect_variation2.phpt
@@ -0,0 +1,161 @@
+--TEST--
+Test array_uintersect() function : usage variation
+--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_uintersect() : usage variation ***\n";
+    // Initialise function arguments not being substituted (if any)
+    $array1 = array(1, 2);
+    include 'compare_function.inc';
+    $data_compare_function = 'compare_function';
+    //get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // 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,
+    );
+    // loop through each element of the array for array2
+    foreach ($inputs as $key => $value) {
+        echo "\n--{$key}--\n";
+        try {
+            var_dump(array_uintersect($array1, $value, $data_compare_function));
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+?>
+--EXPECT--
+*** Testing array_uintersect() : usage variation ***
+
+--int 0--
+array_uintersect(): Argument #2 must be of type array, int given
+
+--int 1--
+array_uintersect(): Argument #2 must be of type array, int given
+
+--int 12345--
+array_uintersect(): Argument #2 must be of type array, int given
+
+--int -12345--
+array_uintersect(): Argument #2 must be of type array, int given
+
+--float 10.5--
+array_uintersect(): Argument #2 must be of type array, float given
+
+--float -10.5--
+array_uintersect(): Argument #2 must be of type array, float given
+
+--float 12.3456789000e10--
+array_uintersect(): Argument #2 must be of type array, float given
+
+--float -12.3456789000e10--
+array_uintersect(): Argument #2 must be of type array, float given
+
+--float .5--
+array_uintersect(): Argument #2 must be of type array, float given
+
+--uppercase NULL--
+array_uintersect(): Argument #2 must be of type array, null given
+
+--lowercase null--
+array_uintersect(): Argument #2 must be of type array, null given
+
+--lowercase true--
+array_uintersect(): Argument #2 must be of type array, true given
+
+--lowercase false--
+array_uintersect(): Argument #2 must be of type array, false given
+
+--uppercase TRUE--
+array_uintersect(): Argument #2 must be of type array, true given
+
+--uppercase FALSE--
+array_uintersect(): Argument #2 must be of type array, false given
+
+--empty string DQ--
+array_uintersect(): Argument #2 must be of type array, string given
+
+--empty string SQ--
+array_uintersect(): Argument #2 must be of type array, string given
+
+--string DQ--
+array_uintersect(): Argument #2 must be of type array, string given
+
+--string SQ--
+array_uintersect(): Argument #2 must be of type array, string given
+
+--mixed case string--
+array_uintersect(): Argument #2 must be of type array, string given
+
+--heredoc--
+array_uintersect(): Argument #2 must be of type array, string given
+
+--instance of classWithToString--
+array_uintersect(): Argument #2 must be of type array, classWithToString given
+
+--instance of classWithoutToString--
+array_uintersect(): Argument #2 must be of type array, classWithoutToString given
+
+--undefined var--
+array_uintersect(): Argument #2 must be of type array, null given
+
+--unset var--
+array_uintersect(): Argument #2 must be of type array, null given
diff --git a/tests/std/array/array_uintersect_variation5.phpt b/tests/std/array/array_uintersect_variation5.phpt
new file mode 100644
index 00000000..e3ad1e5a
--- /dev/null
+++ b/tests/std/array/array_uintersect_variation5.phpt
@@ -0,0 +1,51 @@
+--TEST--
+Test array_uintersect() function : usage variation - differing comparison functions
+--SKIPIF--
+<?php //die("skip AOT does not support string-based callbacks"); ?>
+
+--FILE--
+<?php
+function incorrect_return_value($val1, $val2)
+{
+    return array(1);
+}
+function too_many_parameters($val1, $val2)
+{
+    return 1;
+}
+function too_few_parameters($val1, $val2)
+{
+    return 1;
+}
+function main()
+{
+    echo "*** Testing array_uintersect() : usage variation - differing comparison functions***\n";
+    $arr1 = array(1);
+    $arr2 = array(1, 2);
+    echo "\n-- comparison function with an incorrect return value --\n";
+    var_dump(array_uintersect($arr1, $arr2, 'incorrect_return_value'));
+    echo "\n-- comparison function taking too many parameters --\n";
+    try {
+        var_dump(array_uintersect($arr1, $arr2, 'too_many_parameters'));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "\n-- comparison function taking too few parameters --\n";
+    var_dump(array_uintersect($arr1, $arr2, 'too_few_parameters'));
+}
+?>
+--EXPECT--
+*** Testing array_uintersect() : usage variation - differing comparison functions***
+
+-- comparison function with an incorrect return value --
+array(0) {
+}
+
+-- comparison function taking too many parameters --
+array(0) {
+}
+
+-- comparison function taking too few parameters --
+array(0) {
+}
+
diff --git a/tests/std/array/array_unique_basic.phpt b/tests/std/array/array_unique_basic.phpt
new file mode 100644
index 00000000..d76c2e34
--- /dev/null
+++ b/tests/std/array/array_unique_basic.phpt
@@ -0,0 +1,43 @@
+--TEST--
+Test array_unique() function : basic functionality
+--FILE--
+<?php
+echo "*** Testing array_unique() : basic functionality ***\n";
+
+// array with default keys
+$input = array(1, 2, "1", '2');
+var_dump( array_unique($input) );
+
+// associative array
+$input = array("1" => "one", 1 => "one", 2 => "two", '2' => "two");
+var_dump( array_unique($input) );
+
+// mixed array
+$input = array("1" => "one", "two", "one", 2 => "two", "three");
+var_dump( array_unique($input) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unique() : basic functionality ***
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+array(3) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [4]=>
+  string(5) "three"
+}
+Done
diff --git a/tests/std/array/array_unique_variation2.phpt b/tests/std/array/array_unique_variation2.phpt
new file mode 100644
index 00000000..736aefdb
--- /dev/null
+++ b/tests/std/array/array_unique_variation2.phpt
@@ -0,0 +1,229 @@
+--TEST--
+Test array_unique() function : usage variations - different arrays for 'input' argument
+--SKIPIF--
+<?php die("skip AOT empty string key handling differs from PHP"); ?>
+--FILE--
+<?php
+/*
+* Passing different arrays to $input argument and testing whether
+* array_unique() behaves in an expected way.
+*/
+
+echo "*** Testing array_unique() : Passing different arrays to \$input 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 $input argument
+$inputs = array (
+/*1*/  array(1, 2, 2, 1), // with default keys and numeric values
+       array(1.1, 2.2, 1.1), // with default keys & float values
+       array(false, true, false), // with default keys and boolean values
+       array(), // empty array
+/*5*/  array(NULL, null), // with NULL
+       array("a\v\f", "aaaa\r", "b", "aaaa\r", "\[\]\!\@\#\$\%\^\&\*\(\)\{\}"),  // with double quoted strings
+       array('a\v\f', 'aaaa\r', 'b', 'aaaa\r', '\[\]\!\@\#\$\%\^\&\*\(\)\{\}'),  // with single quoted strings
+       array("h1" => $blank_line, "h2" => $multiline_string, "h3" => $diff_whitespaces, $blank_line),  // with heredocs
+
+       // associative arrays
+/*9*/  array(1 => "one", 2 => "two", 2 => "two"),  // explicit numeric keys, string values
+       array("one" => 1, "two" => 2, "1" => 1 ),  // string keys & numeric values
+       array( 1 => 10, 2 => 20, 4 => 40, 5 => 10),  // explicit numeric keys and numeric values
+       array( "one" => "ten", "two" => "twenty", "10" => "ten"),  // 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),
+/*18*/ array('' => 1, "" => 2, NULL => 3, null => 4, false => 5, true => 6),
+);
+
+// loop through each sub-array of $inputs to check the behavior of array_unique()
+$iterator = 1;
+foreach($inputs as $input) {
+  echo "-- Iteration $iterator --\n";
+  var_dump( array_unique($input, SORT_STRING) );
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unique() : Passing different arrays to $input argument ***
+-- Iteration 1 --
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+-- Iteration 2 --
+array(2) {
+  [0]=>
+  float(1.1)
+  [1]=>
+  float(2.2)
+}
+-- Iteration 3 --
+array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+-- Iteration 4 --
+array(0) {
+}
+-- Iteration 5 --
+array(1) {
+  [0]=>
+  NULL
+}
+-- Iteration 6 --
+array(4) {
+  [0]=>
+  string(3) "a"
+  [1]=>
+  string(5) "aaaa
"
+  [2]=>
+  string(1) "b"
+  [4]=>
+  string(27) "\[\]\!\@\#$\%\^\&\*\(\)\{\}"
+}
+-- Iteration 7 --
+array(4) {
+  [0]=>
+  string(5) "a\v\f"
+  [1]=>
+  string(6) "aaaa\r"
+  [2]=>
+  string(1) "b"
+  [4]=>
+  string(28) "\[\]\!\@\#\$\%\^\&\*\(\)\{\}"
+}
+-- Iteration 8 --
+array(3) {
+  ["h1"]=>
+  string(1) "
+"
+  ["h2"]=>
+  string(88) "hello world
+The quick brown fox jumped over;
+the lazy dog
+This is a double quoted string"
+  ["h3"]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+}
+-- Iteration 9 --
+array(2) {
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+-- Iteration 10 --
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+-- Iteration 11 --
+array(3) {
+  [1]=>
+  int(10)
+  [2]=>
+  int(20)
+  [4]=>
+  int(40)
+}
+-- Iteration 12 --
+array(2) {
+  ["one"]=>
+  string(3) "ten"
+  ["two"]=>
+  string(6) "twenty"
+}
+-- Iteration 13 --
+array(3) {
+  ["one"]=>
+  int(1)
+  [2]=>
+  string(3) "two"
+  [4]=>
+  string(4) "four"
+}
+-- Iteration 14 --
+array(2) {
+  [""]=>
+  string(4) "null"
+  ["NULL"]=>
+  NULL
+}
+-- Iteration 15 --
+array(4) {
+  [1]=>
+  string(4) "true"
+  [0]=>
+  string(5) "false"
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+}
+-- Iteration 16 --
+array(2) {
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+}
+-- Iteration 17 --
+array(2) {
+  [1]=>
+  string(0) ""
+  [6]=>
+  bool(true)
+}
+-- Iteration 18 --
+array(3) {
+  [""]=>
+  int(4)
+  [0]=>
+  int(5)
+  [1]=>
+  int(6)
+}
+Done
diff --git a/tests/std/array/array_unique_variation3.phpt b/tests/std/array/array_unique_variation3.phpt
new file mode 100644
index 00000000..015f42d3
--- /dev/null
+++ b/tests/std/array/array_unique_variation3.phpt
@@ -0,0 +1,109 @@
+--TEST--
+Test array_unique() function : usage variations - associative array with different keys
+--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_unique() by passing different
+     * associative arrays having different keys to $input argument.
+    */
+    echo "*** Testing array_unique() : assoc. array with diff. keys passed to \$input 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 associative arrays to be passed to $input argument
+    $inputs = array(
+        /*1*/
+        // arrays with integer keys
+        array(0 => "0", 1 => "0"),
+        array(1 => "1", 2 => "2", 3 => 1, 4 => "4"),
+        // arrays with string keys
+        /*5*/
+        array('\tHello' => 111, 're\td' => "color", '\v\fworld' => 2.2, 'pen\n' => 111),
+        array("\tHello" => 111, "re\td" => "color", "\v\fworld" => 2.2, "pen\n" => 111),
+        array("hello", $heredoc => "string", "string"),
+        // array with object, unset variable and resource variable
+        /*8*/
+        array(@$unset_var => "hello", $fp => 'resource', 11, "hello"),
+    );
+    // loop through each sub-array of $inputs to check the behavior of array_unique()
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "-- Iteration {$iterator} --\n";
+        var_dump(array_unique($input));
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_unique() : assoc. array with diff. keys passed to $input argument ***
+
+Warning: Resource ID#%d used as offset, casting to integer (%d) in %s on line %d
+-- Iteration 1 --
+array(1) {
+  [0]=>
+  string(1) "0"
+}
+-- Iteration 2 --
+array(3) {
+  [1]=>
+  string(1) "1"
+  [2]=>
+  string(1) "2"
+  [4]=>
+  string(1) "4"
+}
+-- Iteration 3 --
+array(3) {
+  ["\tHello"]=>
+  int(111)
+  ["re\td"]=>
+  string(5) "color"
+  ["\v\fworld"]=>
+  float(2.2)
+}
+-- Iteration 4 --
+array(3) {
+  ["	Hello"]=>
+  int(111)
+  ["re	d"]=>
+  string(5) "color"
+  ["world"]=>
+  float(2.2)
+}
+-- Iteration 5 --
+array(2) {
+  [0]=>
+  string(5) "hello"
+  ["Hello world"]=>
+  string(6) "string"
+}
+-- Iteration 6 --
+array(3) {
+  [""]=>
+  string(5) "hello"
+  [5]=>
+  string(8) "resource"
+  [6]=>
+  int(11)
+}
+Done
diff --git a/tests/std/array/array_unique_variation4.phpt b/tests/std/array/array_unique_variation4.phpt
new file mode 100644
index 00000000..92ed76e6
--- /dev/null
+++ b/tests/std/array/array_unique_variation4.phpt
@@ -0,0 +1,106 @@
+--TEST--
+Test array_unique() function : usage variations - associative array with different values
+--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_unique() by passing different
+     * associative arrays having different values to $input argument.
+    */
+    echo "*** Testing array_unique() : assoc. array with diff. values to \$input 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;
+    // associative arrays with different values
+    $inputs = array(
+        // arrays with integer values
+        /*1*/
+        array('0' => 0, '1' => 0),
+        array("one" => 1, 'two' => 2, "three" => 1, 4 => 1),
+        // arrays with string values
+        /*5*/
+        array(111 => "\tHello", "red" => "col\tor", 2 => "\v\fworld", 3 => "\tHello"),
+        array(111 => '\tHello', "red" => 'col\tor', 2 => '\v\fworld', 3 => '\tHello'),
+        array(1 => "hello", "heredoc" => $heredoc, $heredoc),
+        // array with object, unset variable and resource variable
+        /*8*/
+        array(11 => new classA(), "unset" => @$unset_var, "resource" => $fp, new classA(), $fp),
+    );
+    // loop through each sub-array of $inputs to check the behavior of array_unique()
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "-- Iteration {$iterator} --\n";
+        var_dump(array_unique($input));
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_unique() : assoc. array with diff. values to $input argument ***
+-- Iteration 1 --
+array(1) {
+  [0]=>
+  int(0)
+}
+-- Iteration 2 --
+array(2) {
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+}
+-- Iteration 3 --
+array(3) {
+  [111]=>
+  string(6) "	Hello"
+  ["red"]=>
+  string(6) "col	or"
+  [2]=>
+  string(7) "world"
+}
+-- Iteration 4 --
+array(3) {
+  [111]=>
+  string(7) "\tHello"
+  ["red"]=>
+  string(7) "col\tor"
+  [2]=>
+  string(9) "\v\fworld"
+}
+-- Iteration 5 --
+array(2) {
+  [1]=>
+  string(5) "hello"
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+-- Iteration 6 --
+array(3) {
+  [11]=>
+  object(classA)#%d (0) {
+  }
+  ["unset"]=>
+  NULL
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+Done
diff --git a/tests/std/array/array_unique_variation5.phpt b/tests/std/array/array_unique_variation5.phpt
new file mode 100644
index 00000000..8a2df526
--- /dev/null
+++ b/tests/std/array/array_unique_variation5.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Test array_unique() function : usage variations - array with duplicate keys
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_unique() by passing
+ * array having duplicate keys as values.
+*/
+
+echo "*** Testing array_unique() : array with duplicate keys for \$input argument ***\n";
+
+// initialize the array having duplicate keys
+$input = array( 1 => "one", 2 => "two", 2 => "2", 3 => "three", 1 => "1", "1", "2");
+var_dump( array_unique($input) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unique() : array with duplicate keys for $input argument ***
+array(3) {
+  [1]=>
+  string(1) "1"
+  [2]=>
+  string(1) "2"
+  [3]=>
+  string(5) "three"
+}
+Done
diff --git a/tests/std/array/array_unique_variation6.phpt b/tests/std/array/array_unique_variation6.phpt
new file mode 100644
index 00000000..f1a888d0
--- /dev/null
+++ b/tests/std/array/array_unique_variation6.phpt
@@ -0,0 +1,41 @@
+--TEST--
+Test array_unique() function : usage variations - array with reference variables
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_unique() by passing
+ * array having reference variables as values.
+*/
+
+echo "*** Testing array_unique() : array with reference variables for \$input argument ***\n";
+
+$value1 = 10;
+$value2 = "hello";
+$value3 = 0;
+$value4 = &$value2;
+
+// input array containing elements as reference variables
+$input = array(
+  0 => 0,
+  1 => &$value4,
+  2 => &$value2,
+  3 => "hello",
+  4 => &$value3,
+  5 => $value4
+);
+
+var_dump( array_unique($input, SORT_STRING) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unique() : array with reference variables for $input argument ***
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  &string(5) "hello"
+}
+Done
diff --git a/tests/std/array/array_unique_variation7.phpt b/tests/std/array/array_unique_variation7.phpt
new file mode 100644
index 00000000..e5a7542b
--- /dev/null
+++ b/tests/std/array/array_unique_variation7.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Test array_unique() function : usage variations - binary safe checking
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_unique() by passing an array having binary values.
+*/
+
+echo "*** Testing array_unique() : array with binary data for \$input argument ***\n";
+
+// array with binary values
+$input = array( b"1", b"hello", "world", "str1" => "hello", "str2" => "world");
+
+var_dump( array_unique($input) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unique() : array with binary data for $input argument ***
+array(3) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+}
+Done
diff --git a/tests/std/array/array_unique_variation8.phpt b/tests/std/array/array_unique_variation8.phpt
new file mode 100644
index 00000000..ae9faffc
--- /dev/null
+++ b/tests/std/array/array_unique_variation8.phpt
@@ -0,0 +1,47 @@
+--TEST--
+Test array_unique() function : usage variations - two dimensional arrays
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_unique() by passing
+ * two dimensional arrays for $input argument.
+*/
+
+echo "*** Testing array_unique() : two dimensional array for \$input argument ***\n";
+
+// initialize the 2-d array
+$input = array(
+  array(1, 2, 3, 1),
+  array("hello", "world", "str1" => "hello", "str2" => 'world'),
+  array(1 => "one", 2 => "two", "one", 'two'),
+  array(1, 2, 3, 1)
+);
+
+var_dump( array_unique($input, SORT_STRING) );
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing array_unique() : two dimensional array for $input argument ***
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+
+Warning: Array to string conversion in %s on line %d
+array(1) {
+  [0]=>
+  array(4) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(1)
+  }
+}
+Done
diff --git a/tests/std/array/array_unique_variation9.phpt b/tests/std/array/array_unique_variation9.phpt
new file mode 100644
index 00000000..aa083010
--- /dev/null
+++ b/tests/std/array/array_unique_variation9.phpt
@@ -0,0 +1,109 @@
+--TEST--
+Test array_unique() function : usage variations - more than 16 elements
+--CREDITS--
+Matteo Beccati
+--FILE--
+<?php
+
+$a = array (
+  0 => 'acls_channel',
+  1 => 'acls_channel',
+  2 => 'ad_zone_assoc',
+  3 => 'ad_zone_assoc',
+  4 => 'ad_zone_assoc',
+  5 => 'affiliates',
+  6 => 'affiliates',
+  7 => 'affiliates',
+  8 => 'banners',
+  9 => 'banners',
+  10 => 'banners',
+  11 => 'campaigns',
+  12 => 'campaigns',
+  13 => 'campaigns',
+  14 => 'campaigns_trackers',
+  15 => 'campaigns_trackers',
+  16 => 'campaigns_trackers',
+  17 => 'clients',
+  18 => 'clients',
+  19 => 'clients',
+  20 => 'data_intermediate_ad',
+  21 => 'data_intermediate_ad',
+  22 => 'data_summary_ad_hourly',
+  23 => 'data_summary_ad_hourly',
+  24 => 'data_summary_zone_country_daily',
+  25 => 'data_summary_zone_country_daily',
+  26 => 'data_summary_zone_country_daily',
+  27 => 'data_summary_zone_country_forecast',
+  28 => 'data_summary_zone_country_forecast',
+  29 => 'data_summary_zone_country_forecast',
+  30 => 'data_summary_zone_country_monthly',
+  31 => 'data_summary_zone_country_monthly',
+  32 => 'data_summary_zone_country_monthly',
+  33 => 'data_summary_zone_domain_page_daily',
+  34 => 'data_summary_zone_domain_page_daily',
+  35 => 'data_summary_zone_domain_page_daily',
+  36 => 'data_summary_zone_domain_page_forecast',
+  37 => 'data_summary_zone_domain_page_forecast',
+  38 => 'data_summary_zone_domain_page_forecast',
+  39 => 'data_summary_zone_domain_page_monthly',
+  40 => 'data_summary_zone_domain_page_monthly',
+  41 => 'data_summary_zone_domain_page_monthly',
+  42 => 'data_summary_zone_site_keyword_daily',
+  43 => 'data_summary_zone_site_keyword_daily',
+  44 => 'data_summary_zone_site_keyword_daily',
+  45 => 'data_summary_zone_site_keyword_forecast',
+  46 => 'data_summary_zone_site_keyword_forecast',
+  47 => 'data_summary_zone_site_keyword_forecast',
+  48 => 'data_summary_zone_site_keyword_monthly',
+  49 => 'data_summary_zone_site_keyword_monthly',
+  50 => 'data_summary_zone_site_keyword_monthly',
+  51 => 'data_summary_zone_source_daily',
+  52 => 'data_summary_zone_source_daily',
+  53 => 'data_summary_zone_source_daily',
+  54 => 'data_summary_zone_source_forecast',
+  55 => 'data_summary_zone_source_forecast',
+  56 => 'data_summary_zone_source_forecast',
+  57 => 'data_summary_zone_source_monthly',
+  58 => 'data_summary_zone_source_monthly',
+  59 => 'data_summary_zone_source_monthly',
+  60 => 'placement_zone_assoc',
+  61 => 'placement_zone_assoc',
+  62 => 'placement_zone_assoc',
+  63 => 'trackers',
+  64 => 'trackers',
+  65 => 'trackers',
+  66 => 'variables',
+  67 => 'variables',
+  68 => 'variables',
+);
+
+print_r(array_unique($a));
+?>
+--EXPECT--
+Array
+(
+    [0] => acls_channel
+    [2] => ad_zone_assoc
+    [5] => affiliates
+    [8] => banners
+    [11] => campaigns
+    [14] => campaigns_trackers
+    [17] => clients
+    [20] => data_intermediate_ad
+    [22] => data_summary_ad_hourly
+    [24] => data_summary_zone_country_daily
+    [27] => data_summary_zone_country_forecast
+    [30] => data_summary_zone_country_monthly
+    [33] => data_summary_zone_domain_page_daily
+    [36] => data_summary_zone_domain_page_forecast
+    [39] => data_summary_zone_domain_page_monthly
+    [42] => data_summary_zone_site_keyword_daily
+    [45] => data_summary_zone_site_keyword_forecast
+    [48] => data_summary_zone_site_keyword_monthly
+    [51] => data_summary_zone_source_daily
+    [54] => data_summary_zone_source_forecast
+    [57] => data_summary_zone_source_monthly
+    [60] => placement_zone_assoc
+    [63] => trackers
+    [66] => variables
+)
diff --git a/tests/std/array/array_unshift.phpt b/tests/std/array/array_unshift.phpt
new file mode 100644
index 00000000..265de4e8
--- /dev/null
+++ b/tests/std/array/array_unshift.phpt
@@ -0,0 +1,31 @@
+--TEST--
+array_unshift() tests
+--FILE--
+<?php
+
+$a = array();
+$s = "";
+var_dump(array_unshift($a, $s));
+var_dump($a);
+var_dump(array_unshift($a, $a));
+var_dump($a);
+
+echo "Done\n";
+?>
+--EXPECT--
+int(1)
+array(1) {
+  [0]=>
+  string(0) ""
+}
+int(2)
+array(2) {
+  [0]=>
+  array(1) {
+    [0]=>
+    string(0) ""
+  }
+  [1]=>
+  string(0) ""
+}
+Done
diff --git a/tests/std/array/array_unshift_basic1.phpt b/tests/std/array/array_unshift_basic1.phpt
new file mode 100644
index 00000000..ef0de5e7
--- /dev/null
+++ b/tests/std/array/array_unshift_basic1.phpt
@@ -0,0 +1,58 @@
+--TEST--
+Test array_unshift() function : basic functionality - array with default keys for 'array' argument
+--FILE--
+<?php
+/*
+ * Testing array_unshift() by giving array with default keys for $array argument
+*/
+
+echo "*** Testing array_unshift() : basic functionality with default key array ***\n";
+
+// Initialise the array
+$array = array(1, 2);
+
+// Calling array_unshift() with default argument
+$temp_array = $array;
+// returns element count in the resulting array after arguments are pushed to
+// beginning of the given array
+var_dump( array_unshift($temp_array, 10) );
+
+// dump the resulting array
+var_dump($temp_array);
+
+// Calling array_unshift() with optional arguments
+$temp_array = $array;
+// returns element count in the resulting array after arguments are pushed to
+// beginning of the given array
+var_dump( array_unshift($temp_array, 222, "hello", 12.33) );
+
+// dump the resulting array
+var_dump($temp_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unshift() : basic functionality with default key array ***
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+int(5)
+array(5) {
+  [0]=>
+  int(222)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  float(12.33)
+  [3]=>
+  int(1)
+  [4]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/array_unshift_basic2.phpt b/tests/std/array/array_unshift_basic2.phpt
new file mode 100644
index 00000000..7c19dcda
--- /dev/null
+++ b/tests/std/array/array_unshift_basic2.phpt
@@ -0,0 +1,66 @@
+--TEST--
+Test array_unshift() function : basic functionality - associative arrays for 'array' argument
+--FILE--
+<?php
+/*
+ * Testing array_unshift() by giving associative arrays for $array argument
+*/
+
+echo "*** Testing array_unshift() : basic functionality with associative array ***\n";
+
+// Initialise the array
+$array = array('f' => "first", "s" => 'second', 1 => "one", 2 => 'two');
+
+// Calling array_unshift() with default argument
+$temp_array = $array;
+// returns element count in the resulting array after arguments are pushed to
+// beginning of the given array
+var_dump( array_unshift($temp_array, 10) );
+
+// dump the resulting array
+var_dump($temp_array);
+
+// Calling array_unshift() with optional arguments
+$temp_array = $array;
+// returns element count in the resulting array after arguments are pushed to
+// beginning of the given array
+var_dump( array_unshift($temp_array, 222, "hello", 12.33) );
+
+// dump the resulting array
+var_dump($temp_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unshift() : basic functionality with associative array ***
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+}
+int(7)
+array(7) {
+  [0]=>
+  int(222)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  float(12.33)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  string(3) "one"
+  [4]=>
+  string(3) "two"
+}
+Done
diff --git a/tests/std/array/array_unshift_empty.phpt b/tests/std/array/array_unshift_empty.phpt
new file mode 100644
index 00000000..43bad5b3
--- /dev/null
+++ b/tests/std/array/array_unshift_empty.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Test array_unshift() function : prepend array with empty set
+--FILE--
+<?php
+$array = [1,2,3];
+$values = [];
+
+var_dump( array_unshift($array) );
+var_dump( array_unshift($array, ...$values) );
+var_dump( $array );
+
+echo "Done";
+?>
+--EXPECT--
+int(3)
+int(3)
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/array_unshift_object.phpt b/tests/std/array/array_unshift_object.phpt
new file mode 100644
index 00000000..a7deb4b8
--- /dev/null
+++ b/tests/std/array/array_unshift_object.phpt
@@ -0,0 +1,273 @@
+--TEST--
+Test array_unshift() function : passing object for 'var' argument
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+// simple class with a variable and method
+class SimpleClass
+{
+    public $var1 = 1;
+    public function fun1()
+    {
+        return $var1;
+    }
+}
+// class without members
+class EmptyClass
+{
+}
+// abstract class
+abstract class AbstractClass
+{
+    protected $var2 = 5;
+    abstract function emptyFunction();
+}
+// class deriving the above abstract class
+class ChildClass extends AbstractClass
+{
+    private $var3;
+    public function emptyFunction()
+    {
+        echo "defined in child";
+    }
+}
+// class with final method
+class FinalClass
+{
+    private $var4;
+    final function finalMethod()
+    {
+        echo "This function can't be overloaded";
+    }
+}
+// class with static members
+class StaticClass
+{
+    static $var5 = 2;
+    public static function staticMethod()
+    {
+        echo "This is a static method";
+    }
+}
+function main()
+{
+    /*
+     * Testing the functionality of array_unshift() by passing
+     * an object to the $var argument
+    */
+    echo "*** Testing array_unshift() : Passing object to \$var argument ***\n";
+    // array to be passed to $array argument
+    $array = array('f' => "first", "s" => 'second', 1, 2.222);
+    // array containing different types of objects as elements
+    $vars = array(new SimpleClass(), new EmptyClass(), new ChildClass(), new FinalClass(), new StaticClass());
+    // loop through the various elements of $arrays to check the functionality of array_unshift
+    $iterator = 1;
+    foreach ($vars as $var) {
+        echo "-- Iteration {$iterator} --\n";
+        /* with default argument */
+        // returns element count in the resulting array after arguments are pushed to
+        // beginning of the given array
+        $temp_array = $array;
+        var_dump(array_unshift($temp_array, $var));
+        // dump the resulting array
+        var_dump($temp_array);
+        /* with optional arguments */
+        // returns element count in the resulting array after arguments are pushed to
+        // beginning of the given array
+        $temp_array = $array;
+        var_dump(array_unshift($temp_array, $var, "hello", 'world'));
+        // dump the resulting array
+        var_dump($temp_array);
+        $iterator++;
+    }
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_unshift() : Passing object to $var argument ***
+-- Iteration 1 --
+int(5)
+array(5) {
+  [0]=>
+  object(SimpleClass)#%d (1) {
+    ["var1"]=>
+    int(1)
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  object(SimpleClass)#%d (1) {
+    ["var1"]=>
+    int(1)
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 2 --
+int(5)
+array(5) {
+  [0]=>
+  object(EmptyClass)#%d (0) {
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  object(EmptyClass)#%d (0) {
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 3 --
+int(5)
+array(5) {
+  [0]=>
+  object(ChildClass)#%d (2) {
+    ["var2":protected]=>
+    int(5)
+    ["var3":"ChildClass":private]=>
+    NULL
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  object(ChildClass)#%d (2) {
+    ["var2":protected]=>
+    int(5)
+    ["var3":"ChildClass":private]=>
+    NULL
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 4 --
+int(5)
+array(5) {
+  [0]=>
+  object(FinalClass)#%d (1) {
+    ["var4":"FinalClass":private]=>
+    NULL
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  object(FinalClass)#%d (1) {
+    ["var4":"FinalClass":private]=>
+    NULL
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 5 --
+int(5)
+array(5) {
+  [0]=>
+  object(StaticClass)#%d (0) {
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  object(StaticClass)#%d (0) {
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+Done
diff --git a/tests/std/array/array_unshift_variation2.phpt b/tests/std/array/array_unshift_variation2.phpt
new file mode 100644
index 00000000..b23b151f
--- /dev/null
+++ b/tests/std/array/array_unshift_variation2.phpt
@@ -0,0 +1,1048 @@
+--TEST--
+Test array_unshift() function : usage variations - all possible values for 'var' 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()
+{
+    /*
+     * Testing array_unshift() by giving all the possible values for $var argument
+    */
+    echo "*** Testing array_unshift() : all possible values for \$var argument ***\n";
+    // array to be passed to $array argument
+    $array = array('f' => "first", "s" => 'second', 1, 2.222);
+    // get a resource variable
+    $fp = fopen(__FILE__, "r");
+    // heredoc string
+    $heredoc = <<<EOT
+    hello world
+    EOT;
+    // get an unset variable
+    $unset_var = 10;
+    unset($unset_var);
+    // different types of values to be passed to $var argument
+    $vars = array(
+        // int data
+        /*1*/
+        0,
+        1,
+        12345,
+        -2345,
+        // float data
+        /*5*/
+        10.5,
+        -10.5,
+        123456789000.0,
+        1.23456789E-9,
+        0.5,
+        // array data
+        /*10*/
+        array(),
+        array(0),
+        array(1),
+        array(1, 2),
+        array('color' => 'red', 'item' => 'pen'),
+        // null data
+        /*15*/
+        NULL,
+        null,
+        // boolean data
+        /*17*/
+        true,
+        false,
+        TRUE,
+        FALSE,
+        // empty data
+        /*21*/
+        "",
+        '',
+        // string data
+        /*23*/
+        "string",
+        'string',
+        $heredoc,
+        // object data
+        /*26*/
+        new classA(),
+        // undefined data
+        @$undefined_var,
+        // unset data
+        @$unset_var,
+        // resource variable
+        /*29*/
+        $fp,
+    );
+    // loop through each element of $vars to check the functionality of array_unshift()
+    $iterator = 1;
+    foreach ($vars as $var) {
+        echo "-- Iteration {$iterator} --\n";
+        $temp_array = $array;
+        /* with default argument */
+        // returns element count in the resulting array after arguments are pushed to
+        // beginning of the given array
+        var_dump(array_unshift($temp_array, $var));
+        // dump the resulting array
+        var_dump($temp_array);
+        /* with optional arguments */
+        // returns element count in the resulting array after arguments are pushed to
+        // beginning of the given array
+        $temp_array = $array;
+        var_dump(array_unshift($temp_array, $var, "hello", 'world'));
+        // dump the resulting array
+        var_dump($temp_array);
+        $iterator++;
+    }
+    // close the file resource used
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_unshift() : all possible values for $var argument ***
+-- Iteration 1 --
+int(5)
+array(5) {
+  [0]=>
+  int(0)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(0)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 2 --
+int(5)
+array(5) {
+  [0]=>
+  int(1)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 3 --
+int(5)
+array(5) {
+  [0]=>
+  int(12345)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(12345)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 4 --
+int(5)
+array(5) {
+  [0]=>
+  int(-2345)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(-2345)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 5 --
+int(5)
+array(5) {
+  [0]=>
+  float(10.5)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  float(10.5)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 6 --
+int(5)
+array(5) {
+  [0]=>
+  float(-10.5)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  float(-10.5)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 7 --
+int(5)
+array(5) {
+  [0]=>
+  float(123456789000)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  float(123456789000)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 8 --
+int(5)
+array(5) {
+  [0]=>
+  float(1.23456789E-9)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  float(1.23456789E-9)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 9 --
+int(5)
+array(5) {
+  [0]=>
+  float(0.5)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  float(0.5)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 10 --
+int(5)
+array(5) {
+  [0]=>
+  array(0) {
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 11 --
+int(5)
+array(5) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 12 --
+int(5)
+array(5) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 13 --
+int(5)
+array(5) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 14 --
+int(5)
+array(5) {
+  [0]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  array(2) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 15 --
+int(5)
+array(5) {
+  [0]=>
+  NULL
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  NULL
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 16 --
+int(5)
+array(5) {
+  [0]=>
+  NULL
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  NULL
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 17 --
+int(5)
+array(5) {
+  [0]=>
+  bool(true)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  bool(true)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 18 --
+int(5)
+array(5) {
+  [0]=>
+  bool(false)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  bool(false)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 19 --
+int(5)
+array(5) {
+  [0]=>
+  bool(true)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  bool(true)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 20 --
+int(5)
+array(5) {
+  [0]=>
+  bool(false)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  bool(false)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 21 --
+int(5)
+array(5) {
+  [0]=>
+  string(0) ""
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 22 --
+int(5)
+array(5) {
+  [0]=>
+  string(0) ""
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 23 --
+int(5)
+array(5) {
+  [0]=>
+  string(6) "string"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 24 --
+int(5)
+array(5) {
+  [0]=>
+  string(6) "string"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 25 --
+int(5)
+array(5) {
+  [0]=>
+  string(11) "hello world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(11) "hello world"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 26 --
+int(5)
+array(5) {
+  [0]=>
+  object(classA)#%d (0) {
+  }
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  object(classA)#%d (0) {
+  }
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 27 --
+int(5)
+array(5) {
+  [0]=>
+  NULL
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  NULL
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 28 --
+int(5)
+array(5) {
+  [0]=>
+  NULL
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  NULL
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 29 --
+int(5)
+array(5) {
+  [0]=>
+  resource(%d) of type (stream)
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  resource(%d) of type (stream)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+Done
diff --git a/tests/std/array/array_unshift_variation3.phpt b/tests/std/array/array_unshift_variation3.phpt
new file mode 100644
index 00000000..6ed96472
--- /dev/null
+++ b/tests/std/array/array_unshift_variation3.phpt
@@ -0,0 +1,568 @@
+--TEST--
+Test array_unshift() function : usage variations - different array values for 'array' argument
+--SKIPIF--
+<?php die("skip AOT array_unshift behavior differs for mixed types"); ?>
+--FILE--
+<?php
+/*
+ * Testing the behavior of array_unshift() by passing different types of arrays
+ * to $array argument to which the $var arguments will be prepended
+*/
+
+echo "*** Testing array_unshift() : different arrays for \$array argument ***\n";
+
+// initialize $var argument
+$var = 10;
+
+// different arrays to be passed to $array argument
+$arrays = array (
+/*1*/  array(1, 2), // array with default keys and numeric values
+       array(1.1, 2.2), // array with default keys & float values
+       array( array(2), array(1)), // sub arrays
+       array(false,true), // array with default keys and boolean values
+       array(), // empty array
+       array(NULL), // array with NULL
+       array("a","aaaa","b","bbbb","c","ccccc"),
+
+       // associative arrays
+/*8*/  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
+/*13*/ 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
+/*18*/ array("One" => 1, "two" => 2, "One" => 10, "two" => 20, "three" => 3)
+);
+
+// loop through the various elements of $arrays to test array_unshift()
+$iterator = 1;
+foreach($arrays as $array) {
+  echo "-- Iteration $iterator --\n";
+
+  /* with default argument */
+  // returns element count in the resulting array after arguments are pushed to
+  // beginning of the given array
+  $temp_array = $array;
+  var_dump( array_unshift($temp_array, $var) );
+
+  // dump the resulting array
+  var_dump($temp_array);
+
+  /* with optional arguments */
+  // returns element count in the resulting array after arguments are pushed to
+  // beginning of the given array
+  $temp_array = $array;
+  var_dump( array_unshift($temp_array, $var, "hello", 'world') );
+
+  // dump the resulting array
+  var_dump($temp_array);
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unshift() : different arrays for $array argument ***
+-- Iteration 1 --
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  int(1)
+  [4]=>
+  int(2)
+}
+-- Iteration 2 --
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  float(1.1)
+  [2]=>
+  float(2.2)
+}
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  float(1.1)
+  [4]=>
+  float(2.2)
+}
+-- Iteration 3 --
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  array(1) {
+    [0]=>
+    int(2)
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+}
+-- Iteration 4 --
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(true)
+}
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  bool(false)
+  [4]=>
+  bool(true)
+}
+-- Iteration 5 --
+int(1)
+array(1) {
+  [0]=>
+  int(10)
+}
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+}
+-- Iteration 6 --
+int(2)
+array(2) {
+  [0]=>
+  int(10)
+  [1]=>
+  NULL
+}
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  NULL
+}
+-- Iteration 7 --
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(1) "a"
+  [2]=>
+  string(4) "aaaa"
+  [3]=>
+  string(1) "b"
+  [4]=>
+  string(4) "bbbb"
+  [5]=>
+  string(1) "c"
+  [6]=>
+  string(5) "ccccc"
+}
+int(9)
+array(9) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(1) "a"
+  [4]=>
+  string(4) "aaaa"
+  [5]=>
+  string(1) "b"
+  [6]=>
+  string(4) "bbbb"
+  [7]=>
+  string(1) "c"
+  [8]=>
+  string(5) "ccccc"
+}
+-- Iteration 8 --
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  string(5) "three"
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(3) "one"
+  [4]=>
+  string(3) "two"
+  [5]=>
+  string(5) "three"
+}
+-- Iteration 9 --
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+}
+-- Iteration 10 --
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(10)
+  [2]=>
+  int(20)
+  [3]=>
+  int(40)
+  [4]=>
+  int(30)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  int(10)
+  [4]=>
+  int(20)
+  [5]=>
+  int(40)
+  [6]=>
+  int(30)
+}
+-- Iteration 11 --
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  ["one"]=>
+  string(3) "ten"
+  ["two"]=>
+  string(6) "twenty"
+  ["three"]=>
+  string(6) "thirty"
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["one"]=>
+  string(3) "ten"
+  ["two"]=>
+  string(6) "twenty"
+  ["three"]=>
+  string(6) "thirty"
+}
+-- Iteration 12 --
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  ["one"]=>
+  int(1)
+  [1]=>
+  string(3) "two"
+  [2]=>
+  string(4) "four"
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["one"]=>
+  int(1)
+  [3]=>
+  string(3) "two"
+  [4]=>
+  string(4) "four"
+}
+-- Iteration 13 --
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [""]=>
+  string(4) "null"
+  ["NULL"]=>
+  NULL
+  ["null"]=>
+  NULL
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [""]=>
+  string(4) "null"
+  ["NULL"]=>
+  NULL
+  ["null"]=>
+  NULL
+}
+-- Iteration 14 --
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(4) "true"
+  [2]=>
+  string(5) "false"
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(4) "true"
+  [4]=>
+  string(5) "false"
+  ["false"]=>
+  bool(false)
+  ["true"]=>
+  bool(true)
+}
+-- Iteration 15 --
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+  ["emptys"]=>
+  string(0) ""
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [""]=>
+  string(6) "emptys"
+  ["emptyd"]=>
+  string(0) ""
+  ["emptys"]=>
+  string(0) ""
+}
+-- Iteration 16 --
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(0) ""
+  [2]=>
+  string(0) ""
+  [3]=>
+  NULL
+  [4]=>
+  NULL
+  [5]=>
+  bool(false)
+  [6]=>
+  bool(true)
+}
+int(9)
+array(9) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(0) ""
+  [4]=>
+  string(0) ""
+  [5]=>
+  NULL
+  [6]=>
+  NULL
+  [7]=>
+  bool(false)
+  [8]=>
+  bool(true)
+}
+-- Iteration 17 --
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [""]=>
+  int(4)
+  [1]=>
+  int(5)
+  [2]=>
+  int(6)
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [""]=>
+  int(4)
+  [3]=>
+  int(5)
+  [4]=>
+  int(6)
+}
+-- Iteration 18 --
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  ["One"]=>
+  int(10)
+  ["two"]=>
+  int(20)
+  ["three"]=>
+  int(3)
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["One"]=>
+  int(10)
+  ["two"]=>
+  int(20)
+  ["three"]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/array_unshift_variation4.phpt b/tests/std/array/array_unshift_variation4.phpt
new file mode 100644
index 00000000..908557fc
--- /dev/null
+++ b/tests/std/array/array_unshift_variation4.phpt
@@ -0,0 +1,316 @@
+--TEST--
+Test array_unshift() function : usage variations - assoc. array with diff. keys for 'array' argument
+--SKIPIF--
+<?php die("skip AOT array_unshift behavior differs for mixed types"); ?>
+--FILE--
+<?php
+//get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Testing the functionality of array_unshift() by passing different
+     * associative arrays having different possible keys to $array argument.
+     * The $var argument passed is a fixed value
+    */
+    echo "*** Testing array_unshift() : associative array with different keys ***\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;
+    // initializing $var argument
+    $var = 10;
+    // different variations of associative arrays to be passed to $array 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
+        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"),
+    );
+    // loop through the various elements of $arrays to test array_unshift()
+    $iterator = 1;
+    foreach ($arrays as $array) {
+        echo "-- Iteration {$iterator} --\n";
+        /* with default argument */
+        // returns element count in the resulting array after arguments are pushed to
+        // beginning of the given array
+        $temp_array = $array;
+        var_dump(array_unshift($temp_array, $var));
+        // dump the resulting array
+        var_dump($temp_array);
+        /* with optional arguments */
+        // returns element count in the resulting array after arguments are pushed to
+        // beginning of the given array
+        $temp_array = $array;
+        var_dump(array_unshift($temp_array, $var, "hello", 'world'));
+        // dump the resulting array
+        var_dump($temp_array);
+        $iterator++;
+    }
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_unshift() : associative array with different keys ***
+
+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 --
+int(1)
+array(1) {
+  [0]=>
+  int(10)
+}
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+}
+-- Iteration 2 --
+int(2)
+array(2) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(1) "0"
+}
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(1) "0"
+}
+-- Iteration 3 --
+int(2)
+array(2) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(1) "1"
+}
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(1) "1"
+}
+-- Iteration 4 --
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(1) "1"
+  [2]=>
+  string(1) "2"
+  [3]=>
+  string(1) "3"
+  [4]=>
+  string(1) "4"
+}
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(1) "1"
+  [4]=>
+  string(1) "2"
+  [5]=>
+  string(1) "3"
+  [6]=>
+  string(1) "4"
+}
+-- Iteration 5 --
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  ["\tHello"]=>
+  int(111)
+  ["re\td"]=>
+  string(5) "color"
+  ["\v\fworld"]=>
+  float(2.2)
+  ["pen\n"]=>
+  int(33)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["\tHello"]=>
+  int(111)
+  ["re\td"]=>
+  string(5) "color"
+  ["\v\fworld"]=>
+  float(2.2)
+  ["pen\n"]=>
+  int(33)
+}
+-- Iteration 6 --
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  ["	Hello"]=>
+  int(111)
+  ["re	d"]=>
+  string(5) "color"
+  ["world"]=>
+  float(2.2)
+  ["pen
+"]=>
+  int(33)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["	Hello"]=>
+  int(111)
+  ["re	d"]=>
+  string(5) "color"
+  ["world"]=>
+  float(2.2)
+  ["pen
+"]=>
+  int(33)
+}
+-- Iteration 7 --
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  ["Hello world"]=>
+  string(6) "string"
+}
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(5) "hello"
+  ["Hello world"]=>
+  string(6) "string"
+}
+-- Iteration 8 --
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [""]=>
+  string(5) "hello"
+  [1]=>
+  string(8) "resource"
+}
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [""]=>
+  string(5) "hello"
+  [3]=>
+  string(8) "resource"
+}
+-- Iteration 9 --
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  ["hello"]=>
+  int(1)
+  ["fruit"]=>
+  float(2.2)
+  [1]=>
+  string(8) "resource"
+  [2]=>
+  string(3) "int"
+  [""]=>
+  string(5) "unset"
+  ["Hello world"]=>
+  string(7) "heredoc"
+}
+int(9)
+array(9) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["hello"]=>
+  int(1)
+  ["fruit"]=>
+  float(2.2)
+  [3]=>
+  string(8) "resource"
+  [4]=>
+  string(3) "int"
+  [""]=>
+  string(5) "unset"
+  ["Hello world"]=>
+  string(7) "heredoc"
+}
+Done
diff --git a/tests/std/array/array_unshift_variation5.phpt b/tests/std/array/array_unshift_variation5.phpt
new file mode 100644
index 00000000..303971f6
--- /dev/null
+++ b/tests/std/array/array_unshift_variation5.phpt
@@ -0,0 +1,383 @@
+--TEST--
+Test array_unshift() function : usage variations - assoc. array with diff values for 'array' argument
+--INI--
+precision=12
+--SKIPIF--
+<?php die("skip AOT array_unshift behavior differs for mixed types"); ?>
+--FILE--
+<?php
+// get a class
+class classA
+{
+    public function __toString(): string {
+        return "Class A object";
+    }
+}
+function main()
+{
+    /*
+     * Testing the functionality of array_unshift() by passing different
+     * associative arrays having different possible values to $array argument.
+     * The $var argument passed is a fixed value
+    */
+    echo "*** Testing array_unshift() : associative array with different values ***\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;
+    // initializing $var argument
+    $var = 10;
+    // different variations of associative arrays to be passed to $array argument
+    $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.333333),
+        // 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
+        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 the various elements of $arrays to test array_unshift()
+    $iterator = 1;
+    foreach ($arrays as $array) {
+        echo "-- Iteration {$iterator} --\n";
+        /* with default argument */
+        // returns element count in the resulting array after arguments are pushed to
+        // beginning of the given array
+        $temp_array = $array;
+        var_dump(array_unshift($temp_array, $var));
+        // dump the resulting array
+        var_dump($temp_array);
+        /* with optional arguments */
+        // returns element count in the resulting array after arguments are pushed to
+        // beginning of the given array
+        $temp_array = $array;
+        var_dump(array_unshift($temp_array, $var, "hello", 'world'));
+        // dump the resulting array
+        var_dump($temp_array);
+        $iterator++;
+    }
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_unshift() : associative array with different values ***
+-- Iteration 1 --
+int(1)
+array(1) {
+  [0]=>
+  int(10)
+}
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+}
+-- Iteration 2 --
+int(2)
+array(2) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(0)
+}
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  int(0)
+}
+-- Iteration 3 --
+int(2)
+array(2) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(1)
+}
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  int(1)
+}
+-- Iteration 4 --
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [1]=>
+  int(4)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["one"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [3]=>
+  int(4)
+}
+-- Iteration 5 --
+int(2)
+array(2) {
+  [0]=>
+  int(10)
+  ["float"]=>
+  float(2.3333)
+}
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["float"]=>
+  float(2.3333)
+}
+-- Iteration 6 --
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  ["f1"]=>
+  float(1.2)
+  ["f2"]=>
+  float(3.33)
+  [1]=>
+  float(4.89999922839999)
+  ["f4"]=>
+  float(33333333.333333)
+}
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f1"]=>
+  float(1.2)
+  ["f2"]=>
+  float(3.33)
+  [3]=>
+  float(4.89999922839999)
+  ["f4"]=>
+  float(33333333.333333)
+}
+-- Iteration 7 --
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(6) "	Hello"
+  ["red"]=>
+  string(6) "col	or"
+  [2]=>
+  string(7) "world"
+  [3]=>
+  string(4) "pen
+"
+}
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(6) "	Hello"
+  ["red"]=>
+  string(6) "col	or"
+  [4]=>
+  string(7) "world"
+  [5]=>
+  string(4) "pen
+"
+}
+-- Iteration 8 --
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(7) "\tHello"
+  ["red"]=>
+  string(7) "col\tor"
+  [2]=>
+  string(9) "\v\fworld"
+  [3]=>
+  string(5) "pen\n"
+}
+int(7)
+array(7) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(7) "\tHello"
+  ["red"]=>
+  string(7) "col\tor"
+  [4]=>
+  string(9) "\v\fworld"
+  [5]=>
+  string(5) "pen\n"
+}
+-- Iteration 9 --
+int(3)
+array(3) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+int(5)
+array(5) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(5) "hello"
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+-- Iteration 10 --
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  object(classA)#%d (0) {
+  }
+  ["unset"]=>
+  NULL
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  object(classA)#%d (0) {
+  }
+  ["unset"]=>
+  NULL
+  ["resource"]=>
+  resource(%d) of type (stream)
+}
+-- Iteration 11 --
+int(9)
+array(9) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  object(classA)#%d (0) {
+  }
+  [3]=>
+  string(5) "fruit"
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["int"]=>
+  int(133)
+  ["float"]=>
+  float(444.432)
+  ["unset"]=>
+  NULL
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+int(11)
+array(11) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  string(5) "hello"
+  [4]=>
+  object(classA)#%d (0) {
+  }
+  [5]=>
+  string(5) "fruit"
+  ["resource"]=>
+  resource(%d) of type (stream)
+  ["int"]=>
+  int(133)
+  ["float"]=>
+  float(444.432)
+  ["unset"]=>
+  NULL
+  ["heredoc"]=>
+  string(11) "Hello world"
+}
+Done
diff --git a/tests/std/array/array_unshift_variation6.phpt b/tests/std/array/array_unshift_variation6.phpt
new file mode 100644
index 00000000..89f7e228
--- /dev/null
+++ b/tests/std/array/array_unshift_variation6.phpt
@@ -0,0 +1,191 @@
+--TEST--
+Test array_unshift() function : usage variations - two dimensional arrays for 'array' argument
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_unshift() by giving two-dimensional
+ * arrays and also sub-arrays within the two-dimensional array for $array argument.
+ * The $var argument passed is a fixed value
+*/
+
+echo "*** Testing array_unshift() : two dimensional arrays for \$array argument ***\n";
+
+// initializing $var argument
+$var = 10;
+
+// two-dimensional array to be passed to $array argument
+$two_dimensional_array = array(
+
+   // associative array
+   array('color' => 'red', 'item' => 'pen', 'place' => 'LA'),
+
+   // numeric array
+   array(1, 2, 3, 4, 5),
+
+   // combination of numeric and associative arrays
+   array('a' => 'green', 'red', 'brown', 33, 88, 'orange', 'item' => 'ball')
+);
+
+/* Passing the entire $two_dimensional_array to $array */
+
+/* With default argument */
+// returns element count in the resulting array after arguments are pushed to
+// beginning of the given array
+$temp_array = $two_dimensional_array;
+var_dump( array_unshift($temp_array, $var) );  // whole 2-d array
+
+// dumps the resulting array
+var_dump($temp_array);
+
+/* With optional arguments */
+// returns element count in the resulting array after arguments are pushed to
+// beginning of the given array
+$temp_array = $two_dimensional_array;
+var_dump( array_unshift($temp_array, $var, "hello", 'world') );  // whole 2-d array
+
+// dumps the resulting array
+var_dump($temp_array);
+
+/* Passing the sub-array within the $two_dimensional_array to $array argument */
+
+/* With default argument */
+// returns element count in the resulting array after arguments are pushed to
+// beginning of the given array
+$temp_array = $two_dimensional_array[0];
+var_dump( array_unshift($temp_array, $var) );  // sub array
+
+// dumps the resulting array
+var_dump($temp_array);
+
+/* With optional arguments */
+// returns element count in the resulting array after arguments are pushed to
+// beginning of the given array
+$temp_array = $two_dimensional_array[0];
+var_dump( array_unshift($temp_array, $var, "hello", 'world') );  // sub array
+
+// dumps the resulting array
+var_dump($temp_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unshift() : two dimensional arrays for $array argument ***
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  array(3) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+    ["place"]=>
+    string(2) "LA"
+  }
+  [2]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [3]=>
+  array(7) {
+    ["a"]=>
+    string(5) "green"
+    [0]=>
+    string(3) "red"
+    [1]=>
+    string(5) "brown"
+    [2]=>
+    int(33)
+    [3]=>
+    int(88)
+    [4]=>
+    string(6) "orange"
+    ["item"]=>
+    string(4) "ball"
+  }
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  [3]=>
+  array(3) {
+    ["color"]=>
+    string(3) "red"
+    ["item"]=>
+    string(3) "pen"
+    ["place"]=>
+    string(2) "LA"
+  }
+  [4]=>
+  array(5) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+  }
+  [5]=>
+  array(7) {
+    ["a"]=>
+    string(5) "green"
+    [0]=>
+    string(3) "red"
+    [1]=>
+    string(5) "brown"
+    [2]=>
+    int(33)
+    [3]=>
+    int(88)
+    [4]=>
+    string(6) "orange"
+    ["item"]=>
+    string(4) "ball"
+  }
+}
+int(4)
+array(4) {
+  [0]=>
+  int(10)
+  ["color"]=>
+  string(3) "red"
+  ["item"]=>
+  string(3) "pen"
+  ["place"]=>
+  string(2) "LA"
+}
+int(6)
+array(6) {
+  [0]=>
+  int(10)
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["color"]=>
+  string(3) "red"
+  ["item"]=>
+  string(3) "pen"
+  ["place"]=>
+  string(2) "LA"
+}
+Done
diff --git a/tests/std/array/array_unshift_variation7.phpt b/tests/std/array/array_unshift_variation7.phpt
new file mode 100644
index 00000000..f42ac1cf
--- /dev/null
+++ b/tests/std/array/array_unshift_variation7.phpt
@@ -0,0 +1,211 @@
+--TEST--
+Test array_unshift() function : usage variations - double quoted strings for 'var' argument
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_unshift() by passing different
+ * double quoted strings for $var argument that is prepended to the array
+ * passed through $array argument
+*/
+
+echo "*** Testing array_unshift() : double quoted strings for \$var argument ***\n";
+
+// array to be passed to $array argument
+$array = array('f' => "first", "s" => 'second', 1, 2.222);
+
+// different variations of double quoted strings to be passed to $var argument
+$vars = array (
+  "\$ -> This represents the dollar sign. hello dollar!!!",
+  "\t\r\v The quick brown fo\fx jumped over the lazy dog",
+  "This is a text with special chars: \!\@\#\$\%\^\&\*\(\)\\",
+  "hello world\\t",
+  "This is \ta text in bold letters\r\s\malong with slashes\n : HELLO WORLD\t"
+);
+
+// loop through the various elements of $arrays to test array_unshift()
+$iterator = 1;
+foreach($vars as $var) {
+  echo "-- Iteration $iterator --\n";
+  $temp_array = $array;  // assign $array to another temporary $temp_array
+
+  /* with default argument */
+  // returns element count in the resulting array after arguments are pushed to
+  // beginning of the given array
+  var_dump( array_unshift($temp_array, $var) );
+
+// dump the resulting array
+  var_dump($temp_array);
+
+  /* with optional arguments */
+  // returns element count in the resulting array after arguments are pushed to
+  // beginning of the given array
+  $temp_array = $array;
+  var_dump( array_unshift($temp_array, $var, "hello", 'world') );
+
+  // dump the resulting array
+  var_dump($temp_array);
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unshift() : double quoted strings for $var argument ***
+-- Iteration 1 --
+int(5)
+array(5) {
+  [0]=>
+  string(53) "$ -> This represents the dollar sign. hello dollar!!!"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(53) "$ -> This represents the dollar sign. hello dollar!!!"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 2 --
+int(5)
+array(5) {
+  [0]=>
+  string(49) "	
 The quick brown fox jumped over the lazy dog"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(49) "	
 The quick brown fox jumped over the lazy dog"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 3 --
+int(5)
+array(5) {
+  [0]=>
+  string(55) "This is a text with special chars: \!\@\#$\%\^\&\*\(\)\"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(55) "This is a text with special chars: \!\@\#$\%\^\&\*\(\)\"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 4 --
+int(5)
+array(5) {
+  [0]=>
+  string(13) "hello world\t"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(13) "hello world\t"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 5 --
+int(5)
+array(5) {
+  [0]=>
+  string(70) "This is 	a text in bold letters
\s\malong with slashes
+ : HELLO WORLD	"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(70) "This is 	a text in bold letters
\s\malong with slashes
+ : HELLO WORLD	"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+Done
diff --git a/tests/std/array/array_unshift_variation8.phpt b/tests/std/array/array_unshift_variation8.phpt
new file mode 100644
index 00000000..ff87f370
--- /dev/null
+++ b/tests/std/array/array_unshift_variation8.phpt
@@ -0,0 +1,209 @@
+--TEST--
+Test array_unshift() function : usage variations - single quoted strings for 'var' argument
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_unshift() by passing different
+ * single quoted strings for $var argument that is prepended to the array
+ * passed through $array argument
+*/
+
+echo "*** Testing array_unshift() : single quoted strings for \$var argument ***\n";
+
+// array to be passed to $array argument
+$array = array('f' => "first", "s" => 'second', 1, 2.222);
+
+// different variations of single quoted strings to be passed to $var argument
+$vars = array (
+  '\$ -> This represents the dollar sign. hello dollar!!!',
+  '\t\r\v The quick brown fo\fx jumped over the lazy dog',
+  'This is a text with special chars: \!\@\#\$\%\^\&\*\(\)\\',
+  'hello world\\t',
+  'This is \ta text in bold letters\r\s\malong with slashes\n : HELLO WORLD\t'
+);
+
+// loop through the various elements of $arrays to test array_unshift()
+$iterator = 1;
+foreach($vars as $var) {
+  echo "-- Iteration $iterator --\n";
+  $temp_array = $array;  // assign $array to another temporary $temp_array
+
+  /* with default argument */
+  // returns element count in the resulting array after arguments are pushed to
+  // beginning of the given array
+  var_dump( array_unshift($temp_array, $var) );
+
+  // dump the resulting array
+  var_dump($temp_array);
+
+  /* with optional arguments */
+  // returns element count in the resulting array after arguments are pushed to
+  // beginning of the given array
+  $temp_array = $array;
+  var_dump( array_unshift($temp_array, $var, "hello", 'world') );
+
+  // dump the resulting array
+  var_dump($temp_array);
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unshift() : single quoted strings for $var argument ***
+-- Iteration 1 --
+int(5)
+array(5) {
+  [0]=>
+  string(54) "\$ -> This represents the dollar sign. hello dollar!!!"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(54) "\$ -> This represents the dollar sign. hello dollar!!!"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 2 --
+int(5)
+array(5) {
+  [0]=>
+  string(53) "\t\r\v The quick brown fo\fx jumped over the lazy dog"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(53) "\t\r\v The quick brown fo\fx jumped over the lazy dog"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 3 --
+int(5)
+array(5) {
+  [0]=>
+  string(56) "This is a text with special chars: \!\@\#\$\%\^\&\*\(\)\"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(56) "This is a text with special chars: \!\@\#\$\%\^\&\*\(\)\"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 4 --
+int(5)
+array(5) {
+  [0]=>
+  string(13) "hello world\t"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(13) "hello world\t"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 5 --
+int(5)
+array(5) {
+  [0]=>
+  string(74) "This is \ta text in bold letters\r\s\malong with slashes\n : HELLO WORLD\t"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(74) "This is \ta text in bold letters\r\s\malong with slashes\n : HELLO WORLD\t"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+Done
diff --git a/tests/std/array/array_unshift_variation9.phpt b/tests/std/array/array_unshift_variation9.phpt
new file mode 100644
index 00000000..133f8f91
--- /dev/null
+++ b/tests/std/array/array_unshift_variation9.phpt
@@ -0,0 +1,304 @@
+--TEST--
+Test array_unshift() function : usage variations - heredoc strings for 'var' argument
+--FILE--
+<?php
+/*
+ * Testing the functionality of array_unshift() by passing different
+ * heredoc strings for $var argument that is prepended to the array
+ * passed through $array argument
+*/
+
+echo "*** Testing array_unshift() : heredoc strings for \$var argument ***\n";
+
+// heredoc with empty value
+$empty_string = <<<EOT
+EOT;
+
+// heredoc with blank line
+$blank_line = <<<EOT
+
+
+EOT;
+
+// heredoc with multiline string
+$multiline_string = <<<EOT
+hello world
+The big 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 numeric values
+$numeric_string = <<<EOT
+11 < 12. 123 >22
+2222 != 1111.\t 0000 = 0000\n
+EOT;
+
+// heredoc with quote chars & slash
+$quote_char_string = <<<EOT
+This's a string with quotes:
+"strings in double quote";
+'strings in single quote';
+this\line is single quoted /with\slashes
+EOT;
+
+// array to be passed to $array argument
+$array = array('f' => "first", "s" => 'second', 1, 2.222);
+
+// different heredoc strings to be passed to $var argument
+$vars = array(
+  $empty_string,
+  $blank_line,
+  $multiline_string,
+  $diff_whitespaces,
+  $numeric_string,
+  $quote_char_string
+);
+
+// loop through the various elements of $arrays to test array_unshift()
+$iterator = 1;
+foreach($vars as $var) {
+  echo "-- Iteration $iterator --\n";
+  $temp_array = $array;  // assign $array to another temporary $temp_array
+
+  /* with default argument */
+  // returns element count in the resulting array after arguments are pushed to
+  // beginning of the given array
+  var_dump( array_unshift($temp_array, $var) );
+
+  // dump the resulting array
+  var_dump($temp_array);
+
+  /* with all possible arguments */
+  // returns element count in the resulting array after arguments are pushed to
+  // beginning of the given array
+  $temp_array = $array;
+  var_dump( array_unshift($temp_array, $var, "hello", 'world') );
+
+  // dump the resulting array
+  var_dump($temp_array);
+  $iterator++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_unshift() : heredoc strings for $var argument ***
+-- Iteration 1 --
+int(5)
+array(5) {
+  [0]=>
+  string(0) ""
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 2 --
+int(5)
+array(5) {
+  [0]=>
+  string(1) "
+"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(1) "
+"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 3 --
+int(5)
+array(5) {
+  [0]=>
+  string(86) "hello world
+The big brown fox jumped over;
+the lazy dog
+This is a double quoted string"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(86) "hello world
+The big brown fox jumped over;
+the lazy dog
+This is a double quoted string"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 4 --
+int(5)
+array(5) {
+  [0]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(88) "hello
 world	
+1111		 != 2222
+heredoc
+double quoted string. withdifferentwhitespaces"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 5 --
+int(5)
+array(5) {
+  [0]=>
+  string(44) "11 < 12. 123 >22
+2222 != 1111.	 0000 = 0000
+"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(44) "11 < 12. 123 >22
+2222 != 1111.	 0000 = 0000
+"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+-- Iteration 6 --
+int(5)
+array(5) {
+  [0]=>
+  string(123) "This's a string with quotes:
+"strings in double quote";
+'strings in single quote';
+this\line is single quoted /with\slashes"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [1]=>
+  int(1)
+  [2]=>
+  float(2.222)
+}
+int(7)
+array(7) {
+  [0]=>
+  string(123) "This's a string with quotes:
+"strings in double quote";
+'strings in single quote';
+this\line is single quoted /with\slashes"
+  [1]=>
+  string(5) "hello"
+  [2]=>
+  string(5) "world"
+  ["f"]=>
+  string(5) "first"
+  ["s"]=>
+  string(6) "second"
+  [3]=>
+  int(1)
+  [4]=>
+  float(2.222)
+}
+Done
diff --git a/tests/std/array/array_user_key_compare.phpt b/tests/std/array/array_user_key_compare.phpt
new file mode 100644
index 00000000..3bb02c10
--- /dev/null
+++ b/tests/std/array/array_user_key_compare.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Fix UMR in array_user_key_compare (MOPB24)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+function array_compare(&$key1, &$key2)
+{
+    $GLOBALS['a'] =& $key2;
+    unset($key2);
+    return 1;
+}
+function main()
+{
+    $arr = array("A" => 1, "B" => 1);
+    uksort($arr, "array_compare");
+    var_dump($a);
+}
+?>
+--EXPECTF--
+Warning: array_compare(): Argument #1 ($key1) must be passed by reference, value given in %s on line %d
+
+Warning: array_compare(): Argument #2 ($key2) must be passed by reference, value given in %s on line %d
+string(1) "B"
diff --git a/tests/std/array/array_values.phpt b/tests/std/array/array_values.phpt
new file mode 100644
index 00000000..443a4676
--- /dev/null
+++ b/tests/std/array/array_values.phpt
@@ -0,0 +1,233 @@
+--TEST--
+Test array_values() function
+--INI--
+precision=14
+--FILE--
+<?php
+echo "*** Testing array_values() on basic array ***\n";
+$basic_arr = array( 1, 2, 2.0, "asdasd", array(1,2,3) );
+var_dump( array_values($basic_arr) );
+
+echo "\n*** Testing array_values() on various arrays ***";
+$arrays = array (
+  array(),
+  array(0),
+  array(-1),
+  array( array() ),
+  array("Hello"),
+  array(""),
+  array("", array()),
+  array(1,2,3),
+  array(1,2,3, array()),
+  array(1,2,3, array(4,6)),
+  array("a" => 1, "b" => 2, "c" =>3),
+  array(0 => 0, 1 => 1, 2 => 2),
+  array(TRUE, FALSE, NULL, true, false, null, "TRUE", "FALSE",
+        "NULL", "\x000", "\000"),
+  array("Hi" => 1, "Hello" => 2, "World" => 3),
+  array("a" => "abcd", "a" => "", "ab" => -6, "cd" => -0.5 ),
+  array(0 => array(), 1=> array(0), 2 => array(1), ""=> array(), ""=>"" )
+);
+
+$i = 0;
+/* loop through to test array_values() with different arrays given above */
+foreach ($arrays as $array) {
+  echo "\n-- Iteration $i --\n";
+  var_dump( array_values($array) );
+  $i++;
+}
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing array_values() on basic array ***
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  float(2)
+  [3]=>
+  string(6) "asdasd"
+  [4]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+
+*** Testing array_values() on various arrays ***
+-- Iteration 0 --
+array(0) {
+}
+
+-- Iteration 1 --
+array(1) {
+  [0]=>
+  int(0)
+}
+
+-- Iteration 2 --
+array(1) {
+  [0]=>
+  int(-1)
+}
+
+-- Iteration 3 --
+array(1) {
+  [0]=>
+  array(0) {
+  }
+}
+
+-- Iteration 4 --
+array(1) {
+  [0]=>
+  string(5) "Hello"
+}
+
+-- Iteration 5 --
+array(1) {
+  [0]=>
+  string(0) ""
+}
+
+-- Iteration 6 --
+array(2) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  array(0) {
+  }
+}
+
+-- Iteration 7 --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+
+-- Iteration 8 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  array(0) {
+  }
+}
+
+-- Iteration 9 --
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  array(2) {
+    [0]=>
+    int(4)
+    [1]=>
+    int(6)
+  }
+}
+
+-- Iteration 10 --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+
+-- Iteration 11 --
+array(3) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+}
+
+-- Iteration 12 --
+array(11) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(false)
+  [2]=>
+  NULL
+  [3]=>
+  bool(true)
+  [4]=>
+  bool(false)
+  [5]=>
+  NULL
+  [6]=>
+  string(4) "TRUE"
+  [7]=>
+  string(5) "FALSE"
+  [8]=>
+  string(4) "NULL"
+  [9]=>
+  string(2) "%00"
+  [10]=>
+  string(1) "%0"
+}
+
+-- Iteration 13 --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+
+-- Iteration 14 --
+array(3) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  int(-6)
+  [2]=>
+  float(-0.5)
+}
+
+-- Iteration 15 --
+array(4) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(1)
+  }
+  [3]=>
+  string(0) ""
+}
+Done
diff --git a/tests/std/array/array_values_basic.phpt b/tests/std/array/array_values_basic.phpt
new file mode 100644
index 00000000..f7434ad6
--- /dev/null
+++ b/tests/std/array/array_values_basic.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Test array_values() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of array_values()
+ */
+
+echo "*** Testing array_values() : basic functionality ***\n";
+
+
+// Initialise all required variables
+$input = array('zero', 'one', 'two', 'three' => 3, 10 => 'ten');
+
+// Calling array_values() with all possible arguments
+var_dump( array_values($input) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_values() : basic functionality ***
+array(5) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(3) "two"
+  [3]=>
+  int(3)
+  [4]=>
+  string(3) "ten"
+}
+Done
diff --git a/tests/std/array/array_values_variation.phpt b/tests/std/array/array_values_variation.phpt
new file mode 100644
index 00000000..15eb77da
--- /dev/null
+++ b/tests/std/array/array_values_variation.phpt
@@ -0,0 +1,76 @@
+--TEST--
+Test array_values() function (variation)
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platform only");
+?>
+--INI--
+precision=14
+--FILE--
+<?php
+
+echo "\n*** Testing array_values() with resource type ***\n";
+$resource1 = fopen(__FILE__, "r");  // Creating a file resource
+$resource2 = opendir(".");  // Creating a dir resource
+
+/* creating an array with resources as elements */
+$arr_resource = array( "a" => $resource1, "b" => $resource2);
+var_dump( array_values($arr_resource) );
+
+echo "\n*** Testing array_values() with range checking ***\n";
+$arr_range = array(
+  2147483647,
+  2147483648,
+  -2147483647,
+  -2147483648,
+  -0,
+  0,
+  -2147483649
+);
+var_dump( array_values($arr_range) );
+
+echo "\n*** Testing array_values() on an array created on the fly ***\n";
+var_dump( array_values(array(1,2,3)) );
+var_dump( array_values(array()) );  // null array
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing array_values() with resource type ***
+array(2) {
+  [0]=>
+  resource(%d) of type (stream)
+  [1]=>
+  resource(%d) of type (stream)
+}
+
+*** Testing array_values() with range checking ***
+array(7) {
+  [0]=>
+  int(2147483647)
+  [1]=>
+  float(2147483648)
+  [2]=>
+  int(-2147483647)
+  [3]=>
+  float(-2147483648)
+  [4]=>
+  int(0)
+  [5]=>
+  int(0)
+  [6]=>
+  float(-2147483649)
+}
+
+*** Testing array_values() on an array created on the fly ***
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(0) {
+}
+Done
diff --git a/tests/std/array/array_values_variation2.phpt b/tests/std/array/array_values_variation2.phpt
new file mode 100644
index 00000000..c4efdb92
--- /dev/null
+++ b/tests/std/array/array_values_variation2.phpt
@@ -0,0 +1,173 @@
+--TEST--
+Test array_values() function : usage variations - arrays of 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()
+{
+    /*
+     * Pass arrays of different data types as $input argument to array_values() to test behaviour
+     */
+    echo "*** Testing array_values() : usage variations ***\n";
+    //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");
+    // arrays of different data types to be passed as $input
+    $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 string' => array("", ''),
+        /*6*/
+        'empty array' => array(),
+        // string data
+        /*7*/
+        'string' => array("string", 'string', $heredoc),
+        // object data
+        /*8*/
+        'object' => array(new classA()),
+        // undefined data
+        /*9*/
+        'undefined' => array(@$undefined_var),
+        // unset data
+        /*10*/
+        'unset' => array(@$unset_var),
+        // resource variable
+        /*11*/
+        'resource' => array($fp),
+    );
+    // loop through each element of $inputs to check the behavior of array_values()
+    $iterator = 1;
+    foreach ($inputs as $key => $input) {
+        echo "\n-- Iteration {$iterator}: {$key} data --\n";
+        var_dump(array_values($input));
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_values() : usage variations ***
+
+-- Iteration 1: int data --
+array(4) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(12345)
+  [3]=>
+  int(-2345)
+}
+
+-- Iteration 2: float data --
+array(5) {
+  [0]=>
+  float(10.5)
+  [1]=>
+  float(-10.5)
+  [2]=>
+  float(123456789000)
+  [3]=>
+  float(1.23456789E-9)
+  [4]=>
+  float(0.5)
+}
+
+-- Iteration 3: null data --
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+
+-- Iteration 4: bool data --
+array(4) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(false)
+}
+
+-- Iteration 5: empty string data --
+array(2) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+}
+
+-- Iteration 6: empty array data --
+array(0) {
+}
+
+-- Iteration 7: string data --
+array(3) {
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(6) "string"
+  [2]=>
+  string(11) "hello world"
+}
+
+-- Iteration 8: object data --
+array(1) {
+  [0]=>
+  object(classA)#%d (0) {
+  }
+}
+
+-- Iteration 9: undefined data --
+array(1) {
+  [0]=>
+  NULL
+}
+
+-- Iteration 10: unset data --
+array(1) {
+  [0]=>
+  NULL
+}
+
+-- Iteration 11: resource data --
+array(1) {
+  [0]=>
+  resource(%d) of type (stream)
+}
+Done
diff --git a/tests/std/array/array_values_variation3.phpt b/tests/std/array/array_values_variation3.phpt
new file mode 100644
index 00000000..43efed83
--- /dev/null
+++ b/tests/std/array/array_values_variation3.phpt
@@ -0,0 +1,169 @@
+--TEST--
+Test array_values() function : usage variations - array keys different data types
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Pass arrays where the keys are different data types as $input argument
+ * to array_values() to test behaviour
+ */
+
+echo "*** Testing array_values() : usage variations ***\n";
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// heredoc string
+$heredoc = <<<EOT
+hello world
+EOT;
+
+// unexpected values to be passed as $input
+$inputs = array(
+
+       // int data
+/*1*/  'int' => array(
+       0 => 'zero',
+       1 => 'one',
+       12345 => 'positive',
+       -2345 => 'negative',
+       ),
+
+       // null data
+/*4*/ 'null uppercase' => array(
+       NULL => 'null 1',
+       ),
+
+/*5*/  'null lowercase' => array(
+       null => 'null 2',
+       ),
+
+       // boolean data
+/*6*/ 'bool lowercase' => array(
+       true => 'lowert',
+       false => 'lowerf',
+       ),
+
+/*7*/  'bool uppercase' => array(
+       TRUE => 'uppert',
+       FALSE => 'upperf',
+       ),
+
+       // empty data
+/*8*/ 'empty double quotes' => array(
+       "" => 'emptyd',
+       ),
+
+/*9*/  'empty single quotes' => array(
+       '' => 'emptys',
+       ),
+
+       // string data
+/*10*/ 'string' => array(
+       "stringd" => 'stringd',
+       'strings' => 'strings',
+       $heredoc => 'stringh',
+       ),
+
+       // undefined data
+/*11*/ 'undefined' => array(
+       @$undefined_var => 'undefined',
+       ),
+
+       // unset data
+/*12*/ 'unset' => array(
+       @$unset_var => 'unset',
+       ),
+);
+
+// loop through each element of $inputs to check the behavior of array_values()
+$iterator = 1;
+foreach($inputs as $key => $input) {
+  echo "\n-- Iteration $iterator: $key data --\n";
+  var_dump( array_values($input) );
+  $iterator++;
+};
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_values() : usage variations ***
+
+-- Iteration 1: int data --
+array(4) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  string(8) "positive"
+  [3]=>
+  string(8) "negative"
+}
+
+-- Iteration 2: null uppercase data --
+array(1) {
+  [0]=>
+  string(6) "null 1"
+}
+
+-- Iteration 3: null lowercase data --
+array(1) {
+  [0]=>
+  string(6) "null 2"
+}
+
+-- Iteration 4: bool lowercase data --
+array(2) {
+  [0]=>
+  string(6) "lowert"
+  [1]=>
+  string(6) "lowerf"
+}
+
+-- Iteration 5: bool uppercase data --
+array(2) {
+  [0]=>
+  string(6) "uppert"
+  [1]=>
+  string(6) "upperf"
+}
+
+-- Iteration 6: empty double quotes data --
+array(1) {
+  [0]=>
+  string(6) "emptyd"
+}
+
+-- Iteration 7: empty single quotes data --
+array(1) {
+  [0]=>
+  string(6) "emptys"
+}
+
+-- Iteration 8: string data --
+array(3) {
+  [0]=>
+  string(7) "stringd"
+  [1]=>
+  string(7) "strings"
+  [2]=>
+  string(7) "stringh"
+}
+
+-- Iteration 9: undefined data --
+array(1) {
+  [0]=>
+  string(9) "undefined"
+}
+
+-- Iteration 10: unset data --
+array(1) {
+  [0]=>
+  string(5) "unset"
+}
+Done
diff --git a/tests/std/array/array_values_variation4.phpt b/tests/std/array/array_values_variation4.phpt
new file mode 100644
index 00000000..17e7bdd4
--- /dev/null
+++ b/tests/std/array/array_values_variation4.phpt
@@ -0,0 +1,93 @@
+--TEST--
+Test array_values() function : usage variations - multi-dimensional arrays
+--FILE--
+<?php
+/*
+ * Test array_values when:
+ * 1. Passed a two-dimensional array as $input argument
+ * 2. Passed a sub-array as $input argument
+ * 3. Passed an infinitely recursive multi-dimensional array
+ */
+
+echo "*** Testing array_values() : usage variations ***\n";
+
+$input = array ('zero' => 'zero', 'un' => 'one', 'sub' => array (1, 2, 3));
+
+echo "\n-- Array values of a two-dimensional array --\n";
+var_dump(array_values($input));
+
+echo "\n-- Array values of a sub-array --\n";
+var_dump(array_values($input['sub']));
+
+// get an infinitely recursive array
+$input[] = &$input;
+echo "\n-- Array values of an infinitely recursive array --\n";
+var_dump(array_values($input));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_values() : usage variations ***
+
+-- Array values of a two-dimensional array --
+array(3) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+
+-- Array values of a sub-array --
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+
+-- Array values of an infinitely recursive array --
+array(4) {
+  [0]=>
+  string(4) "zero"
+  [1]=>
+  string(3) "one"
+  [2]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  [3]=>
+  &array(4) {
+    ["zero"]=>
+    string(4) "zero"
+    ["un"]=>
+    string(3) "one"
+    ["sub"]=>
+    array(3) {
+      [0]=>
+      int(1)
+      [1]=>
+      int(2)
+      [2]=>
+      int(3)
+    }
+    [0]=>
+    *RECURSION*
+  }
+}
+Done
diff --git a/tests/std/array/array_values_variation5.phpt b/tests/std/array/array_values_variation5.phpt
new file mode 100644
index 00000000..8dbd7ca3
--- /dev/null
+++ b/tests/std/array/array_values_variation5.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Test array_values() function : usage variations - internal array pointer
+--FILE--
+<?php
+/*
+ * Test the position of the internal array pointer after a call to array_values
+ */
+
+echo "*** Testing array_values() : usage variations ***\n";
+
+$input = array ('one' => 'un', 'two' => 'deux', 'three' => 'trois');
+
+echo "\n-- Call array_values() --\n";
+var_dump($result = array_values($input));
+
+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_values() : usage variations ***
+
+-- Call array_values() --
+array(3) {
+  [0]=>
+  string(2) "un"
+  [1]=>
+  string(4) "deux"
+  [2]=>
+  string(5) "trois"
+}
+-- Position of Internal Pointer in Result: --
+0 => un
+
+-- Position of Internal Pointer in Original Array: --
+one => un
+Done
diff --git a/tests/std/array/array_values_variation6.phpt b/tests/std/array/array_values_variation6.phpt
new file mode 100644
index 00000000..b4c953c4
--- /dev/null
+++ b/tests/std/array/array_values_variation6.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Test array_values() function : usage variations - Referenced variables
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+/*
+ * Test array_values() when:
+ * 1. Passed an array made up of referenced variables
+ * 2. Passed an array by reference
+ */
+
+echo "*** Testing array_values() : usage variations ***\n";
+
+$val1 = 'one';
+$val2 = 'two';
+$val3 = 'three';
+
+echo "\n-- \$input is an array made up of referenced variables: --\n";
+$input = array(&$val1, &$val2, &$val3);
+var_dump($result1 = array_values($input));
+
+echo "Change \$val2 and check result of array_values():\n";
+$val2 = 'deux';
+var_dump($result1);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_values() : usage variations ***
+
+-- $input is an array made up of referenced variables: --
+array(3) {
+  [0]=>
+  &string(3) "one"
+  [1]=>
+  &string(3) "two"
+  [2]=>
+  &string(5) "three"
+}
+Change $val2 and check result of array_values():
+array(3) {
+  [0]=>
+  &string(3) "one"
+  [1]=>
+  &string(4) "deux"
+  [2]=>
+  &string(5) "three"
+}
+Done
diff --git a/tests/std/array/array_values_variation7.phpt b/tests/std/array/array_values_variation7.phpt
new file mode 100644
index 00000000..b17451ed
--- /dev/null
+++ b/tests/std/array/array_values_variation7.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Test array_values() function : usage variations - Internal order check
+--FILE--
+<?php
+/*
+ * Check that array_values is re-assigning keys according to the internal order of the array,
+ * and is not dependent on the \$input argument's keys
+ */
+
+echo "*** Testing array_values() : usage variations ***\n";
+
+// populate array with 'default' keys in reverse order
+$input = array(3 => 'three', 2 => 'two', 1 => 'one', 0 => 'zero');
+
+echo "\n-- \$input argument: --\n";
+var_dump($input);
+
+echo "\n-- Result of array_values() --\n";
+var_dump(array_values($input));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_values() : usage variations ***
+
+-- $input argument: --
+array(4) {
+  [3]=>
+  string(5) "three"
+  [2]=>
+  string(3) "two"
+  [1]=>
+  string(3) "one"
+  [0]=>
+  string(4) "zero"
+}
+
+-- Result of array_values() --
+array(4) {
+  [0]=>
+  string(5) "three"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  string(3) "one"
+  [3]=>
+  string(4) "zero"
+}
+Done
diff --git a/tests/std/array/array_values_variation_64bit.phpt b/tests/std/array/array_values_variation_64bit.phpt
new file mode 100644
index 00000000..066d35da
--- /dev/null
+++ b/tests/std/array/array_values_variation_64bit.phpt
@@ -0,0 +1,74 @@
+--TEST--
+Test array_values() function
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only");
+?>
+--INI--
+precision=14
+--FILE--
+<?php
+
+echo "\n*** Testing array_values() with resource type ***\n";
+$resource1 = fopen(__FILE__, "r");  // Creating a file resource
+$resource2 = opendir(".");  // Creating a dir resource
+
+/* creating an array with resources as elements */
+$arr_resource = array( "a" => $resource1, "b" => $resource2);
+var_dump( array_values($arr_resource) );
+
+echo "\n*** Testing array_values() with range checking ***\n";
+$arr_range = array(
+  2147483647,
+  2147483648,
+  -2147483647,
+  -2147483648,
+  -0,
+  0,
+  -2147483649
+);
+var_dump( array_values($arr_range) );
+
+echo "\n*** Testing array_values() on an array created on the fly ***\n";
+var_dump( array_values(array(1,2,3)) );
+var_dump( array_values(array()) );  // null array
+
+?>
+--EXPECTF--
+*** Testing array_values() with resource type ***
+array(2) {
+  [0]=>
+  resource(%d) of type (stream)
+  [1]=>
+  resource(%d) of type (stream)
+}
+
+*** Testing array_values() with range checking ***
+array(7) {
+  [0]=>
+  int(2147483647)
+  [1]=>
+  int(2147483648)
+  [2]=>
+  int(-2147483647)
+  [3]=>
+  int(-2147483648)
+  [4]=>
+  int(0)
+  [5]=>
+  int(0)
+  [6]=>
+  int(-2147483649)
+}
+
+*** Testing array_values() on an array created on the fly ***
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(0) {
+}
diff --git a/tests/std/array/array_walk.phpt b/tests/std/array/array_walk.phpt
new file mode 100644
index 00000000..db454a5a
--- /dev/null
+++ b/tests/std/array/array_walk.phpt
@@ -0,0 +1,38 @@
+--TEST--
+array_walk() tests
+--SKIPIF--
+<?php die("skip AOT array_walk differs from PHP"); ?>
+--FILE--
+<?php
+function foo($v1, $v2, $v3)
+{
+    var_dump($v1);
+    var_dump($v2);
+    var_dump($v3);
+}
+function foo2($v1, $v2, $v3)
+{
+    throw new Exception($v3);
+}
+function main()
+{
+    $var = array(1, 2);
+    var_dump(array_walk($var, "foo", "data"));
+    try {
+        var_dump(array_walk($var, "foo2", "data"));
+    } catch (Exception $e) {
+        var_dump($e->getMessage());
+    }
+    echo "Done\n";
+}
+?>
+--EXPECT--
+int(1)
+int(0)
+string(4) "data"
+int(2)
+int(1)
+string(4) "data"
+bool(true)
+string(4) "data"
+Done
diff --git a/tests/std/array/array_walk_basic1.phpt b/tests/std/array/array_walk_basic1.phpt
new file mode 100644
index 00000000..f4db6f29
--- /dev/null
+++ b/tests/std/array/array_walk_basic1.phpt
@@ -0,0 +1,75 @@
+--TEST--
+Test array_walk() function : basic functionality - regular array
+--FILE--
+<?php
+function test_print($item, $key)
+{
+    // dump the arguments to check that they are passed
+    // with proper type
+    var_dump($item);
+    // value
+    var_dump($key);
+    // key
+    echo "\n";
+    // new line to separate the output between each element
+}
+function with_userdata($item, $key, $user_data)
+{
+    // dump the arguments to check that they are passed
+    // with proper type
+    var_dump($item);
+    // value
+    var_dump($key);
+    // key
+    var_dump($user_data);
+    // user supplied data
+    echo "\n";
+    // new line to separate the output between each element
+}
+function main()
+{
+    echo "*** Testing array_walk() : basic functionality ***\n";
+    // regular array
+    $fruits = array("lemon", "orange", "banana", "apple");
+    echo "-- Using array_walk() with default parameters to show array contents --\n";
+    var_dump(array_walk($fruits, 'test_print'));
+    echo "-- Using array_walk() with all parameters --\n";
+    var_dump(array_walk($fruits, 'with_userdata', "Added"));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk() : basic functionality ***
+-- Using array_walk() with default parameters to show array contents --
+string(5) "lemon"
+int(0)
+
+string(6) "orange"
+int(1)
+
+string(6) "banana"
+int(2)
+
+string(5) "apple"
+int(3)
+
+bool(true)
+-- Using array_walk() with all parameters --
+string(5) "lemon"
+int(0)
+string(5) "Added"
+
+string(6) "orange"
+int(1)
+string(5) "Added"
+
+string(6) "banana"
+int(2)
+string(5) "Added"
+
+string(5) "apple"
+int(3)
+string(5) "Added"
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_basic2.phpt b/tests/std/array/array_walk_basic2.phpt
new file mode 100644
index 00000000..42df9939
--- /dev/null
+++ b/tests/std/array/array_walk_basic2.phpt
@@ -0,0 +1,91 @@
+--TEST--
+Test array_walk() function : basic functionality - associative array
+--FILE--
+<?php
+function test_alter(&$item, $key, $prefix)
+{
+    // dump the arguments to check that they are passed
+    // with proper type
+    var_dump($item);
+    // value
+    var_dump($key);
+    // key
+    var_dump($prefix);
+    // additional argument passed to callback function
+    echo "\n";
+    // new line to separate the output between each element
+}
+function test_print($item, $key)
+{
+    // dump the arguments to check that they are passed
+    // with proper type
+    var_dump($item);
+    // value
+    var_dump($key);
+    // key
+    echo "\n";
+    // new line to separate the output between each element
+}
+function main()
+{
+    echo "*** Testing array_walk() : basic functionality ***\n";
+    // associative array
+    $fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
+    echo "-- Using array_walk with default parameters to show array contents --\n";
+    var_dump(array_walk($fruits, 'test_print'));
+    echo "-- Using array_walk with one optional parameter to modify contents --\n";
+    var_dump(array_walk($fruits, 'test_alter', 'fruit'));
+    echo "-- Using array_walk with default parameters to show modified array contents --\n";
+    var_dump(array_walk($fruits, 'test_print'));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk() : basic functionality ***
+-- Using array_walk with default parameters to show array contents --
+string(5) "lemon"
+string(1) "d"
+
+string(6) "orange"
+string(1) "a"
+
+string(6) "banana"
+string(1) "b"
+
+string(5) "apple"
+string(1) "c"
+
+bool(true)
+-- Using array_walk with one optional parameter to modify contents --
+string(5) "lemon"
+string(1) "d"
+string(5) "fruit"
+
+string(6) "orange"
+string(1) "a"
+string(5) "fruit"
+
+string(6) "banana"
+string(1) "b"
+string(5) "fruit"
+
+string(5) "apple"
+string(1) "c"
+string(5) "fruit"
+
+bool(true)
+-- Using array_walk with default parameters to show modified array contents --
+string(5) "lemon"
+string(1) "d"
+
+string(6) "orange"
+string(1) "a"
+
+string(6) "banana"
+string(1) "b"
+
+string(5) "apple"
+string(1) "c"
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_closure.phpt b/tests/std/array/array_walk_closure.phpt
new file mode 100644
index 00000000..e7ddf112
--- /dev/null
+++ b/tests/std/array/array_walk_closure.phpt
@@ -0,0 +1,247 @@
+--TEST--
+array_walk() closure tests
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference parameters in closures");
+?>
+
+--FILE--
+<?php
+function sum_it_up_object($value, $key, $udata)
+{
+    var_dump($udata);
+    $udata->sum += $value;
+}
+function sum_it_up_array($value, $key, $udata)
+{
+    var_dump($udata);
+    $udata['sum'] += $value;
+}
+function main()
+{
+    $ar = ["one" => 1, "two" => 2, "three" => 3];
+    var_dump(array_walk($ar, function () {
+        var_dump(func_get_args());
+    }));
+    echo "\nclosure with array\n";
+    $ar = ["one" => 1, "two" => 2, "three" => 3];
+    $user_data = ["sum" => 42];
+    $func = function ($value, $key, &$udata) {
+        var_dump($udata);
+        $udata["sum"] += $value;
+    };
+    var_dump(array_walk($ar, $func, $user_data));
+    echo "End result:";
+    var_dump($user_data["sum"]);
+    echo "\nclosure with use\n";
+    $ar = ["one" => 1, "two" => 2, "three" => 3];
+    $user_data = ["sum" => 42];
+    $func = function ($value, $key) use (&$user_data) {
+        var_dump($user_data);
+        $user_data["sum"] += $value;
+    };
+    var_dump(array_walk($ar, $func, $user_data));
+    echo "End result:";
+    var_dump($user_data["sum"]);
+    echo "\nclosure with object\n";
+    $ar = ["one" => 1, "two" => 2, "three" => 3];
+    $user_data = (object) ["sum" => 42];
+    $func = function ($value, $key, &$udata) {
+        var_dump($udata);
+        $udata->sum += $value;
+    };
+    var_dump(array_walk($ar, $func, $user_data));
+    echo "End result:";
+    var_dump($user_data->sum);
+    echo "\nfunction with object\n";
+    $ar = ["one" => 1, "two" => 2, "three" => 3];
+    $user_data = (object) ["sum" => 42];
+    var_dump(array_walk($ar, "sum_it_up_object", $user_data));
+    echo "End result:";
+    var_dump($user_data->sum);
+    echo "\nfunction with array\n";
+    $ar = ["one" => 1, "two" => 2, "three" => 3];
+    $user_data = ["sum" => 42];
+    var_dump(array_walk($ar, "sum_it_up_array", $user_data));
+    echo "End result:";
+    var_dump($user_data['sum']);
+    echo "\nclosure and exception\n";
+    $ar = ["one" => 1, "two" => 2, "three" => 3];
+    try {
+        var_dump(array_walk($ar, function ($v, $k) {
+            if ($v == 2) {
+                throw new Exception();
+            }
+        }));
+    } catch (Exception $e) {
+        var_dump($e->getTrace());
+    }
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "one"
+}
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  string(3) "two"
+}
+array(2) {
+  [0]=>
+  int(3)
+  [1]=>
+  string(5) "three"
+}
+bool(true)
+
+closure with array
+
+Warning: {closure:%s:%d}(): Argument #3 ($udata) must be passed by reference, value given in %s on line %d
+array(1) {
+  ["sum"]=>
+  int(42)
+}
+
+Warning: {closure:%s:%d}(): Argument #3 ($udata) must be passed by reference, value given in %s on line %d
+array(1) {
+  ["sum"]=>
+  int(42)
+}
+
+Warning: {closure:%s:%d}(): Argument #3 ($udata) must be passed by reference, value given in %s on line %d
+array(1) {
+  ["sum"]=>
+  int(42)
+}
+bool(true)
+End result:int(42)
+
+closure with use
+array(1) {
+  ["sum"]=>
+  int(42)
+}
+array(1) {
+  ["sum"]=>
+  int(43)
+}
+array(1) {
+  ["sum"]=>
+  int(45)
+}
+bool(true)
+End result:int(48)
+
+closure with object
+
+Warning: {closure:%s:%d}(): Argument #3 ($udata) must be passed by reference, value given in %s on line %d
+object(stdClass)#1 (1) {
+  ["sum"]=>
+  int(42)
+}
+
+Warning: {closure:%s:%d}(): Argument #3 ($udata) must be passed by reference, value given in %s on line %d
+object(stdClass)#1 (1) {
+  ["sum"]=>
+  int(43)
+}
+
+Warning: {closure:%s:%d}(): Argument #3 ($udata) must be passed by reference, value given in %s on line %d
+object(stdClass)#1 (1) {
+  ["sum"]=>
+  int(45)
+}
+bool(true)
+End result:int(48)
+
+function with object
+object(stdClass)#2 (1) {
+  ["sum"]=>
+  int(42)
+}
+object(stdClass)#2 (1) {
+  ["sum"]=>
+  int(43)
+}
+object(stdClass)#2 (1) {
+  ["sum"]=>
+  int(45)
+}
+bool(true)
+End result:int(48)
+
+function with array
+array(1) {
+  ["sum"]=>
+  int(42)
+}
+array(1) {
+  ["sum"]=>
+  int(42)
+}
+array(1) {
+  ["sum"]=>
+  int(42)
+}
+bool(true)
+End result:int(42)
+
+closure and exception
+array(2) {
+  [0]=>
+  array(2) {
+    ["function"]=>
+    string(%d) "{closure:%s:%d}"
+    ["args"]=>
+    array(2) {
+      [0]=>
+      int(2)
+      [1]=>
+      string(3) "two"
+    }
+  }
+  [1]=>
+  array(4) {
+    ["file"]=>
+    string(%d) "%s"
+    ["line"]=>
+    int(%d)
+    ["function"]=>
+    string(10) "array_walk"
+    ["args"]=>
+    array(2) {
+      [0]=>
+      array(3) {
+        ["one"]=>
+        int(1)
+        ["two"]=>
+        int(2)
+        ["three"]=>
+        int(3)
+      }
+      [1]=>
+      object(Closure)#%d (4) {
+        ["name"]=>
+        string(%d) "{closure:%s:%d}"
+        ["file"]=>
+        string(%d) "%s"
+        ["line"]=>
+        int(%d)
+        ["parameter"]=>
+        array(2) {
+          ["$v"]=>
+          string(10) "<required>"
+          ["$k"]=>
+          string(10) "<required>"
+        }
+      }
+    }
+  }
+}
+Done
diff --git a/tests/std/array/array_walk_error2.phpt b/tests/std/array/array_walk_error2.phpt
new file mode 100644
index 00000000..7ab3b22a
--- /dev/null
+++ b/tests/std/array/array_walk_error2.phpt
@@ -0,0 +1,64 @@
+--TEST--
+Test array_walk() function : error conditions - callback parameters
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support testing invalid argument counts in this way");
+?>
+
+--FILE--
+<?php
+function callback1($value, $key, $user_data)
+{
+    echo "\ncallback1() invoked \n";
+}
+function callback2($value, $key, $user_data1, $user_data2)
+{
+    echo "\ncallback2() invoked \n";
+}
+function main()
+{
+    /*
+     * Testing array_walk() by passing more number of parameters to callback function
+     */
+    $input = array(1);
+    echo "*** Testing array_walk() : error conditions - callback parameters ***\n";
+    // expected: Missing argument Warning
+    try {
+        var_dump(array_walk($input, "callback1"));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    try {
+        var_dump(array_walk($input, "callback2", 4));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    // expected: Warning is suppressed
+    try {
+        var_dump(@array_walk($input, "callback1"));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    try {
+        var_dump(@array_walk($input, "callback2", 4));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "-- Testing array_walk() function with too many callback parameters --\n";
+    try {
+        var_dump(array_walk($input, "callback1", 20, 10));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk() : error conditions - callback parameters ***
+Exception: Too few arguments to function callback1(), 2 passed and exactly 3 expected
+Exception: Too few arguments to function callback2(), 3 passed and exactly 4 expected
+Exception: Too few arguments to function callback1(), 2 passed and exactly 3 expected
+Exception: Too few arguments to function callback2(), 3 passed and exactly 4 expected
+-- Testing array_walk() function with too many callback parameters --
+Exception: array_walk() expects at most 3 arguments, 4 given
+Done
diff --git a/tests/std/array/array_walk_object1.phpt b/tests/std/array/array_walk_object1.phpt
new file mode 100644
index 00000000..9c241124
--- /dev/null
+++ b/tests/std/array/array_walk_object1.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Test array_walk() function : object functionality
+--FILE--
+<?php
+/*
+* Passing object in place of 'input' argument to test object functionality
+*/
+
+function callback($value, $key, $user_data)
+{
+  var_dump($key);
+  var_dump($value);
+  var_dump($user_data);
+  echo "\n";
+}
+
+class MyClass
+{
+  private $pri_value;
+  public $pub_value;
+  protected $pro_value;
+  public function __construct($setVal)
+  {
+    $this->pri_value = $setVal;
+    $this->pub_value = $setVal;
+    $this->pro_value = $setVal;
+  }
+};
+
+function main() {
+echo "*** Testing array_walk() : object functionality ***\n";
+
+// object for 'input' argument
+$input = new MyClass(10);
+
+var_dump( array_walk($input, "callback", 1));
+
+echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_walk() : object functionality ***
+string(18) "%r\0%rMyClass%r\0%rpri_value"
+int(10)
+int(1)
+
+string(9) "pub_value"
+int(10)
+int(1)
+
+string(12) "%r\0%r*%r\0%rpro_value"
+int(10)
+int(1)
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_object2.phpt b/tests/std/array/array_walk_object2.phpt
new file mode 100644
index 00000000..f49be31a
--- /dev/null
+++ b/tests/std/array/array_walk_object2.phpt
@@ -0,0 +1,94 @@
+--TEST--
+Test array_walk() function : object functionality - array of objects
+--FILE--
+<?php
+/*
+* Testing array_walk() with an array of objects
+*/
+
+function callback_private($value, $key, $addValue)
+{
+  echo "value : ";
+  var_dump($value->getValue());
+  echo "key : ";
+  var_dump($key);
+}
+
+function callback_public($value, $key)
+{
+  echo "value : ";
+  var_dump($value->pub_value);
+}
+function callback_protected($value, $key)
+{
+  echo "value : ";
+  var_dump($value->get_pro_value());
+}
+
+class MyClass
+{
+  private $pri_value;
+  public $pub_value;
+  protected $pro_value;
+  public function __construct($setVal)
+  {
+    $this->pri_value = $setVal;
+    $this->pub_value = $setVal;
+    $this->pro_value = $setVal;
+  }
+  public function getValue()
+  {
+    return $this->pri_value;
+  }
+  public function get_pro_value()
+  {
+    return $this->pro_value;
+  }
+};
+
+function main() {
+echo "*** Testing array_walk() : array of objects ***\n";
+
+// array containing objects of MyClass
+$input = array (
+  new MyClass(3),
+  new MyClass(10),
+  new MyClass(20),
+  new MyClass(-10)
+);
+
+echo "-- For private member --\n";
+var_dump( array_walk($input, "callback_private", 1));
+echo "-- For public member --\n";
+var_dump( array_walk($input, "callback_public"));
+echo "-- For protected member --\n";
+var_dump( array_walk($input, "callback_protected"));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk() : array of objects ***
+-- For private member --
+value : int(3)
+key : int(0)
+value : int(10)
+key : int(1)
+value : int(20)
+key : int(2)
+value : int(-10)
+key : int(3)
+bool(true)
+-- For public member --
+value : int(3)
+value : int(10)
+value : int(20)
+value : int(-10)
+bool(true)
+-- For protected member --
+value : int(3)
+value : int(10)
+value : int(20)
+value : int(-10)
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_objects.phpt b/tests/std/array/array_walk_objects.phpt
new file mode 100644
index 00000000..a481d3c5
--- /dev/null
+++ b/tests/std/array/array_walk_objects.phpt
@@ -0,0 +1,46 @@
+--TEST--
+array_walk() and objects
+--FILE--
+<?php
+function walk($key, $value)
+{
+    var_dump($value, $key);
+}
+class test
+{
+    private $var_pri = "test_private";
+    protected $var_pro = "test_protected";
+    public $var_pub = "test_public";
+}
+function main()
+{
+    $stdclass = new stdclass();
+    $stdclass->foo = "foo";
+    $stdclass->bar = "bar";
+    array_walk($stdclass, "walk");
+    $t = new test();
+    array_walk($t, "walk");
+    $var = array();
+    array_walk($var, "walk");
+    $var_str = "";
+    try {
+        array_walk($var_str, "walk");
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+string(3) "foo"
+string(3) "foo"
+string(3) "bar"
+string(3) "bar"
+string(13) "%r\0%rtest%r\0%rvar_pri"
+string(12) "test_private"
+string(10) "%r\0%r*%r\0%rvar_pro"
+string(14) "test_protected"
+string(7) "var_pub"
+string(11) "test_public"
+array_walk(): Argument #1 ($array) must be of type array, string given
+Done
diff --git a/tests/std/array/array_walk_rec_objects.phpt b/tests/std/array/array_walk_rec_objects.phpt
new file mode 100644
index 00000000..a26e8989
--- /dev/null
+++ b/tests/std/array/array_walk_rec_objects.phpt
@@ -0,0 +1,46 @@
+--TEST--
+array_walk_recursive() and objects
+--FILE--
+<?php
+function walk($key, $value)
+{
+    var_dump($value, $key);
+}
+class test
+{
+    private $var_pri = "test_private";
+    protected $var_pro = "test_protected";
+    public $var_pub = "test_public";
+}
+function main()
+{
+    $stdclass = new stdclass();
+    $stdclass->foo = "foo";
+    $stdclass->bar = "bar";
+    array_walk_recursive($stdclass, "walk");
+    $t = new test();
+    array_walk_recursive($t, "walk");
+    $var = array();
+    array_walk_recursive($var, "walk");
+    $var_str = "";
+    try {
+        array_walk_recursive($var_str, "walk");
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+string(3) "foo"
+string(3) "foo"
+string(3) "bar"
+string(3) "bar"
+string(13) "%0test%0var_pri"
+string(12) "test_private"
+string(10) "%0*%0var_pro"
+string(14) "test_protected"
+string(7) "var_pub"
+string(11) "test_public"
+array_walk_recursive(): Argument #1 ($array) must be of type array, string given
+Done
diff --git a/tests/std/array/array_walk_recursive.phpt b/tests/std/array/array_walk_recursive.phpt
new file mode 100644
index 00000000..3c331cfb
--- /dev/null
+++ b/tests/std/array/array_walk_recursive.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test array_walk_recursive()
+--SKIPIF--
+--FILE--
+<?php
+function foo($value, $key)
+{
+    echo $value . " foo\n";
+}
+function bar($value, $key)
+{
+    echo $value . " bar\n";
+}
+function main()
+{
+    $arr = array(1, 2, 3);
+    var_dump(array_walk_recursive($arr, 'foo'));
+    var_dump(array_walk_recursive($arr, 'bar'));
+}
+?>
+--EXPECT--
+1 foo
+2 foo
+3 foo
+bool(true)
+1 bar
+2 bar
+3 bar
+bool(true)
diff --git a/tests/std/array/array_walk_recursive1.phpt b/tests/std/array/array_walk_recursive1.phpt
new file mode 100644
index 00000000..cd57bc5a
--- /dev/null
+++ b/tests/std/array/array_walk_recursive1.phpt
@@ -0,0 +1,44 @@
+--TEST--
+array_walk_recursive() tests
+--SKIPIF--
+<?php die("skip AOT array_walk_recursive differs from PHP"); ?>
+--FILE--
+<?php
+function foo($v1, $v2, $v3)
+{
+    var_dump($v1);
+    var_dump($v2);
+    var_dump($v3);
+}
+function foo2($v1, $v2, $v3)
+{
+    throw new Exception($v3);
+}
+function main()
+{
+    $var = array(1, 2, array(2, 3));
+    var_dump(array_walk_recursive($var, "foo", "data"));
+    try {
+        var_dump(array_walk_recursive($var, "foo2", "data"));
+    } catch (Exception $e) {
+        var_dump($e->getMessage());
+    }
+    echo "Done\n";
+}
+?>
+--EXPECT--
+int(1)
+int(0)
+string(4) "data"
+int(2)
+int(1)
+string(4) "data"
+int(2)
+int(0)
+string(4) "data"
+int(3)
+int(1)
+string(4) "data"
+bool(true)
+string(4) "data"
+Done
diff --git a/tests/std/array/array_walk_recursive_basic1.phpt b/tests/std/array/array_walk_recursive_basic1.phpt
new file mode 100644
index 00000000..fbdbd52c
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_basic1.phpt
@@ -0,0 +1,75 @@
+--TEST--
+Test array_walk_recursive() function : basic functionality - regular array
+--FILE--
+<?php
+function test_print($item, $key)
+{
+    // dump the arguments to check that they are passed
+    // with proper type
+    var_dump($item);
+    // value
+    var_dump($key);
+    // key
+    echo "\n";
+    // new line to separate the output between each element
+}
+function with_userdata($item, $key, $user_data)
+{
+    // dump the arguments to check that they are passed
+    // with proper type
+    var_dump($item);
+    // value
+    var_dump($key);
+    // key
+    var_dump($user_data);
+    // user supplied data
+    echo "\n";
+    // new line to separate the output between each element
+}
+function main()
+{
+    echo "*** Testing array_walk_recursive() : basic functionality ***\n";
+    // regular array
+    $fruits = array("lemon", array("orange", "banana"), array("apple"));
+    echo "-- Using array_walk_recursive() with default parameters to show array contents --\n";
+    var_dump(array_walk_recursive($fruits, 'test_print'));
+    echo "-- Using array_walk_recursive() with all parameters --\n";
+    var_dump(array_walk_recursive($fruits, 'with_userdata', "Added"));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : basic functionality ***
+-- Using array_walk_recursive() with default parameters to show array contents --
+string(5) "lemon"
+int(0)
+
+string(6) "orange"
+int(0)
+
+string(6) "banana"
+int(1)
+
+string(5) "apple"
+int(0)
+
+bool(true)
+-- Using array_walk_recursive() with all parameters --
+string(5) "lemon"
+int(0)
+string(5) "Added"
+
+string(6) "orange"
+int(0)
+string(5) "Added"
+
+string(6) "banana"
+int(1)
+string(5) "Added"
+
+string(5) "apple"
+int(0)
+string(5) "Added"
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_recursive_basic2.phpt b/tests/std/array/array_walk_recursive_basic2.phpt
new file mode 100644
index 00000000..9664cb92
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_basic2.phpt
@@ -0,0 +1,91 @@
+--TEST--
+Test array_walk_recursive() function : basic functionality - associative array
+--FILE--
+<?php
+function test_alter(&$item, $key, $prefix)
+{
+    // dump the arguments to check that they are passed
+    // with proper type
+    var_dump($item);
+    // value
+    var_dump($key);
+    // key
+    var_dump($prefix);
+    // additional argument passed to callback function
+    echo "\n";
+    // new line to separate the output between each element
+}
+function test_print($item, $key)
+{
+    // dump the arguments to check that they are passed
+    // with proper type
+    var_dump($item);
+    // value
+    var_dump($key);
+    // key
+    echo "\n";
+    // new line to separate the output between each element
+}
+function main()
+{
+    echo "*** Testing array_walk_recursive() : basic functionality ***\n";
+    // associative array
+    $fruits = array("a" => "lemon", "b" => array("c" => "orange", "d" => "banana"), "e" => array("f" => "apple"));
+    echo "-- Using array_walk_recursive with default parameters to show array contents --\n";
+    var_dump(array_walk_recursive($fruits, 'test_print'));
+    echo "-- Using array_walk_recursive with one optional parameter to modify contents --\n";
+    var_dump(array_walk_recursive($fruits, 'test_alter', 'fruit'));
+    echo "-- Using array_walk_recursive with default parameters to show modified array contents --\n";
+    var_dump(array_walk_recursive($fruits, 'test_print'));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : basic functionality ***
+-- Using array_walk_recursive with default parameters to show array contents --
+string(5) "lemon"
+string(1) "a"
+
+string(6) "orange"
+string(1) "c"
+
+string(6) "banana"
+string(1) "d"
+
+string(5) "apple"
+string(1) "f"
+
+bool(true)
+-- Using array_walk_recursive with one optional parameter to modify contents --
+string(5) "lemon"
+string(1) "a"
+string(5) "fruit"
+
+string(6) "orange"
+string(1) "c"
+string(5) "fruit"
+
+string(6) "banana"
+string(1) "d"
+string(5) "fruit"
+
+string(5) "apple"
+string(1) "f"
+string(5) "fruit"
+
+bool(true)
+-- Using array_walk_recursive with default parameters to show modified array contents --
+string(5) "lemon"
+string(1) "a"
+
+string(6) "orange"
+string(1) "c"
+
+string(6) "banana"
+string(1) "d"
+
+string(5) "apple"
+string(1) "f"
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_recursive_error2.phpt b/tests/std/array/array_walk_recursive_error2.phpt
new file mode 100644
index 00000000..e3b9514f
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_error2.phpt
@@ -0,0 +1,64 @@
+--TEST--
+Test array_walk_recursive() function : error conditions - callback parameters
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support testing invalid argument counts in this way");
+?>
+
+--FILE--
+<?php
+function callback1($value, $key, $user_data)
+{
+    echo "\ncallback1() invoked \n";
+}
+function callback2($value, $key, $user_data1, $user_data2)
+{
+    echo "\ncallback2() invoked \n";
+}
+function main()
+{
+    /*
+     * Testing array_walk_recursive() by passing more number of parameters to callback function
+     */
+    $input = array(1);
+    echo "*** Testing array_walk_recursive() : error conditions - callback parameters ***\n";
+    // expected: Missing argument Warning
+    try {
+        var_dump(array_walk_recursive($input, "callback1"));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    try {
+        var_dump(array_walk_recursive($input, "callback2", 4));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    // expected: Warning is suppressed
+    try {
+        var_dump(@array_walk_recursive($input, "callback1"));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    try {
+        var_dump(@array_walk_recursive($input, "callback2", 4));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "-- Testing array_walk_recursive() function with too many callback parameters --\n";
+    try {
+        var_dump(array_walk_recursive($input, "callback1", 20, 10));
+    } catch (Throwable $e) {
+        echo "Exception: " . $e->getMessage() . "\n";
+    }
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : error conditions - callback parameters ***
+Exception: Too few arguments to function callback1(), 2 passed and exactly 3 expected
+Exception: Too few arguments to function callback2(), 3 passed and exactly 4 expected
+Exception: Too few arguments to function callback1(), 2 passed and exactly 3 expected
+Exception: Too few arguments to function callback2(), 3 passed and exactly 4 expected
+-- Testing array_walk_recursive() function with too many callback parameters --
+Exception: array_walk_recursive() expects at most 3 arguments, 4 given
+Done
diff --git a/tests/std/array/array_walk_recursive_object1.phpt b/tests/std/array/array_walk_recursive_object1.phpt
new file mode 100644
index 00000000..cefcff95
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_object1.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Test array_walk_recursive() function : object functionality
+--FILE--
+<?php
+/* Passing object in place of an 'input' argument to test object functionality
+ */
+
+function callback($value, $key, $user_data)
+{
+  var_dump($key);
+  var_dump($value);
+  var_dump($user_data);
+  echo "\n";
+}
+
+class MyClass
+{
+  private $pri_value;
+  public $pub_value;
+  protected $pro_value;
+  public function __construct($setVal)
+  {
+    $this->pri_value = $setVal;
+    $this->pub_value = $setVal;
+    $this->pro_value = $setVal;
+  }
+};
+
+function main() {
+echo "*** Testing array_walk_recursive() : object functionality ***\n";
+
+// object for 'input' argument
+$input = new MyClass(10);
+
+var_dump( array_walk_recursive($input, "callback", 1));
+
+echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing array_walk_recursive() : object functionality ***
+string(18) "%r\0%rMyClass%r\0%rpri_value"
+int(10)
+int(1)
+
+string(9) "pub_value"
+int(10)
+int(1)
+
+string(12) "%r\0%r*%r\0%rpro_value"
+int(10)
+int(1)
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_recursive_object2.phpt b/tests/std/array/array_walk_recursive_object2.phpt
new file mode 100644
index 00000000..faa3a78a
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_object2.phpt
@@ -0,0 +1,96 @@
+--TEST--
+Test array_walk_recursive() function : object functionality - array of objects
+--FILE--
+<?php
+/*
+* Testing array_walk_recursive() with an array of objects
+*/
+
+function callback_private($value, $key, $addValue)
+{
+  echo "value : ";
+  var_dump($value->getValue());
+  echo "key : ";
+  var_dump($key);
+}
+
+function callback_public($value, $key)
+{
+  echo "value : ";
+  var_dump($value->pub_value);
+}
+function callback_protected($value, $key)
+{
+  echo "value : ";
+  var_dump($value->get_pro_value());
+}
+
+class MyClass
+{
+  private $pri_value;
+  public $pub_value;
+  protected $pro_value;
+  public function __construct($setVal)
+  {
+    $this->pri_value = $setVal;
+    $this->pub_value = $setVal;
+    $this->pro_value = $setVal;
+  }
+  public function getValue()
+  {
+    return $this->pri_value;
+  }
+  public function get_pro_value()
+  {
+    return $this->pro_value;
+  }
+};
+
+function main() {
+echo "*** Testing array_walk_recursive() : array of objects ***\n";
+
+// array containing objects of MyClass
+$input = array (
+  array(
+  new MyClass(3),
+  new MyClass(10),
+  ),
+  new MyClass(20),
+  array(new MyClass(-10))
+);
+
+echo "-- For private member --\n";
+var_dump( array_walk_recursive($input, "callback_private", 1));
+echo "-- For public member --\n";
+var_dump( array_walk_recursive($input, "callback_public"));
+echo "-- For protected member --\n";
+var_dump( array_walk_recursive($input, "callback_protected"));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : array of objects ***
+-- For private member --
+value : int(3)
+key : int(0)
+value : int(10)
+key : int(1)
+value : int(20)
+key : int(1)
+value : int(-10)
+key : int(0)
+bool(true)
+-- For public member --
+value : int(3)
+value : int(10)
+value : int(20)
+value : int(-10)
+bool(true)
+-- For protected member --
+value : int(3)
+value : int(10)
+value : int(20)
+value : int(-10)
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_recursive_variation3.phpt b/tests/std/array/array_walk_recursive_variation3.phpt
new file mode 100644
index 00000000..c887d86e
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_variation3.phpt
@@ -0,0 +1,116 @@
+--TEST--
+Test array_walk_recursive() function : usage variations - 'input' array with different values
+--SKIPIF--
+<?php
+if (true) die("skip AOT float-to-string precision differs from PHP");
+?>
+--FILE--
+<?php
+/*
+ * Testing array_walk_recursive() with following types of 'input' arrays:
+ *    integer, float, string, bool, null, empty & mixed
+*/
+
+function print_value($value, $key, $count)
+{
+  echo  $count." : ".$key." ".$value."\n";
+}
+
+function main() {
+echo "*** Testing array_walk_recursive() : 'input' array with different values***\n";
+
+// different arrays as input
+$input_values = array(
+
+       // integer values
+/*1*/  array(array(1, 0, -10), array(023, -041), array(0x5A, 0X1F, -0x6E)),
+
+       // float value
+       array(array(3.4, 0.8, -2.9), array(6.25e2, 8.20E-3)),
+
+       // string values
+       array('Mango', array("Apple", 'Orange', "Lemon")),
+
+       // bool values
+/*4*/  array( array(true, false), array(TRUE, FALSE)),
+
+       // null values
+       array( array(null), array(NULL)),
+
+       // empty array
+       array(),
+
+       // binary array
+       array(array(b'binary')),
+
+       // mixed array
+/*8*/  array(16, 8.345, array("Fruits"), array(true, null), array(FALSE), array(-98, 0.005, 'banana'))
+);
+
+for($count = 0; $count < count($input_values); $count++) {
+  echo "\n-- Iteration ".($count + 1)." --\n";
+  var_dump( array_walk_recursive($input_values[$count], "print_value", $count+1));
+}
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : 'input' array with different values***
+
+-- Iteration 1 --
+1 : 0 1
+1 : 1 0
+1 : 2 -10
+1 : 0 19
+1 : 1 -33
+1 : 0 90
+1 : 1 31
+1 : 2 -110
+bool(true)
+
+-- Iteration 2 --
+2 : 0 3.4
+2 : 1 0.8
+2 : 2 -2.9
+2 : 0 625
+2 : 1 0.0082
+bool(true)
+
+-- Iteration 3 --
+3 : 0 Mango
+3 : 0 Apple
+3 : 1 Orange
+3 : 2 Lemon
+bool(true)
+
+-- Iteration 4 --
+4 : 0 1
+4 : 1
+4 : 0 1
+4 : 1
+bool(true)
+
+-- Iteration 5 --
+5 : 0
+5 : 0
+bool(true)
+
+-- Iteration 6 --
+bool(true)
+
+-- Iteration 7 --
+7 : 0 binary
+bool(true)
+
+-- Iteration 8 --
+8 : 0 16
+8 : 1 8.345
+8 : 0 Fruits
+8 : 0 1
+8 : 1
+8 : 0
+8 : 0 -98
+8 : 1 0.005
+8 : 2 banana
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_recursive_variation4.phpt b/tests/std/array/array_walk_recursive_variation4.phpt
new file mode 100644
index 00000000..a40644ce
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_variation4.phpt
@@ -0,0 +1,67 @@
+--TEST--
+Test array_walk_recursive() function : usage variations - 'input' array with subarray
+--FILE--
+<?php
+/*
+ * Testing array_walk_recursive() with an array having subarrays as elements
+*/
+
+function callback($value, $key)
+{
+   // dump the arguments to check that they are passed
+   // with proper type
+   var_dump($key);  // key
+   var_dump($value); // value
+   echo "\n"; // new line to separate the output between each element
+}
+
+function main() {
+echo "*** Testing array_walk_recursive() : array with subarray ***\n";
+
+$input = array(
+  array(),
+  array(1),
+  array(1,2,3),
+  array("Mango", "Orange"),
+  array(array(1, 2, 3), array(1))
+);
+
+var_dump( array_walk_recursive( $input, "callback"));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : array with subarray ***
+int(0)
+int(1)
+
+int(0)
+int(1)
+
+int(1)
+int(2)
+
+int(2)
+int(3)
+
+int(0)
+string(5) "Mango"
+
+int(1)
+string(6) "Orange"
+
+int(0)
+int(1)
+
+int(1)
+int(2)
+
+int(2)
+int(3)
+
+int(0)
+int(1)
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_recursive_variation5.phpt b/tests/std/array/array_walk_recursive_variation5.phpt
new file mode 100644
index 00000000..55bc642e
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_variation5.phpt
@@ -0,0 +1,59 @@
+--TEST--
+Test array_walk_recursive() function : usage variations - 'input' argument containing reference variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not fully support references");
+?>
+--FILE--
+<?php
+/*
+ * Testing array_walk_recursive() with an array having reference variables
+*/
+
+function callback($value, $key)
+{
+   // dump the arguments to check that they are passed
+   // with proper type
+   var_dump($key);  // key
+   var_dump($value); // value
+   echo "\n"; // new line to separate the output between each element
+}
+
+function main() {
+echo "*** Testing array_walk_recursive() : array with references ***\n";
+
+$value1 = 10;
+$value2 = -20;
+$value3 = &$value1;
+$value4 = 50;
+
+// 'input' array containing references to above variables
+$input = array(&$value1, array(&$value2, -35), array(&$value3, 0), array(&$value4));
+
+var_dump( array_walk_recursive($input, "callback"));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : array with references ***
+int(0)
+int(10)
+
+int(0)
+int(-20)
+
+int(1)
+int(-35)
+
+int(0)
+int(10)
+
+int(1)
+int(0)
+
+int(0)
+int(50)
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_recursive_variation6.phpt b/tests/std/array/array_walk_recursive_variation6.phpt
new file mode 100644
index 00000000..78926a6d
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_variation6.phpt
@@ -0,0 +1,127 @@
+--TEST--
+Test array_walk_recursive() function : usage variations - 'input' argument as diff. associative arrays
+--FILE--
+<?php
+/*
+ * Passing 'input' argument as an associative array
+ *    with Numeric & string keys
+*/
+
+function for_numeric($value, $key, $user_data)
+{
+  // dump the input values to see if they are
+  // passed with correct type
+  var_dump($key);
+  var_dump($value);
+  var_dump($user_data);
+  echo "\n"; // new line to separate the output between each element
+}
+
+function for_string($value, $key)
+{
+  // dump the input values to see if they are
+  // passed with correct type
+  var_dump($key);
+  var_dump($value);
+  echo "\n"; // new line to separate the output between each element
+}
+
+function for_mixed($value, $key)
+{
+  // dump the input values to see if they are
+  // passed with correct type
+  var_dump($key);
+  var_dump($value);
+  echo "\n"; // new line to separate the output between each element
+}
+
+function main() {
+echo "*** Testing array_walk_recursive() : 'input' as an associative array ***\n";
+
+// Numeric keys
+$input = array( 0 => array(1 => 25, 5 => 12, 0 => -80), 1 => array(-2 => 100, 5 => 30));
+echo "-- Associative array with numeric keys --\n";
+var_dump( array_walk_recursive($input, "for_numeric", 10));
+
+// String keys
+$input = array( "a" => "Apple", 'z' => array('b' => 'Bananna', "c" => "carrot"), 'x' => array('o' => "Orange"));
+echo "-- Associative array with string keys --\n";
+var_dump( array_walk_recursive($input, "for_string"));
+
+// binary key
+$input = array( b"a" => "Apple", b"b" => "Banana");
+echo "-- Associative array with binary keys --\n";
+var_dump( array_walk_recursive($input, "for_string"));
+
+// Mixed keys - numeric/string
+$input = array( 0 => array(0 => 1, 1 => 2), "x" => array("a" => "Apple", "b" => "Banana"), 2 =>3);
+echo "-- Associative array with numeric/string keys --\n";
+var_dump( array_walk_recursive($input, "for_mixed"));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : 'input' as an associative array ***
+-- Associative array with numeric keys --
+int(1)
+int(25)
+int(10)
+
+int(5)
+int(12)
+int(10)
+
+int(0)
+int(-80)
+int(10)
+
+int(-2)
+int(100)
+int(10)
+
+int(5)
+int(30)
+int(10)
+
+bool(true)
+-- Associative array with string keys --
+string(1) "a"
+string(5) "Apple"
+
+string(1) "b"
+string(7) "Bananna"
+
+string(1) "c"
+string(6) "carrot"
+
+string(1) "o"
+string(6) "Orange"
+
+bool(true)
+-- Associative array with binary keys --
+string(1) "a"
+string(5) "Apple"
+
+string(1) "b"
+string(6) "Banana"
+
+bool(true)
+-- Associative array with numeric/string keys --
+int(0)
+int(1)
+
+int(1)
+int(2)
+
+string(1) "a"
+string(5) "Apple"
+
+string(1) "b"
+string(6) "Banana"
+
+int(2)
+int(3)
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_recursive_variation7.phpt b/tests/std/array/array_walk_recursive_variation7.phpt
new file mode 100644
index 00000000..012e05b2
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_variation7.phpt
@@ -0,0 +1,81 @@
+--TEST--
+Test array_walk_recursive() function : usage variations - anonymous callback function
+--FILE--
+<?php
+/*
+* Passing anonymous(run-time) callback function with following variations:
+*   with one parameter
+*   two parameters
+*   three parameters
+*   extra parameters
+*   without parameters
+*/
+
+echo "*** Testing array_walk_recursive() : anonymous function as callback ***\n";
+
+$input = array( array(2, 5), array(10, 0));
+
+echo "-- Anonymous function with one argument --\n";
+var_dump( array_walk_recursive($input, function($value) { var_dump($value); echo "\n"; }));
+
+echo "-- Anonymous function with two arguments --\n";
+var_dump( array_walk_recursive($input, function($value, $key) { var_dump($key); var_dump($value); echo "\n"; }));
+
+echo "-- Anonymous function with three arguments --\n";
+var_dump( array_walk_recursive($input, function($value, $key, $user_data) { var_dump($key); var_dump($value); var_dump($user_data); echo "\n"; }, 10));
+
+echo "-- Anonymous function with null argument --\n";
+var_dump( array_walk_recursive( $input, function() { echo "1\n"; }));
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : anonymous function as callback ***
+-- Anonymous function with one argument --
+int(2)
+
+int(5)
+
+int(10)
+
+int(0)
+
+bool(true)
+-- Anonymous function with two arguments --
+int(0)
+int(2)
+
+int(1)
+int(5)
+
+int(0)
+int(10)
+
+int(1)
+int(0)
+
+bool(true)
+-- Anonymous function with three arguments --
+int(0)
+int(2)
+int(10)
+
+int(1)
+int(5)
+int(10)
+
+int(0)
+int(10)
+int(10)
+
+int(1)
+int(0)
+int(10)
+
+bool(true)
+-- Anonymous function with null argument --
+1
+1
+1
+1
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_recursive_variation8.phpt b/tests/std/array/array_walk_recursive_variation8.phpt
new file mode 100644
index 00000000..c3cd3454
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_variation8.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Test array_walk_recursive() function : usage variations - buit-in function as callback
+--FILE--
+<?php
+/*
+ * Passing different buit-in functionns as callback function
+ *    pow function
+ *    min function
+ *    echo language construct
+*/
+
+echo "*** Testing array_walk_recursive() : built-in function as callback ***\n";
+
+$input = array(array(2 => 1, 65), array(98, 100), array(6 => -4));
+
+echo "-- With 'pow' built-in function --\n";
+var_dump( array_walk_recursive($input, 'pow'));
+
+echo "-- With 'min' built-in function --\n";
+var_dump( array_walk_recursive($input, "min"));
+
+echo "-- With 'echo' language construct --\n";
+try {
+    var_dump( array_walk_recursive($input, "echo"));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : built-in function as callback ***
+-- With 'pow' built-in function --
+bool(true)
+-- With 'min' built-in function --
+bool(true)
+-- With 'echo' language construct --
+array_walk_recursive(): Argument #2 ($callback) must be a valid callback, function "echo" not found or invalid function name
+Done
diff --git a/tests/std/array/array_walk_recursive_variation9.phpt b/tests/std/array/array_walk_recursive_variation9.phpt
new file mode 100644
index 00000000..58847eb9
--- /dev/null
+++ b/tests/std/array/array_walk_recursive_variation9.phpt
@@ -0,0 +1,101 @@
+--TEST--
+Test array_walk_recursive() function : usage variations - different callback functions
+--SKIPIF--
+<?php die("skip AOT does not support parameter count mismatch in callbacks"); ?>
+--FILE--
+<?php
+/*
+ * Passing different types of callback functions to array_walk_recursive()
+ *   without parameters
+ *   with less and more parameters
+*/
+
+function callback_two_parameter($value, $key, $arg)
+{
+   // dump the arguments to check that they are passed
+   // with proper type
+   var_dump($key);  // key
+   var_dump($value); // value
+   echo "\n"; // new line to separate the output between each element
+}
+
+function callback_one_parameter($value, $key, $arg)
+{
+   // dump the arguments to check that they are passed
+   // with proper type
+   var_dump($value); // value
+   echo "\n"; // new line to separate the output between each element
+}
+
+function callback_no_parameter($value, $key, $arg)
+{
+  echo "callback3() called\n";
+}
+
+function main() {
+echo "*** Testing array_walk_recursive() : callback function variation ***\n";
+
+$input = array(array('Apple', 'Banana'), 'Mango', array('Orange'));
+
+echo "-- callback function with both parameters --\n";
+var_dump( array_walk_recursive($input, 'callback_two_parameter'));
+
+echo "-- callback function with only one parameter --\n";
+var_dump( array_walk_recursive($input, 'callback_one_parameter'));
+
+echo "-- callback function without parameters --\n";
+var_dump( array_walk_recursive($input, 'callback_no_parameter'));
+
+echo "-- passing one more parameter to function with two parameters --\n";
+var_dump( array_walk_recursive($input, 'callback_two_parameter', 10));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk_recursive() : callback function variation ***
+-- callback function with both parameters --
+int(0)
+string(5) "Apple"
+
+int(1)
+string(6) "Banana"
+
+int(1)
+string(5) "Mango"
+
+int(0)
+string(6) "Orange"
+
+bool(true)
+-- callback function with only one parameter --
+string(5) "Apple"
+
+string(6) "Banana"
+
+string(5) "Mango"
+
+string(6) "Orange"
+
+bool(true)
+-- callback function without parameters --
+callback3() called
+callback3() called
+callback3() called
+callback3() called
+bool(true)
+-- passing one more parameter to function with two parameters --
+int(0)
+string(5) "Apple"
+
+int(1)
+string(6) "Banana"
+
+int(1)
+string(5) "Mango"
+
+int(0)
+string(6) "Orange"
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_variation3.phpt b/tests/std/array/array_walk_variation3.phpt
new file mode 100644
index 00000000..840cbf19
--- /dev/null
+++ b/tests/std/array/array_walk_variation3.phpt
@@ -0,0 +1,116 @@
+--TEST--
+Test array_walk() function : usage variations - 'input' array with different values
+--SKIPIF--
+<?php
+if (true) die("skip AOT float-to-string precision differs from PHP");
+?>
+--FILE--
+<?php
+/*
+ * Testing array_walk() with following types of 'input' arrays:
+ *    integer, float, string, bool, null, empty & mixed
+*/
+
+function print_value($value, $key, $count)
+{
+  echo  $count." : ".$key." ".$value."\n";
+}
+
+function main() {
+echo "*** Testing array_walk() : 'input' array with different values***\n";
+
+// different arrays as input
+$input_values = array(
+
+       // integer values
+/*1*/  array(1, 0, -10, 023, -041, 0x5A, 0X1F, -0x6E),
+
+       // float value
+       array(3.4, 0.8, -2.9, 6.25e2, 8.20E-3),
+
+       // string values
+       array('Mango', "Apple", 'Orange', "Lemon"),
+
+       // bool values
+/*4*/  array(true, false, TRUE, FALSE),
+
+       // null values
+       array(null, NULL),
+
+       // empty array
+       array(),
+
+       // binary array
+       array(b"binary"),
+
+       // mixed array
+/*8*/  array(16, 8.345, "Fruits", true, null, FALSE, -98, 0.005, 'banana')
+);
+
+for($count = 0; $count < count($input_values); $count++) {
+  echo "\n-- Iteration ".($count + 1)." --\n";
+  var_dump( array_walk($input_values[$count], "print_value", $count+1));
+}
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk() : 'input' array with different values***
+
+-- Iteration 1 --
+1 : 0 1
+1 : 1 0
+1 : 2 -10
+1 : 3 19
+1 : 4 -33
+1 : 5 90
+1 : 6 31
+1 : 7 -110
+bool(true)
+
+-- Iteration 2 --
+2 : 0 3.4
+2 : 1 0.8
+2 : 2 -2.9
+2 : 3 625
+2 : 4 0.0082
+bool(true)
+
+-- Iteration 3 --
+3 : 0 Mango
+3 : 1 Apple
+3 : 2 Orange
+3 : 3 Lemon
+bool(true)
+
+-- Iteration 4 --
+4 : 0 1
+4 : 1
+4 : 2 1
+4 : 3
+bool(true)
+
+-- Iteration 5 --
+5 : 0
+5 : 1
+bool(true)
+
+-- Iteration 6 --
+bool(true)
+
+-- Iteration 7 --
+7 : 0 binary
+bool(true)
+
+-- Iteration 8 --
+8 : 0 16
+8 : 1 8.345
+8 : 2 Fruits
+8 : 3 1
+8 : 4
+8 : 5
+8 : 6 -98
+8 : 7 0.005
+8 : 8 banana
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_variation4.phpt b/tests/std/array/array_walk_variation4.phpt
new file mode 100644
index 00000000..46958129
--- /dev/null
+++ b/tests/std/array/array_walk_variation4.phpt
@@ -0,0 +1,78 @@
+--TEST--
+Test array_walk() function : usage variations - 'input' array with subarray
+--FILE--
+<?php
+/*
+ * Testing array_walk() with an array having subarrays as elements
+*/
+
+function callback($value, $key)
+{
+   // dump the arguments to check that they are passed
+   // with proper type
+   var_dump($key);  // key
+   var_dump($value); // value
+   echo "\n"; // new line to separate the output between each element
+}
+
+function main() {
+echo "*** Testing array_walk() : array with subarray ***\n";
+
+$input = array(
+  array(),
+  array(1),
+  array(1,2,3),
+  array("Mango", "Orange"),
+  array(array(1, 2, 3))
+);
+
+var_dump( array_walk( $input, "callback"));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk() : array with subarray ***
+int(0)
+array(0) {
+}
+
+int(1)
+array(1) {
+  [0]=>
+  int(1)
+}
+
+int(2)
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+
+int(3)
+array(2) {
+  [0]=>
+  string(5) "Mango"
+  [1]=>
+  string(6) "Orange"
+}
+
+int(4)
+array(1) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+}
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_variation5.phpt b/tests/std/array/array_walk_variation5.phpt
new file mode 100644
index 00000000..f41fe67e
--- /dev/null
+++ b/tests/std/array/array_walk_variation5.phpt
@@ -0,0 +1,59 @@
+--TEST--
+Test array_walk() function : usage variations - 'input' argument containing reference variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not fully support references");
+?>
+--FILE--
+<?php
+/*
+ * Testing array_walk() with an array having reference variables
+*/
+
+function callback($value, $key)
+{
+   // dump the arguments to check that they are passed
+   // with proper type
+   var_dump($key);  // key
+   var_dump($value); // value
+   echo "\n"; // new line to separate the output between each element
+}
+
+function main() {
+echo "*** Testing array_walk() : array with references ***\n";
+
+$value1 = 10;
+$value2 = -20;
+$value3 = &$value1;
+$value4 = 50;
+
+// 'input' array containing references to above variables
+$input = array(&$value1, &$value2, -35, &$value3, 0, &$value4);
+
+var_dump( array_walk($input, "callback"));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk() : array with references ***
+int(0)
+int(10)
+
+int(1)
+int(-20)
+
+int(2)
+int(-35)
+
+int(3)
+int(10)
+
+int(4)
+int(0)
+
+int(5)
+int(50)
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_variation6.phpt b/tests/std/array/array_walk_variation6.phpt
new file mode 100644
index 00000000..600f67c5
--- /dev/null
+++ b/tests/std/array/array_walk_variation6.phpt
@@ -0,0 +1,123 @@
+--TEST--
+Test array_walk() function : usage variations - 'input' argument as diff. associative arrays
+--FILE--
+<?php
+/*
+ * Passing 'input' argument as an associative array
+ *    with Numeric & string keys
+*/
+
+function for_numeric($value, $key, $user_data)
+{
+  // dump the input values to see if they are
+  // passed with correct type
+  var_dump($key);
+  var_dump($value);
+  var_dump($user_data);
+  echo "\n"; // new line to separate the output between each element
+}
+
+function for_string($value, $key)
+{
+  // dump the input values to see if they are
+  // passed with correct type
+  var_dump($key);
+  var_dump($value);
+  echo "\n"; // new line to separate the output between each element
+}
+
+function for_mixed($value, $key)
+{
+  // dump the input values to see if they are
+  // passed with correct type
+  var_dump($key);
+  var_dump($value);
+  echo "\n"; // new line to separate the output between each element
+}
+
+function main() {
+echo "*** Testing array_walk() : 'input' as an associative array ***\n";
+
+// Numeric keys
+$input = array( 1 => 25, 5 => 12, 0 => -80, -2 => 100, 5 => 30);
+echo "-- Associative array with numeric keys --\n";
+var_dump( array_walk($input, "for_numeric", 10));
+
+// String keys
+$input = array( "a" => "Apple", 'b' => 'Bananna', "c" => "carrot", 'o' => "Orange");
+echo "-- Associative array with string keys --\n";
+var_dump( array_walk($input, "for_string"));
+
+// binary keys
+$input = array( b"a" => "Apple", b"b" => "Banana");
+echo "-- Associative array with binary keys --\n";
+var_dump( array_walk($input, "for_string"));
+
+// Mixed keys - numeric/string
+$input = array( 0 => 1, 1 => 2, "a" => "Apple", "b" => "Banana", 2 =>3);
+echo "-- Associative array with numeric/string keys --\n";
+var_dump( array_walk($input, "for_mixed"));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk() : 'input' as an associative array ***
+-- Associative array with numeric keys --
+int(1)
+int(25)
+int(10)
+
+int(5)
+int(30)
+int(10)
+
+int(0)
+int(-80)
+int(10)
+
+int(-2)
+int(100)
+int(10)
+
+bool(true)
+-- Associative array with string keys --
+string(1) "a"
+string(5) "Apple"
+
+string(1) "b"
+string(7) "Bananna"
+
+string(1) "c"
+string(6) "carrot"
+
+string(1) "o"
+string(6) "Orange"
+
+bool(true)
+-- Associative array with binary keys --
+string(1) "a"
+string(5) "Apple"
+
+string(1) "b"
+string(6) "Banana"
+
+bool(true)
+-- Associative array with numeric/string keys --
+int(0)
+int(1)
+
+int(1)
+int(2)
+
+string(1) "a"
+string(5) "Apple"
+
+string(1) "b"
+string(6) "Banana"
+
+int(2)
+int(3)
+
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_variation7.phpt b/tests/std/array/array_walk_variation7.phpt
new file mode 100644
index 00000000..e5b80ba8
--- /dev/null
+++ b/tests/std/array/array_walk_variation7.phpt
@@ -0,0 +1,81 @@
+--TEST--
+Test array_walk() function : usage variations - anonymous callback function
+--FILE--
+<?php
+/*
+* Passing anonymous(run-time) callback function with following variations:
+*   with one parameter
+*   two parameters
+*   three parameters
+*   extra parameters
+*   without parameters
+*/
+
+echo "*** Testing array_walk() : anonymous function as callback ***\n";
+
+$input = array(2, 5, 10, 0);
+
+echo "-- Anonymous function with one argument --\n";
+var_dump( array_walk($input, function($value) { var_dump($value); echo "\n"; }));
+
+echo "-- Anonymous function with two arguments --\n";
+var_dump( array_walk($input, function($value, $key) { var_dump($key); var_dump($value); echo "\n"; }));
+
+echo "-- Anonymous function with three arguments --\n";
+var_dump( array_walk($input, function($value, $key, $user_data) { var_dump($key); var_dump($value); var_dump($user_data); echo "\n"; }, 10));
+
+echo "-- Anonymous function with null argument --\n";
+var_dump( array_walk( $input, function() { echo "1\n"; }));
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_walk() : anonymous function as callback ***
+-- Anonymous function with one argument --
+int(2)
+
+int(5)
+
+int(10)
+
+int(0)
+
+bool(true)
+-- Anonymous function with two arguments --
+int(0)
+int(2)
+
+int(1)
+int(5)
+
+int(2)
+int(10)
+
+int(3)
+int(0)
+
+bool(true)
+-- Anonymous function with three arguments --
+int(0)
+int(2)
+int(10)
+
+int(1)
+int(5)
+int(10)
+
+int(2)
+int(10)
+int(10)
+
+int(3)
+int(0)
+int(10)
+
+bool(true)
+-- Anonymous function with null argument --
+1
+1
+1
+1
+bool(true)
+Done
diff --git a/tests/std/array/array_walk_variation8.phpt b/tests/std/array/array_walk_variation8.phpt
new file mode 100644
index 00000000..0ba4fe9f
--- /dev/null
+++ b/tests/std/array/array_walk_variation8.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Test array_walk() function : usage variations - buit-in function as callback
+--FILE--
+<?php
+/*
+ * Passing different buit-in functionns as callback function
+ *    pow function
+ *    min function
+ *    echo language construct
+*/
+
+echo "*** Testing array_walk() : built-in function as callback ***\n";
+
+$input = array(2 => 1, 65, 98, 100, 6 => -4);
+
+echo "-- With 'pow' built-in function --\n";
+var_dump( array_walk($input, 'pow'));
+
+echo "-- With 'min' built-in function --\n";
+var_dump( array_walk($input, "min"));
+
+echo "-- With 'echo' language construct --\n";
+try {
+    var_dump( array_walk($input, "echo"));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing array_walk() : built-in function as callback ***
+-- With 'pow' built-in function --
+bool(true)
+-- With 'min' built-in function --
+bool(true)
+-- With 'echo' language construct --
+array_walk(): Argument #2 ($callback) must be a valid callback, function "echo" not found or invalid function name
+Done
diff --git a/tests/std/array/array_walk_variation9.phpt b/tests/std/array/array_walk_variation9.phpt
new file mode 100644
index 00000000..434264de
--- /dev/null
+++ b/tests/std/array/array_walk_variation9.phpt
@@ -0,0 +1,101 @@
+--TEST--
+Test array_walk() function : usage variations - different callback functions
+--SKIPIF--
+<?php die("skip AOT does not support parameter count mismatch in callbacks"); ?>
+--FILE--
+<?php
+/*
+ * Passing different types of callback functions to array_walk()
+ *   without parameters
+ *   with less and more parameters
+*/
+
+function callback_two_parameter($value, $key, $arg)
+{
+   // dump the arguments to check that they are passed
+   // with proper type
+   var_dump($key);  // key
+   var_dump($value); // value
+   echo "\n"; // new line to separate the output between each element
+}
+
+function callback_one_parameter($value, $key, $arg)
+{
+   // dump the arguments to check that they are passed
+   // with proper type
+   var_dump($value); // value
+   echo "\n"; // new line to separate the output between each element
+}
+
+function callback_no_parameter($value, $key, $arg)
+{
+  echo "callback3() called\n";
+}
+
+function main() {
+echo "*** Testing array_walk() : callback function variation ***\n";
+
+$input = array('Apple', 'Banana', 'Mango', 'Orange');
+
+echo "-- callback function with both parameters --\n";
+var_dump( array_walk($input, 'callback_two_parameter'));
+
+echo "-- callback function with only one parameter --\n";
+var_dump( array_walk($input, 'callback_one_parameter'));
+
+echo "-- callback function without parameters --\n";
+var_dump( array_walk($input, 'callback_no_parameter'));
+
+echo "-- passing one more parameter to function with two parameters --\n";
+var_dump( array_walk($input, 'callback_two_parameter', 10));
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing array_walk() : callback function variation ***
+-- callback function with both parameters --
+int(0)
+string(5) "Apple"
+
+int(1)
+string(6) "Banana"
+
+int(2)
+string(5) "Mango"
+
+int(3)
+string(6) "Orange"
+
+bool(true)
+-- callback function with only one parameter --
+string(5) "Apple"
+
+string(6) "Banana"
+
+string(5) "Mango"
+
+string(6) "Orange"
+
+bool(true)
+-- callback function without parameters --
+callback3() called
+callback3() called
+callback3() called
+callback3() called
+bool(true)
+-- passing one more parameter to function with two parameters --
+int(0)
+string(5) "Apple"
+
+int(1)
+string(6) "Banana"
+
+int(2)
+string(5) "Mango"
+
+int(3)
+string(6) "Orange"
+
+bool(true)
+Done
diff --git a/tests/std/array/arsort_basic.phpt b/tests/std/array/arsort_basic.phpt
new file mode 100644
index 00000000..c636a627
--- /dev/null
+++ b/tests/std/array/arsort_basic.phpt
@@ -0,0 +1,239 @@
+--TEST--
+Test arsort() function : basic functionality
+--FILE--
+<?php
+/*
+ * Testing arsort() by providing integer/string arrays to check the basic functionality
+ * with following flag values.
+ *  flag value as default
+ *  SORT_REGULAR - compare items normally
+ *  SORT_NUMERIC - compare items numerically
+ *  SORT_STRING - compare items as strings
+*/
+
+echo "*** Testing arsort() : basic functionality ***\n";
+
+// an array containing unsorted string values with indices
+$unsorted_strings = array(
+    "l" => "lemon", "o" => "orange",
+    "O" => "Orange", "O1" => "Orange1", "o2" => "orange2", "O3" => "Orange3", "o20" => "orange20",
+    "b" => "banana",
+);
+// an array containing unsorted numeric values with indices
+$unsorted_numerics =  array( 1 => 100, 2 => 33, 3 => 555, 4 => 22 );
+
+echo "\n-- Testing arsort() by supplying string array, 'flag' value is default --\n";
+$temp_array = $unsorted_strings;
+var_dump( arsort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying numeric array, 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( arsort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying string array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_strings;
+var_dump( arsort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying numeric array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_numerics;
+var_dump( arsort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying string array, 'flag' = SORT_STRING --\n";
+$temp_array = $unsorted_strings;
+var_dump( arsort($temp_array, SORT_STRING) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( arsort($temp_array, SORT_STRING|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying string array (natural), 'flag' = SORT_NATURAL --\n";
+$temp_array = $unsorted_strings;
+var_dump( arsort($temp_array, SORT_NATURAL) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( arsort($temp_array, SORT_NATURAL|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying numeric array, 'flag' = SORT_NUMERIC --\n";
+$temp_array = $unsorted_numerics;
+var_dump( arsort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing arsort() : basic functionality ***
+
+-- Testing arsort() by supplying string array, 'flag' value is default --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o"]=>
+  string(6) "orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O"]=>
+  string(6) "Orange"
+}
+
+-- Testing arsort() by supplying numeric array, 'flag' value is default --
+bool(true)
+array(4) {
+  [3]=>
+  int(555)
+  [1]=>
+  int(100)
+  [2]=>
+  int(33)
+  [4]=>
+  int(22)
+}
+
+-- Testing arsort() by supplying string array, 'flag' = SORT_REGULAR --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o"]=>
+  string(6) "orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O"]=>
+  string(6) "Orange"
+}
+
+-- Testing arsort() by supplying numeric array, 'flag' = SORT_REGULAR --
+bool(true)
+array(4) {
+  [3]=>
+  int(555)
+  [1]=>
+  int(100)
+  [2]=>
+  int(33)
+  [4]=>
+  int(22)
+}
+
+-- Testing arsort() by supplying string array, 'flag' = SORT_STRING --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o"]=>
+  string(6) "orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O"]=>
+  string(6) "Orange"
+}
+
+-- Testing arsort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  ["O3"]=>
+  string(7) "Orange3"
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["o"]=>
+  string(6) "orange"
+  ["O"]=>
+  string(6) "Orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+}
+
+-- Testing arsort() by supplying string array (natural), 'flag' = SORT_NATURAL --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o"]=>
+  string(6) "orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O"]=>
+  string(6) "Orange"
+}
+
+-- Testing arsort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["o2"]=>
+  string(7) "orange2"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["o"]=>
+  string(6) "orange"
+  ["O"]=>
+  string(6) "Orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+}
+
+-- Testing arsort() by supplying numeric array, 'flag' = SORT_NUMERIC --
+bool(true)
+array(4) {
+  [3]=>
+  int(555)
+  [1]=>
+  int(100)
+  [2]=>
+  int(33)
+  [4]=>
+  int(22)
+}
+Done
diff --git a/tests/std/array/arsort_object1.phpt b/tests/std/array/arsort_object1.phpt
new file mode 100644
index 00000000..edefd9f1
--- /dev/null
+++ b/tests/std/array/arsort_object1.phpt
@@ -0,0 +1,220 @@
+--TEST--
+Test arsort() function : object functionality - sort objects
+--FILE--
+<?php
+// class declaration for integer objects
+class for_integer_arsort
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+}
+// class declaration for string objects
+class for_string_arsort
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * testing arsort() by providing integer/string object arrays with following flag values
+     * 1. Default flag value
+     * 2. SORT_REGULAR - compare items normally
+    */
+    echo "*** Testing arsort() : object functionality ***\n";
+    // array of integer objects
+    $unsorted_int_obj = array(1 => new for_integer_arsort(11), 2 => new for_integer_arsort(66), 3 => new for_integer_arsort(23), 4 => new for_integer_arsort(-5), 5 => new for_integer_arsort(0.001), 6 => new for_integer_arsort(0));
+    // array of string objects
+    $unsorted_str_obj = array("a" => new for_string_arsort("axx"), "b" => new for_string_arsort("t"), "c" => new for_string_arsort("w"), "d" => new for_string_arsort("py"), "e" => new for_string_arsort("apple"), "f" => new for_string_arsort("Orange"), "g" => new for_string_arsort("Lemon"), "h" => new for_string_arsort("aPPle"));
+    echo "\n-- Testing arsort() by supplying various object arrays, 'flag' value is default --\n";
+    // testing arsort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(arsort($temp_array));
+    var_dump($temp_array);
+    // testing arsort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(arsort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Testing arsort() by supplying various object arrays, 'flag' value is SORT_REGULAR --\n";
+    // testing arsort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(arsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing arsort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(arsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done\n";
+}
+?>
+--EXPECT--
+*** Testing arsort() : object functionality ***
+
+-- Testing arsort() by supplying various object arrays, 'flag' value is default --
+bool(true)
+array(6) {
+  [2]=>
+  object(for_integer_arsort)#2 (1) {
+    ["class_value"]=>
+    int(66)
+  }
+  [3]=>
+  object(for_integer_arsort)#3 (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [1]=>
+  object(for_integer_arsort)#1 (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [5]=>
+  object(for_integer_arsort)#5 (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [6]=>
+  object(for_integer_arsort)#6 (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [4]=>
+  object(for_integer_arsort)#4 (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+}
+bool(true)
+array(8) {
+  ["c"]=>
+  object(for_string_arsort)#9 (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+  ["b"]=>
+  object(for_string_arsort)#8 (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  ["d"]=>
+  object(for_string_arsort)#10 (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  ["a"]=>
+  object(for_string_arsort)#7 (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  ["e"]=>
+  object(for_string_arsort)#11 (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  ["h"]=>
+  object(for_string_arsort)#14 (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  ["f"]=>
+  object(for_string_arsort)#12 (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  ["g"]=>
+  object(for_string_arsort)#13 (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+}
+
+-- Testing arsort() by supplying various object arrays, 'flag' value is SORT_REGULAR --
+bool(true)
+array(6) {
+  [2]=>
+  object(for_integer_arsort)#2 (1) {
+    ["class_value"]=>
+    int(66)
+  }
+  [3]=>
+  object(for_integer_arsort)#3 (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [1]=>
+  object(for_integer_arsort)#1 (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [5]=>
+  object(for_integer_arsort)#5 (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [6]=>
+  object(for_integer_arsort)#6 (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [4]=>
+  object(for_integer_arsort)#4 (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+}
+bool(true)
+array(8) {
+  ["c"]=>
+  object(for_string_arsort)#9 (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+  ["b"]=>
+  object(for_string_arsort)#8 (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  ["d"]=>
+  object(for_string_arsort)#10 (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  ["a"]=>
+  object(for_string_arsort)#7 (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  ["e"]=>
+  object(for_string_arsort)#11 (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  ["h"]=>
+  object(for_string_arsort)#14 (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  ["f"]=>
+  object(for_string_arsort)#12 (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  ["g"]=>
+  object(for_string_arsort)#13 (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+}
+Done
diff --git a/tests/std/array/arsort_object2.phpt b/tests/std/array/arsort_object2.phpt
new file mode 100644
index 00000000..3db1891a
--- /dev/null
+++ b/tests/std/array/arsort_object2.phpt
@@ -0,0 +1,232 @@
+--TEST--
+Test arsort() function : object functionality - sorting objects with diff. accessibility of member vars
+--FILE--
+<?php
+// class declaration for integer objects
+class for_integer_arsort
+{
+    public $public_class_value;
+    private $private_class_value;
+    protected $protected_class_value;
+    // initializing object member value
+    function __construct($value1, $value2, $value3)
+    {
+        $this->public_class_value = $value1;
+        $this->private_class_value = $value2;
+        $this->protected_class_value = $value3;
+    }
+}
+// class declaration for string objects
+class for_string_arsort
+{
+    public $public_class_value;
+    private $private_class_value;
+    protected $protected_class_value;
+    // initializing object member value
+    function __construct($value1, $value2, $value3)
+    {
+        $this->public_class_value = $value1;
+        $this->private_class_value = $value2;
+        $this->protected_class_value = $value3;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * testing arsort() by providing integer/string object arrays with following flag values
+     * 1. Default flag value
+       2. SORT_REGULAR - compare items normally
+    */
+    echo "*** Testing arsort() : object functionality ***\n";
+    // array of integer objects
+    $unsorted_int_obj = array(1 => new for_integer_arsort(11, 33, 2), 2 => new for_integer_arsort(44, 66, 3), 3 => new for_integer_arsort(23, 32, 6), 4 => new for_integer_arsort(-88, -5, -4));
+    // array of string objects
+    $unsorted_str_obj = array("a" => new for_string_arsort("axx", "AXX", "d"), "b" => new for_string_arsort("T", "t", "q"), "c" => new for_string_arsort("w", "W", "c"), "d" => new for_string_arsort("PY", "py", "s"));
+    echo "\n-- Testing arsort() by supplying various object arrays, 'flag' value is default --\n";
+    // testing arsort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(arsort($temp_array));
+    var_dump($temp_array);
+    // testing arsort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(arsort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Testing arsort() by supplying various object arrays, 'flag' value is SORT_REGULAR --\n";
+    // testing arsort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(arsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing arsort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(arsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done\n";
+}
+?>
+--EXPECT--
+*** Testing arsort() : object functionality ***
+
+-- Testing arsort() by supplying various object arrays, 'flag' value is default --
+bool(true)
+array(4) {
+  [2]=>
+  object(for_integer_arsort)#2 (3) {
+    ["public_class_value"]=>
+    int(44)
+    ["private_class_value":"for_integer_arsort":private]=>
+    int(66)
+    ["protected_class_value":protected]=>
+    int(3)
+  }
+  [3]=>
+  object(for_integer_arsort)#3 (3) {
+    ["public_class_value"]=>
+    int(23)
+    ["private_class_value":"for_integer_arsort":private]=>
+    int(32)
+    ["protected_class_value":protected]=>
+    int(6)
+  }
+  [1]=>
+  object(for_integer_arsort)#1 (3) {
+    ["public_class_value"]=>
+    int(11)
+    ["private_class_value":"for_integer_arsort":private]=>
+    int(33)
+    ["protected_class_value":protected]=>
+    int(2)
+  }
+  [4]=>
+  object(for_integer_arsort)#4 (3) {
+    ["public_class_value"]=>
+    int(-88)
+    ["private_class_value":"for_integer_arsort":private]=>
+    int(-5)
+    ["protected_class_value":protected]=>
+    int(-4)
+  }
+}
+bool(true)
+array(4) {
+  ["c"]=>
+  object(for_string_arsort)#7 (3) {
+    ["public_class_value"]=>
+    string(1) "w"
+    ["private_class_value":"for_string_arsort":private]=>
+    string(1) "W"
+    ["protected_class_value":protected]=>
+    string(1) "c"
+  }
+  ["a"]=>
+  object(for_string_arsort)#5 (3) {
+    ["public_class_value"]=>
+    string(3) "axx"
+    ["private_class_value":"for_string_arsort":private]=>
+    string(3) "AXX"
+    ["protected_class_value":protected]=>
+    string(1) "d"
+  }
+  ["b"]=>
+  object(for_string_arsort)#6 (3) {
+    ["public_class_value"]=>
+    string(1) "T"
+    ["private_class_value":"for_string_arsort":private]=>
+    string(1) "t"
+    ["protected_class_value":protected]=>
+    string(1) "q"
+  }
+  ["d"]=>
+  object(for_string_arsort)#8 (3) {
+    ["public_class_value"]=>
+    string(2) "PY"
+    ["private_class_value":"for_string_arsort":private]=>
+    string(2) "py"
+    ["protected_class_value":protected]=>
+    string(1) "s"
+  }
+}
+
+-- Testing arsort() by supplying various object arrays, 'flag' value is SORT_REGULAR --
+bool(true)
+array(4) {
+  [2]=>
+  object(for_integer_arsort)#2 (3) {
+    ["public_class_value"]=>
+    int(44)
+    ["private_class_value":"for_integer_arsort":private]=>
+    int(66)
+    ["protected_class_value":protected]=>
+    int(3)
+  }
+  [3]=>
+  object(for_integer_arsort)#3 (3) {
+    ["public_class_value"]=>
+    int(23)
+    ["private_class_value":"for_integer_arsort":private]=>
+    int(32)
+    ["protected_class_value":protected]=>
+    int(6)
+  }
+  [1]=>
+  object(for_integer_arsort)#1 (3) {
+    ["public_class_value"]=>
+    int(11)
+    ["private_class_value":"for_integer_arsort":private]=>
+    int(33)
+    ["protected_class_value":protected]=>
+    int(2)
+  }
+  [4]=>
+  object(for_integer_arsort)#4 (3) {
+    ["public_class_value"]=>
+    int(-88)
+    ["private_class_value":"for_integer_arsort":private]=>
+    int(-5)
+    ["protected_class_value":protected]=>
+    int(-4)
+  }
+}
+bool(true)
+array(4) {
+  ["c"]=>
+  object(for_string_arsort)#7 (3) {
+    ["public_class_value"]=>
+    string(1) "w"
+    ["private_class_value":"for_string_arsort":private]=>
+    string(1) "W"
+    ["protected_class_value":protected]=>
+    string(1) "c"
+  }
+  ["a"]=>
+  object(for_string_arsort)#5 (3) {
+    ["public_class_value"]=>
+    string(3) "axx"
+    ["private_class_value":"for_string_arsort":private]=>
+    string(3) "AXX"
+    ["protected_class_value":protected]=>
+    string(1) "d"
+  }
+  ["b"]=>
+  object(for_string_arsort)#6 (3) {
+    ["public_class_value"]=>
+    string(1) "T"
+    ["private_class_value":"for_string_arsort":private]=>
+    string(1) "t"
+    ["protected_class_value":protected]=>
+    string(1) "q"
+  }
+  ["d"]=>
+  object(for_string_arsort)#8 (3) {
+    ["public_class_value"]=>
+    string(2) "PY"
+    ["private_class_value":"for_string_arsort":private]=>
+    string(2) "py"
+    ["protected_class_value":protected]=>
+    string(1) "s"
+  }
+}
+Done
diff --git a/tests/std/array/arsort_variation10.phpt b/tests/std/array/arsort_variation10.phpt
new file mode 100644
index 00000000..30127b84
--- /dev/null
+++ b/tests/std/array/arsort_variation10.phpt
@@ -0,0 +1,108 @@
+--TEST--
+Test arsort() function : usage variations - sort octal values
+--FILE--
+<?php
+/*
+ * testing arsort() by providing different octal array for $array argument with following flag values
+ * 1.flag value as default
+ * 2.SORT_REGULAR - compare items normally
+ * 3.SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing arsort() : usage variations ***\n";
+
+// an array contains unsorted octal values
+$unsorted_oct_array = array (
+   01235 => 01235, 0321 => 0321, 0345 => 0345, 066 => 066, 0772 => 0772,
+   077 => 077, -066 => -066, -0345 => -0345, 0 => 0
+);
+
+echo "\n-- Testing arsort() by supplying octal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( arsort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing arsort() by supplying octal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( arsort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing arsort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( arsort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing arsort() : usage variations ***
+
+-- Testing arsort() by supplying octal value array, 'flag' value is default  --
+bool(true)
+array(9) {
+  [669]=>
+  int(669)
+  [506]=>
+  int(506)
+  [229]=>
+  int(229)
+  [209]=>
+  int(209)
+  [63]=>
+  int(63)
+  [54]=>
+  int(54)
+  [0]=>
+  int(0)
+  [-54]=>
+  int(-54)
+  [-229]=>
+  int(-229)
+}
+
+-- Testing arsort() by supplying octal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(9) {
+  [669]=>
+  int(669)
+  [506]=>
+  int(506)
+  [229]=>
+  int(229)
+  [209]=>
+  int(209)
+  [63]=>
+  int(63)
+  [54]=>
+  int(54)
+  [0]=>
+  int(0)
+  [-54]=>
+  int(-54)
+  [-229]=>
+  int(-229)
+}
+
+-- Testing arsort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [669]=>
+  int(669)
+  [506]=>
+  int(506)
+  [229]=>
+  int(229)
+  [209]=>
+  int(209)
+  [63]=>
+  int(63)
+  [54]=>
+  int(54)
+  [0]=>
+  int(0)
+  [-54]=>
+  int(-54)
+  [-229]=>
+  int(-229)
+}
+Done
diff --git a/tests/std/array/arsort_variation11.phpt b/tests/std/array/arsort_variation11.phpt
new file mode 100644
index 00000000..8d0f99a2
--- /dev/null
+++ b/tests/std/array/arsort_variation11.phpt
@@ -0,0 +1,155 @@
+--TEST--
+Test arsort() function : usage variations - sort mixed values, 'sort_flags' as default/SORT_REGULAR (OK to fail as result is unpredectable)
+--SKIPIF--
+<?php die("skip AOT sort order may differ from PHP (SORT_REGULAR on mixed types)"); ?>
+--FILE--
+<?php
+/*
+ * testing arsort() by providing mixed value array for $array argument with following flag values.
+ * 1.flag value as default
+ * 2.SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing arsort() : usage variations ***\n";
+
+// mixed value array with different key values
+$mixed_values = array (
+  "array1" => array(),
+  "array2" => array ( "sub_array[2,1]" => array(33,-5,6), "sub_array[2,2]" => array(11),
+                      "sub_array[2,3]" => array(22,-55), "sub_array[2,4]" => array()
+                    ),
+  4 => 4, "4" => "4", 4 => 4.01, "b" => "b", "5" => "5", -2 => -2, -2 => -2.01,
+  -2 => -2.98989, "-.9" => "-.9", "True" => "True", "" =>  "", NULL => NULL,
+  "ab" => "ab", "abcd" => "abcd", 0 => 0.01, -0 => -0, '' => '' ,
+  "abcd\x00abcd\x00abcd" => "abcd\x00abcd\x00abcd", 0 => 0.001
+);
+
+echo "\n-- Testing arsort() by supplying mixed value array, 'flag' value is default --\n";
+$temp_array = $mixed_values;
+var_dump( arsort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing arsort() by supplying mixed value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $mixed_values;
+var_dump( arsort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing arsort() : usage variations ***
+
+-- Testing arsort() by supplying mixed value array, 'flag' value is default --
+bool(true)
+array(13) {
+  ["array2"]=>
+  array(4) {
+    ["sub_array[2,1]"]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    ["sub_array[2,2]"]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    ["sub_array[2,3]"]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    ["sub_array[2,4]"]=>
+    array(0) {
+    }
+  }
+  ["array1"]=>
+  array(0) {
+  }
+  ["b"]=>
+  string(1) "b"
+  ["abcd%0abcd%0abcd"]=>
+  string(14) "abcd%0abcd%0abcd"
+  ["abcd"]=>
+  string(4) "abcd"
+  ["ab"]=>
+  string(2) "ab"
+  ["True"]=>
+  string(4) "True"
+  [5]=>
+  string(1) "5"
+  [4]=>
+  float(4.01)
+  [0]=>
+  float(0.001)
+  ["-.9"]=>
+  string(3) "-.9"
+  [-2]=>
+  float(-2.98989)
+  [""]=>
+  string(0) ""
+}
+
+-- Testing arsort() by supplying mixed value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(13) {
+  ["array2"]=>
+  array(4) {
+    ["sub_array[2,1]"]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    ["sub_array[2,2]"]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    ["sub_array[2,3]"]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    ["sub_array[2,4]"]=>
+    array(0) {
+    }
+  }
+  ["array1"]=>
+  array(0) {
+  }
+  ["b"]=>
+  string(1) "b"
+  ["abcd%0abcd%0abcd"]=>
+  string(14) "abcd%0abcd%0abcd"
+  ["abcd"]=>
+  string(4) "abcd"
+  ["ab"]=>
+  string(2) "ab"
+  ["True"]=>
+  string(4) "True"
+  [5]=>
+  string(1) "5"
+  [4]=>
+  float(4.01)
+  [0]=>
+  float(0.001)
+  ["-.9"]=>
+  string(3) "-.9"
+  [-2]=>
+  float(-2.98989)
+  [""]=>
+  string(0) ""
+}
+Done
diff --git a/tests/std/array/arsort_variation3.phpt b/tests/std/array/arsort_variation3.phpt
new file mode 100644
index 00000000..e54d9c3b
--- /dev/null
+++ b/tests/std/array/arsort_variation3.phpt
@@ -0,0 +1,320 @@
+--TEST--
+Test arsort() function : usage variations - sort integer/float values
+--FILE--
+<?php
+/*
+ * Testing arsort() by providing different integer/float value arrays for $array argument with following values
+ * 1. flag value as default
+ * 2. SORT_REGULAR - compare items normally
+ * 3. SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing arsort() : usage variations ***\n";
+
+// group of various arrays with indices
+$various_arrays = array(
+  // negative/posative integer array
+  array(1 => 11, 2 => -11, 3 => 21, 4 => -21, 5 => 31, 6 => -31, 7 => 0, 8 => 41, 10 =>-41),
+
+  // float value array
+  array(1 => 10.5, 2 => -10.5, 3 => 10.5e2, 4 => 10.6E-2, 5 => .5, 6 => .0001, 7 => -.1),
+
+  // mixed value array
+  array(1 => .0001, 2 => .0021, 3 => -.01, 4 => -1, 5 => 0, 6 => .09, 7 => 2, 8 => -.9, 9 => 10.6E-2, 10 => -10.6E-2, 11 => 33),
+
+  // array values contains minimum and maximum ranges
+  array(1 => 2147483647, 2 => 2147483648, 3 => -2147483647, 4 => -2147483648, 5 => -0, 6 => 0, 7 => -2147483649)
+);
+
+// set of possible flag values
+$flag_value = array("SORT_REGULAR" => SORT_REGULAR, "SORT_NUMERIC" => SORT_NUMERIC);
+
+$count = 1;
+echo "\n-- Testing arsort() by supplying various integer/float arrays --\n";
+
+// loop through to test arsort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort_flag -\n";
+  $temp_array = $array;
+  var_dump(arsort($temp_array) );
+  var_dump($temp_array);
+
+  // loop through $flag_value array and setting all possible flag values
+  foreach($flag_value as $key => $flag){
+    echo "- Sort_flag = $key -\n";
+    $temp_array = $array;
+    var_dump(arsort($temp_array, $flag) );
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing arsort() : usage variations ***
+
+-- Testing arsort() by supplying various integer/float arrays --
+
+-- Iteration 1 --
+- With default sort_flag -
+bool(true)
+array(9) {
+  [8]=>
+  int(41)
+  [5]=>
+  int(31)
+  [3]=>
+  int(21)
+  [1]=>
+  int(11)
+  [7]=>
+  int(0)
+  [2]=>
+  int(-11)
+  [4]=>
+  int(-21)
+  [6]=>
+  int(-31)
+  [10]=>
+  int(-41)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(9) {
+  [8]=>
+  int(41)
+  [5]=>
+  int(31)
+  [3]=>
+  int(21)
+  [1]=>
+  int(11)
+  [7]=>
+  int(0)
+  [2]=>
+  int(-11)
+  [4]=>
+  int(-21)
+  [6]=>
+  int(-31)
+  [10]=>
+  int(-41)
+}
+- Sort_flag = SORT_NUMERIC -
+bool(true)
+array(9) {
+  [8]=>
+  int(41)
+  [5]=>
+  int(31)
+  [3]=>
+  int(21)
+  [1]=>
+  int(11)
+  [7]=>
+  int(0)
+  [2]=>
+  int(-11)
+  [4]=>
+  int(-21)
+  [6]=>
+  int(-31)
+  [10]=>
+  int(-41)
+}
+
+-- Iteration 2 --
+- With default sort_flag -
+bool(true)
+array(7) {
+  [3]=>
+  float(1050)
+  [1]=>
+  float(10.5)
+  [5]=>
+  float(0.5)
+  [4]=>
+  float(0.106)
+  [6]=>
+  float(0.0001)
+  [7]=>
+  float(-0.1)
+  [2]=>
+  float(-10.5)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(7) {
+  [3]=>
+  float(1050)
+  [1]=>
+  float(10.5)
+  [5]=>
+  float(0.5)
+  [4]=>
+  float(0.106)
+  [6]=>
+  float(0.0001)
+  [7]=>
+  float(-0.1)
+  [2]=>
+  float(-10.5)
+}
+- Sort_flag = SORT_NUMERIC -
+bool(true)
+array(7) {
+  [3]=>
+  float(1050)
+  [1]=>
+  float(10.5)
+  [5]=>
+  float(0.5)
+  [4]=>
+  float(0.106)
+  [6]=>
+  float(0.0001)
+  [7]=>
+  float(-0.1)
+  [2]=>
+  float(-10.5)
+}
+
+-- Iteration 3 --
+- With default sort_flag -
+bool(true)
+array(11) {
+  [11]=>
+  int(33)
+  [7]=>
+  int(2)
+  [9]=>
+  float(0.106)
+  [6]=>
+  float(0.09)
+  [2]=>
+  float(0.0021)
+  [1]=>
+  float(0.0001)
+  [5]=>
+  int(0)
+  [3]=>
+  float(-0.01)
+  [10]=>
+  float(-0.106)
+  [8]=>
+  float(-0.9)
+  [4]=>
+  int(-1)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  [11]=>
+  int(33)
+  [7]=>
+  int(2)
+  [9]=>
+  float(0.106)
+  [6]=>
+  float(0.09)
+  [2]=>
+  float(0.0021)
+  [1]=>
+  float(0.0001)
+  [5]=>
+  int(0)
+  [3]=>
+  float(-0.01)
+  [10]=>
+  float(-0.106)
+  [8]=>
+  float(-0.9)
+  [4]=>
+  int(-1)
+}
+- Sort_flag = SORT_NUMERIC -
+bool(true)
+array(11) {
+  [11]=>
+  int(33)
+  [7]=>
+  int(2)
+  [9]=>
+  float(0.106)
+  [6]=>
+  float(0.09)
+  [2]=>
+  float(0.0021)
+  [1]=>
+  float(0.0001)
+  [5]=>
+  int(0)
+  [3]=>
+  float(-0.01)
+  [10]=>
+  float(-0.106)
+  [8]=>
+  float(-0.9)
+  [4]=>
+  int(-1)
+}
+
+-- Iteration 4 --
+- With default sort_flag -
+bool(true)
+array(7) {
+  [2]=>
+  %s(2147483648)
+  [1]=>
+  int(2147483647)
+  [5]=>
+  int(0)
+  [6]=>
+  int(0)
+  [3]=>
+  int(-2147483647)
+  [4]=>
+  %s(-2147483648)
+  [7]=>
+  %s(-2147483649)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(7) {
+  [2]=>
+  %s(2147483648)
+  [1]=>
+  int(2147483647)
+  [5]=>
+  int(0)
+  [6]=>
+  int(0)
+  [3]=>
+  int(-2147483647)
+  [4]=>
+  %s(-2147483648)
+  [7]=>
+  %s(-2147483649)
+}
+- Sort_flag = SORT_NUMERIC -
+bool(true)
+array(7) {
+  [2]=>
+  %s(2147483648)
+  [1]=>
+  int(2147483647)
+  [5]=>
+  int(0)
+  [6]=>
+  int(0)
+  [3]=>
+  int(-2147483647)
+  [4]=>
+  %s(-2147483648)
+  [7]=>
+  %s(-2147483649)
+}
+Done
diff --git a/tests/std/array/arsort_variation4.phpt b/tests/std/array/arsort_variation4.phpt
new file mode 100644
index 00000000..5e0bd2cd
--- /dev/null
+++ b/tests/std/array/arsort_variation4.phpt
@@ -0,0 +1,78 @@
+--TEST--
+Test arsort() function : usage variations - sort reference variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference assignment in this context");
+?>
+
+--FILE--
+<?php
+/*
+ * Testing arsort() by providing reference variable array with following flag values
+ *  flag value as default
+ *  SORT_REGULAR - compare items normally
+ *  SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing arsort() :usage variations  ***\n";
+
+$value1 = 100;
+$value2 = 33;
+$value3 = 555;
+
+// an array containing integer references
+$unsorted_numerics =  array( 1 => &$value1 , 2 => &$value2, 3 => &$value3);
+
+echo "\n-- Testing arsort() by supplying reference variable array, 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( arsort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying reference variable array, 'flag' = SORT_REGULAR --\n";
+$temp_array = &$unsorted_numerics;
+var_dump( arsort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing arsort() by supplying reference variable array, 'flag' = SORT_NUMERIC --\n";
+$temp_array = &$unsorted_numerics;
+var_dump( arsort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing arsort() :usage variations  ***
+
+-- Testing arsort() by supplying reference variable array, 'flag' value is default --
+bool(true)
+array(3) {
+  [3]=>
+  &int(555)
+  [1]=>
+  &int(100)
+  [2]=>
+  &int(33)
+}
+
+-- Testing arsort() by supplying reference variable array, 'flag' = SORT_REGULAR --
+bool(true)
+array(3) {
+  [3]=>
+  &int(555)
+  [1]=>
+  &int(100)
+  [2]=>
+  &int(33)
+}
+
+-- Testing arsort() by supplying reference variable array, 'flag' = SORT_NUMERIC --
+bool(true)
+array(3) {
+  [3]=>
+  &int(555)
+  [1]=>
+  &int(100)
+  [2]=>
+  &int(33)
+}
+Done
diff --git a/tests/std/array/arsort_variation5.phpt b/tests/std/array/arsort_variation5.phpt
new file mode 100644
index 00000000..eb3f2f95
--- /dev/null
+++ b/tests/std/array/arsort_variation5.phpt
@@ -0,0 +1,236 @@
+--TEST--
+Test arsort() function : usage variations - sort strings
+--FILE--
+<?php
+/*
+ * testing arsort() by providing different string arrays for $array argument with following flag values
+ *  flag value as default
+ *  SORT_REGULAR - compare items normally
+ *  SORT_STRING  - compare items as strings
+*/
+
+echo "*** Testing arsort() : usage variations ***\n";
+
+$various_arrays = array (
+  // group of escape sequences
+  array ("null"=>  null, "NULL" => NULL, "\a" => "\a", "\cx" => "\cx", "\e" => "\e",
+        "\f" => "\f", "\n" =>"\n", "\r" => "\r", "\t" => "\t", "\xhh" => "\xhh",
+        "\ddd" => "\ddd", "\v" => "\v"
+        ),
+
+  // array contains combination of capital/small letters
+  array ('l' => "lemoN", 'O' => "Orange", 'b' => "banana", 'a' => "apple", 'Te' => "Test",
+        'T' => "TTTT", 't' => "ttt", 'w' => "ww", 'x' => "x", 'X' => "X", 'o' => "oraNGe",
+        'B' => "BANANA"
+        )
+);
+
+$flags = array("SORT_REGULAR" => SORT_REGULAR, "SORT_STRING" => SORT_STRING);
+
+$count = 1;
+echo "\n-- Testing arsort() by supplying various string arrays --\n";
+
+// loop through to test arsort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort_flag -\n";
+  $temp_array = $array;
+  var_dump(arsort($temp_array) ); // expecting : bool(true)
+  var_dump($temp_array);
+
+  // loop through $flags array and setting all possible flag values
+  foreach($flags as $key => $flag){
+    echo "- Sort_flag = $key -\n";
+    $temp_array = $array;
+    var_dump(arsort($temp_array, $flag) ); // expecting : bool(true)
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing arsort() : usage variations ***
+
+-- Testing arsort() by supplying various string arrays --
+
+-- Iteration 1 --
+- With default sort_flag -
+bool(true)
+array(12) {
+  ["\xhh"]=>
+  string(4) "\xhh"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\a"]=>
+  string(2) "\a"
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
+"]=>
+  string(1) "
+"
+  ["	"]=>
+  string(1) "	"
+  ["null"]=>
+  NULL
+  ["NULL"]=>
+  NULL
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(12) {
+  ["\xhh"]=>
+  string(4) "\xhh"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\a"]=>
+  string(2) "\a"
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
+"]=>
+  string(1) "
+"
+  ["	"]=>
+  string(1) "	"
+  ["null"]=>
+  NULL
+  ["NULL"]=>
+  NULL
+}
+- Sort_flag = SORT_STRING -
+bool(true)
+array(12) {
+  ["\xhh"]=>
+  string(4) "\xhh"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\a"]=>
+  string(2) "\a"
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
+"]=>
+  string(1) "
+"
+  ["	"]=>
+  string(1) "	"
+  ["null"]=>
+  NULL
+  ["NULL"]=>
+  NULL
+}
+
+-- Iteration 2 --
+- With default sort_flag -
+bool(true)
+array(12) {
+  ["x"]=>
+  string(1) "x"
+  ["w"]=>
+  string(2) "ww"
+  ["t"]=>
+  string(3) "ttt"
+  ["o"]=>
+  string(6) "oraNGe"
+  ["l"]=>
+  string(5) "lemoN"
+  ["b"]=>
+  string(6) "banana"
+  ["a"]=>
+  string(5) "apple"
+  ["X"]=>
+  string(1) "X"
+  ["Te"]=>
+  string(4) "Test"
+  ["T"]=>
+  string(4) "TTTT"
+  ["O"]=>
+  string(6) "Orange"
+  ["B"]=>
+  string(6) "BANANA"
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(12) {
+  ["x"]=>
+  string(1) "x"
+  ["w"]=>
+  string(2) "ww"
+  ["t"]=>
+  string(3) "ttt"
+  ["o"]=>
+  string(6) "oraNGe"
+  ["l"]=>
+  string(5) "lemoN"
+  ["b"]=>
+  string(6) "banana"
+  ["a"]=>
+  string(5) "apple"
+  ["X"]=>
+  string(1) "X"
+  ["Te"]=>
+  string(4) "Test"
+  ["T"]=>
+  string(4) "TTTT"
+  ["O"]=>
+  string(6) "Orange"
+  ["B"]=>
+  string(6) "BANANA"
+}
+- Sort_flag = SORT_STRING -
+bool(true)
+array(12) {
+  ["x"]=>
+  string(1) "x"
+  ["w"]=>
+  string(2) "ww"
+  ["t"]=>
+  string(3) "ttt"
+  ["o"]=>
+  string(6) "oraNGe"
+  ["l"]=>
+  string(5) "lemoN"
+  ["b"]=>
+  string(6) "banana"
+  ["a"]=>
+  string(5) "apple"
+  ["X"]=>
+  string(1) "X"
+  ["Te"]=>
+  string(4) "Test"
+  ["T"]=>
+  string(4) "TTTT"
+  ["O"]=>
+  string(6) "Orange"
+  ["B"]=>
+  string(6) "BANANA"
+}
+Done
diff --git a/tests/std/array/arsort_variation6.phpt b/tests/std/array/arsort_variation6.phpt
new file mode 100644
index 00000000..1cf1bb5f
--- /dev/null
+++ b/tests/std/array/arsort_variation6.phpt
@@ -0,0 +1,108 @@
+--TEST--
+Test arsort() function : usage variations - sort hexadecimal values
+--FILE--
+<?php
+/*
+ * testing arsort() by providing different hexa-decimal array for $array argument with following flag values
+ * flag value as default
+ * SORT_REGULAR - compare items normally
+ * SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing arsort() : usage variations ***\n";
+
+// an array contains unsorted hexadecimal values
+// There are multiple keys which are duplicate and the later should be picked
+$unsorted_hex_array = array ( 0x1AB => 0x1AB, 0xFFF => 0xFFF, 0xF => 0xF, 0xFF => 0xFF, 0x2AA => 0x2AA, 0xBB => 0xBB,
+                              0x1ab => 0x1ab, 0xff => 0xff, -0xff => -0xFF, 0 => 0, -0x2aa => -0x2aa
+                            );
+
+echo "\n-- Testing arsort() by supplying hexadecimal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(arsort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing arsort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(arsort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing arsort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(arsort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing arsort() : usage variations ***
+
+-- Testing arsort() by supplying hexadecimal value array, 'flag' value is default  --
+bool(true)
+array(9) {
+  [4095]=>
+  int(4095)
+  [682]=>
+  int(682)
+  [427]=>
+  int(427)
+  [255]=>
+  int(255)
+  [187]=>
+  int(187)
+  [15]=>
+  int(15)
+  [0]=>
+  int(0)
+  [-255]=>
+  int(-255)
+  [-682]=>
+  int(-682)
+}
+
+-- Testing arsort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(9) {
+  [4095]=>
+  int(4095)
+  [682]=>
+  int(682)
+  [427]=>
+  int(427)
+  [255]=>
+  int(255)
+  [187]=>
+  int(187)
+  [15]=>
+  int(15)
+  [0]=>
+  int(0)
+  [-255]=>
+  int(-255)
+  [-682]=>
+  int(-682)
+}
+
+-- Testing arsort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [4095]=>
+  int(4095)
+  [682]=>
+  int(682)
+  [427]=>
+  int(427)
+  [255]=>
+  int(255)
+  [187]=>
+  int(187)
+  [15]=>
+  int(15)
+  [0]=>
+  int(0)
+  [-255]=>
+  int(-255)
+  [-682]=>
+  int(-682)
+}
+Done
diff --git a/tests/std/array/arsort_variation7.phpt b/tests/std/array/arsort_variation7.phpt
new file mode 100644
index 00000000..ecd2afc4
--- /dev/null
+++ b/tests/std/array/arsort_variation7.phpt
@@ -0,0 +1,92 @@
+--TEST--
+Test arsort() function : usage variations - sort bool values
+--FILE--
+<?php
+/*
+ * testing arsort() by providing bool value array for $array argument with following flag values.
+ * flag value as default
+ * SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing arsort() : usage variations ***\n";
+
+// bool value array
+$bool_values = array (1 => true, 2 => false, 3 => TRUE, 4 => FALSE);
+
+echo "\n-- Testing arsort() by supplying bool value array, 'flag' value is default --\n";
+$temp_array = $bool_values;
+var_dump(arsort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing arsort() by supplying bool value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $bool_values;
+var_dump(arsort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "\n-- Testing arsort() by supplying bool value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $bool_values;
+var_dump(arsort($temp_array, SORT_NUMERIC) );
+var_dump($temp_array);
+
+echo "\n-- Testing arsort() by supplying bool value array, 'flag' value is SORT_STRING --\n";
+$temp_array = $bool_values;
+var_dump(arsort($temp_array, SORT_STRING) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing arsort() : usage variations ***
+
+-- Testing arsort() by supplying bool value array, 'flag' value is default --
+bool(true)
+array(4) {
+  [1]=>
+  bool(true)
+  [3]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [4]=>
+  bool(false)
+}
+
+-- Testing arsort() by supplying bool value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(4) {
+  [1]=>
+  bool(true)
+  [3]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [4]=>
+  bool(false)
+}
+
+-- Testing arsort() by supplying bool value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(4) {
+  [1]=>
+  bool(true)
+  [3]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [4]=>
+  bool(false)
+}
+
+-- Testing arsort() by supplying bool value array, 'flag' value is SORT_STRING --
+bool(true)
+array(4) {
+  [1]=>
+  bool(true)
+  [3]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [4]=>
+  bool(false)
+}
+Done
diff --git a/tests/std/array/arsort_variation8.phpt b/tests/std/array/arsort_variation8.phpt
new file mode 100644
index 00000000..267f8ddc
--- /dev/null
+++ b/tests/std/array/arsort_variation8.phpt
@@ -0,0 +1,174 @@
+--TEST--
+Test arsort() function : usage variations - sort array with diff. sub arrays, 'sort_flags' as default/SORT_REGULAR
+--FILE--
+<?php
+/*
+ * testing arsort() by providing arrays contains sub arrays for $array argument with flowing flag values
+ * flag value as default
+ * SORT_REGULAR - compare items normally
+ * Note: arrays are sorted based on total count of elements inside it, when all the elements are arrays
+*/
+
+echo "*** Testing arsort() : usage variations ***\n";
+
+// array of arrays
+$various_arrays = array (
+  // null array
+  "array[0]" => array(),
+
+  // array contains null sub array
+  "array[1]" => array( "sub_array[1][0]" => array() ),
+
+  // array of arrays along with some values
+  "array[2]" => array("data[2,0]" => 44, "data[2,1]" => 11, "sub_array[2][0] " => array(64,61) ),
+
+  // array contains sub arrays
+  "array[3]" => array ( "sub_array[3][0]" => array(33,-5,6), "sub_array[3][1]" => array(11),
+                        "sub_array[3][2]" => array(22,-55), "sub_array[3][3]" => array() )
+);
+
+
+$count = 1;
+echo "\n-- Testing arsort() by supplying various arrays containing sub arrays --\n";
+
+// loop through to test arsort() with different arrays
+foreach ($various_arrays as $array) {
+
+  echo "\n-- Iteration $count --\n";
+  // testing arsort() function by supplying different arrays, flag value is default
+  echo "- With default sort_flag -\n";
+  $temp_array = $array;
+  var_dump(arsort($temp_array) );
+  var_dump($temp_array);
+
+  // testing arsort() function by supplying different arrays, flag value = SORT_REGULAR
+  echo "- Sort_flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump(arsort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing arsort() : usage variations ***
+
+-- Testing arsort() by supplying various arrays containing sub arrays --
+
+-- Iteration 1 --
+- With default sort_flag -
+bool(true)
+array(0) {
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(0) {
+}
+
+-- Iteration 2 --
+- With default sort_flag -
+bool(true)
+array(1) {
+  ["sub_array[1][0]"]=>
+  array(0) {
+  }
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(1) {
+  ["sub_array[1][0]"]=>
+  array(0) {
+  }
+}
+
+-- Iteration 3 --
+- With default sort_flag -
+bool(true)
+array(3) {
+  ["sub_array[2][0] "]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+  ["data[2,0]"]=>
+  int(44)
+  ["data[2,1]"]=>
+  int(11)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  ["sub_array[2][0] "]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+  ["data[2,0]"]=>
+  int(44)
+  ["data[2,1]"]=>
+  int(11)
+}
+
+-- Iteration 4 --
+- With default sort_flag -
+bool(true)
+array(4) {
+  ["sub_array[3][0]"]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+  ["sub_array[3][2]"]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  ["sub_array[3][1]"]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  ["sub_array[3][3]"]=>
+  array(0) {
+  }
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  ["sub_array[3][0]"]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+  ["sub_array[3][2]"]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  ["sub_array[3][1]"]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  ["sub_array[3][3]"]=>
+  array(0) {
+  }
+}
+Done
diff --git a/tests/std/array/arsort_variation9.phpt b/tests/std/array/arsort_variation9.phpt
new file mode 100644
index 00000000..cfad3b44
--- /dev/null
+++ b/tests/std/array/arsort_variation9.phpt
@@ -0,0 +1,252 @@
+--TEST--
+Test arsort() function : usage variations - sorting arrays with/without keys, 'sort_flags' as default/SORT_REGULAR
+--FILE--
+<?php
+/*
+ * Testing arsort() by providing arrays  with key values for $array argument with following flag values.
+ * 1.flag value as default
+ * 2.SORT_REGULAR - compare items normally
+ */
+
+echo "*** Testing arsort() : usage variations ***\n";
+
+// list of arrays with/without key values
+$various_arrays = array (
+  array(5 => 55,  66, 22, 33, 11),
+  array ("a" => "orange",  "banana", "c" => "apple"),
+  array(1, 2, 3, 4, 5, 6),
+  array("first", 5 => "second", "third"),
+  array(1, 1, 8 => 1,  4 => 1, 19, 3 => 13),
+  array('bar' => 'baz', "foo" => 1),
+  array('a'=>1,'b'=>array('e'=>2,'f'=>3),'c'=>array('g'=>4),'d'=>5),
+);
+
+$count = 1;
+echo "\n-- Testing arsort() by supplying various arrays with key values --\n";
+
+// loop through to test arsort() with different arrays,
+// to test the new keys for the elements in the sorted array
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort_flag -\n";
+  $temp_array = $array;
+  var_dump(arsort($temp_array) );
+  var_dump($temp_array);
+
+  echo "- Sort_flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump(arsort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing arsort() : usage variations ***
+
+-- Testing arsort() by supplying various arrays with key values --
+
+-- Iteration 1 --
+- With default sort_flag -
+bool(true)
+array(5) {
+  [6]=>
+  int(66)
+  [5]=>
+  int(55)
+  [8]=>
+  int(33)
+  [7]=>
+  int(22)
+  [9]=>
+  int(11)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(5) {
+  [6]=>
+  int(66)
+  [5]=>
+  int(55)
+  [8]=>
+  int(33)
+  [7]=>
+  int(22)
+  [9]=>
+  int(11)
+}
+
+-- Iteration 2 --
+- With default sort_flag -
+bool(true)
+array(3) {
+  ["a"]=>
+  string(6) "orange"
+  [0]=>
+  string(6) "banana"
+  ["c"]=>
+  string(5) "apple"
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  ["a"]=>
+  string(6) "orange"
+  [0]=>
+  string(6) "banana"
+  ["c"]=>
+  string(5) "apple"
+}
+
+-- Iteration 3 --
+- With default sort_flag -
+bool(true)
+array(6) {
+  [5]=>
+  int(6)
+  [4]=>
+  int(5)
+  [3]=>
+  int(4)
+  [2]=>
+  int(3)
+  [1]=>
+  int(2)
+  [0]=>
+  int(1)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(6) {
+  [5]=>
+  int(6)
+  [4]=>
+  int(5)
+  [3]=>
+  int(4)
+  [2]=>
+  int(3)
+  [1]=>
+  int(2)
+  [0]=>
+  int(1)
+}
+
+-- Iteration 4 --
+- With default sort_flag -
+bool(true)
+array(3) {
+  [6]=>
+  string(5) "third"
+  [5]=>
+  string(6) "second"
+  [0]=>
+  string(5) "first"
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  [6]=>
+  string(5) "third"
+  [5]=>
+  string(6) "second"
+  [0]=>
+  string(5) "first"
+}
+
+-- Iteration 5 --
+- With default sort_flag -
+bool(true)
+array(6) {
+  [9]=>
+  int(19)
+  [3]=>
+  int(13)
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [8]=>
+  int(1)
+  [4]=>
+  int(1)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(6) {
+  [9]=>
+  int(19)
+  [3]=>
+  int(13)
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [8]=>
+  int(1)
+  [4]=>
+  int(1)
+}
+
+-- Iteration 6 --
+- With default sort_flag -
+bool(true)
+array(2) {
+  ["bar"]=>
+  string(3) "baz"
+  ["foo"]=>
+  int(1)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(2) {
+  ["bar"]=>
+  string(3) "baz"
+  ["foo"]=>
+  int(1)
+}
+
+-- Iteration 7 --
+- With default sort_flag -
+bool(true)
+array(4) {
+  ["b"]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+  ["c"]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  ["d"]=>
+  int(5)
+  ["a"]=>
+  int(1)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  ["b"]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+  ["c"]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  ["d"]=>
+  int(5)
+  ["a"]=>
+  int(1)
+}
+Done
diff --git a/tests/std/array/asort_basic.phpt b/tests/std/array/asort_basic.phpt
new file mode 100644
index 00000000..13f03a92
--- /dev/null
+++ b/tests/std/array/asort_basic.phpt
@@ -0,0 +1,239 @@
+--TEST--
+Test asort() function : basic functionality
+--FILE--
+<?php
+/*
+ * Testing asort() by providing integer/string arrays to check the basic functionality
+ * with following flag values.
+ *  flag value as default
+ *  SORT_REGULAR - compare items normally
+ *  SORT_NUMERIC - compare items numerically
+ *  SORT_STRING - compare items as strings
+*/
+
+echo "*** Testing asort() : basic functionality ***\n";
+
+// an array containing unsorted string values with indices
+$unsorted_strings = array(
+    "l" => "lemon", "o" => "orange",
+    "O" => "Orange", "O1" => "Orange1", "o2" => "orange2", "O3" => "Orange3", "o20" => "orange20",
+    "b" => "banana",
+);
+// an array containing unsorted numeric values with indices
+$unsorted_numerics =  array( 1 => 100, 2 => 33, 3 => 555, 4 => 22 );
+
+echo "\n-- Testing asort() by supplying string array, 'flag' value is default --\n";
+$temp_array = $unsorted_strings;
+var_dump( asort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying numeric array, 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( asort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying string array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_strings;
+var_dump( asort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying numeric array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_numerics;
+var_dump( asort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying string array, 'flag' = SORT_STRING --\n";
+$temp_array = $unsorted_strings;
+var_dump( asort($temp_array, SORT_STRING) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( asort($temp_array, SORT_STRING|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying string array (natural), 'flag' = SORT_NATURAL --\n";
+$temp_array = $unsorted_strings;
+var_dump( asort($temp_array, SORT_NATURAL) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( asort($temp_array, SORT_NATURAL|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying numeric array, 'flag' = SORT_NUMERIC --\n";
+$temp_array = $unsorted_numerics;
+var_dump( asort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing asort() : basic functionality ***
+
+-- Testing asort() by supplying string array, 'flag' value is default --
+bool(true)
+array(8) {
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing asort() by supplying numeric array, 'flag' value is default --
+bool(true)
+array(4) {
+  [4]=>
+  int(22)
+  [2]=>
+  int(33)
+  [1]=>
+  int(100)
+  [3]=>
+  int(555)
+}
+
+-- Testing asort() by supplying string array, 'flag' = SORT_REGULAR --
+bool(true)
+array(8) {
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing asort() by supplying numeric array, 'flag' = SORT_REGULAR --
+bool(true)
+array(4) {
+  [4]=>
+  int(22)
+  [2]=>
+  int(33)
+  [1]=>
+  int(100)
+  [3]=>
+  int(555)
+}
+
+-- Testing asort() by supplying string array, 'flag' = SORT_STRING --
+bool(true)
+array(8) {
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing asort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+  ["O3"]=>
+  string(7) "Orange3"
+}
+
+-- Testing asort() by supplying string array (natural), 'flag' = SORT_NATURAL --
+bool(true)
+array(8) {
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing asort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["o2"]=>
+  string(7) "orange2"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing asort() by supplying numeric array, 'flag' = SORT_NUMERIC --
+bool(true)
+array(4) {
+  [4]=>
+  int(22)
+  [2]=>
+  int(33)
+  [1]=>
+  int(100)
+  [3]=>
+  int(555)
+}
+Done
diff --git a/tests/std/array/asort_object1.phpt b/tests/std/array/asort_object1.phpt
new file mode 100644
index 00000000..a4c68a40
--- /dev/null
+++ b/tests/std/array/asort_object1.phpt
@@ -0,0 +1,220 @@
+--TEST--
+Test asort() function : object functionality - sort objects
+--FILE--
+<?php
+// class declaration for integer objects
+class for_integer_asort
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+}
+// class declaration for string objects
+class for_string_asort
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * testing asort() by providing integer/string object arrays with following flag values
+     * 1. Default flag value
+     * 2. SORT_REGULAR - compare items normally
+    */
+    echo "*** Testing asort() : object functionality ***\n";
+    // array of integer objects
+    $unsorted_int_obj = array(1 => new for_integer_asort(11), 2 => new for_integer_asort(66), 3 => new for_integer_asort(23), 4 => new for_integer_asort(-5), 5 => new for_integer_asort(0.001), 6 => new for_integer_asort(0));
+    // array of string objects
+    $unsorted_str_obj = array("a" => new for_string_asort("axx"), "b" => new for_string_asort("t"), "c" => new for_string_asort("w"), "d" => new for_string_asort("py"), "e" => new for_string_asort("apple"), "f" => new for_string_asort("Orange"), "g" => new for_string_asort("Lemon"), "h" => new for_string_asort("aPPle"));
+    echo "\n-- Testing asort() by supplying various object arrays, 'flag' value is default --\n";
+    // testing asort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(asort($temp_array));
+    var_dump($temp_array);
+    // testing asort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(asort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Testing asort() by supplying various object arrays, 'flag' value is SORT_REGULAR --\n";
+    // testing asort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(asort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing asort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(asort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+*** Testing asort() : object functionality ***
+
+-- Testing asort() by supplying various object arrays, 'flag' value is default --
+bool(true)
+array(6) {
+  [4]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+  [6]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [5]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [1]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [3]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [2]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+}
+bool(true)
+array(8) {
+  ["g"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+  ["f"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  ["h"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  ["e"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  ["a"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  ["d"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  ["b"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  ["c"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+}
+
+-- Testing asort() by supplying various object arrays, 'flag' value is SORT_REGULAR --
+bool(true)
+array(6) {
+  [4]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+  [6]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [5]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [1]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [3]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [2]=>
+  object(for_integer_asort)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+}
+bool(true)
+array(8) {
+  ["g"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+  ["f"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  ["h"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  ["e"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  ["a"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  ["d"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  ["b"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  ["c"]=>
+  object(for_string_asort)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+}
+Done
diff --git a/tests/std/array/asort_object2.phpt b/tests/std/array/asort_object2.phpt
new file mode 100644
index 00000000..ca2f1538
--- /dev/null
+++ b/tests/std/array/asort_object2.phpt
@@ -0,0 +1,232 @@
+--TEST--
+Test asort() function : object functionality - sorting objects with diff. accessibility of member vars
+--FILE--
+<?php
+// class declaration for integer objects
+class for_integer_asort
+{
+    public $public_class_value;
+    private $private_class_value;
+    protected $protected_class_value;
+    // initializing object member value
+    function __construct($value1, $value2, $value3)
+    {
+        $this->public_class_value = $value1;
+        $this->private_class_value = $value2;
+        $this->protected_class_value = $value3;
+    }
+}
+// class declaration for string objects
+class for_string_asort
+{
+    public $public_class_value;
+    private $private_class_value;
+    protected $protected_class_value;
+    // initializing object member value
+    function __construct($value1, $value2, $value3)
+    {
+        $this->public_class_value = $value1;
+        $this->private_class_value = $value2;
+        $this->protected_class_value = $value3;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * testing asort() by providing integer/string object arrays with following flag values
+     * 1. Default flag value
+       2. SORT_REGULAR - compare items normally
+    */
+    echo "*** Testing asort() : object functionality ***\n";
+    // array of integer objects
+    $unsorted_int_obj = array(1 => new for_integer_asort(11, 33, 2), 2 => new for_integer_asort(44, 66, 3), 3 => new for_integer_asort(23, 32, 6), 4 => new for_integer_asort(-88, -5, -4));
+    // array of string objects
+    $unsorted_str_obj = array("a" => new for_string_asort("axx", "AXX", "d"), "b" => new for_string_asort("T", "t", "q"), "c" => new for_string_asort("w", "W", "c"), "d" => new for_string_asort("PY", "py", "s"));
+    echo "\n-- Testing asort() by supplying various object arrays, 'flag' value is default --\n";
+    // testing asort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(asort($temp_array));
+    var_dump($temp_array);
+    // testing asort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(asort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Testing asort() by supplying various object arrays, 'flag' value is SORT_REGULAR --\n";
+    // testing asort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(asort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing asort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(asort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+*** Testing asort() : object functionality ***
+
+-- Testing asort() by supplying various object arrays, 'flag' value is default --
+bool(true)
+array(4) {
+  [4]=>
+  object(for_integer_asort)#%d (3) {
+    ["public_class_value"]=>
+    int(-88)
+    ["private_class_value":"for_integer_asort":private]=>
+    int(-5)
+    ["protected_class_value":protected]=>
+    int(-4)
+  }
+  [1]=>
+  object(for_integer_asort)#%d (3) {
+    ["public_class_value"]=>
+    int(11)
+    ["private_class_value":"for_integer_asort":private]=>
+    int(33)
+    ["protected_class_value":protected]=>
+    int(2)
+  }
+  [3]=>
+  object(for_integer_asort)#%d (3) {
+    ["public_class_value"]=>
+    int(23)
+    ["private_class_value":"for_integer_asort":private]=>
+    int(32)
+    ["protected_class_value":protected]=>
+    int(6)
+  }
+  [2]=>
+  object(for_integer_asort)#%d (3) {
+    ["public_class_value"]=>
+    int(44)
+    ["private_class_value":"for_integer_asort":private]=>
+    int(66)
+    ["protected_class_value":protected]=>
+    int(3)
+  }
+}
+bool(true)
+array(4) {
+  ["d"]=>
+  object(for_string_asort)#%d (3) {
+    ["public_class_value"]=>
+    string(2) "PY"
+    ["private_class_value":"for_string_asort":private]=>
+    string(2) "py"
+    ["protected_class_value":protected]=>
+    string(1) "s"
+  }
+  ["b"]=>
+  object(for_string_asort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "T"
+    ["private_class_value":"for_string_asort":private]=>
+    string(1) "t"
+    ["protected_class_value":protected]=>
+    string(1) "q"
+  }
+  ["a"]=>
+  object(for_string_asort)#%d (3) {
+    ["public_class_value"]=>
+    string(3) "axx"
+    ["private_class_value":"for_string_asort":private]=>
+    string(3) "AXX"
+    ["protected_class_value":protected]=>
+    string(1) "d"
+  }
+  ["c"]=>
+  object(for_string_asort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "w"
+    ["private_class_value":"for_string_asort":private]=>
+    string(1) "W"
+    ["protected_class_value":protected]=>
+    string(1) "c"
+  }
+}
+
+-- Testing asort() by supplying various object arrays, 'flag' value is SORT_REGULAR --
+bool(true)
+array(4) {
+  [4]=>
+  object(for_integer_asort)#%d (3) {
+    ["public_class_value"]=>
+    int(-88)
+    ["private_class_value":"for_integer_asort":private]=>
+    int(-5)
+    ["protected_class_value":protected]=>
+    int(-4)
+  }
+  [1]=>
+  object(for_integer_asort)#%d (3) {
+    ["public_class_value"]=>
+    int(11)
+    ["private_class_value":"for_integer_asort":private]=>
+    int(33)
+    ["protected_class_value":protected]=>
+    int(2)
+  }
+  [3]=>
+  object(for_integer_asort)#%d (3) {
+    ["public_class_value"]=>
+    int(23)
+    ["private_class_value":"for_integer_asort":private]=>
+    int(32)
+    ["protected_class_value":protected]=>
+    int(6)
+  }
+  [2]=>
+  object(for_integer_asort)#%d (3) {
+    ["public_class_value"]=>
+    int(44)
+    ["private_class_value":"for_integer_asort":private]=>
+    int(66)
+    ["protected_class_value":protected]=>
+    int(3)
+  }
+}
+bool(true)
+array(4) {
+  ["d"]=>
+  object(for_string_asort)#%d (3) {
+    ["public_class_value"]=>
+    string(2) "PY"
+    ["private_class_value":"for_string_asort":private]=>
+    string(2) "py"
+    ["protected_class_value":protected]=>
+    string(1) "s"
+  }
+  ["b"]=>
+  object(for_string_asort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "T"
+    ["private_class_value":"for_string_asort":private]=>
+    string(1) "t"
+    ["protected_class_value":protected]=>
+    string(1) "q"
+  }
+  ["a"]=>
+  object(for_string_asort)#%d (3) {
+    ["public_class_value"]=>
+    string(3) "axx"
+    ["private_class_value":"for_string_asort":private]=>
+    string(3) "AXX"
+    ["protected_class_value":protected]=>
+    string(1) "d"
+  }
+  ["c"]=>
+  object(for_string_asort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "w"
+    ["private_class_value":"for_string_asort":private]=>
+    string(1) "W"
+    ["protected_class_value":protected]=>
+    string(1) "c"
+  }
+}
+Done
diff --git a/tests/std/array/asort_stability.phpt b/tests/std/array/asort_stability.phpt
new file mode 100644
index 00000000..aeb3b9c1
--- /dev/null
+++ b/tests/std/array/asort_stability.phpt
@@ -0,0 +1,12 @@
+--TEST--
+asort() is stable
+--FILE--
+<?php
+
+$array = $origArray = array_fill(0, 1000, null);
+asort($array);
+var_dump($array === $origArray);
+
+?>
+--EXPECT--
+bool(true)
diff --git a/tests/std/array/asort_variation10.phpt b/tests/std/array/asort_variation10.phpt
new file mode 100644
index 00000000..5c8d9041
--- /dev/null
+++ b/tests/std/array/asort_variation10.phpt
@@ -0,0 +1,108 @@
+--TEST--
+Test asort() function : usage variations - sort octal values
+--FILE--
+<?php
+/*
+ * testing asort() by providing different octal array for $array argument with following flag values
+ * 1.flag value as default
+ * 2.SORT_REGULAR - compare items normally
+ * 3.SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing asort() : usage variations ***\n";
+
+// an array contains unsorted octal values
+$unsorted_oct_array = array (
+   01235 => 01235, 0321 => 0321, 0345 => 0345, 066 => 066, 0772 => 0772,
+   077 => 077, -066 => -066, -0345 => -0345, 0 => 0
+);
+
+echo "\n-- Testing asort() by supplying octal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( asort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing asort() by supplying octal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( asort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing asort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( asort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing asort() : usage variations ***
+
+-- Testing asort() by supplying octal value array, 'flag' value is default  --
+bool(true)
+array(9) {
+  [-229]=>
+  int(-229)
+  [-54]=>
+  int(-54)
+  [0]=>
+  int(0)
+  [54]=>
+  int(54)
+  [63]=>
+  int(63)
+  [209]=>
+  int(209)
+  [229]=>
+  int(229)
+  [506]=>
+  int(506)
+  [669]=>
+  int(669)
+}
+
+-- Testing asort() by supplying octal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(9) {
+  [-229]=>
+  int(-229)
+  [-54]=>
+  int(-54)
+  [0]=>
+  int(0)
+  [54]=>
+  int(54)
+  [63]=>
+  int(63)
+  [209]=>
+  int(209)
+  [229]=>
+  int(229)
+  [506]=>
+  int(506)
+  [669]=>
+  int(669)
+}
+
+-- Testing asort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [-229]=>
+  int(-229)
+  [-54]=>
+  int(-54)
+  [0]=>
+  int(0)
+  [54]=>
+  int(54)
+  [63]=>
+  int(63)
+  [209]=>
+  int(209)
+  [229]=>
+  int(229)
+  [506]=>
+  int(506)
+  [669]=>
+  int(669)
+}
+Done
diff --git a/tests/std/array/asort_variation11.phpt b/tests/std/array/asort_variation11.phpt
new file mode 100644
index 00000000..ef1938b6
--- /dev/null
+++ b/tests/std/array/asort_variation11.phpt
@@ -0,0 +1,155 @@
+--TEST--
+Test asort() function : usage variations - sort mixed values, 'sort_flags' as default/SORT_REGULAR (OK to fail as result is unpredectable)
+--SKIPIF--
+<?php die("skip AOT sort order may differ from PHP (SORT_REGULAR on mixed types)"); ?>
+--FILE--
+<?php
+/*
+ * testing asort() by providing mixed value array for $array argument with following flag values.
+ * 1.flag value as default
+ * 2.SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing asort() : usage variations ***\n";
+
+// mixed value array with different key values
+$mixed_values = array (
+  "array1" => array(),
+  "array2" => array ( "sub_array[2,1]" => array(33,-5,6), "sub_array[2,2]" => array(11),
+                      "sub_array[2,3]" => array(22,-55), "sub_array[2,4]" => array()
+                    ),
+  4 => 4, "4" => "4", 4 => 4.01, "b" => "b", "5" => "5", -2 => -2, -2 => -2.01,
+  -2 => -2.98989, "-.9" => "-.9", "True" => "True", "" =>  "", NULL => NULL,
+  "ab" => "ab", "abcd" => "abcd", 0 => 0.01, -0 => -0, '' => '' ,
+  "abcd\x00abcd\x00abcd" => "abcd\x00abcd\x00abcd", 0 => 0.001
+);
+
+echo "\n-- Testing asort() by supplying mixed value array, 'flag' value is default --\n";
+$temp_array = $mixed_values;
+var_dump( asort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing asort() by supplying mixed value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $mixed_values;
+var_dump( asort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing asort() : usage variations ***
+
+-- Testing asort() by supplying mixed value array, 'flag' value is default --
+bool(true)
+array(13) {
+  [""]=>
+  string(0) ""
+  [-2]=>
+  float(-2.98989)
+  ["-.9"]=>
+  string(3) "-.9"
+  [0]=>
+  float(0.001)
+  [4]=>
+  float(4.01)
+  [5]=>
+  string(1) "5"
+  ["True"]=>
+  string(4) "True"
+  ["ab"]=>
+  string(2) "ab"
+  ["abcd"]=>
+  string(4) "abcd"
+  ["abcd%0abcd%0abcd"]=>
+  string(14) "abcd%0abcd%0abcd"
+  ["b"]=>
+  string(1) "b"
+  ["array1"]=>
+  array(0) {
+  }
+  ["array2"]=>
+  array(4) {
+    ["sub_array[2,1]"]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    ["sub_array[2,2]"]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    ["sub_array[2,3]"]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    ["sub_array[2,4]"]=>
+    array(0) {
+    }
+  }
+}
+
+-- Testing asort() by supplying mixed value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(13) {
+  [""]=>
+  string(0) ""
+  [-2]=>
+  float(-2.98989)
+  ["-.9"]=>
+  string(3) "-.9"
+  [0]=>
+  float(0.001)
+  [4]=>
+  float(4.01)
+  [5]=>
+  string(1) "5"
+  ["True"]=>
+  string(4) "True"
+  ["ab"]=>
+  string(2) "ab"
+  ["abcd"]=>
+  string(4) "abcd"
+  ["abcd%0abcd%0abcd"]=>
+  string(14) "abcd%0abcd%0abcd"
+  ["b"]=>
+  string(1) "b"
+  ["array1"]=>
+  array(0) {
+  }
+  ["array2"]=>
+  array(4) {
+    ["sub_array[2,1]"]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    ["sub_array[2,2]"]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    ["sub_array[2,3]"]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    ["sub_array[2,4]"]=>
+    array(0) {
+    }
+  }
+}
+Done
diff --git a/tests/std/array/asort_variation3.phpt b/tests/std/array/asort_variation3.phpt
new file mode 100644
index 00000000..7736c727
--- /dev/null
+++ b/tests/std/array/asort_variation3.phpt
@@ -0,0 +1,320 @@
+--TEST--
+Test asort() function : usage variations - sort integer/float values
+--FILE--
+<?php
+/*
+ * Testing asort() by providing different integer/float value arrays for $array argument with following values
+ * 1. flag value as default
+ * 2. SORT_REGULAR - compare items normally
+ * 3. SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing asort() : usage variations ***\n";
+
+// group of various arrays with indices
+$various_arrays = array(
+  // negative/posative integer array
+  array(1 => 11, 2 => -11, 3 => 21, 4 => -21, 5 => 31, 6 => -31, 7 => 0, 8 => 41, 10 =>-41),
+
+  // float value array
+  array(1 => 10.5, 2 => -10.5, 3 => 10.5e2, 4 => 10.6E-2, 5 => .5, 6 => .0001, 7 => -.1),
+
+  // mixed value array
+  array(1 => .0001, 2 => .0021, 3 => -.01, 4 => -1, 5 => 0, 6 => .09, 7 => 2, 8 => -.9, 9 => 10.6E-2, 10 => -10.6E-2, 11 => 33),
+
+  // array values contains minimum and maximum ranges
+  array(1 => 2147483647, 2 => 2147483648, 3 => -2147483647, 4 => -2147483648, 5 => -0, 6 => 0, 7 => -2147483649)
+);
+
+// set of possible flag values
+$flag_value = array("SORT_REGULAR" => SORT_REGULAR, "SORT_NUMERIC" => SORT_NUMERIC);
+
+$count = 1;
+echo "\n-- Testing asort() by supplying various integer/float arrays --\n";
+
+// loop through to test asort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort_flag -\n";
+  $temp_array = $array;
+  var_dump(asort($temp_array) );
+  var_dump($temp_array);
+
+  // loop through $flag_value array and setting all possible flag values
+  foreach($flag_value as $key => $flag){
+    echo "- Sort_flag = $key -\n";
+    $temp_array = $array;
+    var_dump(asort($temp_array, $flag) );
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing asort() : usage variations ***
+
+-- Testing asort() by supplying various integer/float arrays --
+
+-- Iteration 1 --
+- With default sort_flag -
+bool(true)
+array(9) {
+  [10]=>
+  int(-41)
+  [6]=>
+  int(-31)
+  [4]=>
+  int(-21)
+  [2]=>
+  int(-11)
+  [7]=>
+  int(0)
+  [1]=>
+  int(11)
+  [3]=>
+  int(21)
+  [5]=>
+  int(31)
+  [8]=>
+  int(41)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(9) {
+  [10]=>
+  int(-41)
+  [6]=>
+  int(-31)
+  [4]=>
+  int(-21)
+  [2]=>
+  int(-11)
+  [7]=>
+  int(0)
+  [1]=>
+  int(11)
+  [3]=>
+  int(21)
+  [5]=>
+  int(31)
+  [8]=>
+  int(41)
+}
+- Sort_flag = SORT_NUMERIC -
+bool(true)
+array(9) {
+  [10]=>
+  int(-41)
+  [6]=>
+  int(-31)
+  [4]=>
+  int(-21)
+  [2]=>
+  int(-11)
+  [7]=>
+  int(0)
+  [1]=>
+  int(11)
+  [3]=>
+  int(21)
+  [5]=>
+  int(31)
+  [8]=>
+  int(41)
+}
+
+-- Iteration 2 --
+- With default sort_flag -
+bool(true)
+array(7) {
+  [2]=>
+  float(-10.5)
+  [7]=>
+  float(-0.1)
+  [6]=>
+  float(0.0001)
+  [4]=>
+  float(0.106)
+  [5]=>
+  float(0.5)
+  [1]=>
+  float(10.5)
+  [3]=>
+  float(1050)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(7) {
+  [2]=>
+  float(-10.5)
+  [7]=>
+  float(-0.1)
+  [6]=>
+  float(0.0001)
+  [4]=>
+  float(0.106)
+  [5]=>
+  float(0.5)
+  [1]=>
+  float(10.5)
+  [3]=>
+  float(1050)
+}
+- Sort_flag = SORT_NUMERIC -
+bool(true)
+array(7) {
+  [2]=>
+  float(-10.5)
+  [7]=>
+  float(-0.1)
+  [6]=>
+  float(0.0001)
+  [4]=>
+  float(0.106)
+  [5]=>
+  float(0.5)
+  [1]=>
+  float(10.5)
+  [3]=>
+  float(1050)
+}
+
+-- Iteration 3 --
+- With default sort_flag -
+bool(true)
+array(11) {
+  [4]=>
+  int(-1)
+  [8]=>
+  float(-0.9)
+  [10]=>
+  float(-0.106)
+  [3]=>
+  float(-0.01)
+  [5]=>
+  int(0)
+  [1]=>
+  float(0.0001)
+  [2]=>
+  float(0.0021)
+  [6]=>
+  float(0.09)
+  [9]=>
+  float(0.106)
+  [7]=>
+  int(2)
+  [11]=>
+  int(33)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  [4]=>
+  int(-1)
+  [8]=>
+  float(-0.9)
+  [10]=>
+  float(-0.106)
+  [3]=>
+  float(-0.01)
+  [5]=>
+  int(0)
+  [1]=>
+  float(0.0001)
+  [2]=>
+  float(0.0021)
+  [6]=>
+  float(0.09)
+  [9]=>
+  float(0.106)
+  [7]=>
+  int(2)
+  [11]=>
+  int(33)
+}
+- Sort_flag = SORT_NUMERIC -
+bool(true)
+array(11) {
+  [4]=>
+  int(-1)
+  [8]=>
+  float(-0.9)
+  [10]=>
+  float(-0.106)
+  [3]=>
+  float(-0.01)
+  [5]=>
+  int(0)
+  [1]=>
+  float(0.0001)
+  [2]=>
+  float(0.0021)
+  [6]=>
+  float(0.09)
+  [9]=>
+  float(0.106)
+  [7]=>
+  int(2)
+  [11]=>
+  int(33)
+}
+
+-- Iteration 4 --
+- With default sort_flag -
+bool(true)
+array(7) {
+  [7]=>
+  %s(-2147483649)
+  [4]=>
+  %s(-2147483648)
+  [3]=>
+  int(-2147483647)
+  [5]=>
+  int(0)
+  [6]=>
+  int(0)
+  [1]=>
+  int(2147483647)
+  [2]=>
+  %s(2147483648)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(7) {
+  [7]=>
+  %s(-2147483649)
+  [4]=>
+  %s(-2147483648)
+  [3]=>
+  int(-2147483647)
+  [5]=>
+  int(0)
+  [6]=>
+  int(0)
+  [1]=>
+  int(2147483647)
+  [2]=>
+  %s(2147483648)
+}
+- Sort_flag = SORT_NUMERIC -
+bool(true)
+array(7) {
+  [7]=>
+  %s(-2147483649)
+  [4]=>
+  %s(-2147483648)
+  [3]=>
+  int(-2147483647)
+  [5]=>
+  int(0)
+  [6]=>
+  int(0)
+  [1]=>
+  int(2147483647)
+  [2]=>
+  %s(2147483648)
+}
+Done
diff --git a/tests/std/array/asort_variation4.phpt b/tests/std/array/asort_variation4.phpt
new file mode 100644
index 00000000..3621e0cc
--- /dev/null
+++ b/tests/std/array/asort_variation4.phpt
@@ -0,0 +1,78 @@
+--TEST--
+Test asort() function : usage variations - sort reference variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference assignment in this context");
+?>
+
+--FILE--
+<?php
+/*
+ * Testing asort() by providing reference variable array with following flag values
+ *  flag value as default
+ *  SORT_REGULAR - compare items normally
+ *  SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing asort() :usage variations  ***\n";
+
+$value1 = 100;
+$value2 = 33;
+$value3 = 555;
+
+// an array containing integer references
+$unsorted_numerics =  array( 1 => &$value1 , 2 => &$value2, 3 => &$value3);
+
+echo "\n-- Testing asort() by supplying reference variable array, 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( asort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying reference variable array, 'flag' = SORT_REGULAR --\n";
+$temp_array = &$unsorted_numerics;
+var_dump( asort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing asort() by supplying reference variable array, 'flag' = SORT_NUMERIC --\n";
+$temp_array = &$unsorted_numerics;
+var_dump( asort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing asort() :usage variations  ***
+
+-- Testing asort() by supplying reference variable array, 'flag' value is default --
+bool(true)
+array(3) {
+  [2]=>
+  &int(33)
+  [1]=>
+  &int(100)
+  [3]=>
+  &int(555)
+}
+
+-- Testing asort() by supplying reference variable array, 'flag' = SORT_REGULAR --
+bool(true)
+array(3) {
+  [2]=>
+  &int(33)
+  [1]=>
+  &int(100)
+  [3]=>
+  &int(555)
+}
+
+-- Testing asort() by supplying reference variable array, 'flag' = SORT_NUMERIC --
+bool(true)
+array(3) {
+  [2]=>
+  &int(33)
+  [1]=>
+  &int(100)
+  [3]=>
+  &int(555)
+}
+Done
diff --git a/tests/std/array/asort_variation5.phpt b/tests/std/array/asort_variation5.phpt
new file mode 100644
index 00000000..f39c4829
--- /dev/null
+++ b/tests/std/array/asort_variation5.phpt
@@ -0,0 +1,236 @@
+--TEST--
+Test asort() function : usage variations - sort strings
+--FILE--
+<?php
+/*
+ * testing asort() by providing different string arrays for $array argument with following flag values
+ *  flag value as default
+ *  SORT_REGULAR - compare items normally
+ *  SORT_STRING  - compare items as strings
+*/
+
+echo "*** Testing asort() : usage variations ***\n";
+
+$various_arrays = array (
+  // group of escape sequences
+  array ("null"=>  null, "NULL" => NULL, "\a" => "\a", "\cx" => "\cx", "\e" => "\e",
+        "\f" => "\f", "\n" =>"\n", "\r" => "\r", "\t" => "\t", "\xhh" => "\xhh",
+        "\ddd" => "\ddd", "\v" => "\v"
+        ),
+
+  // array contains combination of capital/small letters
+  array ('l' => "lemoN", 'O' => "Orange", 'b' => "banana", 'a' => "apple", 'Te' => "Test",
+        'T' => "TTTT", 't' => "ttt", 'w' => "ww", 'x' => "x", 'X' => "X", 'o' => "oraNGe",
+        'B' => "BANANA"
+        )
+);
+
+$flags = array("SORT_REGULAR" => SORT_REGULAR, "SORT_STRING" => SORT_STRING);
+
+$count = 1;
+echo "\n-- Testing asort() by supplying various string arrays --\n";
+
+// loop through to test asort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort_flag -\n";
+  $temp_array = $array;
+  var_dump(asort($temp_array) ); // expecting : bool(true)
+  var_dump($temp_array);
+
+  // loop through $flags array and setting all possible flag values
+  foreach($flags as $key => $flag){
+    echo "- Sort_flag = $key -\n";
+    $temp_array = $array;
+    var_dump(asort($temp_array, $flag) ); // expecting : bool(true)
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing asort() : usage variations ***
+
+-- Testing asort() by supplying various string arrays --
+
+-- Iteration 1 --
+- With default sort_flag -
+bool(true)
+array(12) {
+  ["null"]=>
+  NULL
+  ["NULL"]=>
+  NULL
+  ["	"]=>
+  string(1) "	"
+  ["
+"]=>
+  string(1) "
+"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  ["\a"]=>
+  string(2) "\a"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\xhh"]=>
+  string(4) "\xhh"
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(12) {
+  ["null"]=>
+  NULL
+  ["NULL"]=>
+  NULL
+  ["	"]=>
+  string(1) "	"
+  ["
+"]=>
+  string(1) "
+"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  ["\a"]=>
+  string(2) "\a"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\xhh"]=>
+  string(4) "\xhh"
+}
+- Sort_flag = SORT_STRING -
+bool(true)
+array(12) {
+  ["null"]=>
+  NULL
+  ["NULL"]=>
+  NULL
+  ["	"]=>
+  string(1) "	"
+  ["
+"]=>
+  string(1) "
+"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  ["\a"]=>
+  string(2) "\a"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\xhh"]=>
+  string(4) "\xhh"
+}
+
+-- Iteration 2 --
+- With default sort_flag -
+bool(true)
+array(12) {
+  ["B"]=>
+  string(6) "BANANA"
+  ["O"]=>
+  string(6) "Orange"
+  ["T"]=>
+  string(4) "TTTT"
+  ["Te"]=>
+  string(4) "Test"
+  ["X"]=>
+  string(1) "X"
+  ["a"]=>
+  string(5) "apple"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemoN"
+  ["o"]=>
+  string(6) "oraNGe"
+  ["t"]=>
+  string(3) "ttt"
+  ["w"]=>
+  string(2) "ww"
+  ["x"]=>
+  string(1) "x"
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(12) {
+  ["B"]=>
+  string(6) "BANANA"
+  ["O"]=>
+  string(6) "Orange"
+  ["T"]=>
+  string(4) "TTTT"
+  ["Te"]=>
+  string(4) "Test"
+  ["X"]=>
+  string(1) "X"
+  ["a"]=>
+  string(5) "apple"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemoN"
+  ["o"]=>
+  string(6) "oraNGe"
+  ["t"]=>
+  string(3) "ttt"
+  ["w"]=>
+  string(2) "ww"
+  ["x"]=>
+  string(1) "x"
+}
+- Sort_flag = SORT_STRING -
+bool(true)
+array(12) {
+  ["B"]=>
+  string(6) "BANANA"
+  ["O"]=>
+  string(6) "Orange"
+  ["T"]=>
+  string(4) "TTTT"
+  ["Te"]=>
+  string(4) "Test"
+  ["X"]=>
+  string(1) "X"
+  ["a"]=>
+  string(5) "apple"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemoN"
+  ["o"]=>
+  string(6) "oraNGe"
+  ["t"]=>
+  string(3) "ttt"
+  ["w"]=>
+  string(2) "ww"
+  ["x"]=>
+  string(1) "x"
+}
+Done
diff --git a/tests/std/array/asort_variation6.phpt b/tests/std/array/asort_variation6.phpt
new file mode 100644
index 00000000..7782f95d
--- /dev/null
+++ b/tests/std/array/asort_variation6.phpt
@@ -0,0 +1,108 @@
+--TEST--
+Test asort() function : usage variations - sort hexadecimal values
+--FILE--
+<?php
+/*
+ * testing asort() by providing different hexa-decimal array for $array argument with following flag values
+ * flag value as default
+ * SORT_REGULAR - compare items normally
+ * SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing asort() : usage variations ***\n";
+
+// an array contains unsorted hexadecimal values
+// There are multiple keys which are duplicate and the later should be picked
+$unsorted_hex_array = array ( 0x1AB => 0x1AB, 0xFFF => 0xFFF, 0xF => 0xF, 0xFF => 0xFF, 0x2AA => 0x2AA, 0xBB => 0xBB,
+                              0x1ab => 0x1ab, 0xff => 0xff, -0xff => -0xFF, 0 => 0, -0x2aa => -0x2aa
+                            );
+
+echo "\n-- Testing asort() by supplying hexadecimal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(asort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing asort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(asort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing asort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(asort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing asort() : usage variations ***
+
+-- Testing asort() by supplying hexadecimal value array, 'flag' value is default  --
+bool(true)
+array(9) {
+  [-682]=>
+  int(-682)
+  [-255]=>
+  int(-255)
+  [0]=>
+  int(0)
+  [15]=>
+  int(15)
+  [187]=>
+  int(187)
+  [255]=>
+  int(255)
+  [427]=>
+  int(427)
+  [682]=>
+  int(682)
+  [4095]=>
+  int(4095)
+}
+
+-- Testing asort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(9) {
+  [-682]=>
+  int(-682)
+  [-255]=>
+  int(-255)
+  [0]=>
+  int(0)
+  [15]=>
+  int(15)
+  [187]=>
+  int(187)
+  [255]=>
+  int(255)
+  [427]=>
+  int(427)
+  [682]=>
+  int(682)
+  [4095]=>
+  int(4095)
+}
+
+-- Testing asort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [-682]=>
+  int(-682)
+  [-255]=>
+  int(-255)
+  [0]=>
+  int(0)
+  [15]=>
+  int(15)
+  [187]=>
+  int(187)
+  [255]=>
+  int(255)
+  [427]=>
+  int(427)
+  [682]=>
+  int(682)
+  [4095]=>
+  int(4095)
+}
+Done
diff --git a/tests/std/array/asort_variation7.phpt b/tests/std/array/asort_variation7.phpt
new file mode 100644
index 00000000..64363d25
--- /dev/null
+++ b/tests/std/array/asort_variation7.phpt
@@ -0,0 +1,92 @@
+--TEST--
+Test asort() function : usage variations - sort bool values
+--FILE--
+<?php
+/*
+ * testing asort() by providing bool value array for $array argument with following flag values.
+ * flag value as default
+ * SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing asort() : usage variations ***\n";
+
+// bool value array
+$bool_values = array (1 => true, 2 => false, 3 => TRUE, 4 => FALSE);
+
+echo "\n-- Testing asort() by supplying bool value array, 'flag' value is default --\n";
+$temp_array = $bool_values;
+var_dump(asort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing asort() by supplying bool value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $bool_values;
+var_dump(asort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "\n-- Testing asort() by supplying bool value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $bool_values;
+var_dump(asort($temp_array, SORT_NUMERIC) );
+var_dump($temp_array);
+
+echo "\n-- Testing asort() by supplying bool value array, 'flag' value is SORT_STRING --\n";
+$temp_array = $bool_values;
+var_dump(asort($temp_array, SORT_STRING) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing asort() : usage variations ***
+
+-- Testing asort() by supplying bool value array, 'flag' value is default --
+bool(true)
+array(4) {
+  [2]=>
+  bool(false)
+  [4]=>
+  bool(false)
+  [1]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+
+-- Testing asort() by supplying bool value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(4) {
+  [2]=>
+  bool(false)
+  [4]=>
+  bool(false)
+  [1]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+
+-- Testing asort() by supplying bool value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(4) {
+  [2]=>
+  bool(false)
+  [4]=>
+  bool(false)
+  [1]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+
+-- Testing asort() by supplying bool value array, 'flag' value is SORT_STRING --
+bool(true)
+array(4) {
+  [2]=>
+  bool(false)
+  [4]=>
+  bool(false)
+  [1]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+Done
diff --git a/tests/std/array/asort_variation8.phpt b/tests/std/array/asort_variation8.phpt
new file mode 100644
index 00000000..038c92df
--- /dev/null
+++ b/tests/std/array/asort_variation8.phpt
@@ -0,0 +1,174 @@
+--TEST--
+Test asort() function : usage variations - sort array with diff. sub arrays, 'sort_flags' as default/SORT_REGULAR
+--FILE--
+<?php
+/*
+ * testing asort() by providing arrays contains sub arrays for $array argument with flowing flag values
+ * flag value as default
+ * SORT_REGULAR - compare items normally
+ * Note: arrays are sorted based on total count of elements inside it, when all the elements are arrays
+*/
+
+echo "*** Testing asort() : usage variations ***\n";
+
+// array of arrays
+$various_arrays = array (
+  // null array
+  "array[0]" => array(),
+
+  // array contains null sub array
+  "array[1]" => array( "sub_array[1][0]" => array() ),
+
+  // array of arrays along with some values
+  "array[2]" => array("data[2,0]" => 44, "data[2,1]" => 11, "sub_array[2][0] " => array(64,61) ),
+
+  // array contains sub arrays
+  "array[3]" => array ( "sub_array[3][0]" => array(33,-5,6), "sub_array[3][1]" => array(11),
+                        "sub_array[3][2]" => array(22,-55), "sub_array[3][3]" => array() )
+);
+
+
+$count = 1;
+echo "\n-- Testing asort() by supplying various arrays containing sub arrays --\n";
+
+// loop through to test asort() with different arrays
+foreach ($various_arrays as $array) {
+
+  echo "\n-- Iteration $count --\n";
+  // testing asort() function by supplying different arrays, flag value is default
+  echo "- With default sort_flag -\n";
+  $temp_array = $array;
+  var_dump(asort($temp_array) );
+  var_dump($temp_array);
+
+  // testing asort() function by supplying different arrays, flag value = SORT_REGULAR
+  echo "- Sort_flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump(asort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing asort() : usage variations ***
+
+-- Testing asort() by supplying various arrays containing sub arrays --
+
+-- Iteration 1 --
+- With default sort_flag -
+bool(true)
+array(0) {
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(0) {
+}
+
+-- Iteration 2 --
+- With default sort_flag -
+bool(true)
+array(1) {
+  ["sub_array[1][0]"]=>
+  array(0) {
+  }
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(1) {
+  ["sub_array[1][0]"]=>
+  array(0) {
+  }
+}
+
+-- Iteration 3 --
+- With default sort_flag -
+bool(true)
+array(3) {
+  ["data[2,1]"]=>
+  int(11)
+  ["data[2,0]"]=>
+  int(44)
+  ["sub_array[2][0] "]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  ["data[2,1]"]=>
+  int(11)
+  ["data[2,0]"]=>
+  int(44)
+  ["sub_array[2][0] "]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+}
+
+-- Iteration 4 --
+- With default sort_flag -
+bool(true)
+array(4) {
+  ["sub_array[3][3]"]=>
+  array(0) {
+  }
+  ["sub_array[3][1]"]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  ["sub_array[3][2]"]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  ["sub_array[3][0]"]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  ["sub_array[3][3]"]=>
+  array(0) {
+  }
+  ["sub_array[3][1]"]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  ["sub_array[3][2]"]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  ["sub_array[3][0]"]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+}
+Done
diff --git a/tests/std/array/asort_variation9.phpt b/tests/std/array/asort_variation9.phpt
new file mode 100644
index 00000000..ff2d9077
--- /dev/null
+++ b/tests/std/array/asort_variation9.phpt
@@ -0,0 +1,252 @@
+--TEST--
+Test asort() function : usage variations - sorting arrays with/without keys, 'sort_flags' as default/SORT_REGULAR
+--FILE--
+<?php
+/*
+ * Testing asort() by providing arrays  with key values for $array argument with following flag values.
+ * 1.flag value as default
+ * 2.SORT_REGULAR - compare items normally
+ */
+
+echo "*** Testing asort() : usage variations ***\n";
+
+// list of arrays with/without key values
+$various_arrays = array (
+  array(5 => 55,  66, 22, 33, 11),
+  array ("a" => "orange",  "banana", "c" => "apple"),
+  array(1, 2, 3, 4, 5, 6),
+  array("first", 5 => "second", "third"),
+  array(1, 1, 8 => 1,  4 => 1, 19, 3 => 13),
+  array('bar' => 'baz', "foo" => 1),
+  array('a'=>1,'b'=>array('e'=>2,'f'=>3),'c'=>array('g'=>4),'d'=>5),
+);
+
+$count = 1;
+echo "\n-- Testing asort() by supplying various arrays with key values --\n";
+
+// loop through to test asort() with different arrays,
+// to test the new keys for the elements in the sorted array
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort_flag -\n";
+  $temp_array = $array;
+  var_dump(asort($temp_array) );
+  var_dump($temp_array);
+
+  echo "- Sort_flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump(asort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing asort() : usage variations ***
+
+-- Testing asort() by supplying various arrays with key values --
+
+-- Iteration 1 --
+- With default sort_flag -
+bool(true)
+array(5) {
+  [9]=>
+  int(11)
+  [7]=>
+  int(22)
+  [8]=>
+  int(33)
+  [5]=>
+  int(55)
+  [6]=>
+  int(66)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(5) {
+  [9]=>
+  int(11)
+  [7]=>
+  int(22)
+  [8]=>
+  int(33)
+  [5]=>
+  int(55)
+  [6]=>
+  int(66)
+}
+
+-- Iteration 2 --
+- With default sort_flag -
+bool(true)
+array(3) {
+  ["c"]=>
+  string(5) "apple"
+  [0]=>
+  string(6) "banana"
+  ["a"]=>
+  string(6) "orange"
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  ["c"]=>
+  string(5) "apple"
+  [0]=>
+  string(6) "banana"
+  ["a"]=>
+  string(6) "orange"
+}
+
+-- Iteration 3 --
+- With default sort_flag -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+}
+
+-- Iteration 4 --
+- With default sort_flag -
+bool(true)
+array(3) {
+  [0]=>
+  string(5) "first"
+  [5]=>
+  string(6) "second"
+  [6]=>
+  string(5) "third"
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  [0]=>
+  string(5) "first"
+  [5]=>
+  string(6) "second"
+  [6]=>
+  string(5) "third"
+}
+
+-- Iteration 5 --
+- With default sort_flag -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [8]=>
+  int(1)
+  [4]=>
+  int(1)
+  [3]=>
+  int(13)
+  [9]=>
+  int(19)
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [8]=>
+  int(1)
+  [4]=>
+  int(1)
+  [3]=>
+  int(13)
+  [9]=>
+  int(19)
+}
+
+-- Iteration 6 --
+- With default sort_flag -
+bool(true)
+array(2) {
+  ["foo"]=>
+  int(1)
+  ["bar"]=>
+  string(3) "baz"
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(2) {
+  ["foo"]=>
+  int(1)
+  ["bar"]=>
+  string(3) "baz"
+}
+
+-- Iteration 7 --
+- With default sort_flag -
+bool(true)
+array(4) {
+  ["a"]=>
+  int(1)
+  ["d"]=>
+  int(5)
+  ["c"]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  ["b"]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+}
+- Sort_flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  ["a"]=>
+  int(1)
+  ["d"]=>
+  int(5)
+  ["c"]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  ["b"]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+}
+Done
diff --git a/tests/std/array/bug12776.phpt b/tests/std/array/bug12776.phpt
new file mode 100644
index 00000000..89da38b1
--- /dev/null
+++ b/tests/std/array/bug12776.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Bug #12776 (array_walk crash)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+function test($val, $key)
+{
+    global $globalArray;
+    $globalArray[] = $key;
+    // this will end up crashing
+    $globalArray[] = (string) $key;
+    // this will end up OK
+    print "val: {$val}; key: {$key}\n";
+    flush();
+}
+function main()
+{
+    $arr = array('k' => 'v');
+    array_walk($arr, 'test');
+    print "First value: " . $globalArray[0];
+    print "\nDone\n";
+}
+?>
+--EXPECT--
+val: v; key: k
+First value: k
+Done
diff --git a/tests/std/array/bug14580.phpt b/tests/std/array/bug14580.phpt
new file mode 100644
index 00000000..8f4c7d5b
--- /dev/null
+++ b/tests/std/array/bug14580.phpt
@@ -0,0 +1,11 @@
+--TEST--
+Bug #14580 (key() not binary safe)
+--FILE--
+<?php
+    $arr = array ("foo\0bar" => "foo\0bar");
+    $key = key($arr);
+    echo strlen($key), ': ';
+    echo urlencode($key), "\n";
+?>
+--EXPECT--
+7: foo%00bar
diff --git a/tests/std/array/bug20381.phpt b/tests/std/array/bug20381.phpt
new file mode 100644
index 00000000..0da52d9f
--- /dev/null
+++ b/tests/std/array/bug20381.phpt
@@ -0,0 +1,79 @@
+--TEST--
+Bug #20381 (array_merge_recursive mangles input arrays)
+--FILE--
+<?php
+$a = array(
+    'a1' => 1,
+    'a2' => array( 1, 2, 3 ),
+    'a3' => array(
+        'a' => array( 10, 20, 30 ),
+        'b' => 'b'
+        )
+    );
+$b = array( 'a1' => 2,
+    'a2' => array( 3, 4, 5 ),
+    'a3' => array(
+        'c' => 'cc',
+        'a' => array( 10, 40 )
+        )
+    );
+
+var_dump($a);
+array_merge_recursive( $a, $b );
+var_dump($a);
+?>
+--EXPECT--
+array(3) {
+  ["a1"]=>
+  int(1)
+  ["a2"]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  ["a3"]=>
+  array(2) {
+    ["a"]=>
+    array(3) {
+      [0]=>
+      int(10)
+      [1]=>
+      int(20)
+      [2]=>
+      int(30)
+    }
+    ["b"]=>
+    string(1) "b"
+  }
+}
+array(3) {
+  ["a1"]=>
+  int(1)
+  ["a2"]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+  }
+  ["a3"]=>
+  array(2) {
+    ["a"]=>
+    array(3) {
+      [0]=>
+      int(10)
+      [1]=>
+      int(20)
+      [2]=>
+      int(30)
+    }
+    ["b"]=>
+    string(1) "b"
+  }
+}
diff --git a/tests/std/array/bug20865.phpt b/tests/std/array/bug20865.phpt
new file mode 100644
index 00000000..6fa79f6a
--- /dev/null
+++ b/tests/std/array/bug20865.phpt
@@ -0,0 +1,13 @@
+--TEST--
+Bug #20865 (array_key_exists and NULL key)
+--SKIPIF--
+<?php die("skip AOT array_key_exists with NULL key differs from PHP"); ?>
+--FILE--
+<?php
+    $ta = array(1, 2, 3);
+    $ta[NULL] = "Null Value";
+
+    var_dump(array_key_exists(NULL, $ta));
+?>
+--EXPECT--
+bool(true)
diff --git a/tests/std/array/bug21918.phpt b/tests/std/array/bug21918.phpt
new file mode 100644
index 00000000..e855aacd
--- /dev/null
+++ b/tests/std/array/bug21918.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Bug #21918 (different handling of positive vs. negative array indexes)
+--FILE--
+<?php
+
+echo "==Mixed==\n";
+$a = array(-1=>'a', '-2'=>'b', 3=>'c', '4'=>'d', 5=>'e', '6001'=>'f', '07'=>'g');
+
+foreach($a as $k => $v) {
+    var_dump($k);
+    var_dump($v);
+}
+
+echo "==Normal==\n";
+$b = array();
+$b[] = 'a';
+
+foreach($b as $k => $v) {
+    var_dump($k);
+    var_dump($v);
+}
+
+echo "==Negative==\n";
+$c = array('-2' => 'a');
+
+foreach($c as $k => $v) {
+    var_dump($k);
+    var_dump($v);
+}
+
+?>
+--EXPECT--
+==Mixed==
+int(-1)
+string(1) "a"
+int(-2)
+string(1) "b"
+int(3)
+string(1) "c"
+int(4)
+string(1) "d"
+int(5)
+string(1) "e"
+int(6001)
+string(1) "f"
+string(2) "07"
+string(1) "g"
+==Normal==
+int(0)
+string(1) "a"
+==Negative==
+int(-2)
+string(1) "a"
diff --git a/tests/std/array/bug21998.phpt b/tests/std/array/bug21998.phpt
new file mode 100644
index 00000000..e1bb0033
--- /dev/null
+++ b/tests/std/array/bug21998.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Bug #21998 (array_pop() does not reset the current array position)
+--FILE--
+<?php
+
+$a = array("a", "b", "c");
+
+var_dump(key($a));
+var_dump(array_pop($a));
+var_dump(key($a));
+var_dump(array_pop($a));
+var_dump(key($a));
+var_dump(array_pop($a));
+var_dump(key($a));
+
+?>
+--EXPECT--
+int(0)
+string(1) "c"
+int(0)
+string(1) "b"
+int(0)
+string(1) "a"
+NULL
diff --git a/tests/std/array/bug22088.phpt b/tests/std/array/bug22088.phpt
new file mode 100644
index 00000000..4352cff9
--- /dev/null
+++ b/tests/std/array/bug22088.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Bug #22088 (array_shift() leaves next index to be +1 too much)
+--FILE--
+<?php
+
+$a = array('a', 'b', 'c');
+$last = array_shift ($a);
+$a[] = 'a';
+var_dump($a);
+
+$a = array('a' => 1, 'b' => 2, 'c' => 3);
+$last = array_shift ($a);
+$a[] = 'a';
+var_dump($a);
+
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  string(1) "b"
+  [1]=>
+  string(1) "c"
+  [2]=>
+  string(1) "a"
+}
+array(3) {
+  ["b"]=>
+  int(2)
+  ["c"]=>
+  int(3)
+  [0]=>
+  string(1) "a"
+}
diff --git a/tests/std/array/bug22463.phpt b/tests/std/array/bug22463.phpt
new file mode 100644
index 00000000..973b3863
--- /dev/null
+++ b/tests/std/array/bug22463.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Bug #22463 (array_reduce() segfaults)
+--FILE--
+<?php
+function a($ary)
+{
+    return is_array($ary) ? array_reduce($ary, 'cb', 0) : 1;
+}
+function cb($v, $elem)
+{
+    return $v + a($elem);
+}
+function main()
+{
+    $ary = array(array(array(array(array(array(0, 1, 2, 3, 4))))));
+    var_dump(a($ary));
+}
+?>
+--EXPECT--
+int(5)
diff --git a/tests/std/array/bug23581.phpt b/tests/std/array/bug23581.phpt
new file mode 100644
index 00000000..5cede9a3
--- /dev/null
+++ b/tests/std/array/bug23581.phpt
@@ -0,0 +1,43 @@
+--TEST--
+Bug #23581 (array_map(NULL, array, array, ...) yields an undefined result)
+--FILE--
+<?php
+var_dump(
+  array_map(
+    NULL,
+    array(1,2,3),
+    array(4,5,6),
+    array(7,8,9)
+  )
+);
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(4)
+    [2]=>
+    int(7)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(5)
+    [2]=>
+    int(8)
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    int(3)
+    [1]=>
+    int(6)
+    [2]=>
+    int(9)
+  }
+}
diff --git a/tests/std/array/bug23788.phpt b/tests/std/array/bug23788.phpt
new file mode 100644
index 00000000..014773be
--- /dev/null
+++ b/tests/std/array/bug23788.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Bug #23788 (*_replace() clobbers referenced array elements)
+--SKIPIF--
+<?php die("skip AOT array_replace reference handling differs from PHP"); ?>
+--FILE--
+<?php
+$numeric = 123;
+$bool = true;
+$foo = array(&$numeric, &$bool);
+var_dump($foo);
+str_replace("abc", "def", $foo);
+var_dump($foo);
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  &int(123)
+  [1]=>
+  &bool(true)
+}
+array(2) {
+  [0]=>
+  &int(123)
+  [1]=>
+  &bool(true)
+}
diff --git a/tests/std/array/bug24198.phpt b/tests/std/array/bug24198.phpt
new file mode 100644
index 00000000..a1a30afb
--- /dev/null
+++ b/tests/std/array/bug24198.phpt
@@ -0,0 +1,25 @@
+--TEST--n
+Bug #24198 (array_merge_recursive() invalid recursion detection)
+--FILE--
+<?php
+$c = array('a' => 'aa','b' => 'bb');
+
+var_dump(array_merge_recursive($c, $c));
+?>
+--EXPECT--
+array(2) {
+  ["a"]=>
+  array(2) {
+    [0]=>
+    string(2) "aa"
+    [1]=>
+    string(2) "aa"
+  }
+  ["b"]=>
+  array(2) {
+    [0]=>
+    string(2) "bb"
+    [1]=>
+    string(2) "bb"
+  }
+}
diff --git a/tests/std/array/bug24766.phpt b/tests/std/array/bug24766.phpt
new file mode 100644
index 00000000..ebe2f392
--- /dev/null
+++ b/tests/std/array/bug24766.phpt
@@ -0,0 +1,45 @@
+--TEST--
+Bug #24766 (strange result array from unpack)
+--FILE--
+<?php
+
+error_reporting(E_ALL);
+
+$a = unpack('C2', "\0224V");
+$b = array(1 => 18, 2 => 52);
+var_dump($a, $b);
+$k = array_keys($a);
+$l = array_keys($b);
+var_dump($k, $l);
+$i=$k[0];
+var_dump($a[$i]);
+$i=$l[0];
+var_dump($b[$i]);
+?>
+--EXPECT--
+array(2) {
+  [1]=>
+  int(18)
+  [2]=>
+  int(52)
+}
+array(2) {
+  [1]=>
+  int(18)
+  [2]=>
+  int(52)
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+int(18)
+int(18)
diff --git a/tests/std/array/bug24897.phpt b/tests/std/array/bug24897.phpt
new file mode 100644
index 00000000..45bcde34
--- /dev/null
+++ b/tests/std/array/bug24897.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Bug #24897 (inconsistent behaviour or shuffle() & array_multisort())
+--FILE--
+<?php
+$a = array(1 => 2);
+shuffle($a);
+var_dump($a);
+
+$a = array(1 => 2);
+array_multisort($a);
+var_dump($a);
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  int(2)
+}
+array(1) {
+  [0]=>
+  int(2)
+}
diff --git a/tests/std/array/bug24980.phpt b/tests/std/array/bug24980.phpt
new file mode 100644
index 00000000..da98e10e
--- /dev/null
+++ b/tests/std/array/bug24980.phpt
@@ -0,0 +1,52 @@
+--TEST--
+Bug #24980 (array_reduce() uses first element as default running total)
+--FILE--
+<?php
+/* test #1: numeric data */
+function add_up($running_total, $current_value)
+{
+    echo "running_total is " . (int) $running_total . ", current_value is {$current_value}\n";
+    $running_total += $current_value * $current_value;
+    return $running_total;
+}
+function foo($a, $b)
+{
+    return $a . $b;
+}
+/* test #3: basic test (used to leak memory) */
+function rsum($v, $w)
+{
+    $v += $w;
+    return $v;
+}
+function rmul($v, $w)
+{
+    $v *= $w;
+    return $v;
+}
+function main()
+{
+    $numbers = array(2, 3, 5, 7);
+    $total = array_reduce($numbers, 'add_up');
+    print "Total is {$total}\n";
+    /* test #2: string data */
+    $a = array("a", "b", "c");
+    var_dump(array_reduce($a, "foo"));
+    $a = array(1, 2, 3, 4, 5);
+    $x = array();
+    $b = array_reduce($a, "rsum");
+    $c = array_reduce($a, "rmul", 10);
+    $d = array_reduce($x, "rsum", 1);
+    var_dump($b, $c, $d);
+}
+?>
+--EXPECT--
+running_total is 0, current_value is 2
+running_total is 4, current_value is 3
+running_total is 13, current_value is 5
+running_total is 38, current_value is 7
+Total is 87
+string(3) "abc"
+int(15)
+int(1200)
+int(1)
diff --git a/tests/std/array/bug25359.phpt b/tests/std/array/bug25359.phpt
new file mode 100644
index 00000000..a718fb9e
--- /dev/null
+++ b/tests/std/array/bug25359.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Bug #25359 (array_multisort() does not work in a function if array is global or reference)
+--FILE--
+<?php
+function does_not_work()
+{
+    global $data;
+    // Remove this line to make array_multisort() work
+    $data = array('first', 'fifth', 'second', 'forth', 'third');
+    $sort = array(1, 5, 2, 4, 3);
+    array_multisort($sort, $data);
+    var_dump($data);
+}
+function main()
+{
+    does_not_work();
+}
+?>
+--EXPECT--
+array(5) {
+  [0]=>
+  string(5) "first"
+  [1]=>
+  string(6) "second"
+  [2]=>
+  string(5) "third"
+  [3]=>
+  string(5) "forth"
+  [4]=>
+  string(5) "fifth"
+}
diff --git a/tests/std/array/bug25708.phpt b/tests/std/array/bug25708.phpt
new file mode 100644
index 00000000..f5e49c0e
--- /dev/null
+++ b/tests/std/array/bug25708.phpt
@@ -0,0 +1,230 @@
+--TEST--
+Bug #25708 (extract($GLOBALS, EXTR_REFS) mangles $GLOBALS)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference assignment in this context");
+?>
+
+--FILE--
+<?php
+function foo($ref, $alt)
+{
+    unset($GLOBALS['a']);
+    unset($GLOBALS['b']);
+    $GLOBALS['a'] = 1;
+    $GLOBALS['b'] = 2;
+    $org_a = $GLOBALS['a'];
+    $org_b = $GLOBALS['b'];
+    if ($ref) {
+        global $a, $b;
+    } else {
+        /* zval temp_var(NULL); // refcount = 1
+         * a = temp_var[x] // refcount = 2
+         */
+        $a = NULL;
+        $b = NULL;
+    }
+    var_dump($a, $b, $GLOBALS['a'], $GLOBALS['b']);
+    echo "--\n";
+    if ($alt) {
+        $a =& $GLOBALS['a'];
+        $b =& $GLOBALS['b'];
+    } else {
+        extract($GLOBALS, EXTR_REFS);
+    }
+    var_dump($a, $b, $GLOBALS['a'], $GLOBALS['b']);
+    echo "--\n";
+    $a =& $GLOBALS['a'];
+    $b =& $GLOBALS['b'];
+    var_dump($a, $b, $GLOBALS['a'], $GLOBALS['b']);
+    echo "--\n";
+    $GLOBALS['b'] = 3;
+    var_dump($a, $b, $GLOBALS['a'], $GLOBALS['b']);
+    echo "--\n";
+    $a = 4;
+    var_dump($a, $b, $GLOBALS['a'], $GLOBALS['b']);
+    echo "--\n";
+    $c = $b;
+    var_dump($b, $GLOBALS['b'], $c);
+    echo "--\n";
+    $b = 'x';
+    var_dump($a, $b, $GLOBALS['a'], $GLOBALS['b'], $c);
+    echo "--\n";
+    var_dump($org_a, $org_b);
+    echo "----";
+    if ($ref) {
+        echo 'r';
+    }
+    if ($alt) {
+        echo 'a';
+    }
+    echo "\n";
+}
+function main()
+{
+    $a = 'ok';
+    $b = 'ok';
+    $_a = $a;
+    $_b = $b;
+    foo(false, true);
+    foo(true, true);
+    foo(false, false);
+    foo(true, false);
+    var_dump($_a, $_b);
+}
+?>
+--EXPECT--
+NULL
+NULL
+int(1)
+int(2)
+--
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(3)
+int(1)
+int(3)
+--
+int(4)
+int(3)
+int(4)
+int(3)
+--
+int(3)
+int(3)
+int(3)
+--
+int(4)
+string(1) "x"
+int(4)
+string(1) "x"
+int(3)
+--
+int(1)
+int(2)
+----a
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(3)
+int(1)
+int(3)
+--
+int(4)
+int(3)
+int(4)
+int(3)
+--
+int(3)
+int(3)
+int(3)
+--
+int(4)
+string(1) "x"
+int(4)
+string(1) "x"
+int(3)
+--
+int(1)
+int(2)
+----ra
+NULL
+NULL
+int(1)
+int(2)
+--
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(3)
+int(1)
+int(3)
+--
+int(4)
+int(3)
+int(4)
+int(3)
+--
+int(3)
+int(3)
+int(3)
+--
+int(4)
+string(1) "x"
+int(4)
+string(1) "x"
+int(3)
+--
+int(1)
+int(2)
+----
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(2)
+int(1)
+int(2)
+--
+int(1)
+int(3)
+int(1)
+int(3)
+--
+int(4)
+int(3)
+int(4)
+int(3)
+--
+int(3)
+int(3)
+int(3)
+--
+int(4)
+string(1) "x"
+int(4)
+string(1) "x"
+int(3)
+--
+int(1)
+int(2)
+----r
+string(2) "ok"
+string(2) "ok"
diff --git a/tests/std/array/bug25758.phpt b/tests/std/array/bug25758.phpt
new file mode 100644
index 00000000..a2d2952d
--- /dev/null
+++ b/tests/std/array/bug25758.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Bug #25758 (var_export does not escape ' & \ inside array keys)
+--FILE--
+<?php
+    $a = array ("quote'" => array("quote'"));
+    echo var_export($a, true);
+?>
+--EXPECT--
+array (
+  'quote\'' => 
+  array (
+    0 => 'quote\'',
+  ),
+)
diff --git a/tests/std/array/bug26458.phpt b/tests/std/array/bug26458.phpt
new file mode 100644
index 00000000..67c1586d
--- /dev/null
+++ b/tests/std/array/bug26458.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Bug #26458 (var_dump(), var_export() & debug_zval_dump() are not binary safe for array keys)
+--FILE--
+<?php
+$test = array("A\x00B" => "Hello world");
+var_dump($test);
+var_export($test);
+debug_zval_dump($test);
+?>
+--EXPECTF--
+array(1) {
+  ["A%0B"]=>
+  string(11) "Hello world"
+}
+array (
+  'A' . "\0" . 'B' => 'Hello world',
+)array(1) %s{
+  ["A%0B"]=>
+  string(11) "Hello world" %s
+}
diff --git a/tests/std/array/bug28739.phpt b/tests/std/array/bug28739.phpt
new file mode 100644
index 00000000..d861e209
--- /dev/null
+++ b/tests/std/array/bug28739.phpt
@@ -0,0 +1,71 @@
+--TEST--
+Bug #28739 (*diff() and *intersect() not clearing the fci cache before work)
+--FILE--
+<?php
+class p
+{
+    public $x;
+    function __construct($x)
+    {
+        $this->x = $x;
+    }
+}
+function a($a, $b)
+{
+    var_dump(__FUNCTION__);
+    return $a->x - $b->x;
+}
+function b($a, $b)
+{
+    var_dump(__FUNCTION__);
+    return $a->x - $b->x;
+}
+function main()
+{
+    $p1 = array(new p(2), new p(1), new p(0));
+    $p2 = array(new p(0), new p(2), new p(3));
+    uasort($p1, 'a');
+    print_r($p1);
+    echo "Now diffing:\n";
+    print_r(array_udiff($p1, $p2, 'b'));
+}
+?>
+--EXPECT--
+string(1) "a"
+string(1) "a"
+Array
+(
+    [2] => p Object
+        (
+            [x] => 0
+        )
+
+    [1] => p Object
+        (
+            [x] => 1
+        )
+
+    [0] => p Object
+        (
+            [x] => 2
+        )
+
+)
+Now diffing:
+string(1) "b"
+string(1) "b"
+string(1) "b"
+string(1) "b"
+string(1) "b"
+string(1) "b"
+string(1) "b"
+string(1) "b"
+string(1) "b"
+Array
+(
+    [1] => p Object
+        (
+            [x] => 1
+        )
+
+)
diff --git a/tests/std/array/bug28974.phpt b/tests/std/array/bug28974.phpt
new file mode 100644
index 00000000..a2bd86f6
--- /dev/null
+++ b/tests/std/array/bug28974.phpt
@@ -0,0 +1,89 @@
+--TEST--
+Bug #28974 (array_(p)slice() treats large lengths incorrectly - overflow)
+--FILE--
+<?php
+$a = $b = $c = array(0,1,2,3,4,5);
+print_r($a);
+// this is ok:
+print_r(array_slice($a,2,2147483645));
+
+// this is wrong:
+print_r(array_slice($a,2,2147483646));
+echo 'print_r(array_splice($a,2,1));'."\n";
+print_r(array_splice($a,2,1));
+echo "\$a is :";
+print_r($a);
+echo 'print_r(array_splice($b,2,2147483645));'."\n";
+print_r(array_splice($b,2,2147483645));
+echo "\$b is :";
+print_r($b);
+
+// this is wrong:
+echo 'print_r(array_splice($c,2,2147483646));'."\n";
+print_r(array_splice($c,2,2147483646));
+echo "\$c is :";
+print_r($c);
+?>
+--EXPECT--
+Array
+(
+    [0] => 0
+    [1] => 1
+    [2] => 2
+    [3] => 3
+    [4] => 4
+    [5] => 5
+)
+Array
+(
+    [0] => 2
+    [1] => 3
+    [2] => 4
+    [3] => 5
+)
+Array
+(
+    [0] => 2
+    [1] => 3
+    [2] => 4
+    [3] => 5
+)
+print_r(array_splice($a,2,1));
+Array
+(
+    [0] => 2
+)
+$a is :Array
+(
+    [0] => 0
+    [1] => 1
+    [2] => 3
+    [3] => 4
+    [4] => 5
+)
+print_r(array_splice($b,2,2147483645));
+Array
+(
+    [0] => 2
+    [1] => 3
+    [2] => 4
+    [3] => 5
+)
+$b is :Array
+(
+    [0] => 0
+    [1] => 1
+)
+print_r(array_splice($c,2,2147483646));
+Array
+(
+    [0] => 2
+    [1] => 3
+    [2] => 4
+    [3] => 5
+)
+$c is :Array
+(
+    [0] => 0
+    [1] => 1
+)
diff --git a/tests/std/array/bug29253.phpt b/tests/std/array/bug29253.phpt
new file mode 100644
index 00000000..c690df5d
--- /dev/null
+++ b/tests/std/array/bug29253.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Bug #29253 (array_diff with $GLOBALS argument fails)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+$zz = $GLOBALS;
+$gg = 'afad';
+var_dump(@array_diff_assoc($GLOBALS, $zz));
+var_dump($gg);
+?>
+--EXPECTF--
+array(2) {
+  ["zz"]=>
+  %A
+  ["gg"]=>
+  string(4) "afad"
+}
+string(4) "afad"
diff --git a/tests/std/array/bug29493.phpt b/tests/std/array/bug29493.phpt
new file mode 100644
index 00000000..428028b7
--- /dev/null
+++ b/tests/std/array/bug29493.phpt
@@ -0,0 +1,108 @@
+--TEST--
+Bug #29493 (extract(EXTR_REFS) fails if array has multiple referrals)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+function t1()
+{
+    $a = array('foo' => 'aaa');
+    // refcount($a) = 1
+    // refcount($a['foo']) = 1
+    $b = $a;
+    // refcount($a) = 2
+    // refcount($a['foo']) = 1
+    $b['foo'] = 'bbb';
+    // refcount($a) = 1
+    // refcount($a['foo']) = 1
+    var_dump($a, $b);
+    extract($a, EXTR_REFS);
+    $foo = 'noo';
+    var_dump($a, $b);
+}
+function t2()
+{
+    $a = array('foo' => 'aaa');
+    // refcount($a) = 1
+    // refcount($a['foo']) = 1
+    $b =& $a;
+    // refcount($a) = 2
+    // is_ref($a) = true
+    // refcount($a['foo']) = 1
+    $b['foo'] = 'bbb';
+    // refcount($a) = 2
+    // refcount($a['foo']) = 1
+    var_dump($a, $b);
+    extract($a, EXTR_REFS);
+    $foo = 'noo';
+    var_dump($a, $b);
+}
+function t3()
+{
+    $a = array('foo' => 'aaa');
+    // refcount($a) = 1
+    // refcount($a['foo']) = 1
+    $b =& $a;
+    // refcount($a) = 2
+    // is_ref($a) = true
+    // refcount($a['foo']) = 1
+    unset($b);
+    // refcount($a) = 1
+    // is_ref($a) = true
+    // refcount($a['foo']) = 1
+    var_dump($a);
+    extract($a, EXTR_REFS);
+    $foo = 'noo';
+    var_dump($a);
+}
+function main()
+{
+    t1();
+    t2();
+    t3();
+}
+?>
+--EXPECT--
+array(1) {
+  ["foo"]=>
+  string(3) "aaa"
+}
+array(1) {
+  ["foo"]=>
+  string(3) "bbb"
+}
+array(1) {
+  ["foo"]=>
+  &string(3) "noo"
+}
+array(1) {
+  ["foo"]=>
+  string(3) "bbb"
+}
+array(1) {
+  ["foo"]=>
+  string(3) "bbb"
+}
+array(1) {
+  ["foo"]=>
+  string(3) "bbb"
+}
+array(1) {
+  ["foo"]=>
+  &string(3) "noo"
+}
+array(1) {
+  ["foo"]=>
+  &string(3) "noo"
+}
+array(1) {
+  ["foo"]=>
+  string(3) "aaa"
+}
+array(1) {
+  ["foo"]=>
+  &string(3) "noo"
+}
diff --git a/tests/std/array/bug30074.phpt b/tests/std/array/bug30074.phpt
new file mode 100644
index 00000000..7902e966
--- /dev/null
+++ b/tests/std/array/bug30074.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Bug #30074 (EG(uninitialized_zval_ptr) gets set to reference using EXTR_REFS, affecting later values)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$result = extract(array('a'=>$undefined), EXTR_REFS);
+var_dump(array($a));
+echo "Done\n";
+?>
+--EXPECTF--
+Warning: Undefined variable $undefined in %s on line %d
+array(1) {
+  [0]=>
+  NULL
+}
+Done
diff --git a/tests/std/array/bug30266.phpt b/tests/std/array/bug30266.phpt
new file mode 100644
index 00000000..b31df8ef
--- /dev/null
+++ b/tests/std/array/bug30266.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Bug #30266 (Invalid opcode 137/1/8) and array_walk
+--SKIPIF--
+<?php die("skip AOT array_walk behavior differs from PHP"); ?>
+--FILE--
+<?php
+class testc
+{
+    public $b = "c";
+    function crash($val)
+    {
+        $this->b = $val;
+        throw new Exception("Error");
+    }
+}
+function test($item2, $key, $userd)
+{
+    $userd->crash($item2);
+}
+function main()
+{
+    $fruits = array("d" => "lemon", "a" => "orange", "b" => "banana", "c" => "apple");
+    $myobj = new testc();
+    try {
+        array_walk($fruits, 'test', $myobj);
+    } catch (Exception $e) {
+        echo "Caught: " . $e->getMessage() . "\n";
+    }
+}
+?>
+--EXPECT--
+Caught: Error
diff --git a/tests/std/array/bug30833.phpt b/tests/std/array/bug30833.phpt
new file mode 100644
index 00000000..c79c33fa
--- /dev/null
+++ b/tests/std/array/bug30833.phpt
@@ -0,0 +1,35 @@
+--TEST--
+Bug #30833 (array_count_values() modifies input array)
+--FILE--
+<?php
+
+$foo = array('abc', '0000');
+var_dump($foo);
+
+$count = array_count_values( $foo );
+var_dump($count);
+
+var_dump($foo);
+
+echo "Done\n";
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  string(3) "abc"
+  [1]=>
+  string(4) "0000"
+}
+array(2) {
+  ["abc"]=>
+  int(1)
+  ["0000"]=>
+  int(1)
+}
+array(2) {
+  [0]=>
+  string(3) "abc"
+  [1]=>
+  string(4) "0000"
+}
+Done
diff --git a/tests/std/array/bug31158.phpt b/tests/std/array/bug31158.phpt
new file mode 100644
index 00000000..f5fe6c2e
--- /dev/null
+++ b/tests/std/array/bug31158.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Bug #31158 (array_splice on $GLOBALS crashes)
+--INI--
+error_reporting = E_ALL
+--SKIPIF--
+<?php die("skip AOT array_splice on superglobals differs from PHP"); ?>
+--FILE--
+<?php
+function __()
+{
+    $GLOBALS['a'] = "bug\n";
+    array_splice($GLOBALS, 0, count($GLOBALS));
+    /* All global variables including $GLOBALS are removed */
+    echo $GLOBALS['a'];
+}
+function main()
+{
+    __();
+    echo "ok\n";
+}
+?>
+--EXPECTF--
+Fatal error: Uncaught Error: array_splice(): Argument #1 ($array) could not be passed by reference in %s:%d
+Stack trace:
+#0 %s(%d): __()
+#1 {main}
+  thrown in %s on line %d
diff --git a/tests/std/array/bug31213.phpt b/tests/std/array/bug31213.phpt
new file mode 100644
index 00000000..7a378294
--- /dev/null
+++ b/tests/std/array/bug31213.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Bug #31213 (Sideeffects caused by bug #29493)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+function test($use_extract)
+{
+    $a = 1;
+    $b = 1;
+    $arr = array('_a' => $a, '_b' => &$b);
+    var_dump($a, $b);
+    if ($use_extract) {
+        extract($arr, EXTR_REFS);
+    } else {
+        $_a =& $arr['_a'];
+        $_b =& $arr['_b'];
+    }
+    $_a++;
+    $_b++;
+    var_dump($a, $b, $_a, $_b, $arr);
+}
+function main()
+{
+    test(false);
+    test(true);
+}
+?>
+--EXPECT--
+int(1)
+int(1)
+int(1)
+int(2)
+int(2)
+int(2)
+array(2) {
+  ["_a"]=>
+  &int(2)
+  ["_b"]=>
+  &int(2)
+}
+int(1)
+int(1)
+int(1)
+int(2)
+int(2)
+int(2)
+array(2) {
+  ["_a"]=>
+  &int(2)
+  ["_b"]=>
+  &int(2)
+}
diff --git a/tests/std/array/bug33382.phpt b/tests/std/array/bug33382.phpt
new file mode 100644
index 00000000..0153da90
--- /dev/null
+++ b/tests/std/array/bug33382.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Bug #33382 (array_reverse() fails after *sort() )
+--FILE--
+<?php
+
+$array = array(1,2,3,4,5);
+
+sort($array);
+
+var_dump(array_reverse($array));
+
+echo "Done\n";
+?>
+--EXPECT--
+array(5) {
+  [0]=>
+  int(5)
+  [1]=>
+  int(4)
+  [2]=>
+  int(3)
+  [3]=>
+  int(2)
+  [4]=>
+  int(1)
+}
+Done
diff --git a/tests/std/array/bug33989.phpt b/tests/std/array/bug33989.phpt
new file mode 100644
index 00000000..44ba60d8
--- /dev/null
+++ b/tests/std/array/bug33989.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Bug #33989 (extract($GLOBALS,EXTR_REFS) crashes PHP)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$a="a";
+extract($GLOBALS, EXTR_REFS);
+echo "ok\n";
+?>
+--EXPECT--
+ok
diff --git a/tests/std/array/bug34066.phpt b/tests/std/array/bug34066.phpt
new file mode 100644
index 00000000..5fa475b6
--- /dev/null
+++ b/tests/std/array/bug34066.phpt
@@ -0,0 +1,574 @@
+--TEST--
+Bug #34066 (recursive array_walk causes segfault)
+--FILE--
+<?php
+function dump2xml($array)
+{
+    // output of this goes through 2xml
+    array_walk($array, "gen_xml", "/Docs/");
+}
+function gen_xml($val, $key, $prefix)
+{
+    global $xml_fd;
+    print "gen_xml(prefix={$prefix})\n";
+    if (is_array($val)) {
+        if (preg_match('/^\d+$/', $key)) {
+            if ($key == 1) {
+                print substr($prefix, 0, -1) . "\n";
+            }
+            array_walk($val, "gen_xml", "{$prefix}@");
+        } else {
+            array_walk($val, "gen_xml", "{$prefix}{$key}/");
+        }
+    } else if (strlen($val) > 0) {
+        print "{$prefix}{$key}={$val}\n";
+    } else {
+        print "{$prefix}{$key}\n";
+    }
+    print "gen_xml(prefix={$prefix}) end\n";
+}
+function main()
+{
+    $order = array("DocID" => "1", "DocDate" => "19.09.06", "ReSubmissionDate" => "", "DocTyp" => "Stapelauftrag", "CustID" => "00000", "CustomerAddress" => array(array("Name1" => 'name1', "Name2" => 'name2', "Name3" => "", "City" => 'city', "Street" => 'street', "Postal" => 'postcode', "IATA" => "90", "Country" => "Deutschland", "ShortName" => 'short', "ContactKey" => "", "EMail" => 'email@example.com')), "Text1" => "", "Text2" => "", "Wildcard1" => "", "Wildcard2" => "", "Dispatch" => "Paketdienst", "Weight" => "0,0", "BillingCustID" => "4300200000", "ExtDocNr" => "00000000003", "AnalysisLock" => "", "PrintFlag" => "", "FormType" => "0", "Curr" => "EUR", "ExChangeRate" => "1,0000", "WIRRate" => "0", "OneTimeCustomer" => array(array("BankCode" => "", "BankAccount" => "")), "Language" => "0", "PriceGroup" => "1", "PrFlag" => "0", "SalesTaxKey" => "1", "ProceedKey" => "0", "CustDiscountGroup" => "0", "Discount" => array(array("FinDisc1" => "0,00", "Disc1Base" => "145,72", "Disc1Value" => "0,00", "FinDisc2" => "0,00", "Disc2Base" => "145,72", "Disc2Value" => "0,00", "FinDisc3" => "0,00", "Disc3Base" => "145,72", "Disc3Value" => "0,00", "ValueSummary" => "0,00")), "Contact" => array(array("Repr" => "999", "Region" => "99", "Commission" => "0,00", "Agent" => "000000")), "Booking" => array(array("CostUnit" => "0000000000", "CostCentre" => "0000000000", "AccountingArea" => "01")), "InvoiceCycleKey" => "0", "AnalysisKey" => "", "OrderNumber" => "", "OrderDate" => "", "OrderCode" => "", "DocItems" => array("DocItem" => array("PosType" => "1", "ItemRef" => "1002", "CRef" => "", "Desc1" => "Pr�sentation Niederlande per", "Desc2" => "", "ArticleGroup" => "102", "PosTypeVersion" => "E", "Delivery" => array(array("DelWeek" => "", "DelDay" => "", "DelTime" => "")), "PricePu" => "145,72", "PriceUnit" => "0", "PriceCalculation" => "0", "ItemVal" => "145,72", "InputKey" => "0", "AveragePurchasePrice" => "0", "Tax" => array(array("TaxCode" => "00", "TaxBra" => "000", "TaxBraAccess" => "0", "TaxSumIndex" => "0")), "DiscountArticle" => array(array("DiscPC" => "0,00", "DiscKey" => "1")), "ProceedKeyArticle" => "01", "ActionKey" => "00", "ContactCommissionArticle" => "0,00", "QuantdependentPriceKey" => "", "Quant" => "1", "QuantUnit" => "", "Meas" => array(array("Count" => "1", "Length" => "0,000", "Width" => "0,000", "Height" => "0,000")), "DecimalPlace" => "0", "MultiplierQuant" => "1,000000", "DifferingQuantUnit" => "", "DecimalPlaceConversion" => "0", "WeightArticle" => array(array("Amount" => "0", "Unit" => "0")), "Wreath" => "0,000", "Stock" => "1", "CostUnitArticle" => "", "SerialNbKey" => "0", "TextComplementKey" => "0", "PartsListPrintKey" => "", "Prod" => "0000000000")), "Payment" => array("PaymentKey" => "0", "ReminderKey" => "00", "PayTerms" => array(array("PayTerm" => "1", "PayDays" => "000", "CashDiscDays1" => "000", "CashDiscDays2" => "000", "CashDiscPer1" => "0,00", "CashDiscPer2" => "0,00"), array("PayTerm" => "2", "PayDays" => "000", "CashDiscDays1" => "000", "CashDiscDays2" => "000", "CashDiscPer1" => "0,00", "CashDiscPer2" => "0,00"))), "NetAmountByTurnOverTax" => array(array("TurnOverTaxFree" => "145,72", "TurnOverTax1" => "0,00", "TurnOverTax2" => "0,00", "TurnOverTax3" => "0,00", "TurnOverTax4" => "0,00", "TurnOverTax5" => "0,00", "TurnOverTax6" => "0,00", "TurnOverTax7" => "0,00", "TurnOverTax8" => "0,00")), "GrossAmount" => "145,72", "ProceedAmount" => "145,72", "NetAmountByPayTerm2" => array(array("Sum0" => "0,00", "Sum1" => "0,00", "Sum2" => "0,00", "Sum3" => "0,00", "Sum4" => "0,00", "Sum5" => "0,00", "Sum6" => "0,00", "Sum7" => "0,00", "Sum8" => "0,00")), "TaxCodes" => array(array("TaxCode1" => "0", "TaxCode2" => "0", "TaxCode3" => "0", "TaxCode4" => "0", "TaxCode5" => "0", "TaxCode6" => "0", "TaxCode7" => "0", "TaxCode8" => "0")));
+    $docs = array(array("Version" => "1.0", "ProducerName" => "xxxxxxxx", "ProductName" => "Classic Line", "xmlns" => "x-schema:CL310_DezABFSchema.XML"), "Company" => array(array("MandateNumber" => "111", "MandateName" => "xxx xxxxxxx-xxxxx xxxxxxx", "MandateCurr" => "EUR")), "Doc" => $order);
+    dump2xml($docs);
+    echo "Done\n";
+}
+?>
+--EXPECT--
+gen_xml(prefix=/Docs/)
+gen_xml(prefix=/Docs/@)
+/Docs/@Version=1.0
+gen_xml(prefix=/Docs/@) end
+gen_xml(prefix=/Docs/@)
+/Docs/@ProducerName=xxxxxxxx
+gen_xml(prefix=/Docs/@) end
+gen_xml(prefix=/Docs/@)
+/Docs/@ProductName=Classic Line
+gen_xml(prefix=/Docs/@) end
+gen_xml(prefix=/Docs/@)
+/Docs/@xmlns=x-schema:CL310_DezABFSchema.XML
+gen_xml(prefix=/Docs/@) end
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+gen_xml(prefix=/Docs/Company/)
+gen_xml(prefix=/Docs/Company/@)
+/Docs/Company/@MandateNumber=111
+gen_xml(prefix=/Docs/Company/@) end
+gen_xml(prefix=/Docs/Company/@)
+/Docs/Company/@MandateName=xxx xxxxxxx-xxxxx xxxxxxx
+gen_xml(prefix=/Docs/Company/@) end
+gen_xml(prefix=/Docs/Company/@)
+/Docs/Company/@MandateCurr=EUR
+gen_xml(prefix=/Docs/Company/@) end
+gen_xml(prefix=/Docs/Company/) end
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/DocID=1
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/DocDate=19.09.06
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/ReSubmissionDate
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/DocTyp=Stapelauftrag
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/CustID=00000
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/CustomerAddress/)
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@Name1=name1
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@Name2=name2
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@Name3
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@City=city
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@Street=street
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@Postal=postcode
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@IATA=90
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@Country=Deutschland
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@ShortName=short
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@ContactKey
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@)
+/Docs/Doc/CustomerAddress/@EMail=email@example.com
+gen_xml(prefix=/Docs/Doc/CustomerAddress/@) end
+gen_xml(prefix=/Docs/Doc/CustomerAddress/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/Text1
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/Text2
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/Wildcard1
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/Wildcard2
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/Dispatch=Paketdienst
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/Weight=0,0
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/BillingCustID=4300200000
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/ExtDocNr=00000000003
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/AnalysisLock
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/PrintFlag
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/FormType=0
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/Curr=EUR
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/ExChangeRate=1,0000
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/WIRRate=0
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/OneTimeCustomer/)
+gen_xml(prefix=/Docs/Doc/OneTimeCustomer/@)
+/Docs/Doc/OneTimeCustomer/@BankCode
+gen_xml(prefix=/Docs/Doc/OneTimeCustomer/@) end
+gen_xml(prefix=/Docs/Doc/OneTimeCustomer/@)
+/Docs/Doc/OneTimeCustomer/@BankAccount
+gen_xml(prefix=/Docs/Doc/OneTimeCustomer/@) end
+gen_xml(prefix=/Docs/Doc/OneTimeCustomer/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/Language=0
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/PriceGroup=1
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/PrFlag=0
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/SalesTaxKey=1
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/ProceedKey=0
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/CustDiscountGroup=0
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/Discount/)
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@FinDisc1=0,00
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@Disc1Base=145,72
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@Disc1Value=0,00
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@FinDisc2=0,00
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@Disc2Base=145,72
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@Disc2Value=0,00
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@FinDisc3=0,00
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@Disc3Base=145,72
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@Disc3Value=0,00
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/@)
+/Docs/Doc/Discount/@ValueSummary=0,00
+gen_xml(prefix=/Docs/Doc/Discount/@) end
+gen_xml(prefix=/Docs/Doc/Discount/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/Contact/)
+gen_xml(prefix=/Docs/Doc/Contact/@)
+/Docs/Doc/Contact/@Repr=999
+gen_xml(prefix=/Docs/Doc/Contact/@) end
+gen_xml(prefix=/Docs/Doc/Contact/@)
+/Docs/Doc/Contact/@Region=99
+gen_xml(prefix=/Docs/Doc/Contact/@) end
+gen_xml(prefix=/Docs/Doc/Contact/@)
+/Docs/Doc/Contact/@Commission=0,00
+gen_xml(prefix=/Docs/Doc/Contact/@) end
+gen_xml(prefix=/Docs/Doc/Contact/@)
+/Docs/Doc/Contact/@Agent=000000
+gen_xml(prefix=/Docs/Doc/Contact/@) end
+gen_xml(prefix=/Docs/Doc/Contact/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/Booking/)
+gen_xml(prefix=/Docs/Doc/Booking/@)
+/Docs/Doc/Booking/@CostUnit=0000000000
+gen_xml(prefix=/Docs/Doc/Booking/@) end
+gen_xml(prefix=/Docs/Doc/Booking/@)
+/Docs/Doc/Booking/@CostCentre=0000000000
+gen_xml(prefix=/Docs/Doc/Booking/@) end
+gen_xml(prefix=/Docs/Doc/Booking/@)
+/Docs/Doc/Booking/@AccountingArea=01
+gen_xml(prefix=/Docs/Doc/Booking/@) end
+gen_xml(prefix=/Docs/Doc/Booking/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/InvoiceCycleKey=0
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/AnalysisKey
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/OrderNumber
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/OrderDate
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/OrderCode
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/DocItems/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/PosType=1
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/ItemRef=1002
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/CRef
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/Desc1=Pr�sentation Niederlande per
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/Desc2
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/ArticleGroup=102
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/PosTypeVersion=E
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Delivery/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Delivery/@)
+/Docs/Doc/DocItems/DocItem/Delivery/@DelWeek
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Delivery/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Delivery/@)
+/Docs/Doc/DocItems/DocItem/Delivery/@DelDay
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Delivery/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Delivery/@)
+/Docs/Doc/DocItems/DocItem/Delivery/@DelTime
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Delivery/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Delivery/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/PricePu=145,72
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/PriceUnit=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/PriceCalculation=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/ItemVal=145,72
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/InputKey=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/AveragePurchasePrice=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/@)
+/Docs/Doc/DocItems/DocItem/Tax/@TaxCode=00
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/@)
+/Docs/Doc/DocItems/DocItem/Tax/@TaxBra=000
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/@)
+/Docs/Doc/DocItems/DocItem/Tax/@TaxBraAccess=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/@)
+/Docs/Doc/DocItems/DocItem/Tax/@TaxSumIndex=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Tax/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/DiscountArticle/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/DiscountArticle/@)
+/Docs/Doc/DocItems/DocItem/DiscountArticle/@DiscPC=0,00
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/DiscountArticle/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/DiscountArticle/@)
+/Docs/Doc/DocItems/DocItem/DiscountArticle/@DiscKey=1
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/DiscountArticle/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/DiscountArticle/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/ProceedKeyArticle=01
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/ActionKey=00
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/ContactCommissionArticle=0,00
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/QuantdependentPriceKey
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/Quant=1
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/QuantUnit
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/@)
+/Docs/Doc/DocItems/DocItem/Meas/@Count=1
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/@)
+/Docs/Doc/DocItems/DocItem/Meas/@Length=0,000
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/@)
+/Docs/Doc/DocItems/DocItem/Meas/@Width=0,000
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/@)
+/Docs/Doc/DocItems/DocItem/Meas/@Height=0,000
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/Meas/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/DecimalPlace=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/MultiplierQuant=1,000000
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/DifferingQuantUnit
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/DecimalPlaceConversion=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/WeightArticle/)
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/WeightArticle/@)
+/Docs/Doc/DocItems/DocItem/WeightArticle/@Amount=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/WeightArticle/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/WeightArticle/@)
+/Docs/Doc/DocItems/DocItem/WeightArticle/@Unit=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/WeightArticle/@) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/WeightArticle/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/Wreath=0,000
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/Stock=1
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/CostUnitArticle
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/SerialNbKey=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/TextComplementKey=0
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/PartsListPrintKey
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/)
+/Docs/Doc/DocItems/DocItem/Prod=0000000000
+gen_xml(prefix=/Docs/Doc/DocItems/DocItem/) end
+gen_xml(prefix=/Docs/Doc/DocItems/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/Payment/)
+/Docs/Doc/Payment/PaymentKey=0
+gen_xml(prefix=/Docs/Doc/Payment/) end
+gen_xml(prefix=/Docs/Doc/Payment/)
+/Docs/Doc/Payment/ReminderKey=00
+gen_xml(prefix=/Docs/Doc/Payment/) end
+gen_xml(prefix=/Docs/Doc/Payment/)
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/)
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@PayTerm=1
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@PayDays=000
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@CashDiscDays1=000
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@CashDiscDays2=000
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@CashDiscPer1=0,00
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@CashDiscPer2=0,00
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/)
+/Docs/Doc/Payment/PayTerms
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@PayTerm=2
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@PayDays=000
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@CashDiscDays1=000
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@CashDiscDays2=000
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@CashDiscPer1=0,00
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@)
+/Docs/Doc/Payment/PayTerms/@CashDiscPer2=0,00
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/@) end
+gen_xml(prefix=/Docs/Doc/Payment/PayTerms/) end
+gen_xml(prefix=/Docs/Doc/Payment/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/)
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@)
+/Docs/Doc/NetAmountByTurnOverTax/@TurnOverTaxFree=145,72
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@)
+/Docs/Doc/NetAmountByTurnOverTax/@TurnOverTax1=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@)
+/Docs/Doc/NetAmountByTurnOverTax/@TurnOverTax2=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@)
+/Docs/Doc/NetAmountByTurnOverTax/@TurnOverTax3=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@)
+/Docs/Doc/NetAmountByTurnOverTax/@TurnOverTax4=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@)
+/Docs/Doc/NetAmountByTurnOverTax/@TurnOverTax5=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@)
+/Docs/Doc/NetAmountByTurnOverTax/@TurnOverTax6=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@)
+/Docs/Doc/NetAmountByTurnOverTax/@TurnOverTax7=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@)
+/Docs/Doc/NetAmountByTurnOverTax/@TurnOverTax8=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByTurnOverTax/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/GrossAmount=145,72
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+/Docs/Doc/ProceedAmount=145,72
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/)
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@)
+/Docs/Doc/NetAmountByPayTerm2/@Sum0=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@)
+/Docs/Doc/NetAmountByPayTerm2/@Sum1=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@)
+/Docs/Doc/NetAmountByPayTerm2/@Sum2=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@)
+/Docs/Doc/NetAmountByPayTerm2/@Sum3=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@)
+/Docs/Doc/NetAmountByPayTerm2/@Sum4=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@)
+/Docs/Doc/NetAmountByPayTerm2/@Sum5=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@)
+/Docs/Doc/NetAmountByPayTerm2/@Sum6=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@)
+/Docs/Doc/NetAmountByPayTerm2/@Sum7=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@)
+/Docs/Doc/NetAmountByPayTerm2/@Sum8=0,00
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/@) end
+gen_xml(prefix=/Docs/Doc/NetAmountByPayTerm2/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/Doc/)
+gen_xml(prefix=/Docs/Doc/TaxCodes/)
+gen_xml(prefix=/Docs/Doc/TaxCodes/@)
+/Docs/Doc/TaxCodes/@TaxCode1=0
+gen_xml(prefix=/Docs/Doc/TaxCodes/@) end
+gen_xml(prefix=/Docs/Doc/TaxCodes/@)
+/Docs/Doc/TaxCodes/@TaxCode2=0
+gen_xml(prefix=/Docs/Doc/TaxCodes/@) end
+gen_xml(prefix=/Docs/Doc/TaxCodes/@)
+/Docs/Doc/TaxCodes/@TaxCode3=0
+gen_xml(prefix=/Docs/Doc/TaxCodes/@) end
+gen_xml(prefix=/Docs/Doc/TaxCodes/@)
+/Docs/Doc/TaxCodes/@TaxCode4=0
+gen_xml(prefix=/Docs/Doc/TaxCodes/@) end
+gen_xml(prefix=/Docs/Doc/TaxCodes/@)
+/Docs/Doc/TaxCodes/@TaxCode5=0
+gen_xml(prefix=/Docs/Doc/TaxCodes/@) end
+gen_xml(prefix=/Docs/Doc/TaxCodes/@)
+/Docs/Doc/TaxCodes/@TaxCode6=0
+gen_xml(prefix=/Docs/Doc/TaxCodes/@) end
+gen_xml(prefix=/Docs/Doc/TaxCodes/@)
+/Docs/Doc/TaxCodes/@TaxCode7=0
+gen_xml(prefix=/Docs/Doc/TaxCodes/@) end
+gen_xml(prefix=/Docs/Doc/TaxCodes/@)
+/Docs/Doc/TaxCodes/@TaxCode8=0
+gen_xml(prefix=/Docs/Doc/TaxCodes/@) end
+gen_xml(prefix=/Docs/Doc/TaxCodes/) end
+gen_xml(prefix=/Docs/Doc/) end
+gen_xml(prefix=/Docs/) end
+Done
diff --git a/tests/std/array/bug34066_1.phpt b/tests/std/array/bug34066_1.phpt
new file mode 100644
index 00000000..d23acf4d
--- /dev/null
+++ b/tests/std/array/bug34066_1.phpt
@@ -0,0 +1,501 @@
+--TEST--
+Bug #34066 (recursive array_walk causes segfault)
+--FILE--
+<?php
+function dump2xml($array)
+{
+    // output of this goes through 2xml
+    array_walk_recursive($array, "gen_xml", "/Docs/");
+}
+function gen_xml($val, $key, $prefix)
+{
+    global $xml_fd;
+    print "gen_xml(prefix={$prefix})\n";
+    if (is_array($val)) {
+        if (preg_match('/^\d+$/', $key)) {
+            if ($key == 1) {
+                print substr($prefix, 0, -1) . "\n";
+            }
+            array_walk_recursive($val, "gen_xml", "{$prefix}@");
+        } else {
+            array_walk_recursive($val, "gen_xml", "{$prefix}{$key}/");
+        }
+    } else if (strlen($val) > 0) {
+        print "{$prefix}{$key}={$val}\n";
+    } else {
+        print "{$prefix}{$key}\n";
+    }
+    print "gen_xml(prefix={$prefix}) end\n";
+}
+function main()
+{
+    $order = array("DocID" => "1", "DocDate" => "19.09.06", "ReSubmissionDate" => "", "DocTyp" => "Stapelauftrag", "CustID" => "00000", "CustomerAddress" => array(array("Name1" => 'name1', "Name2" => 'name2', "Name3" => "", "City" => 'city', "Street" => 'street', "Postal" => 'postcode', "IATA" => "90", "Country" => "Deutschland", "ShortName" => 'short', "ContactKey" => "", "EMail" => 'email@example.com')), "Text1" => "", "Text2" => "", "Wildcard1" => "", "Wildcard2" => "", "Dispatch" => "Paketdienst", "Weight" => "0,0", "BillingCustID" => "4300200000", "ExtDocNr" => "00000000003", "AnalysisLock" => "", "PrintFlag" => "", "FormType" => "0", "Curr" => "EUR", "ExChangeRate" => "1,0000", "WIRRate" => "0", "OneTimeCustomer" => array(array("BankCode" => "", "BankAccount" => "")), "Language" => "0", "PriceGroup" => "1", "PrFlag" => "0", "SalesTaxKey" => "1", "ProceedKey" => "0", "CustDiscountGroup" => "0", "Discount" => array(array("FinDisc1" => "0,00", "Disc1Base" => "145,72", "Disc1Value" => "0,00", "FinDisc2" => "0,00", "Disc2Base" => "145,72", "Disc2Value" => "0,00", "FinDisc3" => "0,00", "Disc3Base" => "145,72", "Disc3Value" => "0,00", "ValueSummary" => "0,00")), "Contact" => array(array("Repr" => "999", "Region" => "99", "Commission" => "0,00", "Agent" => "000000")), "Booking" => array(array("CostUnit" => "0000000000", "CostCentre" => "0000000000", "AccountingArea" => "01")), "InvoiceCycleKey" => "0", "AnalysisKey" => "", "OrderNumber" => "", "OrderDate" => "", "OrderCode" => "", "DocItems" => array("DocItem" => array("PosType" => "1", "ItemRef" => "1002", "CRef" => "", "Desc1" => "Pr�sentation Niederlande per", "Desc2" => "", "ArticleGroup" => "102", "PosTypeVersion" => "E", "Delivery" => array(array("DelWeek" => "", "DelDay" => "", "DelTime" => "")), "PricePu" => "145,72", "PriceUnit" => "0", "PriceCalculation" => "0", "ItemVal" => "145,72", "InputKey" => "0", "AveragePurchasePrice" => "0", "Tax" => array(array("TaxCode" => "00", "TaxBra" => "000", "TaxBraAccess" => "0", "TaxSumIndex" => "0")), "DiscountArticle" => array(array("DiscPC" => "0,00", "DiscKey" => "1")), "ProceedKeyArticle" => "01", "ActionKey" => "00", "ContactCommissionArticle" => "0,00", "QuantdependentPriceKey" => "", "Quant" => "1", "QuantUnit" => "", "Meas" => array(array("Count" => "1", "Length" => "0,000", "Width" => "0,000", "Height" => "0,000")), "DecimalPlace" => "0", "MultiplierQuant" => "1,000000", "DifferingQuantUnit" => "", "DecimalPlaceConversion" => "0", "WeightArticle" => array(array("Amount" => "0", "Unit" => "0")), "Wreath" => "0,000", "Stock" => "1", "CostUnitArticle" => "", "SerialNbKey" => "0", "TextComplementKey" => "0", "PartsListPrintKey" => "", "Prod" => "0000000000")), "Payment" => array("PaymentKey" => "0", "ReminderKey" => "00", "PayTerms" => array(array("PayTerm" => "1", "PayDays" => "000", "CashDiscDays1" => "000", "CashDiscDays2" => "000", "CashDiscPer1" => "0,00", "CashDiscPer2" => "0,00"), array("PayTerm" => "2", "PayDays" => "000", "CashDiscDays1" => "000", "CashDiscDays2" => "000", "CashDiscPer1" => "0,00", "CashDiscPer2" => "0,00"))), "NetAmountByTurnOverTax" => array(array("TurnOverTaxFree" => "145,72", "TurnOverTax1" => "0,00", "TurnOverTax2" => "0,00", "TurnOverTax3" => "0,00", "TurnOverTax4" => "0,00", "TurnOverTax5" => "0,00", "TurnOverTax6" => "0,00", "TurnOverTax7" => "0,00", "TurnOverTax8" => "0,00")), "GrossAmount" => "145,72", "ProceedAmount" => "145,72", "NetAmountByPayTerm2" => array(array("Sum0" => "0,00", "Sum1" => "0,00", "Sum2" => "0,00", "Sum3" => "0,00", "Sum4" => "0,00", "Sum5" => "0,00", "Sum6" => "0,00", "Sum7" => "0,00", "Sum8" => "0,00")), "TaxCodes" => array(array("TaxCode1" => "0", "TaxCode2" => "0", "TaxCode3" => "0", "TaxCode4" => "0", "TaxCode5" => "0", "TaxCode6" => "0", "TaxCode7" => "0", "TaxCode8" => "0")));
+    $docs = array(array("Version" => "1.0", "ProducerName" => "xxxxxxxx", "ProductName" => "Classic Line", "xmlns" => "x-schema:CL310_DezABFSchema.XML"), "Company" => array(array("MandateNumber" => "111", "MandateName" => "xxx xxxxxxx-xxxxx xxxxxxx", "MandateCurr" => "EUR")), "Doc" => $order);
+    dump2xml($docs);
+    echo "Done\n";
+}
+?>
+--EXPECT--
+gen_xml(prefix=/Docs/)
+/Docs/Version=1.0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ProducerName=xxxxxxxx
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ProductName=Classic Line
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/xmlns=x-schema:CL310_DezABFSchema.XML
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/MandateNumber=111
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/MandateName=xxx xxxxxxx-xxxxx xxxxxxx
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/MandateCurr=EUR
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DocID=1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DocDate=19.09.06
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ReSubmissionDate
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DocTyp=Stapelauftrag
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CustID=00000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Name1=name1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Name2=name2
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Name3
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/City=city
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Street=street
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Postal=postcode
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/IATA=90
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Country=Deutschland
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ShortName=short
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ContactKey
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/EMail=email@example.com
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Text1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Text2
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Wildcard1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Wildcard2
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Dispatch=Paketdienst
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Weight=0,0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/BillingCustID=4300200000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ExtDocNr=00000000003
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/AnalysisLock
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PrintFlag
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/FormType=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Curr=EUR
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ExChangeRate=1,0000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/WIRRate=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/BankCode
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/BankAccount
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Language=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PriceGroup=1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PrFlag=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/SalesTaxKey=1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ProceedKey=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CustDiscountGroup=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/FinDisc1=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Disc1Base=145,72
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Disc1Value=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/FinDisc2=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Disc2Base=145,72
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Disc2Value=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/FinDisc3=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Disc3Base=145,72
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Disc3Value=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ValueSummary=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Repr=999
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Region=99
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Commission=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Agent=000000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CostUnit=0000000000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CostCentre=0000000000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/AccountingArea=01
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/InvoiceCycleKey=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/AnalysisKey
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/OrderNumber
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/OrderDate
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/OrderCode
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PosType=1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ItemRef=1002
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CRef
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Desc1=Pr�sentation Niederlande per
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Desc2
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ArticleGroup=102
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PosTypeVersion=E
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DelWeek
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DelDay
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DelTime
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PricePu=145,72
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PriceUnit=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PriceCalculation=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ItemVal=145,72
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/InputKey=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/AveragePurchasePrice=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxCode=00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxBra=000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxBraAccess=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxSumIndex=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DiscPC=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DiscKey=1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ProceedKeyArticle=01
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ActionKey=00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ContactCommissionArticle=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/QuantdependentPriceKey
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Quant=1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/QuantUnit
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Count=1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Length=0,000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Width=0,000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Height=0,000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DecimalPlace=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/MultiplierQuant=1,000000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DifferingQuantUnit
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/DecimalPlaceConversion=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Amount=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Unit=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Wreath=0,000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Stock=1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CostUnitArticle
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/SerialNbKey=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TextComplementKey=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PartsListPrintKey
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Prod=0000000000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PaymentKey=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ReminderKey=00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PayTerm=1
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PayDays=000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CashDiscDays1=000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CashDiscDays2=000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CashDiscPer1=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CashDiscPer2=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PayTerm=2
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/PayDays=000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CashDiscDays1=000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CashDiscDays2=000
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CashDiscPer1=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/CashDiscPer2=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TurnOverTaxFree=145,72
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TurnOverTax1=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TurnOverTax2=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TurnOverTax3=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TurnOverTax4=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TurnOverTax5=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TurnOverTax6=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TurnOverTax7=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TurnOverTax8=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/GrossAmount=145,72
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/ProceedAmount=145,72
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Sum0=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Sum1=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Sum2=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Sum3=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Sum4=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Sum5=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Sum6=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Sum7=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/Sum8=0,00
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxCode1=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxCode2=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxCode3=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxCode4=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxCode5=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxCode6=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxCode7=0
+gen_xml(prefix=/Docs/) end
+gen_xml(prefix=/Docs/)
+/Docs/TaxCode8=0
+gen_xml(prefix=/Docs/) end
+Done
diff --git a/tests/std/array/bug34227.phpt b/tests/std/array/bug34227.phpt
new file mode 100644
index 00000000..b7c094c7
--- /dev/null
+++ b/tests/std/array/bug34227.phpt
@@ -0,0 +1,85 @@
+--TEST--
+Bug #34277 (array_filter() crashes with references and objects)
+--FILE--
+<?php
+class C
+{
+    function m1()
+    {
+        $this->m2();
+    }
+    function m2()
+    {
+        $this->m3();
+    }
+    function m3()
+    {
+        $this->m4();
+    }
+    function m4()
+    {
+        $this->m5();
+    }
+    function m5()
+    {
+        $this->m6();
+    }
+    function m6()
+    {
+        $this->m7();
+    }
+    function m7()
+    {
+        $this->m8();
+    }
+    function m8()
+    {
+        $this->m9();
+    }
+    function m9()
+    {
+        $this->m10();
+    }
+    function m10()
+    {
+        $this->m11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    }
+    function m11($a1, $a2, $a3, $a4, $a5, $a6, $a7, $a8, $a9, $a10)
+    {
+        $arr = explode('a', 'b');
+    }
+}
+function f($str)
+{
+    $obj = new C();
+    $obj->m1();
+    return TRUE;
+}
+function p5($a1, $a2, $a3, $a4, $a5, $a6, $a7, $a8, $a9, $a10, $a11, $a12)
+{
+    $ret = array_filter(array(0), 'f');
+}
+function p4()
+{
+    p5(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+}
+function p3()
+{
+    p4();
+}
+function p2()
+{
+    p3();
+}
+function p1()
+{
+    p2();
+}
+function main()
+{
+    p1();
+    echo "ok\n";
+}
+?>
+--EXPECT--
+ok
diff --git a/tests/std/array/bug34982.phpt b/tests/std/array/bug34982.phpt
new file mode 100644
index 00000000..b6629fc2
--- /dev/null
+++ b/tests/std/array/bug34982.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Bug #34982 (array_walk_recursive() modifies elements outside function scope)
+--FILE--
+<?php
+function func($a)
+{
+    array_walk_recursive($a, 'apply');
+    print_r($a);
+}
+function apply(&$input, $key)
+{
+    $input = 'changed';
+}
+function main()
+{
+    $ar = array('element 1', array('subelement1'));
+    func($ar);
+    print_r($ar);
+}
+?>
+--EXPECT--
+Array
+(
+    [0] => changed
+    [1] => Array
+        (
+            [0] => changed
+        )
+
+)
+Array
+(
+    [0] => element 1
+    [1] => Array
+        (
+            [0] => subelement1
+        )
+
+)
diff --git a/tests/std/array/bug35014.phpt b/tests/std/array/bug35014.phpt
new file mode 100644
index 00000000..3935657f
--- /dev/null
+++ b/tests/std/array/bug35014.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Bug #35014 (array_product() always returns 0) (32bit)
+--SKIPIF--
+<?php if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platform only"); ?>
+--FILE--
+<?php
+$tests = array(
+    array(0),
+    array(3),
+    array(3, 3),
+    array(0.5, 2),
+    array(99999999, 99999999),
+    array(8.993, 7443241,988, sprintf("%u", -1)+0.44),
+    array(2,sprintf("%u", -1)),
+);
+
+foreach ($tests as $v) {
+    var_dump(array_product($v));
+}
+?>
+--EXPECT--
+int(0)
+int(3)
+int(9)
+float(1)
+float(9999999800000000)
+float(2.8404260053902914E+20)
+float(8589934590)
diff --git a/tests/std/array/bug35014_64bit.phpt b/tests/std/array/bug35014_64bit.phpt
new file mode 100644
index 00000000..29fa9e18
--- /dev/null
+++ b/tests/std/array/bug35014_64bit.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Bug #35014 (array_product() always returns 0) (64bit)
+--SKIPIF--
+<?php if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only"); ?>
+--INI--
+precision=14
+--FILE--
+<?php
+$tests = array(
+    array(0),
+    array(3),
+    array(3, 3),
+    array(0.5, 2),
+    array(99999999, 99999999),
+    array(8.993, 7443241,988, sprintf("%u", -1)+0.44),
+    array(2,sprintf("%u", -1)),
+);
+
+foreach ($tests as $v) {
+    var_dump(array_product($v));
+}
+?>
+--EXPECT--
+int(0)
+int(3)
+int(9)
+float(1)
+int(9999999800000001)
+float(1.219953680144986E+30)
+float(3.6893488147419103E+19)
diff --git a/tests/std/array/bug35022.phpt b/tests/std/array/bug35022.phpt
new file mode 100644
index 00000000..a7787aaf
--- /dev/null
+++ b/tests/std/array/bug35022.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Bug #35022 (Regression in the behavior of key/current functions)
+--SKIPIF--
+<?php die("skip AOT iteration order/internal pointer handling differs from PHP"); ?>
+--FILE--
+<?php
+function foo(&$state)
+{
+    $contentDict = end($state);
+    for ($contentDict = end($state); $contentDict !== false; $contentDict = prev($state)) {
+        echo key($state) . " => " . current($state) . "\n";
+    }
+}
+function main()
+{
+    $state = array("one" => 1, "two" => 2, "three" => 3);
+    foo($state);
+    reset($state);
+    var_dump(key($state), current($state));
+}
+?>
+--EXPECT--
+three => 3
+two => 2
+one => 1
+string(3) "one"
+int(1)
diff --git a/tests/std/array/bug35821.phpt b/tests/std/array/bug35821.phpt
new file mode 100644
index 00000000..0887f064
--- /dev/null
+++ b/tests/std/array/bug35821.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Bug #35821 (array_map() segfaults when exception is throwed from the callback)
+--SKIPIF--
+<?php die("skip AOT array_map with exception in callback differs from PHP"); ?>
+--FILE--
+<?php
+class Element
+{
+    public function ThrowException()
+    {
+        throw new Exception();
+    }
+    public static function CallBack(Element $elem)
+    {
+        $elem->ThrowException();
+    }
+}
+function main()
+{
+    $arr = array(new Element(), new Element(), new Element());
+    array_map(array('Element', 'CallBack'), $arr);
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+Fatal error: Uncaught Exception in %s:%d
+Stack trace:
+#0 %s(%d): Element->ThrowException()
+#1 [internal function]: Element::CallBack(Object(Element))
+#2 %s(%d): array_map(Array, Array)
+#3 {main}
+  thrown in %s on line %d
diff --git a/tests/std/array/bug36975.phpt b/tests/std/array/bug36975.phpt
new file mode 100644
index 00000000..67a34325
--- /dev/null
+++ b/tests/std/array/bug36975.phpt
@@ -0,0 +1,62 @@
+--TEST--
+Bug #36975 (natcasesort() causes array_pop() to misbehave)
+--FILE--
+<?php
+$a = array('aa', 'aa', 'bb', 'bb', 'cc', 'cc');
+$test = natcasesort($a);
+if ($test) {
+  echo "natcasesort success!\n";
+}
+$val = array_pop($a);
+$a[] = $val;
+var_dump($a);
+
+$b = array(1 => 'foo', 0 => 'baz');
+array_pop($b);
+$b[] = 'bar';
+array_push($b, 'bar');
+print_r($b);
+
+$c = array(0, 0, 0, 0, 0);
+asort($c);
+array_pop($c);
+$c[] = 'foo';
+$c[] = 'bar';
+var_dump($c);
+?>
+--EXPECT--
+natcasesort success!
+array(6) {
+  [0]=>
+  string(2) "aa"
+  [1]=>
+  string(2) "aa"
+  [2]=>
+  string(2) "bb"
+  [3]=>
+  string(2) "bb"
+  [4]=>
+  string(2) "cc"
+  [5]=>
+  string(2) "cc"
+}
+Array
+(
+    [1] => foo
+    [2] => bar
+    [3] => bar
+)
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(0)
+  [2]=>
+  int(0)
+  [3]=>
+  int(0)
+  [4]=>
+  string(3) "foo"
+  [5]=>
+  string(3) "bar"
+}
diff --git a/tests/std/array/bug38464.phpt b/tests/std/array/bug38464.phpt
new file mode 100644
index 00000000..5480109b
--- /dev/null
+++ b/tests/std/array/bug38464.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Bug #38464 (array_count_values() mishandles numeric strings)
+--FILE--
+<?php
+$array = array('-000', ' 001', 1, ' 123', '+123');
+var_dump(array_count_values($array));
+?>
+--EXPECT--
+array(5) {
+  ["-000"]=>
+  int(1)
+  [" 001"]=>
+  int(1)
+  [1]=>
+  int(1)
+  [" 123"]=>
+  int(1)
+  ["+123"]=>
+  int(1)
+}
diff --git a/tests/std/array/bug39576.phpt b/tests/std/array/bug39576.phpt
new file mode 100644
index 00000000..7e3b52d6
--- /dev/null
+++ b/tests/std/array/bug39576.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Bug #39576 (array_walk() doesn't separate userdata zval)
+--SKIPIF--
+<?php die("skip AOT array_walk userdata reference differs from PHP"); ?>
+--FILE--
+<?php
+class Test
+{
+    public $_table = '';
+    public $_columns = array();
+    public $_primary = array();
+    public $name;
+}
+function test($value, $column, &$columns)
+{
+}
+function main()
+{
+    $test = new Test();
+    $test->name = 'test';
+    $test->_columns['name'] = new stdClass();
+    array_walk(get_object_vars($test), 'test', $test->_columns);
+    var_dump($test);
+    array_intersect_key(get_object_vars($test), $test->_primary);
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+Notice: Only variables should be passed by reference in %s on line %d
+
+Warning: test(): Argument #3 ($columns) must be passed by reference, value given in %s on line %d
+
+Warning: test(): Argument #3 ($columns) must be passed by reference, value given in %s on line %d
+
+Warning: test(): Argument #3 ($columns) must be passed by reference, value given in %s on line %d
+
+Warning: test(): Argument #3 ($columns) must be passed by reference, value given in %s on line %d
+object(Test)#%d (4) {
+  ["_table"]=>
+  string(0) ""
+  ["_columns"]=>
+  array(1) {
+    ["name"]=>
+    object(stdClass)#%d (0) {
+    }
+  }
+  ["_primary"]=>
+  array(0) {
+  }
+  ["name"]=>
+  string(4) "test"
+}
+Done
diff --git a/tests/std/array/bug40191.phpt b/tests/std/array/bug40191.phpt
new file mode 100644
index 00000000..c1a0d6b6
--- /dev/null
+++ b/tests/std/array/bug40191.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Bug #40191 (use of array_unique() with objects triggers segfault)
+--FILE--
+<?php
+
+$arrObj = new ArrayObject();
+$arrObj->append('foo');
+$arrObj->append('bar');
+$arrObj->append('foo');
+
+try {
+    $arr = array_unique($arrObj);
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+array_unique(): Argument #1 ($array) must be of type array, ArrayObject given
+Done
diff --git a/tests/std/array/bug40709.phpt b/tests/std/array/bug40709.phpt
new file mode 100644
index 00000000..4a04deb7
--- /dev/null
+++ b/tests/std/array/bug40709.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Bug #40709 (array_reduce() behaves strange with one item stored arrays)
+--FILE--
+<?php
+function CommaSeparatedList($a, $b)
+{
+    if ($a == null) {
+        return $b;
+    } else {
+        return $a . ',' . $b;
+    }
+}
+function main()
+{
+    $arr1 = array(1, 2, 3);
+    $arr2 = array(1);
+    echo "result for arr1: " . array_reduce($arr1, 'CommaSeparatedList') . "\n";
+    echo "result for arr2: " . array_reduce($arr2, 'CommaSeparatedList') . "\n";
+    echo "result for arr1: " . array_reduce($arr1, 'CommaSeparatedList') . "\n";
+    echo "result for arr2: " . array_reduce($arr2, 'CommaSeparatedList') . "\n";
+    echo "Done\n";
+}
+?>
+--EXPECT--
+result for arr1: 1,2,3
+result for arr2: 1
+result for arr1: 1,2,3
+result for arr2: 1
+Done
diff --git a/tests/std/array/bug41686.phpt b/tests/std/array/bug41686.phpt
new file mode 100644
index 00000000..b94acb60
--- /dev/null
+++ b/tests/std/array/bug41686.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Bug #41686 (Omitting length param in array_slice not possible)
+--FILE--
+<?php
+$a = array(1,2,3);
+$b = array('a'=>1,'b'=>1,'c'=>2);
+
+var_dump(
+        array_slice($a, 1),
+        array_slice($a, 1, 2, TRUE),
+        array_slice($a, 1, NULL, TRUE),
+        array_slice($b, 1),
+        array_slice($b, 1, 2, TRUE),
+        array_slice($b, 1, NULL, TRUE)
+);
+
+echo "Done\n";
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+array(2) {
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(2) {
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(2) {
+  ["b"]=>
+  int(1)
+  ["c"]=>
+  int(2)
+}
+array(2) {
+  ["b"]=>
+  int(1)
+  ["c"]=>
+  int(2)
+}
+array(2) {
+  ["b"]=>
+  int(1)
+  ["c"]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/bug42177.phpt b/tests/std/array/bug42177.phpt
new file mode 100644
index 00000000..c838a7db
--- /dev/null
+++ b/tests/std/array/bug42177.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Bug #42177 (Warning "array_merge_recursive(): recursion detected" comes again...)
+--SKIPIF--
+<?php die("skip AOT array_merge_recursive recursion detection differs from PHP"); ?>
+--FILE--
+<?php
+
+$a1 = array( 'key1' => 1, 'key3' => 2 );
+$a2 = array();
+$a1 = array_merge_recursive( $a1, $a2 );
+$a1 = array_merge_recursive( $a1, $a2 );
+unset( $a1, $a2 );
+
+$a1 = array();
+$a2 = array( 'key1' => 1, 'key3' => 2 );
+$a1 = array_merge_recursive( $a1, $a2 );
+$a1 = array_merge_recursive( $a1, $a2 );
+unset( $a1, $a2 );
+
+$a1 = array();
+$a2 = array( 'key1' => &$a1 );
+$a1 = array_merge_recursive( $a1, $a2 );
+try {
+    $a1 = array_merge_recursive( $a1, $a2 );
+} catch (\Error $e) {
+    echo $e->getMessage() . " on line " . $e->getLine() . "\n";
+}
+unset( $a1, $a2 );
+
+$x = 'foo';
+$y =& $x;
+$a1 = array($x, $y, $x, $y);
+$a2 = array( 'key1' => $a1, $x, $y );
+$a1 = array_merge_recursive( $a1, $a2 );
+$a1 = array_merge_recursive( $a1, $a2 );
+unset( $a1, $a2 );
+
+?>
+--EXPECT--
+Recursion detected on line 19
diff --git a/tests/std/array/bug42233.phpt b/tests/std/array/bug42233.phpt
new file mode 100644
index 00000000..a538761b
--- /dev/null
+++ b/tests/std/array/bug42233.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Bug #42233 (extract(): scandic characters not allowed as variable name)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+$test = array(
+    'a'     => '1',
+    'æ'     => '2',
+    'æøåäö' => '3',
+);
+
+var_dump($test);
+var_dump(extract($test));
+var_dump($a);
+var_dump($æ);
+var_dump($æøåäö);
+
+echo "Done.\n";
+?>
+--EXPECT--
+array(3) {
+  ["a"]=>
+  string(1) "1"
+  ["æ"]=>
+  string(1) "2"
+  ["æøåäö"]=>
+  string(1) "3"
+}
+int(3)
+string(1) "1"
+string(1) "2"
+string(1) "3"
+Done.
diff --git a/tests/std/array/bug42838.phpt b/tests/std/array/bug42838.phpt
new file mode 100644
index 00000000..2298db2b
--- /dev/null
+++ b/tests/std/array/bug42838.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Bug #42838 (Wrong results in array_diff_uassoc())
+--FILE--
+<?php
+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', 0 => 'red');
+    $array2 = array("a" => "green", "b" => "Brown", 'c' => 'blue', 0 => 'red');
+    $result = array_diff_uassoc($array1, $array2, "key_compare_func");
+    print_r($result);
+}
+?>
+--EXPECT--
+Array
+(
+)
diff --git a/tests/std/array/bug42850.phpt b/tests/std/array/bug42850.phpt
new file mode 100644
index 00000000..7b1cccac
--- /dev/null
+++ b/tests/std/array/bug42850.phpt
@@ -0,0 +1,64 @@
+--TEST--
+Bug #42850 (array_walk_recursive() leaves references)
+--FILE--
+<?php
+function apply_dumb($item, $key)
+{
+}
+// Bug #34982
+function myfunc($data)
+{
+    array_walk_recursive($data, 'apply_changed');
+}
+function apply_changed(&$input, $key)
+{
+    $input = 'changed';
+}
+function main()
+{
+    // Bug #42850
+    $data = array('key1' => 'val1', array('key2' => 'val2'));
+    var_dump($data);
+    array_walk_recursive($data, 'apply_dumb');
+    $data2 = $data;
+    $data2[0] = 'altered';
+    var_dump($data);
+    var_dump($data2);
+    myfunc($data);
+    var_dump($data);
+}
+?>
+--EXPECT--
+array(2) {
+  ["key1"]=>
+  string(4) "val1"
+  [0]=>
+  array(1) {
+    ["key2"]=>
+    string(4) "val2"
+  }
+}
+array(2) {
+  ["key1"]=>
+  string(4) "val1"
+  [0]=>
+  array(1) {
+    ["key2"]=>
+    string(4) "val2"
+  }
+}
+array(2) {
+  ["key1"]=>
+  string(4) "val1"
+  [0]=>
+  string(7) "altered"
+}
+array(2) {
+  ["key1"]=>
+  string(4) "val1"
+  [0]=>
+  array(1) {
+    ["key2"]=>
+    string(4) "val2"
+  }
+}
diff --git a/tests/std/array/bug43495.phpt b/tests/std/array/bug43495.phpt
new file mode 100644
index 00000000..37c4f6b6
--- /dev/null
+++ b/tests/std/array/bug43495.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Bug #43495 (array_merge_recursive() crashes with recursive arrays)
+--FILE--
+<?php
+$a=array("key1"=>array("key2"=>array()));
+$a["key1"]["key2"]["key3"]=&$a;
+
+$b=array("key1"=>array("key2"=>array()));
+$b["key1"]["key2"]["key3"]=&$b;
+
+
+try {
+    array_merge_recursive($a,$b);
+} catch (\Error $e) {
+    echo $e->getMessage() . "\n";
+}
+
+/* Break recursion */
+$a["key1"]["key2"]["key3"] = null;
+$b["key1"]["key2"]["key3"] = null;
+
+?>
+--EXPECT--
+Recursion detected
diff --git a/tests/std/array/bug43505.phpt b/tests/std/array/bug43505.phpt
new file mode 100644
index 00000000..3a7b1151
--- /dev/null
+++ b/tests/std/array/bug43505.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Bug #43505 (Assign by reference bug)
+--INI--
+error_reporting=0
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+class Test implements Countable
+{
+    #[ReturnTypeWillChange]
+    public function count()
+    {
+        return $some;
+    }
+}
+function main()
+{
+    $obj = new Test();
+    $a = array();
+    $b =& $a['test'];
+    var_dump($a);
+    $t = count($obj);
+    $a = array();
+    $b =& $a['test'];
+    var_dump($a);
+}
+?>
+--EXPECT--
+array(1) {
+  ["test"]=>
+  &NULL
+}
+array(1) {
+  ["test"]=>
+  &NULL
+}
diff --git a/tests/std/array/bug43541.phpt b/tests/std/array/bug43541.phpt
new file mode 100644
index 00000000..847f61ad
--- /dev/null
+++ b/tests/std/array/bug43541.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Bug #43541 (length parameter omitted or not does not work when casted to float)
+--FILE--
+<?php
+$arr = array(1, 2, 3, 4, 5, 6);
+
+var_dump(array_slice($arr, 0, (float)2));
+var_dump(array_slice($arr, 0, (int)2));
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
diff --git a/tests/std/array/bug44181.phpt b/tests/std/array/bug44181.phpt
new file mode 100644
index 00000000..0432d51f
--- /dev/null
+++ b/tests/std/array/bug44181.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Bug #44181 (extract EXTR_OVERWRITE|EXTR_REFS can fail to create references)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$a = array('foo' => 'original.foo');
+
+$foo = 'test';
+$ref = &$a;
+
+extract($a, EXTR_OVERWRITE|EXTR_REFS);
+$foo = 'changed.foo';
+
+var_dump($a['foo']);
+echo "Done\n";
+?>
+--EXPECTF--
+string(%d) "changed.foo"
+Done
diff --git a/tests/std/array/bug44182.phpt b/tests/std/array/bug44182.phpt
new file mode 100644
index 00000000..86504a7a
--- /dev/null
+++ b/tests/std/array/bug44182.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Bug #44182 (extract EXTR_REFS can fail to split copy-on-write references)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$a = array('foo' => 'original.foo');
+
+$nonref = $a['foo'];
+$ref = &$a;
+
+extract($a, EXTR_REFS);
+$a['foo'] = 'changed.foo';
+
+var_dump($nonref);
+echo "Done\n";
+?>
+--EXPECTF--
+string(%d) "original.foo"
+Done
diff --git a/tests/std/array/bug44929.phpt b/tests/std/array/bug44929.phpt
new file mode 100644
index 00000000..efcbcda1
--- /dev/null
+++ b/tests/std/array/bug44929.phpt
@@ -0,0 +1,35 @@
+--TEST--
+Bug #44929 (natsort doesn't handle leading zeros well)
+--FILE--
+<?php
+$a = array('001','008','005','00011','03','000014','-123','0.002','00','0','0_0','0-0');
+natsort($a);
+var_dump($a);
+?>
+--EXPECT--
+array(12) {
+  [6]=>
+  string(4) "-123"
+  [8]=>
+  string(2) "00"
+  [9]=>
+  string(1) "0"
+  [11]=>
+  string(3) "0-0"
+  [7]=>
+  string(5) "0.002"
+  [10]=>
+  string(3) "0_0"
+  [0]=>
+  string(3) "001"
+  [4]=>
+  string(2) "03"
+  [2]=>
+  string(3) "005"
+  [1]=>
+  string(3) "008"
+  [3]=>
+  string(5) "00011"
+  [5]=>
+  string(6) "000014"
+}
diff --git a/tests/std/array/bug45312.phpt b/tests/std/array/bug45312.phpt
new file mode 100644
index 00000000..f005c508
--- /dev/null
+++ b/tests/std/array/bug45312.phpt
@@ -0,0 +1,52 @@
+--TEST--
+Bug #45312 (Segmentation fault on second request for array functions)
+--FILE--
+<?php
+class cr
+{
+    private $priv_member;
+    function __construct($val)
+    {
+        $this->priv_member = $val;
+    }
+    static function comp_func_cr($a, $b)
+    {
+        if ($a->priv_member === $b->priv_member) {
+            return 0;
+        }
+        return $a->priv_member > $b->priv_member ? 1 : -1;
+    }
+    static function comp_func_cr2($a, $b)
+    {
+        echo ".";
+        if ($a->priv_member === $b->priv_member) {
+            return 0;
+        }
+        return $a->priv_member < $b->priv_member ? 1 : -1;
+    }
+    function dump()
+    {
+        echo $this->priv_member . "\n";
+    }
+}
+function main()
+{
+    $a = array("0.1" => new cr(9), "0.5" => new cr(12), 0 => new cr(23), 1 => new cr(4), 2 => new cr(-15));
+    $b = array("0.2" => new cr(9), "0.5" => new cr(22), 0 => new cr(3), 1 => new cr(4), 2 => new cr(-15));
+    $result = array_udiff_assoc($a, $b, array("cr", "comp_func_cr"));
+    foreach ($result as $val) {
+        $val->dump();
+    }
+    $result = array_udiff_assoc($a, $b, array("cr", "comp_func_cr2"));
+    foreach ($result as $val) {
+        $val->dump();
+    }
+}
+?>
+--EXPECT--
+9
+12
+23
+....9
+12
+23
diff --git a/tests/std/array/bug46873.phpt b/tests/std/array/bug46873.phpt
new file mode 100644
index 00000000..2c5f262c
--- /dev/null
+++ b/tests/std/array/bug46873.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Bug #46873 (extract($foo) crashes if $foo['foo'] exists)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$foo = array('foo' => 1, 'bar' => 2, 'test' => 3);
+extract($foo);
+var_dump($foo, $bar, $test);
+?>
+--EXPECT--
+int(1)
+int(2)
+int(3)
diff --git a/tests/std/array/bug48224.phpt b/tests/std/array/bug48224.phpt
new file mode 100644
index 00000000..5b46e183
--- /dev/null
+++ b/tests/std/array/bug48224.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Bug #48224 (array_rand no longer shuffles)
+--FILE--
+<?php
+$a = range(0, 100);
+$a1 = array_rand($a, count($a));
+$a2 = array_rand($a, count($a));
+$a3 = array_rand($a, count($a));
+$a4 = array_rand($a, count($a));
+
+var_dump($a1 === $a2 && $a1 === $a3 && $a1 === $a4);
+
+?>
+--EXPECT--
+bool(true)
diff --git a/tests/std/array/bug48854.phpt b/tests/std/array/bug48854.phpt
new file mode 100644
index 00000000..ed5b8e1a
--- /dev/null
+++ b/tests/std/array/bug48854.phpt
@@ -0,0 +1,43 @@
+--TEST--
+Bug #48854 (array_merge_recursive modifies arrays after first one)
+--FILE--
+<?php
+
+$array1 = array(
+       'friends' => 5,
+       'children' => array(
+               'dogs' => 0,
+       ),
+);
+
+$array2 = array(
+       'friends' => 10,
+       'children' => array(
+               'cats' => 5,
+       ),
+);
+
+$merged = array_merge_recursive($array1, $array2);
+
+var_dump($array1, $array2);
+
+?>
+--EXPECT--
+array(2) {
+  ["friends"]=>
+  int(5)
+  ["children"]=>
+  array(1) {
+    ["dogs"]=>
+    int(0)
+  }
+}
+array(2) {
+  ["friends"]=>
+  int(10)
+  ["children"]=>
+  array(1) {
+    ["cats"]=>
+    int(5)
+  }
+}
diff --git a/tests/std/array/bug50006.phpt b/tests/std/array/bug50006.phpt
new file mode 100644
index 00000000..c7c59752
--- /dev/null
+++ b/tests/std/array/bug50006.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Bug #50006 (Segfault caused by uksort())
+--FILE--
+<?php
+function magic_sort_cmp($a, $b)
+{
+    $a = substr($a, 1);
+    $b = substr($b, 1);
+    if (!$a) {
+        return $b ? -1 : 0;
+    }
+    if (!$b) {
+        return 1;
+    }
+    return magic_sort_cmp($a, $b);
+}
+function main()
+{
+    $data = array('bar-bazbazbaz.' => 0, 'bar-bazbazbaz-' => 0, 'foo' => 0);
+    uksort($data, 'magic_sort_cmp');
+    print_r($data);
+}
+?>
+--EXPECT--
+Array
+(
+    [foo] => 0
+    [bar-bazbazbaz.] => 0
+    [bar-bazbazbaz-] => 0
+)
diff --git a/tests/std/array/bug50006_1.phpt b/tests/std/array/bug50006_1.phpt
new file mode 100644
index 00000000..9a565f87
--- /dev/null
+++ b/tests/std/array/bug50006_1.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Bug #50006 (Segfault caused by uksort()) - usort variant
+--FILE--
+<?php
+function magic_sort_cmp($a, $b)
+{
+    $a = substr($a, 1);
+    $b = substr($b, 1);
+    if (!$a) {
+        return $b ? -1 : 0;
+    }
+    if (!$b) {
+        return 1;
+    }
+    return magic_sort_cmp($a, $b);
+}
+function main()
+{
+    $data = array('bar-bazbazbaz.', 'bar-bazbazbaz-', 'foo');
+    usort($data, 'magic_sort_cmp');
+    print_r($data);
+}
+?>
+--EXPECT--
+Array
+(
+    [0] => foo
+    [1] => bar-bazbazbaz.
+    [2] => bar-bazbazbaz-
+)
diff --git a/tests/std/array/bug50006_2.phpt b/tests/std/array/bug50006_2.phpt
new file mode 100644
index 00000000..82956367
--- /dev/null
+++ b/tests/std/array/bug50006_2.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Bug #50006 (Segfault caused by uksort()) - uasort variant
+--FILE--
+<?php
+function magic_sort_cmp($a, $b)
+{
+    $a = substr($a, 1);
+    $b = substr($b, 1);
+    if (!$a) {
+        return $b ? -1 : 0;
+    }
+    if (!$b) {
+        return 1;
+    }
+    return magic_sort_cmp($a, $b);
+}
+function main()
+{
+    $data = array('bar-bazbazbaz.', 'bar-bazbazbaz-', 'foo');
+    uasort($data, 'magic_sort_cmp');
+    print_r($data);
+}
+?>
+--EXPECT--
+Array
+(
+    [2] => foo
+    [0] => bar-bazbazbaz.
+    [1] => bar-bazbazbaz-
+)
diff --git a/tests/std/array/bug51552.phpt b/tests/std/array/bug51552.phpt
new file mode 100644
index 00000000..609b9eaf
--- /dev/null
+++ b/tests/std/array/bug51552.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Bug #51552 (debug_backtrace() causes segmentation fault and/or memory issues)
+--FILE--
+<?php
+function walk($element, $key, $p)
+{
+    $backtrace = debug_backtrace();
+    echo "{$element}\n";
+}
+function main()
+{
+    $a = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    array_walk($a, 'walk', 'testthis');
+}
+?>
+--EXPECT--
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
diff --git a/tests/std/array/bug52534.phpt b/tests/std/array/bug52534.phpt
new file mode 100644
index 00000000..dfff3fdb
--- /dev/null
+++ b/tests/std/array/bug52534.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Bug #52534 (var_export array with negative key)
+--FILE--
+<?php
+
+$aArray = array ( -1 => 'Hello');
+
+var_export($aArray);
+
+?>
+--EXPECT--
+array (
+  -1 => 'Hello',
+)
diff --git a/tests/std/array/bug52719.phpt b/tests/std/array/bug52719.phpt
new file mode 100644
index 00000000..91bb4ec1
--- /dev/null
+++ b/tests/std/array/bug52719.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Bug #52719: array_walk_recursive crashes if third param of the function is by reference
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference parameters in closures");
+?>
+
+--FILE--
+<?php
+$array = array("hello", array("world"));
+$userdata = array();
+array_walk_recursive(
+    $array,
+    function ($value, $key, &$userdata) { },
+    $userdata
+);
+echo "Done";
+?>
+--EXPECTF--
+Warning: {closure:%s:%d}(): Argument #3 ($userdata) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #3 ($userdata) must be passed by reference, value given in %s on line %d
+Done
diff --git a/tests/std/array/bug61058.phpt b/tests/std/array/bug61058.phpt
new file mode 100644
index 00000000..e5960a55
--- /dev/null
+++ b/tests/std/array/bug61058.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Bug #61058 (array_fill leaks if start index is PHP_INT_MAX)
+--SKIPIF--
+<?php die("skip AOT array_fill edge case differs from PHP"); ?>
+--FILE--
+<?php
+
+try {
+    array_fill(PHP_INT_MAX, 2, '*');
+} catch (\Error $e) {
+    echo $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+Cannot add element to the array as the next element is already occupied
diff --git a/tests/std/array/bug61730.phpt b/tests/std/array/bug61730.phpt
new file mode 100644
index 00000000..ff137151
--- /dev/null
+++ b/tests/std/array/bug61730.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Bug #61730 (Segfault from array_walk modifying an array passed by reference)
+--FILE--
+<?php
+$myArray = array_fill(0, 10, 1);
+
+array_walk(
+    $myArray,
+    function($value, $key) use ($myArray)
+    {
+        reset($myArray);
+    }
+);
+
+array_walk(
+    $myArray,
+    function($value, $key) use (&$myArray)
+    {
+        var_dump($key);
+        unset($myArray[$key]);
+        unset($myArray[$key+1]);
+        unset($myArray[$key+2]);
+    }
+);
+
+
+
+print_r($myArray);
+?>
+--EXPECT--
+int(0)
+int(3)
+int(6)
+int(9)
+Array
+(
+)
diff --git a/tests/std/array/bug61967.phpt b/tests/std/array/bug61967.phpt
new file mode 100644
index 00000000..ee107e5b
--- /dev/null
+++ b/tests/std/array/bug61967.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Bug #61967: unset array item in array_walk_recursive cause inconsistent array
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference parameters in closures");
+?>
+
+--FILE--
+<?php
+$arr = array(
+    range(1, 5),
+    range(1, 5),
+    range(1, 5),
+    range(1, 5),
+    range(1, 5),
+);
+
+array_walk_recursive($arr,
+    function (&$value, $key) use(&$arr) {
+        var_dump($key);
+        unset($arr[$key]);
+    }
+);
+?>
+--EXPECT--
+int(0)
+int(1)
+int(2)
+int(3)
+int(4)
diff --git a/tests/std/array/bug62607.phpt b/tests/std/array/bug62607.phpt
new file mode 100644
index 00000000..a2a3dfd3
--- /dev/null
+++ b/tests/std/array/bug62607.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Bug #62607: array_walk_recursive move internal pointer
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference parameters in closures");
+?>
+
+--FILE--
+<?php
+$arr = array('a'=>'b');
+echo 'Before -> '.current($arr).PHP_EOL;
+array_walk_recursive($arr, function(&$val){});
+echo 'After -> '.current($arr);
+?>
+--EXPECT--
+Before -> b
+After -> b
diff --git a/tests/std/array/bug65251.phpt b/tests/std/array/bug65251.phpt
new file mode 100644
index 00000000..93fe5276
--- /dev/null
+++ b/tests/std/array/bug65251.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Bug #65251: array_merge_recursive() recursion detection broken
+--INI--
+report_memleaks=0
+--SKIPIF--
+<?php //die("skip array_merge_recursive on \$GLOBALS triggers GC assertion failure"); ?>
+--FILE--
+<?php
+
+/* Test that direct $GLOBALS read does not crash.
+ * $GLOBALS is an INDIRECT to &EG(symbol_table).
+ * Reading it directly must use SEPARATE_ARRAY (zend_array_dup)
+ * to avoid manipulating refcount of the engine's symbol table. */
+$array = $GLOBALS;
+try {
+    array_merge_recursive($array, $GLOBALS);
+} catch (\Error $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo "===DONE===\n";
+?>
+--EXPECT--
+===DONE===
diff --git a/tests/std/array/bug65304.phpt b/tests/std/array/bug65304.phpt
new file mode 100644
index 00000000..8ed4c508
--- /dev/null
+++ b/tests/std/array/bug65304.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Bug #65304 (Use of max int in array_sum)
+--FILE--
+<?php
+var_dump(array_sum(array(PHP_INT_MAX, 1)));
+var_dump(PHP_INT_MAX + 1);
+?>
+--EXPECTF--
+float(%s)
+float(%s)
diff --git a/tests/std/array/bug67693.phpt b/tests/std/array/bug67693.phpt
new file mode 100644
index 00000000..c9aa2d86
--- /dev/null
+++ b/tests/std/array/bug67693.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Bug #67693 - incorrect push to empty array
+--FILE--
+<?php
+
+$array = array(-1 => 0);
+
+array_pop($array);
+
+array_push($array, 0);
+array_push($array, 0);
+
+var_dump($array);
+
+echo"\nDone";
+?>
+--EXPECT--
+array(2) {
+  [-1]=>
+  int(0)
+  [0]=>
+  int(0)
+}
+
+Done
diff --git a/tests/std/array/bug68553.phpt b/tests/std/array/bug68553.phpt
new file mode 100644
index 00000000..f17af0a5
--- /dev/null
+++ b/tests/std/array/bug68553.phpt
@@ -0,0 +1,85 @@
+--TEST--
+Bug #68553 (array_column: null values in $index_key become incrementing keys in result)
+--SKIPIF--
+<?php die("skip AOT array_column null index_key differs from PHP"); ?>
+--FILE--
+<?php
+$i = 100;
+/* increase the resource id to make test stable */
+while ($i--) {
+    $fd = fopen(__FILE__, "r");
+    fclose($fd);
+}
+$a = [
+    ['a' => 10],
+    ['a' => 20],
+    ['a' => true],
+    ['a' => false],
+    ['a' => fopen(__FILE__, "r")],
+    ['a' => -5],
+    ['a' => 7.38],
+    ['a' => null, "test"],
+    ['a' => null],
+];
+
+var_dump(array_column($a, null, 'a'));
+
+try {
+    var_dump(array_column([['a' => new stdClass]], null, 'a'));
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump(array_column([['a' => []]], null, 'a'));
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+?>
+--EXPECTF--
+Warning: Resource ID#%d used as offset, casting to integer (%d) in %s on line %d
+
+Deprecated: Implicit conversion from float 7.38 to int loses precision in %s on line %d
+array(8) {
+  [10]=>
+  array(1) {
+    ["a"]=>
+    int(10)
+  }
+  [20]=>
+  array(1) {
+    ["a"]=>
+    int(20)
+  }
+  [1]=>
+  array(1) {
+    ["a"]=>
+    bool(true)
+  }
+  [0]=>
+  array(1) {
+    ["a"]=>
+    bool(false)
+  }
+  [%d]=>
+  array(1) {
+    ["a"]=>
+    resource(%d) of type (stream)
+  }
+  [-5]=>
+  array(1) {
+    ["a"]=>
+    int(-5)
+  }
+  [7]=>
+  array(1) {
+    ["a"]=>
+    float(7.38)
+  }
+  [""]=>
+  array(1) {
+    ["a"]=>
+    NULL
+  }
+}
+Cannot access offset of type stdClass on array
+Cannot access offset of type array on array
diff --git a/tests/std/array/bug69068.phpt b/tests/std/array/bug69068.phpt
new file mode 100644
index 00000000..a069b44b
--- /dev/null
+++ b/tests/std/array/bug69068.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Bug #69068: Exchanging array during array_walk -> memory errors
+--SKIPIF--
+<?php die("skip AOT array_walk array modification differs from PHP"); ?>
+--FILE--
+<?php
+
+$array = [1, 2, 3];
+array_walk($array, function($value, $key) {
+    var_dump($value);
+    if ($value == 2) {
+        $GLOBALS['array'] = [4, 5];
+    }
+});
+var_dump($array);
+
+?>
+--EXPECT--
+int(1)
+int(2)
+int(4)
+int(5)
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
diff --git a/tests/std/array/bug69068_2.phpt b/tests/std/array/bug69068_2.phpt
new file mode 100644
index 00000000..cd744128
--- /dev/null
+++ b/tests/std/array/bug69068_2.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Bug #69068: Exchanging array during array_walk -> memory errors (variation)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference parameters in closures");
+?>
+
+--FILE--
+<?php
+
+$array = [1, 2, 3];
+$array2 = [4, 5];
+array_walk($array, function(&$value, $key) use ($array2) {
+    var_dump($value);
+    if ($value == 2) {
+        $GLOBALS['array'] = $array2;
+    }
+    $value *= 10;
+});
+var_dump($array, $array2);
+
+?>
+--EXPECT--
+int(1)
+int(2)
+int(4)
+int(5)
+array(2) {
+  [0]=>
+  int(40)
+  [1]=>
+  int(50)
+}
+array(2) {
+  [0]=>
+  int(4)
+  [1]=>
+  int(5)
+}
diff --git a/tests/std/array/bug69166.phpt b/tests/std/array/bug69166.phpt
new file mode 100644
index 00000000..d0b5fadd
--- /dev/null
+++ b/tests/std/array/bug69166.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Fixed #69166 (Assigning array_values() to array does not reset key counter)
+--FILE--
+<?php
+
+$array = [0];
+$ar = array_values($array);
+$ar[] = 1;
+var_dump($ar);
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
diff --git a/tests/std/array/bug69198.phpt b/tests/std/array/bug69198.phpt
new file mode 100644
index 00000000..5d4130e7
--- /dev/null
+++ b/tests/std/array/bug69198.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Bug #69198 (Compact function generate array with length but no content)
+--SKIPIF--
+<?php die("skip AOT compact function behavior differs from PHP"); ?>
+--FILE--
+<?php
+if (false) {
+        $willNeverBeDefined = true;
+}
+$result = compact('willNeverBeDefined');
+var_dump($result, empty($result), $result === array(), empty($willNeverBeDefined));
+?>
+--EXPECTF--
+Warning: compact(): Undefined variable $willNeverBeDefined in %s on line %d
+array(0) {
+}
+bool(true)
+bool(true)
+bool(true)
diff --git a/tests/std/array/bug69299.phpt b/tests/std/array/bug69299.phpt
new file mode 100644
index 00000000..77c76166
--- /dev/null
+++ b/tests/std/array/bug69299.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Bug #69299 (Regression in array_filter's $flag argument in PHP 7)
+--FILE--
+<?php
+$toFilter = array('foo' => 'bar', 'fiz' => 'buz');
+$filtered = array_filter($toFilter, function ($value, $key) {
+    if ($value === 'buz'
+        || $key === 'foo'
+    ) {
+        return false;
+    }
+    return true;
+}, ARRAY_FILTER_USE_BOTH);
+var_dump($filtered);
+?>
+--EXPECT--
+array(0) {
+}
diff --git a/tests/std/array/bug69371.phpt b/tests/std/array/bug69371.phpt
new file mode 100644
index 00000000..a4350e66
--- /dev/null
+++ b/tests/std/array/bug69371.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Bug #69371 (Hash table collision leads to inaccessible array keys)
+--SKIPIF--
+--FILE--
+<?php
+$array = array(
+    "d6_node_type" => 1,
+    "d6_filter_format" => 2,
+    "d6_user" => 3,
+    "d6_field_instance_widget_settings" => 4,
+    "d6_field_formatter_settings" => 5,
+);
+
+$weights = array(
+    5, 1, 3, 2, 0
+);
+array_multisort($weights, SORT_DESC, SORT_NUMERIC, $array);
+
+var_dump($array["d6_node_type"]);
+
+?>
+--EXPECT--
+int(1)
diff --git a/tests/std/array/bug69413.phpt b/tests/std/array/bug69413.phpt
new file mode 100644
index 00000000..3a0ab8d0
--- /dev/null
+++ b/tests/std/array/bug69413.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Bug #69413: Warning in array_count_values() about array values not being string/int
+--FILE--
+<?php
+
+$array = ['a', 'b'];
+$ref =& $array[0];
+
+var_dump(array_count_values($array));
+
+?>
+--EXPECT--
+array(2) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  int(1)
+}
diff --git a/tests/std/array/bug69674.phpt b/tests/std/array/bug69674.phpt
new file mode 100644
index 00000000..0d58b6ae
--- /dev/null
+++ b/tests/std/array/bug69674.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Bug #69674 (SIGSEGV array.c:953)
+--FILE--
+<?php
+var_dump(current(array_keys(array())));
+?>
+--EXPECT--
+bool(false)
diff --git a/tests/std/array/bug69723.phpt b/tests/std/array/bug69723.phpt
new file mode 100644
index 00000000..90422a52
--- /dev/null
+++ b/tests/std/array/bug69723.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Bug #69723 (Passing parameters by reference and array_column)
+--FILE--
+<?php
+function byReference(&$array)
+{
+    foreach ($array as &$item) {
+        $item['nanana'] = 'batman';
+        $item['superhero'] = 'robin';
+    }
+}
+function main()
+{
+    $array = [['superhero' => 'superman', 'nanana' => 'no nana'], ['superhero' => 'acuaman', 'nanana' => 'no nana']];
+    var_dump(array_column($array, 'superhero'));
+    byReference($array);
+    var_dump(array_column($array, 'superhero'));
+}
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  string(8) "superman"
+  [1]=>
+  string(7) "acuaman"
+}
+array(2) {
+  [0]=>
+  string(5) "robin"
+  [1]=>
+  string(5) "robin"
+}
diff --git a/tests/std/array/bug70250.phpt b/tests/std/array/bug70250.phpt
new file mode 100644
index 00000000..29e54ea9
--- /dev/null
+++ b/tests/std/array/bug70250.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Bug #70250 (extract() turns array elements to references)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$array = ['key' => 'value'];
+
+$ref = &$array['key'];
+
+unset($ref);
+
+extract($array);
+
+$key = "bad";
+
+var_dump($array);
+?>
+--EXPECT--
+array(1) {
+  ["key"]=>
+  string(5) "value"
+}
diff --git a/tests/std/array/bug70668.phpt b/tests/std/array/bug70668.phpt
new file mode 100644
index 00000000..b35107a0
--- /dev/null
+++ b/tests/std/array/bug70668.phpt
@@ -0,0 +1,63 @@
+--TEST--
+Bug #70668 (array_keys() doesn't respect references when $strict is true)
+--FILE--
+<?php
+$arr = array(1, "1", "", NULL, 0, false, true, array());
+
+$s = &$arr[0];
+var_dump(array_keys($arr, $s, true));
+
+$s = &$arr[1];
+var_dump(array_keys($arr, $s, true));
+
+$s = &$arr[2];
+var_dump(array_keys($arr, $s, true));
+
+$s = &$arr[3];
+var_dump(array_keys($arr, $s, true));
+
+$s = &$arr[4];
+var_dump(array_keys($arr, $s, true));
+
+$s = &$arr[5];
+var_dump(array_keys($arr, $s, true));
+
+$s = &$arr[6];
+var_dump(array_keys($arr, $s, true));
+
+$s = &$arr[7];
+var_dump(array_keys($arr, $s, true));
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  int(0)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+array(1) {
+  [0]=>
+  int(2)
+}
+array(1) {
+  [0]=>
+  int(3)
+}
+array(1) {
+  [0]=>
+  int(4)
+}
+array(1) {
+  [0]=>
+  int(5)
+}
+array(1) {
+  [0]=>
+  int(6)
+}
+array(1) {
+  [0]=>
+  int(7)
+}
diff --git a/tests/std/array/bug70713.phpt b/tests/std/array/bug70713.phpt
new file mode 100644
index 00000000..6a1af9b6
--- /dev/null
+++ b/tests/std/array/bug70713.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Bug #70713: Use After Free Vulnerability in array_walk()/array_walk_recursive()
+--SKIPIF--
+<?php die("skip AOT array_walk_recursive UAF differs from PHP"); ?>
+--FILE--
+<?php
+class obj
+{
+    function __tostring(): string {
+        global $arr;
+        $arr = 1;
+        for ($i = 0; $i < 5; $i++) {
+            $v[$i] = 'hi' . $i;
+        }
+        return 'hi';
+    }
+}
+function main()
+{
+    $arr = array('string' => new obj());
+    try {
+        array_walk_recursive($arr, 'settype');
+    } catch (\TypeError $e) {
+        echo $e->getMessage() . "\n";
+    }
+}
+?>
+--EXPECT--
+Iterated value is no longer an array or object
diff --git a/tests/std/array/bug70808.phpt b/tests/std/array/bug70808.phpt
new file mode 100644
index 00000000..df82da8c
--- /dev/null
+++ b/tests/std/array/bug70808.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Bug #70808 (array_merge_recursive corrupts memory of unset items)
+--FILE--
+<?php
+
+$arr1 = array("key" => array(0, 1));
+$arr2 = array("key" => array(2));
+
+unset($arr1["key"][1]);
+
+$result = array_merge_recursive($arr1, $arr2);
+print_r($result);
+?>
+--EXPECT--
+Array
+(
+    [key] => Array
+        (
+            [0] => 0
+            [2] => 2
+        )
+
+)
diff --git a/tests/std/array/bug70910.phpt b/tests/std/array/bug70910.phpt
new file mode 100644
index 00000000..f4aed175
--- /dev/null
+++ b/tests/std/array/bug70910.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Bug #70910 (extract() breaks variable references)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$var = 'original value';
+$ref =& $var;
+
+$hash = ['var' => 'new value'];
+
+extract($hash);
+var_dump($var === $ref);
+?>
+--EXPECT--
+bool(true)
diff --git a/tests/std/array/bug71220.phpt b/tests/std/array/bug71220.phpt
new file mode 100644
index 00000000..5c5f43ee
--- /dev/null
+++ b/tests/std/array/bug71220.phpt
@@ -0,0 +1,13 @@
+--TEST--
+Bug #71220 (Null pointer deref (segfault) in compact via ob_start)
+--FILE--
+<?php
+ob_start("compact");
+try {
+    ob_end_clean();
+} catch (\Error $e) {
+    echo $e->getMessage();
+}
+?>
+--EXPECT--
+Cannot call compact() dynamically
diff --git a/tests/std/array/bug71334.phpt b/tests/std/array/bug71334.phpt
new file mode 100644
index 00000000..31b720a5
--- /dev/null
+++ b/tests/std/array/bug71334.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Bug #71334: Cannot access array keys while uksort()
+--SKIPIF--
+--FILE--
+<?php
+class myClass
+{
+    private $a = ['foo-test' => [1], '-' => [2], 'bar-test' => [3]];
+    public function _mySort($x, $y)
+    {
+        if (!isset($this->a[$x])) {
+            throw new Exception('Missing X: "' . $x . '"');
+        }
+        if (!isset($this->a[$y])) {
+            throw new Exception('Missing Y: "' . $y . '"');
+        }
+        return $x <=> $y;
+    }
+    public function __construct()
+    {
+        uksort($this->a, [$this, '_mySort']);
+    }
+}
+function main()
+{
+    new myClass();
+    echo "Done";
+}
+?>
+--EXPECT--
+Done
diff --git a/tests/std/array/bug71603.phpt b/tests/std/array/bug71603.phpt
new file mode 100644
index 00000000..099c1b97
--- /dev/null
+++ b/tests/std/array/bug71603.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Bug #71603 (compact() maintains references in php7)
+--FILE--
+<?php
+$foo = "okey";
+$foo_reference =& $foo;
+
+$array = compact('foo_reference');
+
+$foo = 'changed!';
+
+var_dump($array['foo_reference']);
+?>
+--EXPECT--
+string(4) "okey"
diff --git a/tests/std/array/bug71660.phpt b/tests/std/array/bug71660.phpt
new file mode 100644
index 00000000..067f5333
--- /dev/null
+++ b/tests/std/array/bug71660.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Bug #71660 (array_column behaves incorrectly after foreach by reference)
+--FILE--
+<?php
+$arr = array('id' => 12345, 'name' => 'sam');
+foreach ($arr as &$v) {
+        $v = $v;
+}
+
+$arr = [$arr];
+
+var_dump(array_column($arr, 'name', 'id'));
+?>
+--EXPECT--
+array(1) {
+  [12345]=>
+  string(3) "sam"
+}
diff --git a/tests/std/array/bug71837.phpt b/tests/std/array/bug71837.phpt
new file mode 100644
index 00000000..686d144c
--- /dev/null
+++ b/tests/std/array/bug71837.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Bug #71837 (Wrong arrays behaviour)
+--FILE--
+<?php
+
+$p = array(array());
+array_push($p[0], array(100));
+
+$c = array_merge($p, array());
+$c[0][0] = 200;
+
+print_r($p);
+
+?>
+--EXPECT--
+Array
+(
+    [0] => Array
+        (
+            [0] => Array
+                (
+                    [0] => 100
+                )
+
+        )
+
+)
diff --git a/tests/std/array/bug72031.phpt b/tests/std/array/bug72031.phpt
new file mode 100644
index 00000000..00c3eac3
--- /dev/null
+++ b/tests/std/array/bug72031.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Bug #72031: array_column() against an array of objects discards all values matching null
+--FILE--
+<?php
+class myObj
+{
+    public $prop;
+    public function __construct($prop)
+    {
+        $this->prop = $prop;
+    }
+}
+function main()
+{
+    $objects = [new myObj(-1), new myObj(0), new myObj(1), new myObj(2), new myObj(null), new myObj(true), new myObj(false), new myObj('abc'), new myObj('')];
+    var_dump(array_column($objects, 'prop'));
+}
+?>
+--EXPECT--
+array(9) {
+  [0]=>
+  int(-1)
+  [1]=>
+  int(0)
+  [2]=>
+  int(1)
+  [3]=>
+  int(2)
+  [4]=>
+  NULL
+  [5]=>
+  bool(true)
+  [6]=>
+  bool(false)
+  [7]=>
+  string(3) "abc"
+  [8]=>
+  string(0) ""
+}
diff --git a/tests/std/array/bug72116.phpt b/tests/std/array/bug72116.phpt
new file mode 100644
index 00000000..182f6994
--- /dev/null
+++ b/tests/std/array/bug72116.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Bug #72116 (insertion after array_fill fails)
+--FILE--
+<?php
+
+$x = array_fill(0, 1, '..');
+$x[] = 'a';
+var_dump($x);
+
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  string(2) ".."
+  [1]=>
+  string(1) "a"
+}
diff --git a/tests/std/array/bug72369.phpt b/tests/std/array/bug72369.phpt
new file mode 100644
index 00000000..e20b410d
--- /dev/null
+++ b/tests/std/array/bug72369.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Bug #72369 (array_merge() produces references in PHP7)
+--SKIPIF--
+<?php die("skip AOT array_merge reference handling differs from PHP"); ?>
+--FILE--
+<?php
+$x = 'xxx';
+$d = ['test' => &$x];
+unset($x);
+$a = ['test' => 'yyy'];
+$a = array_merge($a, $d);
+debug_zval_dump($a);
+?>
+--EXPECTF--
+array(1) refcount(%d){
+  ["test"]=>
+  string(3) "xxx" interned
+}
diff --git a/tests/std/array/bug72622.phpt b/tests/std/array/bug72622.phpt
new file mode 100644
index 00000000..78813e8d
--- /dev/null
+++ b/tests/std/array/bug72622.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Bug #72622 (array_walk + array_replace_recursive create references from nothing)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference parameters in closures");
+?>
+
+--FILE--
+<?php
+function walk(array $arr)
+{
+    array_walk($arr, function (&$val, $name) {
+    });
+    return $arr;
+}
+function main()
+{
+    $arr3 = ['foo' => 'foo'];
+    $arr4 = walk(['foo' => 'bar']);
+    $arr5 = array_replace_recursive($arr3, $arr4);
+    $arr5['foo'] = 'baz';
+    var_dump($arr3, $arr4, $arr5);
+}
+?>
+--EXPECT--
+array(1) {
+  ["foo"]=>
+  string(3) "foo"
+}
+array(1) {
+  ["foo"]=>
+  string(3) "bar"
+}
+array(1) {
+  ["foo"]=>
+  string(3) "baz"
+}
diff --git a/tests/std/array/bug74345.phpt b/tests/std/array/bug74345.phpt
new file mode 100644
index 00000000..afa08886
--- /dev/null
+++ b/tests/std/array/bug74345.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Bug #74345: Call trampoline leaked if callback not invoked
+--SKIPIF--
+--FILE--
+<?php
+
+class Test {
+    public function __call($name, $args) {
+        echo "__call()\n";
+    }
+}
+
+function main() {
+    $name = "foo" . ($x = "bar");
+    $cb = [new Test, $name];
+    array_map($cb, []);
+    array_map($cb, [], []);
+    try {
+        array_map($cb, null);
+    } catch (Error $e) {
+        echo $e->getMessage(), "\n";
+    }
+    try {
+        array_map($cb, null, null);
+    } catch (Error $e) {
+        echo $e->getMessage(), "\n";
+    }
+    array_filter([], $cb);
+    array_reduce([], $cb);
+
+    $array = [];
+    array_walk($array, $cb);
+    array_walk_recursive($array, $cb);
+    usort($array, $cb);
+
+    try {
+        preg_replace_callback('/./', $cb, new stdClass);
+    } catch (Error $e) {
+        echo $e->getMessage(), "\n";
+    }
+
+    echo "===DONE===\n";
+}
+?>
+--EXPECT--
+array_map(): Argument #2 ($array) must be of type array, null given
+array_map(): Argument #2 ($array) must be of type array, null given
+preg_replace_callback(): Argument #3 ($subject) must be of type array|string, stdClass given
+===DONE===
diff --git a/tests/std/array/bug74361.phpt b/tests/std/array/bug74361.phpt
new file mode 100644
index 00000000..6e745902
--- /dev/null
+++ b/tests/std/array/bug74361.phpt
@@ -0,0 +1,11 @@
+--TEST--
+Bug #74361: Compaction in array_rand() violates COW
+--FILE--
+<?php
+
+$array = [4 => 4];
+var_dump(array_rand($array));
+
+?>
+--EXPECT--
+int(4)
diff --git a/tests/std/array/bug74361_2.phpt b/tests/std/array/bug74361_2.phpt
new file mode 100644
index 00000000..4f4bdcf5
--- /dev/null
+++ b/tests/std/array/bug74361_2.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Bug #74361: Compaction in array_rand() violates COW (variation)
+--FILE--
+<?php
+
+$array = range(0, 15);
+for ($i = 0; $i <= 8; $i++) {
+    unset($array[$i]);
+}
+
+foreach ($array as $x) {
+    var_dump($x);
+    array_rand($array, 1);
+}
+
+?>
+--EXPECT--
+int(9)
+int(10)
+int(11)
+int(12)
+int(13)
+int(14)
+int(15)
diff --git a/tests/std/array/bug75433.phpt b/tests/std/array/bug75433.phpt
new file mode 100644
index 00000000..caf4816a
--- /dev/null
+++ b/tests/std/array/bug75433.phpt
@@ -0,0 +1,18 @@
+--TEST--
+array_values() preserves next index from source array when shallow-copying
+--FILE--
+<?php
+
+$a = [1,2,3];
+unset($a[2]);
+$b = array_values($a);
+$b[] = 4;
+print_r($b);
+?>
+--EXPECT--
+Array
+(
+    [0] => 1
+    [1] => 2
+    [2] => 4
+)
diff --git a/tests/std/array/bug75653.phpt b/tests/std/array/bug75653.phpt
new file mode 100644
index 00000000..d11c1e0c
--- /dev/null
+++ b/tests/std/array/bug75653.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Bug #75653: array_values don't work on empty array
+--FILE--
+<?php
+
+$array[] = 'data1';
+unset($array[0]);
+$array = array_values($array);
+$array[] = 'data2';
+$array[] = 'data3';
+var_dump($array);
+
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  string(5) "data2"
+  [1]=>
+  string(5) "data3"
+}
diff --git a/tests/std/array/bug76505.phpt b/tests/std/array/bug76505.phpt
new file mode 100644
index 00000000..ad0b2c86
--- /dev/null
+++ b/tests/std/array/bug76505.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Bug #76505 (array_merge_recursive() is duplicating sub-array keys)
+--FILE--
+<?php
+$array1 = array(
+    'k' => array(
+        2 => 100,
+        98 => 200,
+    )
+);
+
+$array2 = array(
+    'k' => array(
+        64 => 300
+    )
+);
+
+$array3 = array_merge_recursive( $array1, $array2 );
+
+var_dump($array3);
+?>
+--EXPECT--
+array(1) {
+  ["k"]=>
+  array(3) {
+    [2]=>
+    int(100)
+    [98]=>
+    int(200)
+    [99]=>
+    int(300)
+  }
+}
diff --git a/tests/std/array/bug76713.phpt b/tests/std/array/bug76713.phpt
new file mode 100644
index 00000000..9daae219
--- /dev/null
+++ b/tests/std/array/bug76713.phpt
@@ -0,0 +1,35 @@
+--TEST--
+Bug #76713 (Segmentation fault caused by property corruption)
+--FILE--
+<?php
+function test($obj)
+{
+    return array_column(array($obj), "prop");
+}
+class C
+{
+    public $name;
+    public function __get($name)
+    {
+        return $this->name;
+    }
+}
+function main()
+{
+    $obj = new Stdclass();
+    $obj->prop = str_pad("a", 10, 'a');
+    test($obj);
+    test($obj);
+    test($obj);
+    var_dump($obj->prop);
+    $obj2 = new C();
+    $obj2->name = str_pad("b", 10, 'b');
+    test($obj2);
+    test($obj2);
+    test($obj2);
+    var_dump($obj2->prop);
+}
+?>
+--EXPECT--
+string(10) "aaaaaaaaaa"
+string(10) "bbbbbbbbbb"
diff --git a/tests/std/array/bug76778.phpt b/tests/std/array/bug76778.phpt
new file mode 100644
index 00000000..e07b6f35
--- /dev/null
+++ b/tests/std/array/bug76778.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Bug #76778 (array_reduce leaks memory if callback throws exception)
+--SKIPIF--
+<?php die("skip memory leak detection in test environment adds output"); ?>
+--FILE--
+<?php
+try {
+    array_reduce(
+        [1],
+        function ($carry, $item) {
+            throw new Exception;
+        },
+        range(1, 3)
+    );
+} catch (Exception $e) {
+}
+echo "===DONE===\n";
+?>
+--EXPECT--
+===DONE===
diff --git a/tests/std/array/bug77135.phpt b/tests/std/array/bug77135.phpt
new file mode 100644
index 00000000..c524ba7a
--- /dev/null
+++ b/tests/std/array/bug77135.phpt
@@ -0,0 +1,91 @@
+--TEST--
+Test extract() with $this
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+class Extract
+{
+    public function run(): void
+    {
+        $options = ['EXTR_OVERWRITE' => EXTR_OVERWRITE, 'EXTR_SKIP' => EXTR_SKIP, 'EXTR_PREFIX_SAME' => EXTR_PREFIX_SAME, 'EXTR_PREFIX_ALL' => EXTR_PREFIX_ALL, 'EXTR_PREFIX_INVALID' => EXTR_PREFIX_INVALID, 'EXTR_IF_EXISTS' => EXTR_IF_EXISTS, 'EXTR_PREFIX_IF_EXISTS' => EXTR_PREFIX_IF_EXISTS];
+        foreach ($options as $name => $flags) {
+            echo "{$name}\n";
+            $this->handle($name, $flags);
+            $this->handle("{$name}_REFS", $flags | EXTR_REFS);
+            echo "\n";
+        }
+    }
+    private function handle(string $name, int $flags): void
+    {
+        $array = ["this" => "value"];
+        try {
+            $result = extract($array, $flags, "x");
+            echo "  extract() = {$result}\n";
+            echo "  \$this = " . get_class($this) . "\n";
+            echo "  \$v_this = " . (isset($x_this) ? $x_this : "NULL") . "\n";
+        } catch (\Throwable $e) {
+            echo "  Exception: " . $e->getMessage() . "\n";
+        }
+    }
+}
+function main()
+{
+    (new Extract())->run();
+}
+?>
+--EXPECT--
+EXTR_OVERWRITE
+  Exception: Cannot re-assign $this
+  Exception: Cannot re-assign $this
+
+EXTR_SKIP
+  extract() = 0
+  $this = Extract
+  $v_this = NULL
+  extract() = 0
+  $this = Extract
+  $v_this = NULL
+
+EXTR_PREFIX_SAME
+  extract() = 1
+  $this = Extract
+  $v_this = value
+  extract() = 1
+  $this = Extract
+  $v_this = value
+
+EXTR_PREFIX_ALL
+  extract() = 1
+  $this = Extract
+  $v_this = value
+  extract() = 1
+  $this = Extract
+  $v_this = value
+
+EXTR_PREFIX_INVALID
+  extract() = 1
+  $this = Extract
+  $v_this = value
+  extract() = 1
+  $this = Extract
+  $v_this = value
+
+EXTR_IF_EXISTS
+  extract() = 0
+  $this = Extract
+  $v_this = NULL
+  extract() = 0
+  $this = Extract
+  $v_this = NULL
+
+EXTR_PREFIX_IF_EXISTS
+  extract() = 0
+  $this = Extract
+  $v_this = NULL
+  extract() = 0
+  $this = Extract
+  $v_this = NULL
diff --git a/tests/std/array/bug77395.phpt b/tests/std/array/bug77395.phpt
new file mode 100644
index 00000000..817b36f8
--- /dev/null
+++ b/tests/std/array/bug77395.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Bug #77395 (segfault about array_multisort)
+--SKIPIF--
+--FILE--
+<?php
+function error_handle($level, $message, $file = '', $line = 0)
+{
+    $a = [1, 2, 3];
+    $b = [3, 2, 1];
+    echo $message;
+    array_multisort($a, SORT_ASC, $b);
+    // if comment this line, no segfault happen
+}
+function main()
+{
+    set_error_handler('error_handle');
+    $data = [['aa' => 'bb'], ['aa' => 'bb']];
+    try {
+        array_multisort(array_column($data, 'bb'), SORT_DESC, $data);
+        // PHP Warning error
+    } catch (\ValueError $e) {
+        echo $e->getMessage() . "\n";
+    }
+}
+?>
+--EXPECT--
+Array sizes are inconsistent
diff --git a/tests/std/array/bug77669.phpt b/tests/std/array/bug77669.phpt
new file mode 100644
index 00000000..c267d2b5
--- /dev/null
+++ b/tests/std/array/bug77669.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Bug #77669: Crash in extract() when overwriting extracted array
+--SKIPIF--
+<?php die("skip extract() not supported by AOT"); ?>
+--FILE--
+<?php
+
+function test($mode) {
+    $foo = [];
+    $foo["foo"] = 42;
+    $foo["bar"] = 24;
+    extract($foo, $mode, "");
+    $prefix_foo = [];
+    $prefix_foo["foo"] = 42;
+    $prefix_foo["bar"] = 24;
+    extract($prefix_foo, $mode, "prefix");
+}
+
+function main() {
+    test(EXTR_OVERWRITE);
+    test(EXTR_SKIP);
+    test(EXTR_IF_EXISTS);
+    test(EXTR_PREFIX_SAME);
+    test(EXTR_PREFIX_ALL);
+    test(EXTR_PREFIX_INVALID);
+    test(EXTR_PREFIX_IF_EXISTS);
+    test(EXTR_REFS | EXTR_OVERWRITE);
+    test(EXTR_REFS | EXTR_SKIP);
+    test(EXTR_REFS | EXTR_IF_EXISTS);
+    test(EXTR_REFS | EXTR_PREFIX_SAME);
+    test(EXTR_REFS | EXTR_PREFIX_ALL);
+    test(EXTR_REFS | EXTR_PREFIX_INVALID);
+    test(EXTR_REFS | EXTR_PREFIX_IF_EXISTS);
+
+    echo "===DONE===\n";
+}
+?>
+--EXPECT--
+===DONE===
diff --git a/tests/std/array/bug77793.phpt b/tests/std/array/bug77793.phpt
new file mode 100644
index 00000000..bf5caa44
--- /dev/null
+++ b/tests/std/array/bug77793.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Bug #77793: Segmentation fault in extract() when overwriting reference with itself
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+$str = 'foo';
+$vars = ['var' => $str . 'bar'];
+$var = &$vars['var'];
+extract($vars);
+var_dump($vars, $var);
+
+?>
+--EXPECT--
+array(1) {
+  ["var"]=>
+  &string(6) "foobar"
+}
+string(6) "foobar"
diff --git a/tests/std/array/bug77931.phpt b/tests/std/array/bug77931.phpt
new file mode 100644
index 00000000..d876d4b0
--- /dev/null
+++ b/tests/std/array/bug77931.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Bug #77931: Warning for array_map mentions wrong type
+--FILE--
+<?php
+
+try {
+    array_map('trim', array(), 1);
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    array_map('trim', array(), array(), true);
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    array_map('trim', array(), array(), array(), null);
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+array_map(): Argument #3 must be of type array, int given
+array_map(): Argument #4 must be of type array, true given
+array_map(): Argument #5 must be of type array, null given
diff --git a/tests/std/array/bug78759.phpt b/tests/std/array/bug78759.phpt
new file mode 100644
index 00000000..4ab6414d
--- /dev/null
+++ b/tests/std/array/bug78759.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Bug #78759: array_search in $GLOBALS
+--SKIPIF--
+<?php
+if (true) die("skip AOT has a known issue with this test pattern");
+?>
+
+--FILE--
+<?php
+
+$a = 22;
+var_dump($GLOBALS["a"]);
+var_dump(array_search(22, $GLOBALS));
+var_dump(array_search(22, $GLOBALS, true));
+
+?>
+--EXPECT--
+int(22)
+string(1) "a"
+string(1) "a"
diff --git a/tests/std/array/bug79839.phpt b/tests/std/array/bug79839.phpt
new file mode 100644
index 00000000..8cd49751
--- /dev/null
+++ b/tests/std/array/bug79839.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Bug #79839: array_walk() does not respect property types
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference parameters in closures");
+?>
+
+--FILE--
+<?php
+class Test
+{
+    public int $prop = 42;
+}
+function main()
+{
+    $test = new Test();
+    try {
+        array_walk($test, function (&$ref) {
+            $ref = [];
+            // Should throw
+        });
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    var_dump($test);
+}
+?>
+--EXPECT--
+Cannot assign array to reference held by property Test::$prop of type int
+object(Test)#1 (1) {
+  ["prop"]=>
+  int(42)
+}
diff --git a/tests/std/array/bug79868.phpt b/tests/std/array/bug79868.phpt
new file mode 100644
index 00000000..5c6267d6
--- /dev/null
+++ b/tests/std/array/bug79868.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Bug #79868: Sorting with array_unique gives unwanted result
+--FILE--
+<?php
+
+var_dump(array_unique(['b', 'a', 'b'], SORT_REGULAR));
+
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  string(1) "b"
+  [1]=>
+  string(1) "a"
+}
diff --git a/tests/std/array/bug79930.phpt b/tests/std/array/bug79930.phpt
new file mode 100644
index 00000000..bb4e1dd8
--- /dev/null
+++ b/tests/std/array/bug79930.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Bug #79930: array_merge_recursive() crashes when called with array with single reference
+--FILE--
+<?php
+
+$a = 'a';
+$array = [
+    'value' => $a . 'b',
+];
+
+// Create rc=1 reference.
+array_walk($array, function () {});
+
+$m = array_merge_recursive(['value' => 'a'], $array);
+
+var_dump($a, $array, $m);
+
+?>
+--EXPECT--
+string(1) "a"
+array(1) {
+  ["value"]=>
+  string(2) "ab"
+}
+array(1) {
+  ["value"]=>
+  array(2) {
+    [0]=>
+    string(1) "a"
+    [1]=>
+    string(2) "ab"
+  }
+}
diff --git a/tests/std/array/compact.phpt b/tests/std/array/compact.phpt
new file mode 100644
index 00000000..c10c7dd1
--- /dev/null
+++ b/tests/std/array/compact.phpt
@@ -0,0 +1,42 @@
+--TEST--
+compact()
+--SKIPIF--
+<?php
+if (true) die("skip AOT requires literal string arguments for compact()");
+?>
+
+--FILE--
+<?php
+
+$çity  = "San Francisco";
+$state = "CA";
+$event = "SIGGRAPH";
+
+$location_vars = array("c\\u0327ity", "state");
+
+$result = compact("event", $location_vars);
+var_dump($result);
+
+$result = compact(true);
+$foo = 'bar';
+$bar = 'baz';
+$result = compact($foo, [42]);
+var_dump($result);
+
+?>
+--EXPECTF--
+Warning: compact(): Undefined variable $c\u0327ity in %s on line %d
+array(2) {
+  ["event"]=>
+  string(8) "SIGGRAPH"
+  ["state"]=>
+  string(2) "CA"
+}
+
+Warning: compact(): Argument #1 must be string or array of strings, true given in %s on line %d
+
+Warning: compact(): Argument #2 must be string or array of strings, int given in %s on line %d
+array(1) {
+  ["bar"]=>
+  string(3) "baz"
+}
diff --git a/tests/std/array/compact_basic.phpt b/tests/std/array/compact_basic.phpt
new file mode 100644
index 00000000..42f1ccce
--- /dev/null
+++ b/tests/std/array/compact_basic.phpt
@@ -0,0 +1,78 @@
+--TEST--
+Test compact() function : basic functionality
+--SKIPIF--
+<?php
+if (true) die("skip AOT requires literal string arguments for compact()");
+?>
+
+--FILE--
+<?php
+/*
+ * Test basic functionality
+ */
+
+echo "*** Testing compact() : basic functionality ***\n";
+
+$a=1;
+$b=0.2;
+$c=true;
+$d=array("key"=>"val");
+$e=NULL;
+$f="string";
+
+// simple array test
+var_dump (compact(array("a", "b", "c", "d", "e", "f")));
+// simple parameter test
+var_dump (compact("a", "b", "c", "d", "e", "f"));
+var_dump (compact(array("keyval"=>"a", "b"=>"b")));
+var_dump(compact(array("g")));
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing compact() : basic functionality ***
+array(6) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  float(0.2)
+  ["c"]=>
+  bool(true)
+  ["d"]=>
+  array(1) {
+    ["key"]=>
+    string(3) "val"
+  }
+  ["e"]=>
+  NULL
+  ["f"]=>
+  string(6) "string"
+}
+array(6) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  float(0.2)
+  ["c"]=>
+  bool(true)
+  ["d"]=>
+  array(1) {
+    ["key"]=>
+    string(3) "val"
+  }
+  ["e"]=>
+  NULL
+  ["f"]=>
+  string(6) "string"
+}
+array(2) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  float(0.2)
+}
+
+Warning: compact(): Undefined variable $g in %s on line %d
+array(0) {
+}
+Done
diff --git a/tests/std/array/compact_no_this.phpt b/tests/std/array/compact_no_this.phpt
new file mode 100644
index 00000000..aa60e846
--- /dev/null
+++ b/tests/std/array/compact_no_this.phpt
@@ -0,0 +1,27 @@
+--TEST--
+compact() without object context
+--SKIPIF--
+<?php die("skip AOT compiler rejects compact('this') outside class method"); ?>
+--FILE--
+<?php
+
+var_dump(
+    (new class {
+        function test(){
+            return (static function(){ return compact('this'); })();
+        }
+    })->test()
+);
+
+var_dump(compact('this'));
+
+var_dump((function(){ return compact('this'); })());
+
+?>
+--EXPECT--
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
diff --git a/tests/std/array/compact_order.phpt b/tests/std/array/compact_order.phpt
new file mode 100644
index 00000000..bf6051cc
--- /dev/null
+++ b/tests/std/array/compact_order.phpt
@@ -0,0 +1,25 @@
+--TEST--
+compact() and hashmap order
+--FILE--
+<?php
+
+$foo = null;
+$bar = null;
+
+var_dump(compact('foo', 'bar'));
+var_dump(compact('bar', 'foo'));
+
+?>
+--EXPECT--
+array(2) {
+  ["foo"]=>
+  NULL
+  ["bar"]=>
+  NULL
+}
+array(2) {
+  ["bar"]=>
+  NULL
+  ["foo"]=>
+  NULL
+}
diff --git a/tests/std/array/compact_this.phpt b/tests/std/array/compact_this.phpt
new file mode 100644
index 00000000..20657e90
--- /dev/null
+++ b/tests/std/array/compact_this.phpt
@@ -0,0 +1,46 @@
+--TEST--
+compact() with object context
+--FILE--
+<?php
+
+var_dump(
+    (new class {
+        function test(){
+            return compact('this');
+        }
+    })->test()
+);
+
+var_dump(
+    (new class {
+        function test(){
+            return compact([['this']]);
+        }
+    })->test()
+);
+
+var_dump(
+    (new class {
+        function test(){
+            return (function(){ return compact('this'); })();
+        }
+    })->test()
+);
+
+?>
+--EXPECTF--
+array(1) {
+  ["this"]=>
+  object(%s)#1 (0) {
+  }
+}
+array(1) {
+  ["this"]=>
+  object(%s)#1 (0) {
+  }
+}
+array(1) {
+  ["this"]=>
+  object(%s)#1 (0) {
+  }
+}
diff --git a/tests/std/array/compact_variation1.phpt b/tests/std/array/compact_variation1.phpt
new file mode 100644
index 00000000..f07ccd93
--- /dev/null
+++ b/tests/std/array/compact_variation1.phpt
@@ -0,0 +1,46 @@
+--TEST--
+Test compact() function : usage variations  - arrays containing references.
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support dynamic array access");
+?>
+
+--FILE--
+<?php
+/*
+* compact variations - arrays with references
+*/
+echo "*** Testing compact() : usage variations  - arrays containing references ***\n";
+$a = 1;
+$b = 2;
+$c = 3;
+$string = "c";
+$arr1 = array("a", &$arr1);
+$arr2 = array("a", array(array(array("b"))));
+$arr2[1][0][0][] = &$arr2;
+$arr2[1][0][0][] = &$arr2[1];
+$arr3 = array(&$string);
+
+try {
+    var_dump(compact($arr1));
+} catch (Error $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(compact($arr2));
+} catch (Error $e) {
+    echo $e->getMessage() . "\n";
+}
+
+var_dump(compact($arr3));
+
+?>
+--EXPECT--
+*** Testing compact() : usage variations  - arrays containing references ***
+Recursion detected
+Recursion detected
+array(1) {
+  ["c"]=>
+  int(3)
+}
diff --git a/tests/std/array/compact_variation2.phpt b/tests/std/array/compact_variation2.phpt
new file mode 100644
index 00000000..48d772fc
--- /dev/null
+++ b/tests/std/array/compact_variation2.phpt
@@ -0,0 +1,42 @@
+--TEST--
+Test compact() function: ensure compact() doesn't pick up variables declared outside of current scope.
+--SKIPIF--
+<?php
+if (true) die("skip AOT has a known issue with this test pattern");
+?>
+
+--FILE--
+<?php
+function f()
+{
+    $b = 'f.b';
+    $c = 'f.c';
+    var_dump(compact('a', 'b', 'c'));
+    var_dump(compact(array('a', 'b', 'c')));
+}
+function main()
+{
+    echo "*** Testing compact() : usage variations  - variables outside of current scope ***\n";
+    $a = 'main.a';
+    $b = 'main.b';
+    f();
+}
+?>
+--EXPECTF--
+*** Testing compact() : usage variations  - variables outside of current scope ***
+
+Warning: compact(): Undefined variable $a in %s on line %d
+array(2) {
+  ["b"]=>
+  string(3) "f.b"
+  ["c"]=>
+  string(3) "f.c"
+}
+
+Warning: compact(): Undefined variable $a in %s on line %d
+array(2) {
+  ["b"]=>
+  string(3) "f.b"
+  ["c"]=>
+  string(3) "f.c"
+}
diff --git a/tests/std/array/compare_function.inc b/tests/std/array/compare_function.inc
new file mode 100644
index 00000000..4fa672e7
--- /dev/null
+++ b/tests/std/array/compare_function.inc
@@ -0,0 +1,13 @@
+<?php
+
+function compare_function($var1, $var2) {
+  if ($var1 == $var2) {
+    return 0;
+  } else if ($var1 < $var2) {
+    return -1;
+  } else {
+    return 1;
+  }
+}
+
+?>
diff --git a/tests/std/array/count_basic.phpt b/tests/std/array/count_basic.phpt
new file mode 100644
index 00000000..6d778b4b
--- /dev/null
+++ b/tests/std/array/count_basic.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Test count() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of count() using an array as $var argument
+ * and different values as $mode argument.
+ */
+
+echo "*** Testing count() : basic functionality ***\n";
+
+echo "\n-- One Dimensional Array: --\n";
+$array = array('zero', 'one', 'two');
+var_dump(count($array));
+
+echo "\n-- Two Dimensional Array: --\n";
+$array_multi = array('zero', array(1, 2, 3), 'two');
+echo "\$mode = COUNT_NORMAL:    ";
+var_dump(count($array_multi, COUNT_NORMAL));
+echo "\$mode = 0:               ";
+var_dump(count($array_multi, 0));
+echo "\$mode = COUNT_RECURSIVE: ";
+var_dump(count($array_multi, COUNT_RECURSIVE));
+echo "\$mode = 1:               ";
+var_dump(count($array_multi, 1));
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing count() : basic functionality ***
+
+-- One Dimensional Array: --
+int(3)
+
+-- Two Dimensional Array: --
+$mode = COUNT_NORMAL:    int(3)
+$mode = 0:               int(3)
+$mode = COUNT_RECURSIVE: int(6)
+$mode = 1:               int(6)
+Done
diff --git a/tests/std/array/count_invalid.phpt b/tests/std/array/count_invalid.phpt
new file mode 100644
index 00000000..061ed5fa
--- /dev/null
+++ b/tests/std/array/count_invalid.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Only arrays and countable objects can be counted
+--SKIPIF--
+--FILE--
+<?php
+
+try {
+    $result = count(null);
+    var_dump($result);
+} catch (\TypeError $e) {
+    echo $e->getMessage() . \PHP_EOL;
+}
+
+try {
+    $result = count("string");
+    var_dump($result);
+} catch (\TypeError $e) {
+    echo $e->getMessage() . \PHP_EOL;
+}
+
+try {
+    $result = count(123);
+    var_dump($result);
+} catch (\TypeError $e) {
+    echo $e->getMessage() . \PHP_EOL;
+}
+
+try {
+    $result = count(true);
+    var_dump($result);
+} catch (\TypeError $e) {
+    echo $e->getMessage() . \PHP_EOL;
+}
+
+try {
+    $result = count(false);
+    var_dump($result);
+} catch (\TypeError $e) {
+    echo $e->getMessage() . \PHP_EOL;
+}
+
+try {
+    $result = count((object) []);
+    var_dump($result);
+} catch (\TypeError $e) {
+    echo $e->getMessage() . \PHP_EOL;
+}
+
+?>
+--EXPECT--
+count(): Argument #1 ($value) must be of type Countable|array
+count(): Argument #1 ($value) must be of type Countable|array
+count(): Argument #1 ($value) must be of type Countable|array
+count(): Argument #1 ($value) must be of type Countable|array
+count(): Argument #1 ($value) must be of type Countable|array
+int(1)
diff --git a/tests/std/array/count_invalid_mode.phpt b/tests/std/array/count_invalid_mode.phpt
new file mode 100644
index 00000000..ef4b2655
--- /dev/null
+++ b/tests/std/array/count_invalid_mode.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Test count() function : invalid modes in weak type mode
+--SKIPIF--
+--FILE--
+<?php
+
+$modes = [
+    COUNT_NORMAL,
+    COUNT_RECURSIVE,
+    0,
+    1,
+    -1,
+    2,
+    TRUE,
+    FALSE,
+];
+
+foreach ($modes as $mode) {
+    try {
+        var_dump(count([], $mode));
+    } catch (\ValueError $error) {
+        echo $error->getMessage() . \PHP_EOL;
+    }
+}
+?>
+--EXPECT--
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
diff --git a/tests/std/array/count_recursive.phpt b/tests/std/array/count_recursive.phpt
new file mode 100644
index 00000000..e85c08a5
--- /dev/null
+++ b/tests/std/array/count_recursive.phpt
@@ -0,0 +1,131 @@
+--TEST--
+Test count() function
+--SKIPIF--
+<?php die("skip AOT count recursive differs from PHP"); ?>
+--FILE--
+<?php
+class count_class implements Countable
+{
+    private $var_private;
+    public $var_public;
+    protected $var_protected;
+    public function count(): int
+    {
+        return 3;
+    }
+}
+function main()
+{
+    echo "*** Testing basic functionality of count() function ***\n";
+    print "-- Testing arrays --\n";
+    $arr = array(1, array(3, 4, array(6, array(8))));
+    print "COUNT_NORMAL: should be 2, is " . count($arr, COUNT_NORMAL) . "\n";
+    print "COUNT_RECURSIVE: should be 8, is " . count($arr, COUNT_RECURSIVE) . "\n";
+    print "-- Testing hashes --\n";
+    $arr = array("a" => 1, "b" => 2, array("c" => 3, array("d" => 5)));
+    print "COUNT_NORMAL: should be 3, is " . count($arr, COUNT_NORMAL) . "\n";
+    print "COUNT_RECURSIVE: should be 6, is " . count($arr, COUNT_RECURSIVE) . "\n";
+    print "-- Testing various types with no second argument --\n";
+    print "COUNT_NORMAL: should be 2, is " . count(array("a", array("b"))) . "\n";
+    $arr = array('a' => array(NULL, NULL, NULL), 1 => array(NULL => 1, 1 => NULL), array(array(array(array(array(NULL))))));
+    print "-- Testing really cool arrays --\n";
+    print "COUNT_NORMAL: should be 3, is " . count($arr, COUNT_NORMAL) . "\n";
+    print "COUNT_RECURSIVE: should be 13, is " . count($arr, COUNT_RECURSIVE) . "\n";
+    echo "\n*** Testing possible variations of count() function on arrays ***";
+    $count_array = array(array(), array(1 => "string"), array("" => "string", 0 => "a", NULL => "b", -1 => "c", array(array(array(NULL)))), array(-2 => 12, array(array(1, 2, array(array("0"))))), array("a" => 1, "b" => -2.344, "b" => "string", "c" => NULL, "d" => -2.344), array(4 => 1, 3 => -2.344, "3" => "string", "2" => NULL, 1 => -2.344, array()), array(TRUE => TRUE, FALSE => FALSE, "" => "", " " => " ", NULL => NULL, "\x000" => "\x000", "\x00" => "\x00"), array(NULL, 1 => "Hi", "string" => "hello", array("" => "World", "-2.34" => "a", "0" => "b")));
+    $i = 0;
+    foreach ($count_array as $count_value) {
+        echo "\n-- Iteration {$i} --\n";
+        print "COUNT_NORMAL is " . count($count_value, COUNT_NORMAL) . "\n";
+        print "COUNT_RECURSIVE is " . count($count_value, COUNT_RECURSIVE) . "\n";
+        $i++;
+    }
+    print "\n-- Testing count() on an empty sub-array --\n";
+    $arr = array(1, array(3, 4, array()));
+    print "COUNT_NORMAL: should be 2, is " . count($arr, COUNT_NORMAL) . "\n";
+    print "COUNT_RECURSIVE: should be 5, is " . count($arr, COUNT_RECURSIVE) . "\n";
+    echo "\n-- Testing count() on objects with Countable interface --\n";
+    $obj = new count_class();
+    print "COUNT_NORMAL: should be 3, is " . count($obj) . "\n";
+    echo "\n-- Testing count() on resource type --\n";
+    $resource1 = fopen(__FILE__, "r");
+    // Creating file(stream type) resource
+    $resource2 = opendir(".");
+    // Creating dir resource
+    /* creating an array with resources as elements */
+    $arr_resource = array("a" => $resource1, "b" => $resource2);
+    var_dump(count($arr_resource));
+    echo "\n-- Testing count() on arrays containing references --\n";
+    $arr = array(1, array("a", "b", "c"));
+    $arr[2] =& $arr[1];
+    echo "Count normal" . \PHP_EOL;
+    var_dump(count($arr, COUNT_NORMAL));
+    echo "Count recursive" . \PHP_EOL;
+    var_dump(count($arr, COUNT_RECURSIVE));
+    /* closing the resource handles */
+    fclose($resource1);
+    closedir($resource2);
+}
+?>
+--EXPECT--
+*** Testing basic functionality of count() function ***
+-- Testing arrays --
+COUNT_NORMAL: should be 2, is 2
+COUNT_RECURSIVE: should be 8, is 8
+-- Testing hashes --
+COUNT_NORMAL: should be 3, is 3
+COUNT_RECURSIVE: should be 6, is 6
+-- Testing various types with no second argument --
+COUNT_NORMAL: should be 2, is 2
+-- Testing really cool arrays --
+COUNT_NORMAL: should be 3, is 3
+COUNT_RECURSIVE: should be 13, is 13
+
+*** Testing possible variations of count() function on arrays ***
+-- Iteration 0 --
+COUNT_NORMAL is 0
+COUNT_RECURSIVE is 0
+
+-- Iteration 1 --
+COUNT_NORMAL is 1
+COUNT_RECURSIVE is 1
+
+-- Iteration 2 --
+COUNT_NORMAL is 4
+COUNT_RECURSIVE is 7
+
+-- Iteration 3 --
+COUNT_NORMAL is 2
+COUNT_RECURSIVE is 8
+
+-- Iteration 4 --
+COUNT_NORMAL is 4
+COUNT_RECURSIVE is 4
+
+-- Iteration 5 --
+COUNT_NORMAL is 5
+COUNT_RECURSIVE is 5
+
+-- Iteration 6 --
+COUNT_NORMAL is 6
+COUNT_RECURSIVE is 6
+
+-- Iteration 7 --
+COUNT_NORMAL is 4
+COUNT_RECURSIVE is 7
+
+-- Testing count() on an empty sub-array --
+COUNT_NORMAL: should be 2, is 2
+COUNT_RECURSIVE: should be 5, is 5
+
+-- Testing count() on objects with Countable interface --
+COUNT_NORMAL: should be 3, is 3
+
+-- Testing count() on resource type --
+int(2)
+
+-- Testing count() on arrays containing references --
+Count normal
+int(3)
+Count recursive
+int(9)
diff --git a/tests/std/array/count_symbol_table.phpt b/tests/std/array/count_symbol_table.phpt
new file mode 100644
index 00000000..0fe69871
--- /dev/null
+++ b/tests/std/array/count_symbol_table.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Test count() function : count on symbol table
+--SKIPIF--
+<?php die("skip GLOBALS is not supported in AOT"); ?>
+
+--FILE--
+<?php
+
+$c1 = 0;
+$c2 = 0;
+$a = 1;
+$b = 1;
+$c1 = count($GLOBALS);
+unset($a);
+unset($GLOBALS["b"]);
+$c2 = count($GLOBALS);
+
+var_dump($c1 - $c2);
+$c = 1;
+$c1 = count($GLOBALS);
+var_dump($c1 - $c2);
+?>
+--EXPECT--
+int(2)
+int(1)
diff --git a/tests/std/array/count_variation3.phpt b/tests/std/array/count_variation3.phpt
new file mode 100644
index 00000000..37d6fb63
--- /dev/null
+++ b/tests/std/array/count_variation3.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Test count() function : usage variations - Infinitely recursive array
+--FILE--
+<?php
+/*
+ * Pass count() an infinitely recursive array as $var argument
+ * This will stop the script before it reaches the end.
+ */
+
+echo "*** Testing count() : usage variations ***\n";
+
+$array1 = array (1, 2, 'three');
+// get an infinitely recursive array
+$array1[] = &$array1;
+
+echo "\n-- \$mode not set: --\n";
+var_dump(count ($array1));
+
+echo "\n-- \$mode = 1: --\n";
+var_dump(count ($array1, 1));
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing count() : usage variations ***
+
+-- $mode not set: --
+int(4)
+
+-- $mode = 1: --
+
+Warning:%S Recursion detected in %s on line %d
+int(4)
+Done
diff --git a/tests/std/array/current_basic.phpt b/tests/std/array/current_basic.phpt
new file mode 100644
index 00000000..48d4e5a0
--- /dev/null
+++ b/tests/std/array/current_basic.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Test current() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of current()
+ */
+
+echo "*** Testing current() : basic functionality ***\n";
+
+$array = array ('zero', 'one', 'two', 'three' => 3);
+var_dump(current($array));
+next($array);
+var_dump(current($array));
+end($array);
+var_dump(current($array));
+next($array);
+var_dump(current($array));
+?>
+--EXPECT--
+*** Testing current() : basic functionality ***
+string(4) "zero"
+string(3) "one"
+int(3)
+bool(false)
diff --git a/tests/std/array/current_variation2.phpt b/tests/std/array/current_variation2.phpt
new file mode 100644
index 00000000..723841d5
--- /dev/null
+++ b/tests/std/array/current_variation2.phpt
@@ -0,0 +1,112 @@
+--TEST--
+Test current() function : usage variations - arrays 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()
+{
+    /*
+     * Pass arrays of different data types as $array_arg to current() to test behaviour
+     */
+    echo "*** Testing current() : usage variations ***\n";
+    //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");
+    // arrays of different data types to be passed to $array_arg 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 string' => array("", ''),
+        /*6*/
+        'empty array' => array(),
+        // string data
+        /*7*/
+        'string' => array("string", 'string', $heredoc),
+        // object data
+        /*8*/
+        'object' => array(new classA()),
+        // undefined data
+        /*9*/
+        'undefined' => array(@$undefined_var),
+        // unset data
+        /*10*/
+        'unset' => array(@$unset_var),
+        // resource variable
+        /*11*/
+        'resource' => array($fp),
+    );
+    // loop through each element of $inputs to check the behavior of current()
+    $iterator = 1;
+    foreach ($inputs as $key => $input) {
+        echo "\n-- Iteration {$iterator} : {$key} data --\n";
+        var_dump(current($input));
+        $iterator++;
+    }
+    fclose($fp);
+}
+?>
+--EXPECTF--
+*** Testing current() : usage variations ***
+
+-- Iteration 1 : int data --
+int(0)
+
+-- Iteration 2 : float data --
+float(10.5)
+
+-- Iteration 3 : null data --
+NULL
+
+-- Iteration 4 : bool data --
+bool(true)
+
+-- Iteration 5 : empty string data --
+string(0) ""
+
+-- Iteration 6 : empty array data --
+bool(false)
+
+-- Iteration 7 : string data --
+string(6) "string"
+
+-- Iteration 8 : object data --
+object(classA)#%d (0) {
+}
+
+-- Iteration 9 : undefined data --
+NULL
+
+-- Iteration 10 : unset data --
+NULL
+
+-- Iteration 11 : resource data --
+resource(%d) of type (stream)
diff --git a/tests/std/array/current_variation3.phpt b/tests/std/array/current_variation3.phpt
new file mode 100644
index 00000000..cba2fa2a
--- /dev/null
+++ b/tests/std/array/current_variation3.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Test current() function : usage variations - referenced variables
+--FILE--
+<?php
+/*
+ * Test how the internal pointer is affected when two variables are referenced to each other
+ */
+
+echo "*** Testing current() : usage variations ***\n";
+
+$array1 = array ('zero', 'one', 'two');
+
+echo "\n-- Initial position of internal pointer --\n";
+var_dump(current($array1));
+next($array1);
+
+// Test that when two variables are referenced to one another
+// the internal pointer is the same for both
+$array2 = &$array1;
+echo "\n-- Position after calling next() --\n";
+echo "\$array1: ";
+var_dump(current($array1));
+echo "\$array2: ";
+var_dump(current($array2));
+?>
+--EXPECT--
+*** Testing current() : usage variations ***
+
+-- Initial position of internal pointer --
+string(4) "zero"
+
+-- Position after calling next() --
+$array1: string(3) "one"
+$array2: string(3) "one"
diff --git a/tests/std/array/current_variation4.phpt b/tests/std/array/current_variation4.phpt
new file mode 100644
index 00000000..8f24296f
--- /dev/null
+++ b/tests/std/array/current_variation4.phpt
@@ -0,0 +1,63 @@
+--TEST--
+Test current() function : usage variations - multi-dimensional arrays
+--FILE--
+<?php
+/*
+ * Test how current() behaves with muti-dimensional and recursive arrays
+ */
+
+echo "*** Testing current() : usage variations ***\n";
+
+echo "\n-- Two Dimensional Array --\n";
+$multi_array = array ('zero', array (1, 2, 3), 'two');
+echo "Initial Position: ";
+var_dump(current($multi_array));
+
+echo "Next Position:    ";
+next($multi_array);
+var_dump(current($multi_array));
+
+echo "End Position:     ";
+end($multi_array);
+var_dump(current($multi_array));
+
+echo "\n-- Access an Array Within an Array --\n";
+//accessing an array within an array
+echo "Initial Position: ";
+var_dump(current($multi_array[1]));
+
+echo "\n-- Recursive, Multidimensional Array --\n";
+//create a recursive array
+$multi_array[] = &$multi_array;
+
+//See where internal pointer is after adding more elements
+echo "Current Position: ";
+var_dump(current($multi_array));
+
+//see if internal pointer is in same position as referenced array
+var_dump(current($multi_array[3][3][3]));
+// see if internal pointer is in the same position from when accessing this inner array
+var_dump(current($multi_array[3][3][3][1]));
+?>
+--EXPECT--
+*** Testing current() : usage variations ***
+
+-- Two Dimensional Array --
+Initial Position: string(4) "zero"
+Next Position:    array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+End Position:     string(3) "two"
+
+-- Access an Array Within an Array --
+Initial Position: int(1)
+
+-- Recursive, Multidimensional Array --
+Current Position: string(3) "two"
+string(3) "two"
+int(1)
diff --git a/tests/std/array/current_variation5.phpt b/tests/std/array/current_variation5.phpt
new file mode 100644
index 00000000..c5ef89b7
--- /dev/null
+++ b/tests/std/array/current_variation5.phpt
@@ -0,0 +1,43 @@
+--TEST--
+Test current() function : usage variations - reference & normal parameters
+--FILE--
+<?php
+function current_variation5_ref(&$a)
+{
+    var_dump(current($a));
+    var_dump(next($a));
+}
+function current_variation5($a)
+{
+    var_dump(current($a));
+    var_dump(next($a));
+}
+function main()
+{
+    echo "*** Testing current() : usage variations ***\n";
+    echo "\n-- Function: reference parameter --\n";
+    $a = array('yes', 'maybe', 'no');
+    var_dump(current($a));
+    var_dump(next($a));
+    current_variation5($a);
+    echo "\n-- Function: normal parameter --\n";
+    $a = array('yes', 'maybe', 'no');
+    var_dump(current($a));
+    var_dump(next($a));
+    current_variation5($a);
+}
+?>
+--EXPECT--
+*** Testing current() : usage variations ***
+
+-- Function: reference parameter --
+string(3) "yes"
+string(5) "maybe"
+string(5) "maybe"
+string(2) "no"
+
+-- Function: normal parameter --
+string(3) "yes"
+string(5) "maybe"
+string(5) "maybe"
+string(2) "no"
diff --git a/tests/std/array/current_variation6.phpt b/tests/std/array/current_variation6.phpt
new file mode 100644
index 00000000..d7fb0dcc
--- /dev/null
+++ b/tests/std/array/current_variation6.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Test current() function : internal pointer maintenance at the end of array
+--FILE--
+<?php
+$array = ["foo" => 1, "bar" => 2, "baz" => 3];
+reset($array);
+while ($cur = current($array)) {
+    var_dump($cur);
+    next($array);
+}
+
+unset($array["baz"]);
+$array[] = 4;
+var_dump(current($array));
+?>
+--EXPECT--
+int(1)
+int(2)
+int(3)
+int(4)
diff --git a/tests/std/array/data.inc b/tests/std/array/data.inc
new file mode 100644
index 00000000..c8ad4fe2
--- /dev/null
+++ b/tests/std/array/data.inc
@@ -0,0 +1,13 @@
+<?php
+$tmp = pow(2,24);
+$data = array(
+    'PHP',
+    17=>'PHP: Hypertext Preprocessor',
+    5=>'Test',
+    'test'=>27,
+    1000=>'test',
+    "-1000"=>array('banana', 'orange'),
+    'monkey',
+    $tmp=>-1/3
+);
+?>
diff --git a/tests/std/array/end.phpt b/tests/std/array/end.phpt
new file mode 100644
index 00000000..5876ed2f
--- /dev/null
+++ b/tests/std/array/end.phpt
@@ -0,0 +1,177 @@
+--TEST--
+Test end() function
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platform only");
+?>
+--INI--
+precision=14
+--FILE--
+<?php
+class foo
+{
+    function __toString(): string {
+        return "Object";
+    }
+}
+class foo1
+{
+    function __toString(): string {
+        return "Object1";
+    }
+}
+function main()
+{
+    $arrays = array(array(0), range(1, 100), range('a', 'z', 2), array("a" => "A", 2 => "B", "C" => 3, 4 => 4, "one" => 1, "" => NULL), array(1, array(1, 2 => 3), "one" => 1, "5" => 5), array(-1, -2, -3, -4, "-0.005" => "neg0.005", 2.0 => "float2", "neg.9" => -0.9), array(1.0005, 2.0, -3.0, -4.9999999), array(true, false), array("PHP", "Web2.0", "SOA"), array(1, array()), array(1, 2, ""), array(" "), array(2147483647, 2147483648, -2147483647, -2147483648), array(0x7fffffff, -0x80000000, 017777777777, -020000000000), array(-670.0, -4100.03, 1.0E-5, -100000.0, 2.0));
+    /* loop through $arrays to print the last element of each sub-array */
+    echo "*** Testing end() on different arrays ***\n";
+    $counter = 1;
+    foreach ($arrays as $sub_array) {
+        echo "-- Iteration {$counter} --\n";
+        var_dump(end($sub_array));
+        /* ensure that internal pointer is moved to last element */
+        var_dump(current($sub_array));
+        $counter++;
+    }
+    /* checking for end() on sub-arrays */
+    echo "\n*** Testing end() with sub-arrays ***\n";
+    $test_array = array(1, array(1 => "one", "two" => 2, "" => "f"));
+    var_dump(end($test_array));
+    var_dump(end($test_array[1]));
+    /* checking working of end() when array elements are deleted */
+    echo "\n*** Testing end() when array elements are deleted ***\n";
+    $array_test = array("a", "b", "d", 7, "u" => "U", -4, "-.008" => "neg.008");
+    // remove first element from array
+    echo "\n-- Remove first element from array --\n";
+    unset($array_test[0]);
+    var_dump(end($array_test));
+    // remove last element from array, rewind and check end()
+    echo "\n-- Remove last element from array --\n";
+    unset($array_test['-.008']);
+    var_dump(end($array_test));
+    reset($array_test);
+    var_dump(end($array_test));
+    // remove any element  !first, !last, rewind and check end()
+    echo "\n-- Remove any element from array apart from first and last element --\n";
+    unset($array_test[7]);
+    var_dump(end($array_test));
+    var_dump(reset($array_test));
+    var_dump(end($array_test));
+    /* Checking on OBJECTS type */
+    echo "\n*** Testing end() on objects ***\n";
+    $object1 = new foo();
+    //new object created
+    $object2 = new foo1();
+    $array_object = array();
+    $array_object[0] =& $object1;
+    $array_object[1] =& $object2;
+    var_dump(end($array_object));
+    var_dump($array_object);
+    /* Checking on RESOURCE type */
+    echo "\n*** Testing end() on resource type ***\n";
+    //file type resource
+    $file_handle = fopen(__FILE__, "r");
+    //directory type resource
+    $dir_handle = opendir(__DIR__);
+    //store resources in array
+    $resources = array($file_handle, $dir_handle);
+    var_dump(end($resources));
+    var_dump(current($resources));
+    echo "Done\n";
+    /* cleaning resource handles */
+    fclose($file_handle);
+    //file resource handle deleted
+    closedir($dir_handle);
+}
+?>
+--EXPECTF--
+*** Testing end() on different arrays ***
+-- Iteration 1 --
+int(0)
+int(0)
+-- Iteration 2 --
+int(100)
+int(100)
+-- Iteration 3 --
+string(1) "y"
+string(1) "y"
+-- Iteration 4 --
+NULL
+NULL
+-- Iteration 5 --
+int(5)
+int(5)
+-- Iteration 6 --
+float(-0.9)
+float(-0.9)
+-- Iteration 7 --
+float(-4.9999999)
+float(-4.9999999)
+-- Iteration 8 --
+bool(false)
+bool(false)
+-- Iteration 9 --
+string(3) "SOA"
+string(3) "SOA"
+-- Iteration 10 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 11 --
+string(0) ""
+string(0) ""
+-- Iteration 12 --
+string(1) " "
+string(1) " "
+-- Iteration 13 --
+float(-2147483648)
+float(-2147483648)
+-- Iteration 14 --
+float(-2147483648)
+float(-2147483648)
+-- Iteration 15 --
+float(2)
+float(2)
+
+*** Testing end() with sub-arrays ***
+array(3) {
+  [1]=>
+  string(3) "one"
+  ["two"]=>
+  int(2)
+  [""]=>
+  string(1) "f"
+}
+string(1) "f"
+
+*** Testing end() when array elements are deleted ***
+
+-- Remove first element from array --
+string(7) "neg.008"
+
+-- Remove last element from array --
+int(-4)
+int(-4)
+
+-- Remove any element from array apart from first and last element --
+int(-4)
+string(1) "b"
+int(-4)
+
+*** Testing end() on objects ***
+object(foo1)#%d (0) {
+}
+array(2) {
+  [0]=>
+  &object(foo)#%d (0) {
+  }
+  [1]=>
+  &object(foo1)#%d (0) {
+  }
+}
+
+*** Testing end() on resource type ***
+resource(%d) of type (stream)
+resource(%d) of type (stream)
+Done
diff --git a/tests/std/array/end_64bit.phpt b/tests/std/array/end_64bit.phpt
new file mode 100644
index 00000000..33383ef5
--- /dev/null
+++ b/tests/std/array/end_64bit.phpt
@@ -0,0 +1,173 @@
+--TEST--
+Test end() function
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only");
+?>
+--INI--
+precision=14
+--FILE--
+<?php
+class foo
+{
+    function __toString(): string {
+        return "Object";
+    }
+}
+class foo1
+{
+    function __toString(): string {
+        return "Object1";
+    }
+}
+function main()
+{
+    $arrays = array(array(0), range(1, 100), range('a', 'z', 2), array("a" => "A", 2 => "B", "C" => 3, 4 => 4, "one" => 1, "" => NULL), array(1, array(1, 2 => 3), "one" => 1, "5" => 5), array(-1, -2, -3, -4, "-0.005" => "neg0.005", 2 => "float2", "neg.9" => -0.9), array(1.0005, 2.0, -3.0, -4.9999999), array(true, false), array("PHP", "Web2.0", "SOA"), array(1, array()), array(1, 2, ""), array(" "), array(2147483647, 2147483648, -2147483647, -2147483648), array(0x7fffffff, -0x80000000, 017777777777, -020000000000), array(-670.0, -4100.03, 1.0E-5, -100000.0, 2.0));
+    /* loop through $arrays to print the last element of each sub-array */
+    echo "*** Testing end() on different arrays ***\n";
+    $counter = 1;
+    foreach ($arrays as $sub_array) {
+        echo "-- Iteration {$counter} --\n";
+        var_dump(end($sub_array));
+        /* ensure that internal pointer is moved to last element */
+        var_dump(current($sub_array));
+        $counter++;
+    }
+    /* checking for end() on sub-arrays */
+    echo "\n*** Testing end() with sub-arrays ***\n";
+    $test_array = array(1, array(1 => "one", "two" => 2, "" => "f"));
+    var_dump(end($test_array));
+    var_dump(end($test_array[1]));
+    /* checking working of end() when array elements are deleted */
+    echo "\n*** Testing end() when array elements are deleted ***\n";
+    $array_test = array("a", "b", "d", 7, "u" => "U", -4, "-.008" => "neg.008");
+    // remove first element from array
+    echo "\n-- Remove first element from array --\n";
+    unset($array_test[0]);
+    var_dump(end($array_test));
+    // remove last element from array, rewind and check end()
+    echo "\n-- Remove last element from array --\n";
+    unset($array_test['-.008']);
+    var_dump(end($array_test));
+    reset($array_test);
+    var_dump(end($array_test));
+    // remove any element  !first, !last, rewind and check end()
+    echo "\n-- Remove any element from array apart from first and last element --\n";
+    unset($array_test[7]);
+    var_dump(end($array_test));
+    var_dump(reset($array_test));
+    var_dump(end($array_test));
+    /* Checking on OBJECTS type */
+    echo "\n*** Testing end() on objects ***\n";
+    $object1 = new foo();
+    //new object created
+    $object2 = new foo1();
+    $array_object = array();
+    $array_object[0] =& $object1;
+    $array_object[1] =& $object2;
+    var_dump(end($array_object));
+    var_dump($array_object);
+    /* Checking on RESOURCE type */
+    echo "\n*** Testing end() on resource type ***\n";
+    //file type resource
+    $file_handle = fopen(__FILE__, "r");
+    //directory type resource
+    $dir_handle = opendir(__DIR__);
+    //store resources in array
+    $resources = array($file_handle, $dir_handle);
+    var_dump(end($resources));
+    var_dump(current($resources));
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+*** Testing end() on different arrays ***
+-- Iteration 1 --
+int(0)
+int(0)
+-- Iteration 2 --
+int(100)
+int(100)
+-- Iteration 3 --
+string(1) "y"
+string(1) "y"
+-- Iteration 4 --
+NULL
+NULL
+-- Iteration 5 --
+int(5)
+int(5)
+-- Iteration 6 --
+float(-0.9)
+float(-0.9)
+-- Iteration 7 --
+float(-4.9999999)
+float(-4.9999999)
+-- Iteration 8 --
+bool(false)
+bool(false)
+-- Iteration 9 --
+string(3) "SOA"
+string(3) "SOA"
+-- Iteration 10 --
+array(0) {
+}
+array(0) {
+}
+-- Iteration 11 --
+string(0) ""
+string(0) ""
+-- Iteration 12 --
+string(1) " "
+string(1) " "
+-- Iteration 13 --
+int(-2147483648)
+int(-2147483648)
+-- Iteration 14 --
+int(-2147483648)
+int(-2147483648)
+-- Iteration 15 --
+float(2)
+float(2)
+
+*** Testing end() with sub-arrays ***
+array(3) {
+  [1]=>
+  string(3) "one"
+  ["two"]=>
+  int(2)
+  [""]=>
+  string(1) "f"
+}
+string(1) "f"
+
+*** Testing end() when array elements are deleted ***
+
+-- Remove first element from array --
+string(7) "neg.008"
+
+-- Remove last element from array --
+int(-4)
+int(-4)
+
+-- Remove any element from array apart from first and last element --
+int(-4)
+string(1) "b"
+int(-4)
+
+*** Testing end() on objects ***
+object(foo1)#%d (0) {
+}
+array(2) {
+  [0]=>
+  &object(foo)#%d (0) {
+  }
+  [1]=>
+  &object(foo1)#%d (0) {
+  }
+}
+
+*** Testing end() on resource type ***
+resource(%d) of type (stream)
+resource(%d) of type (stream)
+Done
diff --git a/tests/std/array/end_basic.phpt b/tests/std/array/end_basic.phpt
new file mode 100644
index 00000000..04c49e1c
--- /dev/null
+++ b/tests/std/array/end_basic.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Test end() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of end()
+ */
+
+echo "*** Testing end() : basic functionality ***\n";
+
+$array = array('zero', 'one', 200 => 'two');
+
+echo "\n-- Initial Position: --\n";
+echo key($array) . " => " . current($array) . "\n";
+
+echo "\n-- Call to end() --\n";
+var_dump(end($array));
+
+echo "\n-- Current Position: --\n";
+echo key($array) . " => " . current($array) . "\n";
+
+echo "\n-- Add a new element to array --\n";
+$array[2] = 'foo';
+var_dump(end($array));
+?>
+--EXPECT--
+*** Testing end() : basic functionality ***
+
+-- Initial Position: --
+0 => zero
+
+-- Call to end() --
+string(3) "two"
+
+-- Current Position: --
+200 => two
+
+-- Add a new element to array --
+string(3) "foo"
diff --git a/tests/std/array/end_variation2.phpt b/tests/std/array/end_variation2.phpt
new file mode 100644
index 00000000..3bf399a4
--- /dev/null
+++ b/tests/std/array/end_variation2.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Test end() function : usage variations - Multi-dimensional arrays
+--FILE--
+<?php
+/*
+ * Test end() when passed:
+ * 1. a two-dimensional array
+ * 2. a sub-array
+ * as $array_arg argument.
+ */
+
+echo "*** Testing end() : usage variations ***\n";
+
+$array_arg = array ('a' => 'z', array(9, 8, 7));
+
+echo "\n-- Pass a two-dimensional array as \$array_arg --\n";
+var_dump(end($array_arg));
+
+echo "\n-- Pass a sub-array as \$array_arg --\n";
+var_dump(end($array_arg[0]));
+?>
+--EXPECT--
+*** Testing end() : usage variations ***
+
+-- Pass a two-dimensional array as $array_arg --
+array(3) {
+  [0]=>
+  int(9)
+  [1]=>
+  int(8)
+  [2]=>
+  int(7)
+}
+
+-- Pass a sub-array as $array_arg --
+int(7)
diff --git a/tests/std/array/end_variation3.phpt b/tests/std/array/end_variation3.phpt
new file mode 100644
index 00000000..8d2b78ab
--- /dev/null
+++ b/tests/std/array/end_variation3.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Test end() function : usage variations - Referenced variables
+--FILE--
+<?php
+/*
+ * Test how the internal pointer is affected when two variables are referenced to each other
+ */
+
+echo "*** Testing end() : usage variations ***\n";
+
+$array1 = array ('zero', 'one', 'two');
+
+echo "\n-- Initial position of internal pointer --\n";
+var_dump(current($array1));
+end($array1);
+
+// Test that when two variables are referenced to one another
+// the internal pointer is the same for both
+$array2 = &$array1;
+echo "\n-- Position after calling end() --\n";
+echo "\$array1: ";
+var_dump(current($array1));
+echo "\$array2: ";
+var_dump(current($array2));
+?>
+--EXPECT--
+*** Testing end() : usage variations ***
+
+-- Initial position of internal pointer --
+string(4) "zero"
+
+-- Position after calling end() --
+$array1: string(3) "two"
+$array2: string(3) "two"
diff --git a/tests/std/array/extract_error.phpt b/tests/std/array/extract_error.phpt
new file mode 100644
index 00000000..594f158d
--- /dev/null
+++ b/tests/std/array/extract_error.phpt
@@ -0,0 +1,41 @@
+--TEST--
+Test extract() function (error conditions)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+/* Testing Error Conditions */
+echo "*** Testing Error Conditions ***\n";
+
+/* Invalid second argument ( only 0-6 is valid) */
+$arr = array(1);
+
+try {
+    var_dump( extract($arr, -1) );
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump( extract($arr, 7 , "wddr") );
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+/* Two Arguments, second as prefix but without prefix string as third argument */
+try {
+    var_dump( extract($arr,EXTR_PREFIX_IF_EXISTS) );
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+?>
+--EXPECT--
+*** Testing Error Conditions ***
+extract(): Argument #2 ($flags) must be a valid extract type
+extract(): Argument #2 ($flags) must be a valid extract type
+extract(): Argument #3 ($prefix) is required when using this extract type
diff --git a/tests/std/array/extract_error_variation1.phpt b/tests/std/array/extract_error_variation1.phpt
new file mode 100644
index 00000000..224f31a6
--- /dev/null
+++ b/tests/std/array/extract_error_variation1.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Test extract() function - error condition - Invalid prefix.
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$a = ["1" => "one", "2" => "two", "3" => "three", "4" => "four", "5" => "five"];
+
+try {
+    extract($a, EXTR_PREFIX_ALL, '85bogus');
+} catch (\ValueError $e) {
+    echo $e->getMessage();
+}
+?>
+--EXPECT--
+extract(): Argument #3 ($prefix) must be a valid identifier
diff --git a/tests/std/array/extract_safety.phpt b/tests/std/array/extract_safety.phpt
new file mode 100644
index 00000000..12e9ef5a
--- /dev/null
+++ b/tests/std/array/extract_safety.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Test extract() for overwrite of GLOBALS
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$str = "John";
+var_dump($GLOBALS["str"]);
+
+/* Extracting Global Variables */
+$splat = array("foo" => "bar");
+var_dump(extract(array("GLOBALS" => $splat, EXTR_OVERWRITE)));
+
+unset ($splat);
+
+var_dump($GLOBALS["str"]);
+
+echo "\nDone";
+?>
+--EXPECT--
+string(4) "John"
+int(1)
+string(4) "John"
+
+Done
diff --git a/tests/std/array/extract_typed_ref.phpt b/tests/std/array/extract_typed_ref.phpt
new file mode 100644
index 00000000..9f9b1544
--- /dev/null
+++ b/tests/std/array/extract_typed_ref.phpt
@@ -0,0 +1,31 @@
+--TEST--
+extract() into typed references must respect their type
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+class Test
+{
+    public int $i = 0;
+    public string $s = "";
+}
+function main()
+{
+    $test = new Test();
+    $i =& $test->i;
+    $s =& $test->s;
+    try {
+        extract(['i' => 'foo', 's' => 42]);
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    var_dump($test->i, $test->s);
+}
+?>
+--EXPECT--
+Cannot assign string to reference held by property Test::$i of type int
+int(0)
+string(0) ""
diff --git a/tests/std/array/extract_variation1.phpt b/tests/std/array/extract_variation1.phpt
new file mode 100644
index 00000000..c37a5128
--- /dev/null
+++ b/tests/std/array/extract_variation1.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Test extract() function (variation 1)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+$val = 4;
+$str = "John";
+
+var_dump($val);
+var_dump($str);
+
+/* Extracting Global Variables */
+var_dump(extract($GLOBALS, EXTR_REFS));
+var_dump($val);
+var_dump($str);
+
+echo "\nDone";
+?>
+--EXPECTF--
+int(4)
+string(4) "John"
+int(%d)
+int(4)
+string(4) "John"
+
+Done
diff --git a/tests/std/array/extract_variation10.phpt b/tests/std/array/extract_variation10.phpt
new file mode 100644
index 00000000..2e6c0c9d
--- /dev/null
+++ b/tests/std/array/extract_variation10.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Test extract() function - ensure EXTR_REFS doesn't mess with isRef flag on COW references to array elements.
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$a = array('foo' => 'original.foo');
+$nonref = $a['foo'];
+$ref = &$a;
+extract($a, EXTR_REFS);
+$a['foo'] = 'changed.foo';
+var_dump($nonref);
+?>
+--EXPECT--
+string(12) "original.foo"
diff --git a/tests/std/array/extract_variation11.phpt b/tests/std/array/extract_variation11.phpt
new file mode 100644
index 00000000..208ded28
--- /dev/null
+++ b/tests/std/array/extract_variation11.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Test extract() function - ensure EXTR_REFS works when array is referenced and keys clash with variables in current scope.
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+$a = array('foo' => 'original.foo');
+$ref = &$a;
+$foo = 'test';
+extract($a, EXTR_OVERWRITE|EXTR_REFS);
+$foo = 'changed.foo';
+var_dump($a['foo']);
+?>
+--EXPECT--
+string(11) "changed.foo"
diff --git a/tests/std/array/extract_variation2.phpt b/tests/std/array/extract_variation2.phpt
new file mode 100644
index 00000000..657dc78b
--- /dev/null
+++ b/tests/std/array/extract_variation2.phpt
@@ -0,0 +1,74 @@
+--TEST--
+Test extract() function (variation 2)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+/* various combinations of arrays to be used for the test */
+$mixed_array = array(
+  array(),
+  array( 1,2,3,4,5,6,7,8,9 ),
+  array( "One", "Two", "Three", "Four", "Five" ),
+);
+
+$counter = 0;
+
+foreach ( $mixed_array as $sub_array ) {
+  echo "\n-- Iteration $counter --\n";
+  $counter++;
+
+  var_dump ( extract($sub_array)); /* Single Argument */
+
+  /* variations of two arguments */
+  var_dump ( extract($sub_array, EXTR_OVERWRITE));
+  var_dump ( extract($sub_array, EXTR_SKIP));
+  var_dump ( extract($sub_array, EXTR_IF_EXISTS));
+
+  /* variations of three arguments with use of various extract types*/
+  var_dump ( extract($sub_array, EXTR_PREFIX_INVALID, "ssd"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_SAME, "sss"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_ALL, "bb"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_ALL, ""));  // "_" taken as default prefix
+  var_dump ( extract($sub_array, EXTR_PREFIX_IF_EXISTS, "bb"));
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+-- Iteration 0 --
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+int(0)
+
+-- Iteration 1 --
+int(0)
+int(0)
+int(0)
+int(0)
+int(9)
+int(0)
+int(9)
+int(9)
+int(0)
+
+-- Iteration 2 --
+int(0)
+int(0)
+int(0)
+int(0)
+int(5)
+int(0)
+int(5)
+int(5)
+int(0)
+Done
diff --git a/tests/std/array/extract_variation3.phpt b/tests/std/array/extract_variation3.phpt
new file mode 100644
index 00000000..cce0da67
--- /dev/null
+++ b/tests/std/array/extract_variation3.phpt
@@ -0,0 +1,74 @@
+--TEST--
+Test extract() function (variation 3)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+/* various combinations of arrays to be used for the test */
+$mixed_array = array(
+  array( 6, "six", 7, "seven", 8, "eight", 9, "nine" ),
+  array( "a" => "aaa", "A" => "AAA", "c" => "ccc", "d" => "ddd", "e" => "eee" ),
+  array( "1" => "one", "2" => "two", "3" => "three", "4" => "four", "5" => "five" ),
+);
+
+$counter = 0;
+
+foreach ( $mixed_array as $sub_array ) {
+  echo "\n-- Iteration $counter --\n";
+  $counter++;
+
+  var_dump ( extract($sub_array)); /* Single Argument */
+
+  /* variations of two arguments */
+  var_dump ( extract($sub_array, EXTR_OVERWRITE));
+  var_dump ( extract($sub_array, EXTR_SKIP));
+  var_dump ( extract($sub_array, EXTR_IF_EXISTS));
+
+  /* variations of three arguments with use of various extract types*/
+  var_dump ( extract($sub_array, EXTR_PREFIX_INVALID, "ssd"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_SAME, "sss"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_ALL, "bb"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_ALL, ""));  // "_" taken as default prefix
+  var_dump ( extract($sub_array, EXTR_PREFIX_IF_EXISTS, "bb"));
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+-- Iteration 0 --
+int(0)
+int(0)
+int(0)
+int(0)
+int(8)
+int(0)
+int(8)
+int(8)
+int(0)
+
+-- Iteration 1 --
+int(5)
+int(5)
+int(0)
+int(5)
+int(5)
+int(5)
+int(5)
+int(5)
+int(5)
+
+-- Iteration 2 --
+int(0)
+int(0)
+int(0)
+int(0)
+int(5)
+int(0)
+int(5)
+int(5)
+int(0)
+Done
diff --git a/tests/std/array/extract_variation4.phpt b/tests/std/array/extract_variation4.phpt
new file mode 100644
index 00000000..343b681e
--- /dev/null
+++ b/tests/std/array/extract_variation4.phpt
@@ -0,0 +1,74 @@
+--TEST--
+Test extract() function (variation 4)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+$mixed_array = array(
+  array( 1 => "one", 2 => "two", 3 => 7, 4 => "four", 5 => "five" ),
+  array( "f" => "fff", "1" => "one", 4 => 6, "" => "blank", 2 => "float", "F" => "FFF",
+         "blank" => "", 3 => 3.7, 5 => 7, 6 => 8.6, '5' => "Five", "4name" => "jonny", "a" => NULL, NULL => 3 ),
+  array( 12, "name", 'age', '45' ),
+);
+
+$counter = 0;
+
+foreach ( $mixed_array as $sub_array ) {
+  echo "\n-- Iteration $counter --\n";
+  $counter++;
+
+  var_dump ( extract($sub_array)); /* Single Argument */
+
+  /* variations of two arguments */
+  var_dump ( extract($sub_array, EXTR_OVERWRITE));
+  var_dump ( extract($sub_array, EXTR_SKIP));
+  var_dump ( extract($sub_array, EXTR_IF_EXISTS));
+
+  /* variations of three arguments with use of various extract types*/
+  var_dump ( extract($sub_array, EXTR_PREFIX_INVALID, "ssd"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_SAME, "sss"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_ALL, "bb"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_ALL, ""));  // "_" taken as default prefix
+  var_dump ( extract($sub_array, EXTR_PREFIX_IF_EXISTS, "bb"));
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+-- Iteration 0 --
+int(0)
+int(0)
+int(0)
+int(0)
+int(5)
+int(0)
+int(5)
+int(5)
+int(0)
+
+-- Iteration 1 --
+int(4)
+int(4)
+int(0)
+int(4)
+int(12)
+int(4)
+int(11)
+int(11)
+int(4)
+
+-- Iteration 2 --
+int(0)
+int(0)
+int(0)
+int(0)
+int(4)
+int(0)
+int(4)
+int(4)
+int(0)
+Done
diff --git a/tests/std/array/extract_variation5.phpt b/tests/std/array/extract_variation5.phpt
new file mode 100644
index 00000000..edc3ad5e
--- /dev/null
+++ b/tests/std/array/extract_variation5.phpt
@@ -0,0 +1,62 @@
+--TEST--
+Test extract() function (variation 5)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+$mixed_array = array(
+  array( array("oNe", "tWo", 4), array(10, 20, 30, 40, 50), array() ),
+  array( "one" => 1, "one" => 2, "three" => 3, 3, 4, 3 => 33, 4 => 44, 5, 6,
+          5 => 57, "5.4" => 554, "5.7" => 557 )
+);
+
+$counter = 0;
+
+foreach ( $mixed_array as $sub_array ) {
+  echo "\n-- Iteration $counter --\n";
+  $counter++;
+
+  var_dump ( extract($sub_array)); /* Single Argument */
+
+  /* variations of two arguments */
+  var_dump ( extract($sub_array, EXTR_OVERWRITE));
+  var_dump ( extract($sub_array, EXTR_SKIP));
+  var_dump ( extract($sub_array, EXTR_IF_EXISTS));
+
+  /* variations of three arguments with use of various extract types*/
+  var_dump ( extract($sub_array, EXTR_PREFIX_INVALID, "ssd"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_SAME, "sss"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_ALL, "bb"));
+  var_dump ( extract($sub_array, EXTR_PREFIX_ALL, ""));  // "_" taken as default prefix
+  var_dump ( extract($sub_array, EXTR_PREFIX_IF_EXISTS, "bb"));
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+-- Iteration 0 --
+int(0)
+int(0)
+int(0)
+int(0)
+int(3)
+int(0)
+int(3)
+int(3)
+int(0)
+
+-- Iteration 1 --
+int(2)
+int(2)
+int(0)
+int(2)
+int(8)
+int(2)
+int(8)
+int(8)
+int(2)
+Done
diff --git a/tests/std/array/extract_variation6.phpt b/tests/std/array/extract_variation6.phpt
new file mode 100644
index 00000000..21648f23
--- /dev/null
+++ b/tests/std/array/extract_variation6.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Test extract() function (variation 6)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+/* EXTR_REFS as second Argument */
+$a = array ('foo' => 'aaa');
+var_dump ( extract($a, EXTR_REFS));
+var_dump($foo);
+
+$b = $a;
+$b['foo'] = 'bbb';
+var_dump ( extract($a, EXTR_REFS));
+var_dump($foo);
+var_dump($a);
+
+echo "Done\n";
+?>
+--EXPECT--
+int(1)
+string(3) "aaa"
+int(1)
+string(3) "bbb"
+array(1) {
+  ["foo"]=>
+  &string(3) "bbb"
+}
+Done
diff --git a/tests/std/array/extract_variation7.phpt b/tests/std/array/extract_variation7.phpt
new file mode 100644
index 00000000..e37de2b7
--- /dev/null
+++ b/tests/std/array/extract_variation7.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Test extract() function (variation 7)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+/* EXTR_PREFIX_ALL called twice with same prefix string */
+echo "\n*** Testing for EXTR_PREFIX_ALL called twice with same prefix string ***\n";
+$a = array( "1" => "one", "2" => "two", "3" => "three", "4" => "four", "5" => "five" );
+var_dump ( extract($a, EXTR_PREFIX_ALL, "same"));
+
+$b = array( "f" => "fff", "1" => "one", 4 => 6, "" => "blank", 2 => "float", "F" => "FFF",
+             "blank" => "", 3 => 3.7, 5 => 7, 6 => 8.6, '5' => "Five", "4name" => "jonny", "a" => NULL, NULL => 3 );
+var_dump ( extract($b, EXTR_PREFIX_ALL, "same"));
+var_dump ( extract($b, EXTR_PREFIX_ALL, "diff"));
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing for EXTR_PREFIX_ALL called twice with same prefix string ***
+int(5)
+int(11)
+int(11)
+Done
diff --git a/tests/std/array/extract_variation8.phpt b/tests/std/array/extract_variation8.phpt
new file mode 100644
index 00000000..2a5b33db
--- /dev/null
+++ b/tests/std/array/extract_variation8.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Test extract() function (variation 8)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+
+/* To show variables with numerical prefixes cannot be extracted */
+$var["i"] = 1;
+$var["j"] = 2;
+$var["k"] = 3;
+echo "\n*** Testing for Numerical prefixes ***\n";
+var_dump(extract($var));
+
+$var1["m"] = 1;
+$var1[2] = 2;
+$var1[] = 3;
+var_dump ( extract($var1));
+
+echo "\nDone";
+?>
+--EXPECT--
+*** Testing for Numerical prefixes ***
+int(3)
+int(1)
+
+Done
diff --git a/tests/std/array/extract_variation9.phpt b/tests/std/array/extract_variation9.phpt
new file mode 100644
index 00000000..ca847552
--- /dev/null
+++ b/tests/std/array/extract_variation9.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Test extract() function (variation 9)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support extract()");
+?>
+
+--FILE--
+<?php
+class classA
+{
+    public $v;
+}
+function main()
+{
+    /* Using Class and objects */
+    echo "\n*** Testing for object ***\n";
+    $A = new classA();
+    var_dump(extract(get_object_vars($A), EXTR_REFS));
+    echo "Done\n";
+}
+?>
+--EXPECT--
+*** Testing for object ***
+int(1)
+Done
diff --git a/tests/std/array/gh14140.phpt b/tests/std/array/gh14140.phpt
new file mode 100644
index 00000000..ffba9617
--- /dev/null
+++ b/tests/std/array/gh14140.phpt
@@ -0,0 +1,24 @@
+--TEST--
+GH-14140: Floating point bug in range operation on Apple Silicon hardware
+--SKIPIF--
+<?php die("skip AOT float formatting for print_r differs from PHP"); ?>
+--FILE--
+<?php
+ini_set('serialize_precision', '14');
+/*
+ * This is a problem that occurs not only in Apple silicon, but also in the Arm
+ * processor environment in general, which uses clang as the compiler.
+ */
+print_r(range(-0.03, 0.03, 0.01));
+?>
+--EXPECT--
+Array
+(
+    [0] => -0.03
+    [1] => -0.02
+    [2] => -0.01
+    [3] => 0
+    [4] => 0.01
+    [5] => 0.02
+    [6] => 0.03
+)
diff --git a/tests/std/array/gh14775.phpt b/tests/std/array/gh14775.phpt
new file mode 100644
index 00000000..9902d7f6
--- /dev/null
+++ b/tests/std/array/gh14775.phpt
@@ -0,0 +1,17 @@
+--TEST--
+GH-14775: Range negative step overflow
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support this test pattern");
+?>
+
+--FILE--
+<?php
+$var = -PHP_INT_MAX - 1;
+try {
+	range($var,1,$var);
+} catch (\ValueError $e) {
+	echo $e->getMessage() . PHP_EOL;
+}
+--EXPECTF--
+range(): Argument #3 ($step) must be greater than %s
diff --git a/tests/std/array/gh15982.phpt b/tests/std/array/gh15982.phpt
new file mode 100644
index 00000000..2eb9eceb
--- /dev/null
+++ b/tests/std/array/gh15982.phpt
@@ -0,0 +1,11 @@
+--TEST--
+GH-15982 (Assertion failure with array_find when references are involved)
+--FILE--
+<?php
+$var = "hello";
+$arrayWithRef = [];
+$arrayWithRef[0] =& $var;
+var_dump(array_find($arrayWithRef, fn () => true));
+?>
+--EXPECT--
+string(5) "hello"
diff --git a/tests/std/array/gh16053.phpt b/tests/std/array/gh16053.phpt
new file mode 100644
index 00000000..c290078e
--- /dev/null
+++ b/tests/std/array/gh16053.phpt
@@ -0,0 +1,29 @@
+--TEST--
+GH-16053: Assertion failure in Zend/zend_hash.c
+--FILE--
+<?php
+class test
+{
+}
+function main()
+{
+    $x = new test();
+    $arr1 = array("string" => $x);
+    $arr2 = array("string" => "hello");
+    var_dump($arr1);
+    var_dump(array_merge_recursive($arr1, $arr2));
+}
+?>
+--EXPECTF--
+array(1) {
+  ["string"]=>
+  object(test)#%d (0) {
+  }
+}
+array(1) {
+  ["string"]=>
+  array(1) {
+    [0]=>
+    string(5) "hello"
+  }
+}
diff --git a/tests/std/array/gh16649/array_splice_normal_destructor.phpt b/tests/std/array/gh16649/array_splice_normal_destructor.phpt
new file mode 100644
index 00000000..882ad1d9
--- /dev/null
+++ b/tests/std/array/gh16649/array_splice_normal_destructor.phpt
@@ -0,0 +1,22 @@
+--TEST--
+GH-16649: array_splice with normal destructor should work fine
+--SKIPIF--
+<?php die("skip AOT does not support destructor interaction with array_splice"); ?>
+--FILE--
+<?php
+class C {
+    function __destruct() {
+        echo "Destructor called\n";
+    }
+}
+
+$arr = ["1", new C, "2"];
+array_splice($arr, 1, 2);
+var_dump($arr);
+?>
+--EXPECT--
+Destructor called
+array(1) {
+  [0]=>
+  string(1) "1"
+}
diff --git a/tests/std/array/gh16649/array_splice_uaf_add_elements.phpt b/tests/std/array/gh16649/array_splice_uaf_add_elements.phpt
new file mode 100644
index 00000000..66aa5c4f
--- /dev/null
+++ b/tests/std/array/gh16649/array_splice_uaf_add_elements.phpt
@@ -0,0 +1,24 @@
+--TEST--
+GH-16649: array_splice UAF when destructor adds elements to array
+--SKIPIF--
+<?php die("skip AOT does not support destructor interaction with array_splice"); ?>
+--FILE--
+<?php
+class C {
+    function __destruct() {
+        global $arr;
+        $arr[] = 0;
+    }
+}
+
+$arr = ["1", new C, "2"];
+
+try {
+    array_splice($arr, 1, 2);
+    echo "ERROR: Should have thrown exception\n";
+} catch (Error $e) {
+    echo "Exception caught: " . $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+Exception caught: Array was modified during array_splice operation
diff --git a/tests/std/array/gh16649/array_splice_uaf_array_deallocated.phpt b/tests/std/array/gh16649/array_splice_uaf_array_deallocated.phpt
new file mode 100644
index 00000000..85133e23
--- /dev/null
+++ b/tests/std/array/gh16649/array_splice_uaf_array_deallocated.phpt
@@ -0,0 +1,24 @@
+--TEST--
+GH-16649: array_splice UAF when array is released entirely
+--SKIPIF--
+<?php die("skip AOT does not support destructor interaction with array_splice"); ?>
+--FILE--
+<?php
+class C {
+    function __destruct() {
+        global $arr;
+        $arr = null;
+    }
+}
+
+$arr = ["1", new C, "2"];
+
+try {
+    array_splice($arr, 1, 2);
+    echo "ERROR: Should have thrown exception\n";
+} catch (Error $e) {
+    echo "Exception caught: " . $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+Exception caught: Array was modified during array_splice operation
diff --git a/tests/std/array/gh16649/array_splice_uaf_complex_modification.phpt b/tests/std/array/gh16649/array_splice_uaf_complex_modification.phpt
new file mode 100644
index 00000000..f6e64ca3
--- /dev/null
+++ b/tests/std/array/gh16649/array_splice_uaf_complex_modification.phpt
@@ -0,0 +1,27 @@
+--TEST--
+GH-16649: array_splice UAF with complex array modification
+--SKIPIF--
+<?php die("skip AOT does not support destructor interaction with array_splice"); ?>
+--FILE--
+<?php
+class ComplexModifier {
+    function __destruct() {
+        global $arr;
+        // complex modification that causes cow
+        unset($arr[0]);
+        $arr["new_key"] = "new_value";
+        $arr[100] = "another_value";
+    }
+}
+
+$arr = ["first", new ComplexModifier, "last"];
+
+try {
+    array_splice($arr, 1, 1, ["replacement"]);
+    echo "ERROR: Should have thrown exception\n";
+} catch (Error $e) {
+    echo "Exception caught: " . $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+Exception caught: Array was modified during array_splice operation
diff --git a/tests/std/array/gh16649/array_splice_uaf_multiple_destructors.phpt b/tests/std/array/gh16649/array_splice_uaf_multiple_destructors.phpt
new file mode 100644
index 00000000..c39ef6d0
--- /dev/null
+++ b/tests/std/array/gh16649/array_splice_uaf_multiple_destructors.phpt
@@ -0,0 +1,35 @@
+--TEST--
+GH-16649: array_splice UAF with multiple destructors
+--SKIPIF--
+<?php die("skip AOT does not support destructor interaction with array_splice"); ?>
+--FILE--
+<?php
+class MultiDestructor {
+    public $id;
+
+    function __construct($id) {
+        $this->id = $id;
+    }
+
+    function __destruct() {
+        global $arr;
+        echo "Destructor {$this->id} called\n";
+        if ($this->id == 2) {
+            $arr = null;
+        }
+    }
+}
+
+$arr = ["start", new MultiDestructor(1), new MultiDestructor(2), "end"];
+
+try {
+    array_splice($arr, 1, 2);
+    echo "ERROR: Should have thrown exception\n";
+} catch (Error $e) {
+    echo "Exception caught: " . $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+Destructor 1 called
+Destructor 2 called
+Exception caught: Array was modified during array_splice operation
diff --git a/tests/std/array/gh16649/array_splice_uaf_original_case.phpt b/tests/std/array/gh16649/array_splice_uaf_original_case.phpt
new file mode 100644
index 00000000..e4357414
--- /dev/null
+++ b/tests/std/array/gh16649/array_splice_uaf_original_case.phpt
@@ -0,0 +1,31 @@
+--TEST--
+GH-16649: array_splice UAF with destructor modifying array (original case)
+--SKIPIF--
+<?php die("skip AOT does not support destructor interaction with array_splice"); ?>
+--FILE--
+<?php
+function resize_arr() {
+    global $arr;
+    for ($i = 0; $i < 10; $i++) {
+        $arr[$i] = $i;
+    }
+}
+
+class C {
+    function __destruct() {
+        resize_arr();
+        return "3";
+    }
+}
+
+$arr = ["a" => "1", "3" => new C, "2" => "2"];
+
+try {
+    array_splice($arr, 1, 2);
+    echo "ERROR: Should have thrown exception\n";
+} catch (Error $e) {
+    echo "Exception caught: " . $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+Exception caught: Array was modified during array_splice operation
diff --git a/tests/std/array/gh16649/array_splice_uaf_packed_to_hash.phpt b/tests/std/array/gh16649/array_splice_uaf_packed_to_hash.phpt
new file mode 100644
index 00000000..13dd56a9
--- /dev/null
+++ b/tests/std/array/gh16649/array_splice_uaf_packed_to_hash.phpt
@@ -0,0 +1,25 @@
+--TEST--
+GH-16649: array_splice UAF when array is converted from packed to hash
+--SKIPIF--
+<?php die("skip AOT does not support destructor interaction with array_splice"); ?>
+--FILE--
+<?php
+class C {
+    function __destruct() {
+        global $arr;
+        // array is converted from packed to hash
+        $arr["str"] = 0;
+    }
+}
+
+$arr = ["1", new C, "2"];
+
+try {
+    array_splice($arr, 1, 2);
+    echo "ERROR: Should have thrown exception\n";
+} catch (Error $e) {
+    echo "Exception caught: " . $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+Exception caught: Array was modified during array_splice operation
diff --git a/tests/std/array/gh16649/array_splice_with_replacement.phpt b/tests/std/array/gh16649/array_splice_with_replacement.phpt
new file mode 100644
index 00000000..f06932dc
--- /dev/null
+++ b/tests/std/array/gh16649/array_splice_with_replacement.phpt
@@ -0,0 +1,25 @@
+--TEST--
+GH-16649: array_splice with replacement array when destructor modifies array
+--SKIPIF--
+<?php die("skip AOT does not support destructor interaction with array_splice"); ?>
+--FILE--
+<?php
+class C {
+    function __destruct() {
+        global $arr;
+        $arr["modified"] = "by_destructor";
+    }
+}
+
+$arr = ["a", new C, "b"];
+$replacement = ["replacement1", "replacement2"];
+
+try {
+    array_splice($arr, 1, 1, $replacement);
+    echo "ERROR: Should have thrown exception\n";
+} catch (Error $e) {
+    echo "Exception caught: " . $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+Exception caught: Array was modified during array_splice operation
diff --git a/tests/std/array/gh16905.phpt b/tests/std/array/gh16905.phpt
new file mode 100644
index 00000000..d3a64ddb
--- /dev/null
+++ b/tests/std/array/gh16905.phpt
@@ -0,0 +1,89 @@
+--TEST--
+GH-16905 (Internal iterator functions can't handle UNDEF properties)
+--SKIPIF--
+<?php die("skip AOT iteration order/internal pointer handling differs from PHP"); ?>
+--FILE--
+<?php
+class TestSomeUndef
+{
+    public int $a;
+    public int $b;
+    public int $c;
+    public int $d;
+}
+class TestAllUndef
+{
+    public int $a;
+}
+function main()
+{
+    $x = new TestSomeUndef();
+    $x->b = 1;
+    $x->c = 2;
+    var_dump(reset($x));
+    var_dump(current($x));
+    var_dump(end($x));
+    var_dump(reset($x));
+    var_dump(next($x));
+    var_dump(end($x));
+    var_dump(prev($x));
+    var_dump(key($x));
+    var_dump(current($x));
+    $x2 = new TestAllUndef();
+    var_dump(key($x2));
+    var_dump(current($x2));
+    $x2->a = 1;
+    var_dump(key($x2));
+    var_dump(current($x2));
+    reset($x2);
+    var_dump(key($x2));
+    var_dump(current($x2));
+}
+?>
+--EXPECTF--
+Deprecated: reset(): Calling reset() on an object is deprecated in %s on line %d
+int(1)
+
+Deprecated: current(): Calling current() on an object is deprecated in %s on line %d
+int(1)
+
+Deprecated: end(): Calling end() on an object is deprecated in %s on line %d
+int(2)
+
+Deprecated: reset(): Calling reset() on an object is deprecated in %s on line %d
+int(1)
+
+Deprecated: next(): Calling next() on an object is deprecated in %s on line %d
+int(2)
+
+Deprecated: end(): Calling end() on an object is deprecated in %s on line %d
+int(2)
+
+Deprecated: prev(): Calling prev() on an object is deprecated in %s on line %d
+int(1)
+
+Deprecated: key(): Calling key() on an object is deprecated in %s on line %d
+string(1) "b"
+
+Deprecated: current(): Calling current() on an object is deprecated in %s on line %d
+int(1)
+
+Deprecated: key(): Calling key() on an object is deprecated in %s on line %d
+NULL
+
+Deprecated: current(): Calling current() on an object is deprecated in %s on line %d
+bool(false)
+
+Deprecated: key(): Calling key() on an object is deprecated in %s on line %d
+NULL
+
+Deprecated: current(): Calling current() on an object is deprecated in %s on line %d
+bool(false)
+
+Deprecated: reset(): Calling reset() on an object is deprecated in %s on line %d
+
+Deprecated: key(): Calling key() on an object is deprecated in %s on line %d
+string(1) "a"
+
+Deprecated: current(): Calling current() on an object is deprecated in %s on line %d
+int(1)
diff --git a/tests/std/array/gh16957.phpt b/tests/std/array/gh16957.phpt
new file mode 100644
index 00000000..74094906
--- /dev/null
+++ b/tests/std/array/gh16957.phpt
@@ -0,0 +1,43 @@
+--TEST--
+GH-16957 (Assertion failure in array_shift with self-referencing array)
+--SKIPIF--
+<?php die("skip AOT array_shift with self-reference differs from PHP"); ?>
+--FILE--
+<?php
+$new_array = array(&$new_array, 1, 'two');
+var_dump($shifted = array_shift($new_array));
+var_dump($new_array);
+var_dump($new_array === $shifted);
+
+$new_array2 = array(&$new_array2, 2 => 1, 300 => 'two');
+var_dump($shifted = array_shift($new_array2));
+var_dump($new_array2);
+var_dump($new_array2 === $shifted);
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "two"
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "two"
+}
+bool(true)
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "two"
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "two"
+}
+bool(true)
diff --git a/tests/std/array/gh17447.phpt b/tests/std/array/gh17447.phpt
new file mode 100644
index 00000000..e107efbd
--- /dev/null
+++ b/tests/std/array/gh17447.phpt
@@ -0,0 +1,12 @@
+--TEST--
+GH-17447 (Assertion failure when array poping a self addressing variable)
+--FILE--
+<?php
+$input[] = &$input;
+var_dump(array_pop($input), $input);
+?>
+--EXPECT--
+array(0) {
+}
+array(0) {
+}
diff --git a/tests/std/array/gh17977.phpt b/tests/std/array/gh17977.phpt
new file mode 100644
index 00000000..4a4f344d
--- /dev/null
+++ b/tests/std/array/gh17977.phpt
@@ -0,0 +1,18 @@
+--TEST--
+array_any() / array_all() leak
+--DESCRIPTION--
+Found in GH-16831#issuecomment-2700410631
+--FILE--
+<?php
+
+// Don't touch this str_repeat + random_int combination,
+// this is to circumvent SCCP and interning
+$key = str_repeat('abc', random_int(3, 3));
+
+var_dump(array_any([$key => 1], static fn () => true));
+var_dump(array_all([$key => 1], static fn () => false));
+
+?>
+--EXPECT--
+bool(true)
+bool(false)
diff --git a/tests/std/array/gh18480.phpt b/tests/std/array/gh18480.phpt
new file mode 100644
index 00000000..21571de2
--- /dev/null
+++ b/tests/std/array/gh18480.phpt
@@ -0,0 +1,45 @@
+--TEST--
+GH-18480 (array_splice overflow with large offset / length values)
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support this test pattern");
+?>
+
+--FILE--
+<?php
+
+foreach ([PHP_INT_MIN, PHP_INT_MAX] as $length) {
+	$a = [PHP_INT_MAX];
+	$offset = PHP_INT_MAX;
+	var_dump(array_splice($a,$offset, $length));
+	$a = [PHP_INT_MAX];
+	$offset = PHP_INT_MIN;
+	var_dump(array_splice($a,$offset, $length));
+	$a = ["a" => PHP_INT_MAX];
+	$offset = PHP_INT_MAX;
+	var_dump(array_splice($a,$offset, $length));
+	$a = ["a" => PHP_INT_MAX];
+	$offset = PHP_INT_MIN;
+	var_dump(array_splice($a,$offset, $length));
+}
+--EXPECTF--
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(1) {
+  [0]=>
+  int(%d)
+}
+array(0) {
+}
+array(1) {
+  ["a"]=>
+  int(%d)
+}
diff --git a/tests/std/array/gh19300_1.phpt b/tests/std/array/gh19300_1.phpt
new file mode 100644
index 00000000..a7182257
--- /dev/null
+++ b/tests/std/array/gh19300_1.phpt
@@ -0,0 +1,42 @@
+--TEST--
+GH-19300 (Nested array_multisort invocation with error breaks) - correct invocation variation
+--SKIPIF--
+--FILE--
+<?php
+class MyStringable
+{
+    public function __construct(private string $data)
+    {
+    }
+    public function __tostring(): string {
+        array_multisort([]);
+        // Trigger update of array sort globals in happy path
+        return $this->data;
+    }
+}
+function main()
+{
+    $inputs = [new MyStringable('3'), new MyStringable('1'), new MyStringable('2')];
+    var_dump(array_multisort($inputs, SORT_STRING));
+    var_dump($inputs);
+}
+?>
+--EXPECT--
+bool(true)
+array(3) {
+  [0]=>
+  object(MyStringable)#2 (1) {
+    ["data":"MyStringable":private]=>
+    string(1) "1"
+  }
+  [1]=>
+  object(MyStringable)#3 (1) {
+    ["data":"MyStringable":private]=>
+    string(1) "2"
+  }
+  [2]=>
+  object(MyStringable)#1 (1) {
+    ["data":"MyStringable":private]=>
+    string(1) "3"
+  }
+}
diff --git a/tests/std/array/gh19300_2.phpt b/tests/std/array/gh19300_2.phpt
new file mode 100644
index 00000000..41a54f2e
--- /dev/null
+++ b/tests/std/array/gh19300_2.phpt
@@ -0,0 +1,39 @@
+--TEST--
+GH-19300 (Nested array_multisort invocation with error breaks) - error variation
+--SKIPIF--
+--FILE--
+<?php
+function error_handle($level, $message, $file = '', $line = 0)
+{
+    try {
+        array_multisort($a, SORT_ASC);
+        // Trigger multisort abort
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+}
+function main()
+{
+    set_error_handler('error_handle');
+    $inputs = [new stdClass(), new stdClass(), new stdClass()];
+    var_dump(array_multisort($inputs, SORT_NUMERIC));
+    var_dump($inputs);
+}
+?>
+--EXPECT--
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
+bool(true)
+array(3) {
+  [0]=>
+  object(stdClass)#1 (0) {
+  }
+  [1]=>
+  object(stdClass)#2 (0) {
+  }
+  [2]=>
+  object(stdClass)#3 (0) {
+  }
+}
diff --git a/tests/std/array/gh19926.phpt b/tests/std/array/gh19926.phpt
new file mode 100644
index 00000000..ecff0cfa
--- /dev/null
+++ b/tests/std/array/gh19926.phpt
@@ -0,0 +1,25 @@
+--TEST--
+GH-19926 (Assertion failure zend_hash_internal_pointer_reset_ex)
+--SKIPIF--
+<?php die("skip AOT does not support throwing destructors during array_splice"); ?>
+--FILE--
+<?php
+class ThrowingDestructor
+{
+    function __destruct()
+    {
+        throw new Exception();
+    }
+}
+function main()
+{
+    $arr = [new ThrowingDestructor(), new ThrowingDestructor()];
+    try {
+        array_splice($arr, 0, 2);
+    } catch (Exception $e) {
+        echo "Exception caught, no assertion failure\n";
+    }
+}
+?>
+--EXPECT--
+Exception caught, no assertion failure
diff --git a/tests/std/array/gh19926_pointer.phpt b/tests/std/array/gh19926_pointer.phpt
new file mode 100644
index 00000000..c134f3b5
--- /dev/null
+++ b/tests/std/array/gh19926_pointer.phpt
@@ -0,0 +1,19 @@
+--TEST--
+GH-19926 (internal pointer behavior after array_splice)
+--FILE--
+<?php
+$a = [1, 2, 3];
+unset($a[0]);
+next($a);
+
+echo "Before array_splice: ";
+var_dump(current($a));
+
+array_splice($a, 0, 0, [999]);
+
+echo "After array_splice: ";
+var_dump(current($a));
+?>
+--EXPECT--
+Before array_splice: int(3)
+After array_splice: int(999)
diff --git a/tests/std/array/gh20043.phpt b/tests/std/array/gh20043.phpt
new file mode 100644
index 00000000..d5c7e064
--- /dev/null
+++ b/tests/std/array/gh20043.phpt
@@ -0,0 +1,12 @@
+--TEST--
+GH-20043 (array_unique assertion failure with RC1 array causing an exception on sort)
+--FILE--
+<?php
+try {
+	array_unique([new stdClass, new stdClass], SORT_STRING | SORT_FLAG_CASE);
+} catch (Error $e) {
+	echo $e->getMessage();
+}
+?>
+--EXPECT--
+Object of class stdClass could not be converted to string
diff --git a/tests/std/array/gh9244.phpt b/tests/std/array/gh9244.phpt
new file mode 100644
index 00000000..04c34d42
--- /dev/null
+++ b/tests/std/array/gh9244.phpt
@@ -0,0 +1,11 @@
+--TEST--
+Bug GH-9244 (Segfault with array_multisort + array_shift)
+--FILE--
+<?php
+$items = ['foo' => 1, 'bar' => 2];
+$order = [4, 3];
+array_multisort($order, $items);
+var_dump(array_shift($items));
+?>
+--EXPECT--
+int(2)
diff --git a/tests/std/array/gh9296.phpt b/tests/std/array/gh9296.phpt
new file mode 100644
index 00000000..cfbc5cbb
--- /dev/null
+++ b/tests/std/array/gh9296.phpt
@@ -0,0 +1,17 @@
+--TEST--
+GH-9296: incorrect ksort(..., SORT_REGULAR) behaviour on arrays with numeric and string keys
+--FILE--
+<?php
+$array = ["aaa" => 0, 600 => 1];
+ksort($array, SORT_REGULAR);
+var_dump($array);
+var_dump(array_key_first($array) <=> array_key_last($array));
+?>
+--EXPECT--
+array(2) {
+  [600]=>
+  int(1)
+  ["aaa"]=>
+  int(0)
+}
+int(-1)
diff --git a/tests/std/array/in_array_variation1.phpt b/tests/std/array/in_array_variation1.phpt
new file mode 100644
index 00000000..0c88a453
--- /dev/null
+++ b/tests/std/array/in_array_variation1.phpt
@@ -0,0 +1,635 @@
+--TEST--
+Test in_array() function : usage variations - different needdle values
+--FILE--
+<?php
+/* Test in_array() with different possible needle values */
+
+echo "*** Testing in_array() with different needle values ***\n";
+$arrays = array (
+  array(0),
+  array("a" => "A", 2 => "B", "C" => 3, 4 => 4, "one" => 1, "" => NULL, "b", "ab", "abcd"),
+  array(4, array(1, 2 => 3), "one" => 1, "5" => 5 ),
+  array(-1, -2, -3, -4, -2.989888, "-0.005" => "neg0.005", 2 => "float2", "-.9" => -.9),
+  array(TRUE, FALSE),
+  array("", array()),
+  array("abcd\x00abcd\x00abcd"),
+  array("abcd\tabcd\nabcd\rabcd\0abcdefghij")
+);
+
+$array_compare = array (
+  4,
+  "4",
+  4.00,
+  "b",
+  "5",
+  -2,
+  -2.0,
+  -2.98989,
+  "-.9",
+  "True",
+  "",
+  array(),
+  NULL,
+  "ab",
+  "abcd",
+  0.0,
+  -0,
+  "abcd\x00abcd\x00abcd"
+);
+/* loop to check if elements in $array_compare exist in $arrays
+   using in_array() */
+$counter = 1;
+foreach($arrays as $array) {
+  foreach($array_compare as $compare) {
+    echo "-- Iteration $counter --\n";
+    //strict option OFF
+    var_dump(in_array($compare,$array));
+    //strict option ON
+    var_dump(in_array($compare,$array,TRUE));
+    //strict option OFF
+    var_dump(in_array($compare,$array,FALSE));
+    $counter++;
+ }
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing in_array() with different needle values ***
+-- Iteration 1 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 2 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 3 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 4 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 5 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 6 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 7 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 8 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 9 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 10 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 11 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 12 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 13 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 14 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 15 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 16 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 17 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 18 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 19 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 20 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 21 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 22 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 23 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 24 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 25 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 26 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 27 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 28 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 29 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 30 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 31 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 32 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 33 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 34 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 35 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 36 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 37 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 38 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 39 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 40 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 41 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 42 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 43 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 44 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 45 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 46 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 47 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 48 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 49 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 50 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 51 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 52 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 53 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 54 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 55 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 56 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 57 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 58 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 59 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 60 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 61 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 62 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 63 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 64 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 65 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 66 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 67 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 68 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 69 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 70 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 71 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 72 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 73 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 74 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 75 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 76 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 77 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 78 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 79 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 80 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 81 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 82 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 83 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 84 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 85 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 86 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 87 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 88 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 89 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 90 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 91 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 92 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 93 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 94 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 95 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 96 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 97 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 98 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 99 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 100 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 101 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 102 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 103 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 104 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 105 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 106 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 107 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 108 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 109 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 110 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 111 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 112 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 113 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 114 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 115 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 116 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 117 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 118 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 119 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 120 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 121 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 122 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 123 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 124 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 125 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 126 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 127 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 128 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 129 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 130 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 131 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 132 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 133 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 134 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 135 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 136 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 137 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 138 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 139 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 140 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 141 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 142 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 143 --
+bool(false)
+bool(false)
+bool(false)
+-- Iteration 144 --
+bool(false)
+bool(false)
+bool(false)
+Done
diff --git a/tests/std/array/in_array_variation2.phpt b/tests/std/array/in_array_variation2.phpt
new file mode 100644
index 00000000..39762322
--- /dev/null
+++ b/tests/std/array/in_array_variation2.phpt
@@ -0,0 +1,95 @@
+--TEST--
+Test in_array() function : usage variations - different haystack values
+--FILE--
+<?php
+/* Test in_array() with different possible haystack values */
+
+echo "*** Testing in_array() with different haystack values ***\n";
+$misc_array = array (
+  'a',
+  'key' =>'d',
+  3,
+  ".001" =>-67,
+  "-.051" =>"k",
+  0 =>"-.08",
+  "e" =>"5",
+  "y" =>NULL,
+  NULL =>"",
+  0,
+  TRUE,
+  FALSE,
+  -27.39999999999,
+  " ",
+  "abcd\x00abcd\x00\abcd\x00abcdefghij",
+  "abcd\nabcd\tabcd\rabcd\0abcd"
+);
+$array_type = array(TRUE, FALSE, 1, 0, -1, "1", "0", "-1", NULL, array(), "PHP", "");
+/* loop to do loose and strict type check of elements in
+   $array_type on elements in $misc_array using in_array();
+   checking PHP type comparison tables
+*/
+$counter = 1;
+foreach($array_type as $type) {
+  echo "-- Iteration $counter --\n";
+  //loose type checking
+  var_dump( in_array($type,$misc_array ) );
+  //strict type checking
+  var_dump( in_array($type,$misc_array,true) );
+  //loose type checking
+  var_dump( in_array($type,$misc_array,false) );
+  $counter++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing in_array() with different haystack values ***
+-- Iteration 1 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 2 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 3 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 4 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 5 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 6 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 7 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 8 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 9 --
+bool(true)
+bool(true)
+bool(true)
+-- Iteration 10 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 11 --
+bool(true)
+bool(false)
+bool(true)
+-- Iteration 12 --
+bool(true)
+bool(true)
+bool(true)
+Done
diff --git a/tests/std/array/in_array_variation3.phpt b/tests/std/array/in_array_variation3.phpt
new file mode 100644
index 00000000..de0a5e7d
--- /dev/null
+++ b/tests/std/array/in_array_variation3.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Test in_array() function : usage variations - haystack as sub-array/object
+--SKIPIF--
+<?php die("skip AOT resource/object search differs from PHP"); ?>
+--FILE--
+<?php
+class in_array_check
+{
+    public $array_var = array(1 => "one", "two" => 2, 3 => 3);
+    public function foo()
+    {
+        echo "Public function\n";
+    }
+}
+function main()
+{
+    /* Test in_array() with haystack as sub-array and object */
+    /* checking for sub-arrays with in_array() */
+    echo "*** Testing sub-arrays with in_array() ***\n";
+    $sub_array = array("one", array(1, 2 => "two", "three" => 3), 4 => "four", "five" => 5, array('', 'i'));
+    var_dump(in_array("four", $sub_array));
+    //checking for element in a sub-array
+    var_dump(in_array(3, $sub_array[1]));
+    var_dump(in_array(array('', 'i'), $sub_array));
+    /* checking for objects in in_array() */
+    echo "\n*** Testing objects with in_array() ***\n";
+    $in_array_obj = new in_array_check();
+    //creating new object
+    //error: as wrong datatype for second argument
+    try {
+        var_dump(in_array("array_var", $in_array_obj));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    //error: as wrong datatype for second argument
+    try {
+        var_dump(in_array("foo", $in_array_obj));
+    } catch (TypeError $e) {
+        echo $e->getMessage(), "\n";
+    }
+    //element found as "one" exists in array $array_var
+    var_dump(in_array("one", $in_array_obj->array_var));
+    echo "Done\n";
+}
+?>
+--EXPECT--
+*** Testing sub-arrays with in_array() ***
+bool(true)
+bool(true)
+bool(true)
+
+*** Testing objects with in_array() ***
+in_array(): Argument #2 ($haystack) must be of type array, in_array_check given
+in_array(): Argument #2 ($haystack) must be of type array, in_array_check given
+bool(true)
+Done
diff --git a/tests/std/array/in_array_variation4.phpt b/tests/std/array/in_array_variation4.phpt
new file mode 100644
index 00000000..c7c91278
--- /dev/null
+++ b/tests/std/array/in_array_variation4.phpt
@@ -0,0 +1,70 @@
+--TEST--
+Test in_array() function : usage variations - haystack as resource/multi dimensional array
+--FILE--
+<?php
+/* Test in_array() with haystack as resource and multidimensional arrays */
+
+/* checking for Resources */
+echo "*** Testing resource type with in_array() ***\n";
+//file type resource
+$file_handle = fopen(__FILE__, "r");
+
+//directory type resource
+$dir_handle = opendir( __DIR__ );
+
+//store resources in array for comparison.
+$resources = array($file_handle, $dir_handle);
+
+// search for resource type in the resource array
+var_dump( in_array($file_handle, $resources, true) );
+//checking for (int) type resource
+var_dump( in_array((int)$dir_handle, $resources, true) );
+
+/* Miscellenous input check  */
+echo "\n*** Testing miscelleneos inputs with in_array() ***\n";
+//matching "Good" in array(0,"hello"), result:true in loose type check
+var_dump( in_array("Good", array(0,"hello")) );
+//false in strict mode
+var_dump( in_array("Good", array(0,"hello"), TRUE) );
+
+//matching integer 0 in array("this"), result:true in loose type check
+var_dump( in_array(0, array("this")) );
+// false in strict mode
+var_dump( in_array(0, array("this")),TRUE );
+
+//matching string "this" in array(0), result:true in loose type check
+var_dump( in_array("this", array(0)) );
+// false in stric mode
+var_dump( in_array("this", array(0), TRUE) );
+
+//checking for type FALSE in multidimensional array with loose checking, result:false in loose type check
+var_dump( in_array(FALSE,
+                   array("a"=> TRUE, "b"=> TRUE,
+                         array("c"=> TRUE, "d"=>TRUE)
+                        )
+                  )
+        );
+
+//matching string having integer in beginning, result:true in loose type check
+var_dump( in_array('123abc', array(123)) );
+var_dump( in_array('123abc', array(123), TRUE) ); // false in strict mode
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing resource type with in_array() ***
+bool(true)
+bool(false)
+
+*** Testing miscelleneos inputs with in_array() ***
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+Done
diff --git a/tests/std/array/in_array_with_ref.phpt b/tests/std/array/in_array_with_ref.phpt
new file mode 100644
index 00000000..2ad3667d
--- /dev/null
+++ b/tests/std/array/in_array_with_ref.phpt
@@ -0,0 +1,14 @@
+--TEST--
+in_array() with references
+--FILE--
+<?php
+
+$value = 42;
+$array = [&$value];
+var_dump(in_array(42, $array, false));
+var_dump(in_array(42, $array, true));
+
+?>
+--EXPECT--
+bool(true)
+bool(true)
diff --git a/tests/std/array/key_basic.phpt b/tests/std/array/key_basic.phpt
new file mode 100644
index 00000000..f6b9300b
--- /dev/null
+++ b/tests/std/array/key_basic.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Test key() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of key()
+ */
+
+echo "*** Testing key() : basic functionality ***\n";
+
+$array = array ('zero', 99 => 'one', 'two', 'three' => 3);
+echo "\n-- Initial Position: --\n";
+var_dump(key($array));
+
+echo "\n-- Next Position: --\n";
+next($array);
+var_dump(key($array));
+
+echo "\n-- End Position: --\n";
+end($array);
+var_dump(key($array));
+
+echo "\n-- Past end of the array --\n";
+next($array);
+var_dump(key($array));
+?>
+--EXPECT--
+*** Testing key() : basic functionality ***
+
+-- Initial Position: --
+int(0)
+
+-- Next Position: --
+int(99)
+
+-- End Position: --
+string(5) "three"
+
+-- Past end of the array --
+NULL
diff --git a/tests/std/array/key_exists_basic.phpt b/tests/std/array/key_exists_basic.phpt
new file mode 100644
index 00000000..37fed4e2
--- /dev/null
+++ b/tests/std/array/key_exists_basic.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Test function key_exists() by calling it with its expected arguments
+--CREDITS--
+Francesco Fullone ff@ideato.it
+#PHPTestFest Cesena Italia on 2009-06-20
+--FILE--
+<?php
+echo "*** test key_exists() by calling it with its expected arguments ***\n";
+$a = array('bar' => 1);
+var_dump(key_exists('bar', $a));
+var_dump(key_exists('foo', $a));
+?>
+--EXPECT--
+*** test key_exists() by calling it with its expected arguments ***
+bool(true)
+bool(false)
diff --git a/tests/std/array/key_exists_variation1.phpt b/tests/std/array/key_exists_variation1.phpt
new file mode 100644
index 00000000..b902a9ea
--- /dev/null
+++ b/tests/std/array/key_exists_variation1.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Test function key_exists() by calling it with its expected arguments
+--CREDITS--
+Francesco Fullone ff@ideato.it
+#PHPTestFest Cesena Italia on 2009-06-20
+--FILE--
+<?php
+echo "*** test key_exists() by calling it with its expected arguments ***\n";
+$a = array('bar' => 1, 'foo' => array('bar' => 2, 'baz' => 3));
+var_dump(key_exists('baz', $a));
+var_dump(key_exists('baz', $a['foo']));
+?>
+--EXPECT--
+*** test key_exists() by calling it with its expected arguments ***
+bool(false)
+bool(true)
diff --git a/tests/std/array/key_exists_variation2.phpt b/tests/std/array/key_exists_variation2.phpt
new file mode 100644
index 00000000..cb2b9502
--- /dev/null
+++ b/tests/std/array/key_exists_variation2.phpt
@@ -0,0 +1,64 @@
+--TEST--
+Test function key_exists() by calling it with its expected arguments
+--CREDITS--
+Francesco Fullone ff@ideato.it
+#PHPTestFest Cesena Italia on 2009-06-20
+--FILE--
+<?php
+class ObjectA
+{
+    public $foo = 'bar';
+}
+function main()
+{
+    echo "*** test key_exists() by using mixed type of arrays ***\n";
+    // there is not a index = 0 element
+    $a = array(1 => 'bar', 'foo' => 'baz');
+    var_dump(key_exists(0, $a));
+    echo "integer\n";
+    // 1 has index = 0
+    $b = array(1, 'foo' => 'baz');
+    var_dump(key_exists(0, $b));
+    // 42 has index = 0, netherless its position is the latest
+    $c = array('foo' => 'baz', 42);
+    var_dump(key_exists(0, $c));
+    echo "string\n";
+    // 'bar' has index = 0, netherless it is a string
+    $d = array('bar', 'foo' => 'baz');
+    var_dump(key_exists(0, $d));
+    // 'baz' has index = 0, netherless its position is the latest
+    $e = array('foo' => 'baz', 'baz');
+    var_dump(key_exists(0, $e));
+    echo "obj\n";
+    $obj = new ObjectA();
+    // object has index = 0, netherless its position is the latest
+    $f = array('foo' => 'baz', $obj);
+    var_dump(key_exists(0, $f));
+    // object has index = 0, netherless its position is the first
+    $g = array($obj, 'foo' => 'baz');
+    var_dump(key_exists(0, $g));
+    echo "stream resource\n";
+    // stream resource has index = 0, netherless its position is the first
+    $st = fopen('php://memory', '+r');
+    $h = array($st, 'foo' => 'baz');
+    var_dump(key_exists(0, $h));
+    // stream resource has index = 0, netherless its position is the latest
+    $i = array('foo' => 'baz', $st);
+    var_dump(key_exists(0, $i));
+}
+?>
+--EXPECT--
+*** test key_exists() by using mixed type of arrays ***
+bool(false)
+integer
+bool(true)
+bool(true)
+string
+bool(true)
+bool(true)
+obj
+bool(true)
+bool(true)
+stream resource
+bool(true)
+bool(true)
diff --git a/tests/std/array/key_variation2.phpt b/tests/std/array/key_variation2.phpt
new file mode 100644
index 00000000..a81c3350
--- /dev/null
+++ b/tests/std/array/key_variation2.phpt
@@ -0,0 +1,132 @@
+--TEST--
+Test key() function : usage variations
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Pass arrays where keys are different data types as $array_arg to key() to test behaviour
+ */
+
+echo "*** Testing key() : usage variations ***\n";
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// heredoc string
+$heredoc = <<<EOT
+hello world
+EOT;
+
+// unexpected values to be passed as $array_arg
+$inputs = array(
+
+       // int data
+/*1*/  'int' => array(
+       0 => 'zero',
+       1 => 'one',
+       12345 => 'positive',
+       -2345 => 'negative',
+       ),
+
+       // null data
+/*4*/ 'null uppercase' => array(
+       NULL => 'null 1',
+       ),
+
+/*5*/  'null lowercase' => array(
+       null => 'null 2',
+       ),
+
+       // boolean data
+/*6*/ 'bool lowercase' => array(
+       true => 'lowert',
+       false => 'lowerf',
+       ),
+
+/*7*/  'bool uppercase' => array(
+       TRUE => 'uppert',
+       FALSE => 'upperf',
+       ),
+
+       // empty data
+/*8*/ 'empty double quotes' => array(
+       "" => 'emptyd',
+       ),
+
+/*9*/  'empty single quotes' => array(
+       '' => 'emptys',
+       ),
+
+       // string data
+/*10*/ 'string' => array(
+       "stringd" => 'stringd',
+       'strings' => 'strings',
+       $heredoc => 'stringh',
+       ),
+
+       // undefined data
+/*11*/ 'undefined' => array(
+       @$undefined_var => 'undefined',
+       ),
+
+       // unset data
+/*12*/ 'unset' => array(
+       @$unset_var => 'unset',
+       ),
+);
+
+// loop through each element of $inputs to check the behavior of key()
+$iterator = 1;
+foreach($inputs as $key => $input) {
+  echo "\n-- Iteration $iterator : $key data --\n";
+  while (key($input) !== NULL) {
+    var_dump(key($input));
+    next($input);
+  }
+  $iterator++;
+};
+?>
+--EXPECT--
+*** Testing key() : usage variations ***
+
+-- Iteration 1 : int data --
+int(0)
+int(1)
+int(12345)
+int(-2345)
+
+-- Iteration 2 : null uppercase data --
+string(0) ""
+
+-- Iteration 3 : null lowercase data --
+string(0) ""
+
+-- Iteration 4 : bool lowercase data --
+int(1)
+int(0)
+
+-- Iteration 5 : bool uppercase data --
+int(1)
+int(0)
+
+-- Iteration 6 : empty double quotes data --
+string(0) ""
+
+-- Iteration 7 : empty single quotes data --
+string(0) ""
+
+-- Iteration 8 : string data --
+string(7) "stringd"
+string(7) "strings"
+string(11) "hello world"
+
+-- Iteration 9 : undefined data --
+string(0) ""
+
+-- Iteration 10 : unset data --
+string(0) ""
diff --git a/tests/std/array/key_variation3.phpt b/tests/std/array/key_variation3.phpt
new file mode 100644
index 00000000..dfebd4bd
--- /dev/null
+++ b/tests/std/array/key_variation3.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Test key() function : usage variations
+--FILE--
+<?php
+/*
+ * Test how the internal pointer is affected when two variables are referenced to each other
+ */
+
+echo "*** Testing key() : usage variations ***\n";
+
+$array1 = array ('zero', 'one', 'two');
+
+echo "\n-- Initial position of internal pointer --\n";
+var_dump(key($array1));
+
+// Test that when two variables are referenced to one another
+// the internal pointer is the same for both
+$array2 = &$array1;
+
+next($array1);
+
+echo "\n-- Position after calling next() --\n";
+echo "\$array1: ";
+var_dump(key($array1));
+echo "\$array2: ";
+var_dump(key($array2));
+?>
+--EXPECT--
+*** Testing key() : usage variations ***
+
+-- Initial position of internal pointer --
+int(0)
+
+-- Position after calling next() --
+$array1: int(1)
+$array2: int(1)
diff --git a/tests/std/array/key_variation4.phpt b/tests/std/array/key_variation4.phpt
new file mode 100644
index 00000000..a71e6732
--- /dev/null
+++ b/tests/std/array/key_variation4.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Test key() function : usage variations
+--FILE--
+<?php
+/*
+ * Test how key() behaves with muti-dimensional and recursive arrays
+ */
+
+echo "*** Testing key() : usage variations ***\n";
+
+echo "\n-- Two Dimensional Array --\n";
+$multi_array = array ('zero', array (1, 2, 3), 'two');
+echo "Initial Position: ";
+var_dump(key($multi_array));
+
+echo "Next Position:    ";
+next($multi_array);
+var_dump(key($multi_array));
+
+echo "End Position:     ";
+end($multi_array);
+var_dump(key($multi_array));
+
+echo "\n-- Access an Array Within an Array --\n";
+//accessing an array within an array
+echo "Initial Position: ";
+var_dump(key($multi_array[1]));
+
+echo "\n-- Recursive, Multidimensional Array --\n";
+//create a recursive array
+$multi_array[] = &$multi_array;
+
+//See where internal pointer is after adding more elements
+echo "Current Position: ";
+var_dump(key($multi_array));
+
+//see if internal pointer is in same position as referenced array
+var_dump(key($multi_array[3][3][3]));
+// see if internal pointer is in the same position from when accessing this inner array
+var_dump(key($multi_array[3][3][3][1]));
+?>
+--EXPECT--
+*** Testing key() : usage variations ***
+
+-- Two Dimensional Array --
+Initial Position: int(0)
+Next Position:    int(1)
+End Position:     int(2)
+
+-- Access an Array Within an Array --
+Initial Position: int(0)
+
+-- Recursive, Multidimensional Array --
+Current Position: int(2)
+int(2)
+int(0)
diff --git a/tests/std/array/krsort_basic.phpt b/tests/std/array/krsort_basic.phpt
new file mode 100644
index 00000000..6137e1b2
--- /dev/null
+++ b/tests/std/array/krsort_basic.phpt
@@ -0,0 +1,240 @@
+--TEST--
+Test krsort() function : basic functionality
+--FILE--
+<?php
+/*
+ * Testing krsort() by providing array of integer/string values to check the basic functionality
+ * with following flag values :
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_NUMERIC - compare items numerically
+ *  4.SORT_STRING - compare items as strings
+*/
+
+echo "*** Testing krsort() : basic functionality ***\n";
+
+// an array containing unsorted string values with indices
+$unsorted_strings =   array( "lemon" => "l", "orange" => "o", "banana" => "b" );
+$unsorted_strings = array(
+    "l" => "lemon", "o" => "orange",
+    "O" => "Orange", "O1" => "Orange1", "o2" => "orange2", "O3" => "Orange3", "o20" => "orange20",
+    "b" => "banana",
+);
+// an array containing unsorted numeric values with indices
+$unsorted_numerics =  array( 100 => 4, 33 => 3, 555 => 2, 22 => 1 );
+
+echo "\n-- Testing krsort() by supplying string array, 'flag' value is default --\n";
+$temp_array = $unsorted_strings;
+var_dump( krsort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing krsort() by supplying numeric array, 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( krsort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing krsort() by supplying string array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_strings;
+var_dump( krsort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing krsort() by supplying numeric array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_numerics;
+var_dump( krsort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing krsort() by supplying string array, 'flag' = SORT_STRING --\n";
+$temp_array = $unsorted_strings;
+var_dump( krsort($temp_array, SORT_STRING) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing krsort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( krsort($temp_array, SORT_STRING|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing krsort() by supplying string array (natural), 'flag' = SORT_NATURAL --\n";
+$temp_array = $unsorted_strings;
+var_dump( krsort($temp_array, SORT_NATURAL) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing krsort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( krsort($temp_array, SORT_NATURAL|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing krsort() by supplying numeric array, 'flag' = SORT_NUMERIC --\n";
+$temp_array = $unsorted_numerics;
+var_dump( krsort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing krsort() : basic functionality ***
+
+-- Testing krsort() by supplying string array, 'flag' value is default --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o"]=>
+  string(6) "orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O"]=>
+  string(6) "Orange"
+}
+
+-- Testing krsort() by supplying numeric array, 'flag' value is default --
+bool(true)
+array(4) {
+  [555]=>
+  int(2)
+  [100]=>
+  int(4)
+  [33]=>
+  int(3)
+  [22]=>
+  int(1)
+}
+
+-- Testing krsort() by supplying string array, 'flag' = SORT_REGULAR --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o"]=>
+  string(6) "orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O"]=>
+  string(6) "Orange"
+}
+
+-- Testing krsort() by supplying numeric array, 'flag' = SORT_REGULAR --
+bool(true)
+array(4) {
+  [555]=>
+  int(2)
+  [100]=>
+  int(4)
+  [33]=>
+  int(3)
+  [22]=>
+  int(1)
+}
+
+-- Testing krsort() by supplying string array, 'flag' = SORT_STRING --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o"]=>
+  string(6) "orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O"]=>
+  string(6) "Orange"
+}
+
+-- Testing krsort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  ["O3"]=>
+  string(7) "Orange3"
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["o"]=>
+  string(6) "orange"
+  ["O"]=>
+  string(6) "Orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+}
+
+-- Testing krsort() by supplying string array (natural), 'flag' = SORT_NATURAL --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o"]=>
+  string(6) "orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O"]=>
+  string(6) "Orange"
+}
+
+-- Testing krsort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  ["o20"]=>
+  string(8) "orange20"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["o2"]=>
+  string(7) "orange2"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["o"]=>
+  string(6) "orange"
+  ["O"]=>
+  string(6) "Orange"
+  ["l"]=>
+  string(5) "lemon"
+  ["b"]=>
+  string(6) "banana"
+}
+
+-- Testing krsort() by supplying numeric array, 'flag' = SORT_NUMERIC --
+bool(true)
+array(4) {
+  [555]=>
+  int(2)
+  [100]=>
+  int(4)
+  [33]=>
+  int(3)
+  [22]=>
+  int(1)
+}
+Done
diff --git a/tests/std/array/krsort_object.phpt b/tests/std/array/krsort_object.phpt
new file mode 100644
index 00000000..6e75ce1f
--- /dev/null
+++ b/tests/std/array/krsort_object.phpt
@@ -0,0 +1,220 @@
+--TEST--
+Test krsort() function : object functionality - sort objects
+--FILE--
+<?php
+// class declaration for integer objects
+class IntegerObject
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+}
+// class declaration for string objects
+class StringObject
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * testing krsort() by providing array of integer/string objects with following flag values:
+     *  1.Default flag value
+     *  2.SORT_REGULAR - compare items normally
+    */
+    echo "*** Testing krsort() : object functionality ***\n";
+    // array of integer objects with different key values
+    $unsorted_int_obj = array(10 => new IntegerObject(11), 20 => new IntegerObject(66), 3 => new IntegerObject(23), 4 => new IntegerObject(-5), 50 => new IntegerObject(0.001), 6 => new IntegerObject(0));
+    // array of string objects with different key values
+    $unsorted_str_obj = array("axx" => new StringObject("axx"), "t" => new StringObject("t"), "w" => new StringObject("w"), "py" => new StringObject("py"), "apple" => new StringObject("apple"), "Orange" => new StringObject("Orange"), "Lemon" => new StringObject("Lemon"), "aPPle" => new StringObject("aPPle"));
+    echo "\n-- Testing krsort() by supplying various object arrays, 'flag' value is default --\n";
+    // testing krsort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(krsort($temp_array));
+    var_dump($temp_array);
+    // testing krsort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(krsort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Testing krsort() by supplying various object arrays, 'flag' value is SORT_REGULAR --\n";
+    // testing krsort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(krsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing krsort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(krsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+*** Testing krsort() : object functionality ***
+
+-- Testing krsort() by supplying various object arrays, 'flag' value is default --
+bool(true)
+array(6) {
+  [50]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [20]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+  [10]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [6]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [4]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+  [3]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+}
+bool(true)
+array(8) {
+  ["w"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+  ["t"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  ["py"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  ["axx"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  ["apple"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  ["aPPle"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  ["Orange"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  ["Lemon"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+}
+
+-- Testing krsort() by supplying various object arrays, 'flag' value is SORT_REGULAR --
+bool(true)
+array(6) {
+  [50]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [20]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+  [10]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [6]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [4]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+  [3]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+}
+bool(true)
+array(8) {
+  ["w"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+  ["t"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  ["py"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  ["axx"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  ["apple"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  ["aPPle"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  ["Orange"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  ["Lemon"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+}
+Done
diff --git a/tests/std/array/krsort_variation10.phpt b/tests/std/array/krsort_variation10.phpt
new file mode 100644
index 00000000..104ed032
--- /dev/null
+++ b/tests/std/array/krsort_variation10.phpt
@@ -0,0 +1,93 @@
+--TEST--
+Test krsort() function : usage variations - sort heredoc strings
+--FILE--
+<?php
+/*
+ * testing krsort() by providing array of heredoc strings for $array argument with
+ * following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_STRING  - compare items as strings
+*/
+
+echo "*** Testing krsort() : usage variations ***\n";
+
+// Different heredoc strings to be sorted
+$simple_heredoc1 =<<<EOT
+Heredoc
+EOT;
+
+$simple_heredoc2 =<<<EOT
+HEREDOC
+EOT;
+
+$multiline_heredoc =<<<EOT
+heredoc string\twith!@# and 123
+Test this!!!
+EOT;
+
+$array = array (
+  $simple_heredoc1 => "Heredoc",
+  $simple_heredoc2 => "HEREDOC",
+  $multiline_heredoc => "heredoc string\twith!@# and 123\nTest this!!!"
+);
+
+echo "\n-- Testing krsort() by supplying heredoc string array, 'flag' value is default --\n";
+$temp_array = $array;
+var_dump(krsort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying heredoc string array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $array;
+var_dump(krsort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying heredoc string array, 'flag' = SORT_STRING --\n";
+$temp_array = $array;
+var_dump(krsort($temp_array, SORT_STRING) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing krsort() : usage variations ***
+
+-- Testing krsort() by supplying heredoc string array, 'flag' value is default --
+bool(true)
+array(3) {
+  ["heredoc string	with!@# and 123
+Test this!!!"]=>
+  string(43) "heredoc string	with!@# and 123
+Test this!!!"
+  ["Heredoc"]=>
+  string(7) "Heredoc"
+  ["HEREDOC"]=>
+  string(7) "HEREDOC"
+}
+
+-- Testing krsort() by supplying heredoc string array, 'flag' = SORT_REGULAR --
+bool(true)
+array(3) {
+  ["heredoc string	with!@# and 123
+Test this!!!"]=>
+  string(43) "heredoc string	with!@# and 123
+Test this!!!"
+  ["Heredoc"]=>
+  string(7) "Heredoc"
+  ["HEREDOC"]=>
+  string(7) "HEREDOC"
+}
+
+-- Testing krsort() by supplying heredoc string array, 'flag' = SORT_STRING --
+bool(true)
+array(3) {
+  ["heredoc string	with!@# and 123
+Test this!!!"]=>
+  string(43) "heredoc string	with!@# and 123
+Test this!!!"
+  ["Heredoc"]=>
+  string(7) "Heredoc"
+  ["HEREDOC"]=>
+  string(7) "HEREDOC"
+}
+Done
diff --git a/tests/std/array/krsort_variation11.phpt b/tests/std/array/krsort_variation11.phpt
new file mode 100644
index 00000000..9e0e696f
--- /dev/null
+++ b/tests/std/array/krsort_variation11.phpt
@@ -0,0 +1,77 @@
+--TEST--
+Test krsort() function : usage variations - sort bool values
+--SKIPIF--
+--FILE--
+<?php
+/*
+ * testing krsort() by providing array of boolean values for $array argument with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing krsort() : usage variations ***\n";
+
+// bool value array
+$bool_values = array (true => true, false => false, TRUE => TRUE, FALSE => FALSE);
+
+echo "\n-- Testing krsort() by supplying boolean value array, 'flag' value is default --\n";
+$temp_array = $bool_values;
+var_dump(krsort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying boolean value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $bool_values;
+var_dump(krsort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying boolean value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $bool_values;
+var_dump(krsort($temp_array, SORT_NUMERIC) );
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying boolean value array, 'flag' value is SORT_STRING --\n";
+$temp_array = $bool_values;
+var_dump(krsort($temp_array, SORT_STRING) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing krsort() : usage variations ***
+
+-- Testing krsort() by supplying boolean value array, 'flag' value is default --
+bool(true)
+array(2) {
+  [1]=>
+  bool(true)
+  [0]=>
+  bool(false)
+}
+
+-- Testing krsort() by supplying boolean value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(2) {
+  [1]=>
+  bool(true)
+  [0]=>
+  bool(false)
+}
+
+-- Testing krsort() by supplying boolean value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(2) {
+  [1]=>
+  bool(true)
+  [0]=>
+  bool(false)
+}
+
+-- Testing krsort() by supplying boolean value array, 'flag' value is SORT_STRING --
+bool(true)
+array(2) {
+  [1]=>
+  bool(true)
+  [0]=>
+  bool(false)
+}
+Done
diff --git a/tests/std/array/krsort_variation3.phpt b/tests/std/array/krsort_variation3.phpt
new file mode 100644
index 00000000..979d3844
--- /dev/null
+++ b/tests/std/array/krsort_variation3.phpt
@@ -0,0 +1,204 @@
+--TEST--
+Test krsort() function : usage variations - sort integer/float values
+--FILE--
+<?php
+/*
+ * Testing krsort() by providing array of integer/float/mixed values for $array argument
+ * with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing krsort() : usage variations ***\n";
+
+// diff. associative arrays to sort
+$various_arrays = array(
+  // negative/positive integer key value array
+  array(1 => 11, -2 => -11, 3 => 21, -4 => -21, 5 => 31, -6 => -31, 7 => 0, 8 => 41, -10 =>-41),
+
+  // mixed value array with different types of keys
+  array(1 => .0001, 2 => .0021, -3 => -.01, 4 => -1, 5 => 0, 6 => .09, 7 => 2, -8 => -.9, 9 => 10.6E-2,
+        -10 => -10.6E-2, 11 => 33)
+);
+
+// set of possible flag values
+$flags = array("SORT_REGULAR" => SORT_REGULAR, "SORT_NUMERIC" => SORT_NUMERIC);
+
+$count = 1;
+echo "\n-- Testing krsort() by supplying various integer/float arrays --\n";
+
+// loop through to test krsort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort flag -\n";
+  $temp_array = $array;
+  var_dump(krsort($temp_array) );
+  var_dump($temp_array);
+
+  // loop through $flags array and call krsort() with all possible sort flag values
+  foreach($flags as $key => $flag){
+    echo "- Sort flag = $key -\n";
+    $temp_array = $array;
+    var_dump(krsort($temp_array, $flag) );
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing krsort() : usage variations ***
+
+-- Testing krsort() by supplying various integer/float arrays --
+
+-- Iteration 1 --
+- With default sort flag -
+bool(true)
+array(9) {
+  [8]=>
+  int(41)
+  [7]=>
+  int(0)
+  [5]=>
+  int(31)
+  [3]=>
+  int(21)
+  [1]=>
+  int(11)
+  [-2]=>
+  int(-11)
+  [-4]=>
+  int(-21)
+  [-6]=>
+  int(-31)
+  [-10]=>
+  int(-41)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(9) {
+  [8]=>
+  int(41)
+  [7]=>
+  int(0)
+  [5]=>
+  int(31)
+  [3]=>
+  int(21)
+  [1]=>
+  int(11)
+  [-2]=>
+  int(-11)
+  [-4]=>
+  int(-21)
+  [-6]=>
+  int(-31)
+  [-10]=>
+  int(-41)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(9) {
+  [8]=>
+  int(41)
+  [7]=>
+  int(0)
+  [5]=>
+  int(31)
+  [3]=>
+  int(21)
+  [1]=>
+  int(11)
+  [-2]=>
+  int(-11)
+  [-4]=>
+  int(-21)
+  [-6]=>
+  int(-31)
+  [-10]=>
+  int(-41)
+}
+
+-- Iteration 2 --
+- With default sort flag -
+bool(true)
+array(11) {
+  [11]=>
+  int(33)
+  [9]=>
+  float(0.106)
+  [7]=>
+  int(2)
+  [6]=>
+  float(0.09)
+  [5]=>
+  int(0)
+  [4]=>
+  int(-1)
+  [2]=>
+  float(0.0021)
+  [1]=>
+  float(0.0001)
+  [-3]=>
+  float(-0.01)
+  [-8]=>
+  float(-0.9)
+  [-10]=>
+  float(-0.106)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  [11]=>
+  int(33)
+  [9]=>
+  float(0.106)
+  [7]=>
+  int(2)
+  [6]=>
+  float(0.09)
+  [5]=>
+  int(0)
+  [4]=>
+  int(-1)
+  [2]=>
+  float(0.0021)
+  [1]=>
+  float(0.0001)
+  [-3]=>
+  float(-0.01)
+  [-8]=>
+  float(-0.9)
+  [-10]=>
+  float(-0.106)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(11) {
+  [11]=>
+  int(33)
+  [9]=>
+  float(0.106)
+  [7]=>
+  int(2)
+  [6]=>
+  float(0.09)
+  [5]=>
+  int(0)
+  [4]=>
+  int(-1)
+  [2]=>
+  float(0.0021)
+  [1]=>
+  float(0.0001)
+  [-3]=>
+  float(-0.01)
+  [-8]=>
+  float(-0.9)
+  [-10]=>
+  float(-0.106)
+}
+Done
diff --git a/tests/std/array/krsort_variation4.phpt b/tests/std/array/krsort_variation4.phpt
new file mode 100644
index 00000000..1f28d021
--- /dev/null
+++ b/tests/std/array/krsort_variation4.phpt
@@ -0,0 +1,109 @@
+--TEST--
+Test krsort() function : usage variations - sort octal values
+--FILE--
+<?php
+/*
+ * testing krsort() by providing array of octal values for $array argument
+ * with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing krsort() : usage variations ***\n";
+
+// an array containing unsorted octal values
+$unsorted_oct_array = array (
+  01235 => 01, 0321 => 02, 0345 => 03, 066 => 04, 0772 => 05,
+  077 => 06, -066 => -01, -0345 => -02, 0 => 0
+);
+
+echo "\n-- Testing krsort() by supplying octal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( krsort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying octal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( krsort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( krsort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing krsort() : usage variations ***
+
+-- Testing krsort() by supplying octal value array, 'flag' value is default  --
+bool(true)
+array(9) {
+  [669]=>
+  int(1)
+  [506]=>
+  int(5)
+  [229]=>
+  int(3)
+  [209]=>
+  int(2)
+  [63]=>
+  int(6)
+  [54]=>
+  int(4)
+  [0]=>
+  int(0)
+  [-54]=>
+  int(-1)
+  [-229]=>
+  int(-2)
+}
+
+-- Testing krsort() by supplying octal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(9) {
+  [669]=>
+  int(1)
+  [506]=>
+  int(5)
+  [229]=>
+  int(3)
+  [209]=>
+  int(2)
+  [63]=>
+  int(6)
+  [54]=>
+  int(4)
+  [0]=>
+  int(0)
+  [-54]=>
+  int(-1)
+  [-229]=>
+  int(-2)
+}
+
+-- Testing krsort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [669]=>
+  int(1)
+  [506]=>
+  int(5)
+  [229]=>
+  int(3)
+  [209]=>
+  int(2)
+  [63]=>
+  int(6)
+  [54]=>
+  int(4)
+  [0]=>
+  int(0)
+  [-54]=>
+  int(-1)
+  [-229]=>
+  int(-2)
+}
+Done
diff --git a/tests/std/array/krsort_variation5.phpt b/tests/std/array/krsort_variation5.phpt
new file mode 100644
index 00000000..616a23c8
--- /dev/null
+++ b/tests/std/array/krsort_variation5.phpt
@@ -0,0 +1,227 @@
+--TEST--
+Test krsort() function : usage variations - sort strings
+--SKIPIF--
+<?php die("skip AOT krsort string sort differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * testing krsort() by providing array of string values for $array argument with
+ * following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_STRING  - compare items as strings
+*/
+
+echo "*** Testing krsort() : usage variations ***\n";
+
+$various_arrays = array (
+  // diff. escape sequence chars with key values
+  array ( null =>  null, NULL => NULL, "\a" => "\a", "\cx" => "\cx", "\e" => "\e",
+          "\f" => "\f", "\n" =>"\n", "\r" => "\r", "\t" => "\t", "\xhh" => "\xhh",
+          "\ddd" => "\ddd", "\v" => "\v"
+        ),
+
+  // array containing different strings with key values
+  array ( 'Lemon' => "lemoN", 'o' => "Orange", 'B' => "banana", 'Apple' => "apple", 'te' => "Test",
+          't' => "TTTT", 'T' => "ttt", 'W' => "ww", 'X' => "x", 'x' => "X", 'O' => "oraNGe",
+          'B' => "BANANA"
+        )
+);
+
+$flags = array("SORT_REGULAR" => SORT_REGULAR, "SORT_STRING" => SORT_STRING);
+
+$count = 1;
+echo "\n-- Testing krsort() by supplying various string arrays --\n";
+
+// loop through to test krsort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort flag -\n";
+  $temp_array = $array;
+  var_dump(krsort($temp_array) ); // expecting : bool(true)
+  var_dump($temp_array);
+
+  // loop through $flags array and call krsort() with all possible sort flag values
+  foreach($flags as $key => $flag){
+    echo "- Sort flag = $key -\n";
+    $temp_array = $array;
+    var_dump(krsort($temp_array, $flag) ); // expecting : bool(true)
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing krsort() : usage variations ***
+
+-- Testing krsort() by supplying various string arrays --
+
+-- Iteration 1 --
+- With default sort flag -
+bool(true)
+array(11) {
+  ["\xhh"]=>
+  string(4) "\xhh"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\a"]=>
+  string(2) "\a"
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
+"]=>
+  string(1) "
+"
+  ["	"]=>
+  string(1) "	"
+  [""]=>
+  NULL
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  ["\xhh"]=>
+  string(4) "\xhh"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\a"]=>
+  string(2) "\a"
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
+"]=>
+  string(1) "
+"
+  ["	"]=>
+  string(1) "	"
+  [""]=>
+  NULL
+}
+- Sort flag = SORT_STRING -
+bool(true)
+array(11) {
+  ["\xhh"]=>
+  string(4) "\xhh"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\a"]=>
+  string(2) "\a"
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
+"]=>
+  string(1) "
+"
+  ["	"]=>
+  string(1) "	"
+  [""]=>
+  NULL
+}
+
+-- Iteration 2 --
+- With default sort flag -
+bool(true)
+array(11) {
+  ["x"]=>
+  string(1) "X"
+  ["te"]=>
+  string(4) "Test"
+  ["t"]=>
+  string(4) "TTTT"
+  ["o"]=>
+  string(6) "Orange"
+  ["X"]=>
+  string(1) "x"
+  ["W"]=>
+  string(2) "ww"
+  ["T"]=>
+  string(3) "ttt"
+  ["O"]=>
+  string(6) "oraNGe"
+  ["Lemon"]=>
+  string(5) "lemoN"
+  ["B"]=>
+  string(6) "BANANA"
+  ["Apple"]=>
+  string(5) "apple"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  ["x"]=>
+  string(1) "X"
+  ["te"]=>
+  string(4) "Test"
+  ["t"]=>
+  string(4) "TTTT"
+  ["o"]=>
+  string(6) "Orange"
+  ["X"]=>
+  string(1) "x"
+  ["W"]=>
+  string(2) "ww"
+  ["T"]=>
+  string(3) "ttt"
+  ["O"]=>
+  string(6) "oraNGe"
+  ["Lemon"]=>
+  string(5) "lemoN"
+  ["B"]=>
+  string(6) "BANANA"
+  ["Apple"]=>
+  string(5) "apple"
+}
+- Sort flag = SORT_STRING -
+bool(true)
+array(11) {
+  ["x"]=>
+  string(1) "X"
+  ["te"]=>
+  string(4) "Test"
+  ["t"]=>
+  string(4) "TTTT"
+  ["o"]=>
+  string(6) "Orange"
+  ["X"]=>
+  string(1) "x"
+  ["W"]=>
+  string(2) "ww"
+  ["T"]=>
+  string(3) "ttt"
+  ["O"]=>
+  string(6) "oraNGe"
+  ["Lemon"]=>
+  string(5) "lemoN"
+  ["B"]=>
+  string(6) "BANANA"
+  ["Apple"]=>
+  string(5) "apple"
+}
+Done
diff --git a/tests/std/array/krsort_variation6.phpt b/tests/std/array/krsort_variation6.phpt
new file mode 100644
index 00000000..c737cb4b
--- /dev/null
+++ b/tests/std/array/krsort_variation6.phpt
@@ -0,0 +1,109 @@
+--TEST--
+Test krsort() function : usage variations - sort hexadecimal values
+--FILE--
+<?php
+/*
+ * testing krsort() by providing array of hexa-decimal values for $array argument
+ * with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing krsort() : usage variations ***\n";
+
+// an array containing unsorted hexadecimal values with keys
+$unsorted_hex_array = array (
+  0x1AB => 0x1AB, 0xFFF => 0xFFF, 0xF => 0xF, 0xFF => 0xFF, 0x2AA => 0x2AA, 0xBB => 0xBB,
+  0x1ab => 0x1ab, 0xff => 0xff, -0xff => -0xFF, 0 => 0, -0x2aa => -0x2aa
+);
+
+echo "\n-- Testing krsort() by supplying hexadecimal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(krsort( $temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(krsort( $temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(krsort( $temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing krsort() : usage variations ***
+
+-- Testing krsort() by supplying hexadecimal value array, 'flag' value is default  --
+bool(true)
+array(9) {
+  [4095]=>
+  int(4095)
+  [682]=>
+  int(682)
+  [427]=>
+  int(427)
+  [255]=>
+  int(255)
+  [187]=>
+  int(187)
+  [15]=>
+  int(15)
+  [0]=>
+  int(0)
+  [-255]=>
+  int(-255)
+  [-682]=>
+  int(-682)
+}
+
+-- Testing krsort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(9) {
+  [4095]=>
+  int(4095)
+  [682]=>
+  int(682)
+  [427]=>
+  int(427)
+  [255]=>
+  int(255)
+  [187]=>
+  int(187)
+  [15]=>
+  int(15)
+  [0]=>
+  int(0)
+  [-255]=>
+  int(-255)
+  [-682]=>
+  int(-682)
+}
+
+-- Testing krsort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [4095]=>
+  int(4095)
+  [682]=>
+  int(682)
+  [427]=>
+  int(427)
+  [255]=>
+  int(255)
+  [187]=>
+  int(187)
+  [15]=>
+  int(15)
+  [0]=>
+  int(0)
+  [-255]=>
+  int(-255)
+  [-682]=>
+  int(-682)
+}
+Done
diff --git a/tests/std/array/krsort_variation7.phpt b/tests/std/array/krsort_variation7.phpt
new file mode 100644
index 00000000..9d25d93a
--- /dev/null
+++ b/tests/std/array/krsort_variation7.phpt
@@ -0,0 +1,172 @@
+--TEST--
+Test krsort() function : usage variations - sort array with diff. sub arrays
+--FILE--
+<?php
+/*
+ * testing krsort() by providing arrays contains sub arrays for $array argument
+ * with flowing flag values
+ *  1.flag  value as default
+ *  2.SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing krsort() : usage variations ***\n";
+
+// array with diff sub arrays to be sorted
+$various_arrays = array (
+  // null array
+  1  => array(),
+
+  // array contains null sub array
+  2 => array( 1 => array() ),
+
+  // array of arrays along with some values
+  3 => array(4 => 44, 1 => 11, 3 => array(64,61) ),
+
+  // array contains sub arrays
+  4 => array ( 3 => array(33,-5,6), 1 => array(11),
+               2 => array(22,-55), 0  => array() )
+);
+
+
+$count = 1;
+echo "\n-- Testing krsort() by supplying various arrays containing sub arrays --\n";
+
+// loop through to test krsort() with different arrays
+foreach ($various_arrays as $array) {
+
+  echo "\n-- Iteration $count --\n";
+  echo "- With default sort flag -\n";
+  $temp_array = $array;
+  var_dump( krsort($temp_array) );
+  var_dump($temp_array);
+
+  echo "- Sort flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump( krsort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing krsort() : usage variations ***
+
+-- Testing krsort() by supplying various arrays containing sub arrays --
+
+-- Iteration 1 --
+- With default sort flag -
+bool(true)
+array(0) {
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(0) {
+}
+
+-- Iteration 2 --
+- With default sort flag -
+bool(true)
+array(1) {
+  [1]=>
+  array(0) {
+  }
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(1) {
+  [1]=>
+  array(0) {
+  }
+}
+
+-- Iteration 3 --
+- With default sort flag -
+bool(true)
+array(3) {
+  [4]=>
+  int(44)
+  [3]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+  [1]=>
+  int(11)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  [4]=>
+  int(44)
+  [3]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+  [1]=>
+  int(11)
+}
+
+-- Iteration 4 --
+- With default sort flag -
+bool(true)
+array(4) {
+  [3]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  [0]=>
+  array(0) {
+  }
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  [3]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  [0]=>
+  array(0) {
+  }
+}
+Done
diff --git a/tests/std/array/krsort_variation8.phpt b/tests/std/array/krsort_variation8.phpt
new file mode 100644
index 00000000..458ee1e3
--- /dev/null
+++ b/tests/std/array/krsort_variation8.phpt
@@ -0,0 +1,156 @@
+--TEST--
+Test krsort() function : usage variations - sort mixed values, 'sort_flags' as default/SORT_REGULAR (OK to fail as result is unpredectable)
+--SKIPIF--
+<?php die("skip AOT sort order may differ from PHP (SORT_REGULAR on mixed types)"); ?>
+--FILE--
+<?php
+/*
+ * testing krsort() by providing array of mixed values for $array argument
+ * with following flag  values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing krsort() : usage variations ***\n";
+
+// mixed value array with different key values
+$mixed_values = array (
+  "array1" => array(),
+  "array2" => array ( "sub_array[2,1]" => array(33,-5,6), "sub_array[2,2]" => array(11),
+                      "sub_array[2,3]" => array(22,-55), "sub_array[2,4]" => array()
+                    ),
+  4 => 4, "4" => "4", 4 => 4.01, "b" => "b", "5" => "5", -2 => -2, -2 => -2.01,
+  -2 => -2.98989, "-.9" => "-.9", "True" => "True", "" =>  "", NULL => NULL,
+  "ab" => "ab", "abcd" => "abcd", 0 => 0.01, -0 => -0, '' => '' ,
+  "abcd\x00abcd\x00abcd" => "abcd\x00abcd\x00abcd", 0 => 0.001
+);
+
+echo "\n-- Testing krsort() by supplying mixed value array, 'flag' value is default --\n";
+$temp_array = $mixed_values;
+var_dump( krsort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing krsort() by supplying mixed value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $mixed_values;
+var_dump( krsort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing krsort() : usage variations ***
+
+-- Testing krsort() by supplying mixed value array, 'flag' value is default --
+bool(true)
+array(13) {
+  ["b"]=>
+  string(1) "b"
+  ["array2"]=>
+  array(4) {
+    ["sub_array[2,1]"]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    ["sub_array[2,2]"]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    ["sub_array[2,3]"]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    ["sub_array[2,4]"]=>
+    array(0) {
+    }
+  }
+  ["array1"]=>
+  array(0) {
+  }
+  ["abcd%0abcd%0abcd"]=>
+  string(14) "abcd%0abcd%0abcd"
+  ["abcd"]=>
+  string(4) "abcd"
+  ["ab"]=>
+  string(2) "ab"
+  ["True"]=>
+  string(4) "True"
+  [5]=>
+  string(1) "5"
+  [4]=>
+  float(4.01)
+  [0]=>
+  float(0.001)
+  ["-.9"]=>
+  string(3) "-.9"
+  [-2]=>
+  float(-2.98989)
+  [""]=>
+  string(0) ""
+}
+
+-- Testing krsort() by supplying mixed value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(13) {
+  ["b"]=>
+  string(1) "b"
+  ["array2"]=>
+  array(4) {
+    ["sub_array[2,1]"]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    ["sub_array[2,2]"]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    ["sub_array[2,3]"]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    ["sub_array[2,4]"]=>
+    array(0) {
+    }
+  }
+  ["array1"]=>
+  array(0) {
+  }
+  ["abcd%0abcd%0abcd"]=>
+  string(14) "abcd%0abcd%0abcd"
+  ["abcd"]=>
+  string(4) "abcd"
+  ["ab"]=>
+  string(2) "ab"
+  ["True"]=>
+  string(4) "True"
+  [5]=>
+  string(1) "5"
+  [4]=>
+  float(4.01)
+  [0]=>
+  float(0.001)
+  ["-.9"]=>
+  string(3) "-.9"
+  [-2]=>
+  float(-2.98989)
+  [""]=>
+  string(0) ""
+}
+Done
diff --git a/tests/std/array/krsort_variation9.phpt b/tests/std/array/krsort_variation9.phpt
new file mode 100644
index 00000000..b0309f37
--- /dev/null
+++ b/tests/std/array/krsort_variation9.phpt
@@ -0,0 +1,252 @@
+--TEST--
+Test krsort() function : usage variations - sort array with/without key values
+--FILE--
+<?php
+/*
+ * Testing krsort() by providing arrays  with/without key values for $array argument
+ * with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ */
+
+echo "*** Testing krsort() : usage variations ***\n";
+
+// list of arrays with/without key values
+$various_arrays = array (
+  array(5 => 55,  66, 22, 33, 11),
+  array ("a" => "orange",  "banana", "c" => "apple"),
+  array(1, 2, 3, 4, 5, 6),
+  array("first", 5 => "second", 1 => "third"),
+  array(1, 1, 8 => 1,  4 => 1, 19, 3 => 13),
+  array('bar' => 'baz', "foo" => 1),
+  array('a' => 1,'b' => array('e' => 2,'f' => 3),'c' => array('g' => 4),'d' => 5),
+);
+
+$count = 1;
+echo "\n-- Testing krsort() by supplying various arrays with/without key values --\n";
+
+// loop through to test krsort() with different arrays,
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort flag -\n";
+  $temp_array = $array;
+  var_dump( krsort($temp_array) );
+  var_dump($temp_array);
+
+  echo "- Sort flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump( krsort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing krsort() : usage variations ***
+
+-- Testing krsort() by supplying various arrays with/without key values --
+
+-- Iteration 1 --
+- With default sort flag -
+bool(true)
+array(5) {
+  [9]=>
+  int(11)
+  [8]=>
+  int(33)
+  [7]=>
+  int(22)
+  [6]=>
+  int(66)
+  [5]=>
+  int(55)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(5) {
+  [9]=>
+  int(11)
+  [8]=>
+  int(33)
+  [7]=>
+  int(22)
+  [6]=>
+  int(66)
+  [5]=>
+  int(55)
+}
+
+-- Iteration 2 --
+- With default sort flag -
+bool(true)
+array(3) {
+  ["c"]=>
+  string(5) "apple"
+  ["a"]=>
+  string(6) "orange"
+  [0]=>
+  string(6) "banana"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  ["c"]=>
+  string(5) "apple"
+  ["a"]=>
+  string(6) "orange"
+  [0]=>
+  string(6) "banana"
+}
+
+-- Iteration 3 --
+- With default sort flag -
+bool(true)
+array(6) {
+  [5]=>
+  int(6)
+  [4]=>
+  int(5)
+  [3]=>
+  int(4)
+  [2]=>
+  int(3)
+  [1]=>
+  int(2)
+  [0]=>
+  int(1)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(6) {
+  [5]=>
+  int(6)
+  [4]=>
+  int(5)
+  [3]=>
+  int(4)
+  [2]=>
+  int(3)
+  [1]=>
+  int(2)
+  [0]=>
+  int(1)
+}
+
+-- Iteration 4 --
+- With default sort flag -
+bool(true)
+array(3) {
+  [5]=>
+  string(6) "second"
+  [1]=>
+  string(5) "third"
+  [0]=>
+  string(5) "first"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  [5]=>
+  string(6) "second"
+  [1]=>
+  string(5) "third"
+  [0]=>
+  string(5) "first"
+}
+
+-- Iteration 5 --
+- With default sort flag -
+bool(true)
+array(6) {
+  [9]=>
+  int(19)
+  [8]=>
+  int(1)
+  [4]=>
+  int(1)
+  [3]=>
+  int(13)
+  [1]=>
+  int(1)
+  [0]=>
+  int(1)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(6) {
+  [9]=>
+  int(19)
+  [8]=>
+  int(1)
+  [4]=>
+  int(1)
+  [3]=>
+  int(13)
+  [1]=>
+  int(1)
+  [0]=>
+  int(1)
+}
+
+-- Iteration 6 --
+- With default sort flag -
+bool(true)
+array(2) {
+  ["foo"]=>
+  int(1)
+  ["bar"]=>
+  string(3) "baz"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(2) {
+  ["foo"]=>
+  int(1)
+  ["bar"]=>
+  string(3) "baz"
+}
+
+-- Iteration 7 --
+- With default sort flag -
+bool(true)
+array(4) {
+  ["d"]=>
+  int(5)
+  ["c"]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  ["b"]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+  ["a"]=>
+  int(1)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  ["d"]=>
+  int(5)
+  ["c"]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  ["b"]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+  ["a"]=>
+  int(1)
+}
+Done
diff --git a/tests/std/array/ksort_basic.phpt b/tests/std/array/ksort_basic.phpt
new file mode 100644
index 00000000..96135981
--- /dev/null
+++ b/tests/std/array/ksort_basic.phpt
@@ -0,0 +1,238 @@
+--TEST--
+Test ksort() function : basic functionality
+--FILE--
+<?php
+/*
+ * Testing ksort() by providing  array of integer/string values to check the basic functionality with following flag values :
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_NUMERIC - compare items numerically
+ *  4.SORT_STRING - compare items as strings
+*/
+
+echo "*** Testing ksort() : basic functionality ***\n";
+
+// an array containing unsorted string values with indices
+$unsorted_strings =   array(
+    "l" => "lemon", "o" => "orange",
+    "O" => "Orange", "O1" => "Orange1", "o2" => "orange2", "O3" => "Orange3", "o20" => "orange20",
+    "b" => "banana",
+);
+// an array containing unsorted numeric values with indices
+$unsorted_numerics =  array( 100 => 4, 33 => 3, 555 => 2, 22 => 1 );
+
+echo "\n-- Testing ksort() by supplying string array, 'flag' value is default --\n";
+$temp_array = $unsorted_strings;
+var_dump( ksort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing ksort() by supplying numeric array, 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( ksort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing ksort() by supplying string array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_strings;
+var_dump( ksort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing ksort() by supplying numeric array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_numerics;
+var_dump( ksort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing ksort() by supplying string array, 'flag' = SORT_STRING --\n";
+$temp_array = $unsorted_strings;
+var_dump( ksort($temp_array, SORT_STRING) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing ksort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( ksort($temp_array, SORT_STRING|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing ksort() by supplying string array (natural), 'flag' = SORT_NATURAL --\n";
+$temp_array = $unsorted_strings;
+var_dump( ksort($temp_array, SORT_NATURAL) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing ksort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( ksort($temp_array, SORT_NATURAL|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing ksort() by supplying numeric array, 'flag' = SORT_NUMERIC --\n";
+$temp_array = $unsorted_numerics;
+var_dump( ksort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing ksort() : basic functionality ***
+
+-- Testing ksort() by supplying string array, 'flag' value is default --
+bool(true)
+array(8) {
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing ksort() by supplying numeric array, 'flag' value is default --
+bool(true)
+array(4) {
+  [22]=>
+  int(1)
+  [33]=>
+  int(3)
+  [100]=>
+  int(4)
+  [555]=>
+  int(2)
+}
+
+-- Testing ksort() by supplying string array, 'flag' = SORT_REGULAR --
+bool(true)
+array(8) {
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing ksort() by supplying numeric array, 'flag' = SORT_REGULAR --
+bool(true)
+array(4) {
+  [22]=>
+  int(1)
+  [33]=>
+  int(3)
+  [100]=>
+  int(4)
+  [555]=>
+  int(2)
+}
+
+-- Testing ksort() by supplying string array, 'flag' = SORT_STRING --
+bool(true)
+array(8) {
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing ksort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+  ["O3"]=>
+  string(7) "Orange3"
+}
+
+-- Testing ksort() by supplying string array (natural), 'flag' = SORT_NATURAL --
+bool(true)
+array(8) {
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["o2"]=>
+  string(7) "orange2"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing ksort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  ["b"]=>
+  string(6) "banana"
+  ["l"]=>
+  string(5) "lemon"
+  ["o"]=>
+  string(6) "orange"
+  ["O"]=>
+  string(6) "Orange"
+  ["O1"]=>
+  string(7) "Orange1"
+  ["o2"]=>
+  string(7) "orange2"
+  ["O3"]=>
+  string(7) "Orange3"
+  ["o20"]=>
+  string(8) "orange20"
+}
+
+-- Testing ksort() by supplying numeric array, 'flag' = SORT_NUMERIC --
+bool(true)
+array(4) {
+  [22]=>
+  int(1)
+  [33]=>
+  int(3)
+  [100]=>
+  int(4)
+  [555]=>
+  int(2)
+}
+Done
diff --git a/tests/std/array/ksort_object.phpt b/tests/std/array/ksort_object.phpt
new file mode 100644
index 00000000..86e2d6b4
--- /dev/null
+++ b/tests/std/array/ksort_object.phpt
@@ -0,0 +1,220 @@
+--TEST--
+Test ksort() function : object functionality - sort objects
+--FILE--
+<?php
+// class declaration for integer objects
+class IntegerObject
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+}
+// class declaration for string objects
+class StringObject
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * testing ksort() by providing array ofinteger/string objects with following flag values:
+     *  1.SORT_NUMERIC - compare items numerically
+     *  2.SORT_STRING - compare items as strings
+    */
+    echo "*** Testing ksort() : object functionality ***\n";
+    // array of integer objects
+    $unsorted_int_obj = array(11 => new IntegerObject(11), 66 => new IntegerObject(66), 23 => new IntegerObject(23), -5 => new IntegerObject(-5), 1 => new IntegerObject(0.001), 0 => new IntegerObject(0));
+    // array of string objects
+    $unsorted_str_obj = array("axx" => new StringObject("axx"), "t" => new StringObject("t"), "w" => new StringObject("w"), "py" => new StringObject("py"), "apple" => new StringObject("apple"), "Orange" => new StringObject("Orange"), "Lemon" => new StringObject("Lemon"), "aPPle" => new StringObject("aPPle"));
+    echo "\n-- Testing ksort() by supplying various object arrays, 'flag' value is default --\n";
+    // testing ksort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(ksort($temp_array));
+    var_dump($temp_array);
+    // testing ksort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(ksort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Testing ksort() by supplying various object arrays, 'flag' value is SORT_REGULAR --\n";
+    // testing ksort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(ksort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing ksort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(ksort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+*** Testing ksort() : object functionality ***
+
+-- Testing ksort() by supplying various object arrays, 'flag' value is default --
+bool(true)
+array(6) {
+  [-5]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+  [0]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [1]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [11]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [23]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [66]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+}
+bool(true)
+array(8) {
+  ["Lemon"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+  ["Orange"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  ["aPPle"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  ["apple"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  ["axx"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  ["py"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  ["t"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  ["w"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+}
+
+-- Testing ksort() by supplying various object arrays, 'flag' value is SORT_REGULAR --
+bool(true)
+array(6) {
+  [-5]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+  [0]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [1]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [11]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [23]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [66]=>
+  object(IntegerObject)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+}
+bool(true)
+array(8) {
+  ["Lemon"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+  ["Orange"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  ["aPPle"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  ["apple"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  ["axx"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  ["py"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  ["t"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  ["w"]=>
+  object(StringObject)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+}
+Done
diff --git a/tests/std/array/ksort_variation10.phpt b/tests/std/array/ksort_variation10.phpt
new file mode 100644
index 00000000..6d151b92
--- /dev/null
+++ b/tests/std/array/ksort_variation10.phpt
@@ -0,0 +1,108 @@
+--TEST--
+Test ksort() function : usage variations - sort octal values
+--FILE--
+<?php
+/*
+ * testing ksort() by providing array of octal values for $array argument with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing ksort() : usage variations ***\n";
+
+// an array containing unsorted octal values
+$unsorted_oct_array = array (
+  01235 => 01, 0321 => 02, 0345 => 03, 066 => 04, 0772 => 05,
+  077 => 06, -066 => -01, -0345 => -02, 0 => 0
+);
+
+echo "\n-- Testing ksort() by supplying octal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( ksort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying octal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( ksort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump( ksort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing ksort() : usage variations ***
+
+-- Testing ksort() by supplying octal value array, 'flag' value is default  --
+bool(true)
+array(9) {
+  [-229]=>
+  int(-2)
+  [-54]=>
+  int(-1)
+  [0]=>
+  int(0)
+  [54]=>
+  int(4)
+  [63]=>
+  int(6)
+  [209]=>
+  int(2)
+  [229]=>
+  int(3)
+  [506]=>
+  int(5)
+  [669]=>
+  int(1)
+}
+
+-- Testing ksort() by supplying octal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(9) {
+  [-229]=>
+  int(-2)
+  [-54]=>
+  int(-1)
+  [0]=>
+  int(0)
+  [54]=>
+  int(4)
+  [63]=>
+  int(6)
+  [209]=>
+  int(2)
+  [229]=>
+  int(3)
+  [506]=>
+  int(5)
+  [669]=>
+  int(1)
+}
+
+-- Testing ksort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [-229]=>
+  int(-2)
+  [-54]=>
+  int(-1)
+  [0]=>
+  int(0)
+  [54]=>
+  int(4)
+  [63]=>
+  int(6)
+  [209]=>
+  int(2)
+  [229]=>
+  int(3)
+  [506]=>
+  int(5)
+  [669]=>
+  int(1)
+}
+Done
diff --git a/tests/std/array/ksort_variation11.phpt b/tests/std/array/ksort_variation11.phpt
new file mode 100644
index 00000000..59b18aa6
--- /dev/null
+++ b/tests/std/array/ksort_variation11.phpt
@@ -0,0 +1,93 @@
+--TEST--
+Test ksort() function : usage variations - sort heredoc strings
+--FILE--
+<?php
+/*
+ * testing ksort() by providing array of heredoc strings for $array argument with
+ * following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_STRING  - compare items as strings
+*/
+
+echo "*** Testing ksort() : usage variations ***\n";
+
+// Different heredoc strings to be sorted
+$simple_heredoc1 =<<<EOT
+Heredoc
+EOT;
+
+$simple_heredoc2 =<<<EOT
+HEREDOC
+EOT;
+
+$multiline_heredoc =<<<EOT
+heredoc string\twith!@# and 123
+Test this!!!
+EOT;
+
+$array = array (
+  $simple_heredoc1 => "Heredoc",
+  $simple_heredoc2 => "HEREDOC",
+  $multiline_heredoc => "heredoc string\twith!@# and 123\nTest this!!!"
+);
+
+echo "\n-- Testing ksort() by supplying heredoc string array, 'flag' value is default --\n";
+$temp_array = $array;
+var_dump(ksort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying heredoc string array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $array;
+var_dump(ksort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying heredoc string array, 'flag' = SORT_STRING --\n";
+$temp_array = $array;
+var_dump(ksort($temp_array, SORT_STRING) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing ksort() : usage variations ***
+
+-- Testing ksort() by supplying heredoc string array, 'flag' value is default --
+bool(true)
+array(3) {
+  ["HEREDOC"]=>
+  string(7) "HEREDOC"
+  ["Heredoc"]=>
+  string(7) "Heredoc"
+  ["heredoc string	with!@# and 123
+Test this!!!"]=>
+  string(43) "heredoc string	with!@# and 123
+Test this!!!"
+}
+
+-- Testing ksort() by supplying heredoc string array, 'flag' = SORT_REGULAR --
+bool(true)
+array(3) {
+  ["HEREDOC"]=>
+  string(7) "HEREDOC"
+  ["Heredoc"]=>
+  string(7) "Heredoc"
+  ["heredoc string	with!@# and 123
+Test this!!!"]=>
+  string(43) "heredoc string	with!@# and 123
+Test this!!!"
+}
+
+-- Testing ksort() by supplying heredoc string array, 'flag' = SORT_STRING --
+bool(true)
+array(3) {
+  ["HEREDOC"]=>
+  string(7) "HEREDOC"
+  ["Heredoc"]=>
+  string(7) "Heredoc"
+  ["heredoc string	with!@# and 123
+Test this!!!"]=>
+  string(43) "heredoc string	with!@# and 123
+Test this!!!"
+}
+Done
diff --git a/tests/std/array/ksort_variation3.phpt b/tests/std/array/ksort_variation3.phpt
new file mode 100644
index 00000000..35954ba6
--- /dev/null
+++ b/tests/std/array/ksort_variation3.phpt
@@ -0,0 +1,204 @@
+--TEST--
+Test ksort() function : usage variations - sort integer/float values
+--FILE--
+<?php
+/*
+ * Testing ksort() by providing array of integer/float/mixed values for $array argument
+ * with following flag  values:
+ *  1. flag value as default
+ *  2. SORT_REGULAR - compare items normally
+ *  3. SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing ksort() : usage variations ***\n";
+
+// diff. associative arrays to sort
+$various_arrays = array(
+  // negative/posative integer key value array
+  array(1 => 11, -2 => -11, 3 => 21, -4 => -21, 5 => 31, -6 => -31, 7 => 0, 8 => 41, -10 =>-41),
+
+  // mixed value array with different types of keys
+  array(1 => .0001, 2 => .0021, -3 => -.01, 4 => -1, 5 => 0, 6 => .09, 7 => 2, -8 => -.9,
+        9 => 10.6E-2, -10 => -10.6E-2, 11 => 33)
+);
+
+// set of possible flag values
+$flags = array("SORT_REGULAR" => SORT_REGULAR, "SORT_NUMERIC" => SORT_NUMERIC);
+
+$count = 1;
+echo "\n-- Testing ksort() by supplying various integer/float arrays --\n";
+
+// loop through to test ksort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort flag -\n";
+  $temp_array = $array;
+  var_dump(ksort($temp_array) );
+  var_dump($temp_array);
+
+  // loop through $flags array and call ksort() with all possible sort flag values
+  foreach($flags as $key => $flag){
+    echo "- Sort flag = $key -\n";
+    $temp_array = $array;
+    var_dump(ksort($temp_array, $flag) );
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing ksort() : usage variations ***
+
+-- Testing ksort() by supplying various integer/float arrays --
+
+-- Iteration 1 --
+- With default sort flag -
+bool(true)
+array(9) {
+  [-10]=>
+  int(-41)
+  [-6]=>
+  int(-31)
+  [-4]=>
+  int(-21)
+  [-2]=>
+  int(-11)
+  [1]=>
+  int(11)
+  [3]=>
+  int(21)
+  [5]=>
+  int(31)
+  [7]=>
+  int(0)
+  [8]=>
+  int(41)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(9) {
+  [-10]=>
+  int(-41)
+  [-6]=>
+  int(-31)
+  [-4]=>
+  int(-21)
+  [-2]=>
+  int(-11)
+  [1]=>
+  int(11)
+  [3]=>
+  int(21)
+  [5]=>
+  int(31)
+  [7]=>
+  int(0)
+  [8]=>
+  int(41)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(9) {
+  [-10]=>
+  int(-41)
+  [-6]=>
+  int(-31)
+  [-4]=>
+  int(-21)
+  [-2]=>
+  int(-11)
+  [1]=>
+  int(11)
+  [3]=>
+  int(21)
+  [5]=>
+  int(31)
+  [7]=>
+  int(0)
+  [8]=>
+  int(41)
+}
+
+-- Iteration 2 --
+- With default sort flag -
+bool(true)
+array(11) {
+  [-10]=>
+  float(-0.106)
+  [-8]=>
+  float(-0.9)
+  [-3]=>
+  float(-0.01)
+  [1]=>
+  float(0.0001)
+  [2]=>
+  float(0.0021)
+  [4]=>
+  int(-1)
+  [5]=>
+  int(0)
+  [6]=>
+  float(0.09)
+  [7]=>
+  int(2)
+  [9]=>
+  float(0.106)
+  [11]=>
+  int(33)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  [-10]=>
+  float(-0.106)
+  [-8]=>
+  float(-0.9)
+  [-3]=>
+  float(-0.01)
+  [1]=>
+  float(0.0001)
+  [2]=>
+  float(0.0021)
+  [4]=>
+  int(-1)
+  [5]=>
+  int(0)
+  [6]=>
+  float(0.09)
+  [7]=>
+  int(2)
+  [9]=>
+  float(0.106)
+  [11]=>
+  int(33)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(11) {
+  [-10]=>
+  float(-0.106)
+  [-8]=>
+  float(-0.9)
+  [-3]=>
+  float(-0.01)
+  [1]=>
+  float(0.0001)
+  [2]=>
+  float(0.0021)
+  [4]=>
+  int(-1)
+  [5]=>
+  int(0)
+  [6]=>
+  float(0.09)
+  [7]=>
+  int(2)
+  [9]=>
+  float(0.106)
+  [11]=>
+  int(33)
+}
+Done
diff --git a/tests/std/array/ksort_variation4.phpt b/tests/std/array/ksort_variation4.phpt
new file mode 100644
index 00000000..30dc42bf
--- /dev/null
+++ b/tests/std/array/ksort_variation4.phpt
@@ -0,0 +1,77 @@
+--TEST--
+Test ksort() function : usage variations - sort bool values
+--SKIPIF--
+--FILE--
+<?php
+/*
+ * testing ksort() by providing array of boolean values for $array argument with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing ksort() : usage variations ***\n";
+
+// bool value array
+$bool_values = array (true => true, false => false, TRUE => TRUE, FALSE => FALSE);
+
+echo "\n-- Testing ksort() by supplying boolean value array, 'flag' value is default --\n";
+$temp_array = $bool_values;
+var_dump(ksort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying boolean value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $bool_values;
+var_dump(ksort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying boolean value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $bool_values;
+var_dump(ksort($temp_array, SORT_NUMERIC) );
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying boolean value array, 'flag' value is SORT_STRING --\n";
+$temp_array = $bool_values;
+var_dump(ksort($temp_array, SORT_STRING) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing ksort() : usage variations ***
+
+-- Testing ksort() by supplying boolean value array, 'flag' value is default --
+bool(true)
+array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+
+-- Testing ksort() by supplying boolean value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+
+-- Testing ksort() by supplying boolean value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+
+-- Testing ksort() by supplying boolean value array, 'flag' value is SORT_STRING --
+bool(true)
+array(2) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+}
+Done
diff --git a/tests/std/array/ksort_variation5.phpt b/tests/std/array/ksort_variation5.phpt
new file mode 100644
index 00000000..b948ddbd
--- /dev/null
+++ b/tests/std/array/ksort_variation5.phpt
@@ -0,0 +1,227 @@
+--TEST--
+Test ksort() function : usage variations - sort strings
+--SKIPIF--
+<?php die("skip AOT ksort string sort differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * testing ksort() by providing array of string values for $array argument with
+ * following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_STRING  - compare items as strings
+*/
+
+echo "*** Testing ksort() : usage variations ***\n";
+
+$various_arrays = array (
+  // diff. escape sequence chars with key values
+  array ( null =>  null, NULL => NULL, "\a" => "\a", "\cx" => "\cx", "\e" => "\e",
+          "\f" => "\f", "\n" =>"\n", "\r" => "\r", "\t" => "\t", "\xhh" => "\xhh",
+          "\ddd" => "\ddd", "\v" => "\v"
+        ),
+
+  // array containing different strings with key values
+  array ( 'Lemon' => "lemoN", 'o' => "Orange", 'B' => "banana", 'Apple' => "apple", 'te' => "Test",
+          't' => "TTTT", 'T' => "ttt", 'W' => "ww", 'X' => "x", 'x' => "X", 'O' => "oraNGe",
+          'B' => "BANANA"
+        )
+);
+
+$flags = array("SORT_REGULAR" => SORT_REGULAR, "SORT_STRING" => SORT_STRING);
+
+$count = 1;
+echo "\n-- Testing ksort() by supplying various string arrays --\n";
+
+// loop through to test ksort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort flag -\n";
+  $temp_array = $array;
+  var_dump(ksort($temp_array) ); // expecting : bool(true)
+  var_dump($temp_array);
+
+  // loop through $flags array and call ksort() with all possible sort flag values
+  foreach($flags as $key => $flag){
+    echo "- Sort flag = $key -\n";
+    $temp_array = $array;
+    var_dump(ksort($temp_array, $flag) ); // expecting : bool(true)
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing ksort() : usage variations ***
+
+-- Testing ksort() by supplying various string arrays --
+
+-- Iteration 1 --
+- With default sort flag -
+bool(true)
+array(11) {
+  [""]=>
+  NULL
+  ["	"]=>
+  string(1) "	"
+  ["
+"]=>
+  string(1) "
+"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  ["\a"]=>
+  string(2) "\a"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\xhh"]=>
+  string(4) "\xhh"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  [""]=>
+  NULL
+  ["	"]=>
+  string(1) "	"
+  ["
+"]=>
+  string(1) "
+"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  ["\a"]=>
+  string(2) "\a"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\xhh"]=>
+  string(4) "\xhh"
+}
+- Sort flag = SORT_STRING -
+bool(true)
+array(11) {
+  [""]=>
+  NULL
+  ["	"]=>
+  string(1) "	"
+  ["
+"]=>
+  string(1) "
+"
+  [""]=>
+  string(1) ""
+  [""]=>
+  string(1) ""
+  ["
"]=>
+  string(1) "
"
+  [""]=>
+  string(1) ""
+  ["\a"]=>
+  string(2) "\a"
+  ["\cx"]=>
+  string(3) "\cx"
+  ["\ddd"]=>
+  string(4) "\ddd"
+  ["\xhh"]=>
+  string(4) "\xhh"
+}
+
+-- Iteration 2 --
+- With default sort flag -
+bool(true)
+array(11) {
+  ["Apple"]=>
+  string(5) "apple"
+  ["B"]=>
+  string(6) "BANANA"
+  ["Lemon"]=>
+  string(5) "lemoN"
+  ["O"]=>
+  string(6) "oraNGe"
+  ["T"]=>
+  string(3) "ttt"
+  ["W"]=>
+  string(2) "ww"
+  ["X"]=>
+  string(1) "x"
+  ["o"]=>
+  string(6) "Orange"
+  ["t"]=>
+  string(4) "TTTT"
+  ["te"]=>
+  string(4) "Test"
+  ["x"]=>
+  string(1) "X"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  ["Apple"]=>
+  string(5) "apple"
+  ["B"]=>
+  string(6) "BANANA"
+  ["Lemon"]=>
+  string(5) "lemoN"
+  ["O"]=>
+  string(6) "oraNGe"
+  ["T"]=>
+  string(3) "ttt"
+  ["W"]=>
+  string(2) "ww"
+  ["X"]=>
+  string(1) "x"
+  ["o"]=>
+  string(6) "Orange"
+  ["t"]=>
+  string(4) "TTTT"
+  ["te"]=>
+  string(4) "Test"
+  ["x"]=>
+  string(1) "X"
+}
+- Sort flag = SORT_STRING -
+bool(true)
+array(11) {
+  ["Apple"]=>
+  string(5) "apple"
+  ["B"]=>
+  string(6) "BANANA"
+  ["Lemon"]=>
+  string(5) "lemoN"
+  ["O"]=>
+  string(6) "oraNGe"
+  ["T"]=>
+  string(3) "ttt"
+  ["W"]=>
+  string(2) "ww"
+  ["X"]=>
+  string(1) "x"
+  ["o"]=>
+  string(6) "Orange"
+  ["t"]=>
+  string(4) "TTTT"
+  ["te"]=>
+  string(4) "Test"
+  ["x"]=>
+  string(1) "X"
+}
+Done
diff --git a/tests/std/array/ksort_variation6.phpt b/tests/std/array/ksort_variation6.phpt
new file mode 100644
index 00000000..b9c35b54
--- /dev/null
+++ b/tests/std/array/ksort_variation6.phpt
@@ -0,0 +1,109 @@
+--TEST--
+Test ksort() function : usage variations - sort hexadecimal values
+--FILE--
+<?php
+/*
+ * testing ksort() by providing array of hexa-decimal values for $array argument with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ *  3.SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing ksort() : usage variations ***\n";
+
+// an array containng unsorted hexadecimal values with keys
+// There are multiple keys which are duplicate and the later should be picked
+$unsorted_hex_array = array (
+  0x1AB => 0x1AB, 0xFFF => 0xFFF, 0xF => 0xF, 0xFF => 0xFF, 0x2AA => 0x2AA, 0xBB => 0xBB,
+  0x1ab => 0x1ab, 0xff => 0xff, -0xff => -0xFF, 0 => 0, -0x2aa => -0x2aa
+);
+
+echo "\n-- Testing ksort() by supplying hexadecimal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(ksort( $temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(ksort( $temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(ksort( $temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing ksort() : usage variations ***
+
+-- Testing ksort() by supplying hexadecimal value array, 'flag' value is default  --
+bool(true)
+array(9) {
+  [-682]=>
+  int(-682)
+  [-255]=>
+  int(-255)
+  [0]=>
+  int(0)
+  [15]=>
+  int(15)
+  [187]=>
+  int(187)
+  [255]=>
+  int(255)
+  [427]=>
+  int(427)
+  [682]=>
+  int(682)
+  [4095]=>
+  int(4095)
+}
+
+-- Testing ksort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(9) {
+  [-682]=>
+  int(-682)
+  [-255]=>
+  int(-255)
+  [0]=>
+  int(0)
+  [15]=>
+  int(15)
+  [187]=>
+  int(187)
+  [255]=>
+  int(255)
+  [427]=>
+  int(427)
+  [682]=>
+  int(682)
+  [4095]=>
+  int(4095)
+}
+
+-- Testing ksort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [-682]=>
+  int(-682)
+  [-255]=>
+  int(-255)
+  [0]=>
+  int(0)
+  [15]=>
+  int(15)
+  [187]=>
+  int(187)
+  [255]=>
+  int(255)
+  [427]=>
+  int(427)
+  [682]=>
+  int(682)
+  [4095]=>
+  int(4095)
+}
+Done
diff --git a/tests/std/array/ksort_variation7.phpt b/tests/std/array/ksort_variation7.phpt
new file mode 100644
index 00000000..7ca42069
--- /dev/null
+++ b/tests/std/array/ksort_variation7.phpt
@@ -0,0 +1,172 @@
+--TEST--
+Test ksort() function : usage variations - sort array with diff. sub arrays
+--FILE--
+<?php
+/*
+ * testing ksort() by providing arrays containing sub arrays for $array argument
+ * with flowing flag values:
+ *  1. flag value as default
+ *  2. SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing ksort() : usage variations ***\n";
+
+// array with diff sub arrays to be sorted
+$various_arrays = array (
+  // null array
+  1  => array(),
+
+  // array contains null sub array
+  2 => array( 1 => array() ),
+
+  // array of arrays along with some values
+  3 => array(4 => 44, 1 => 11, 3 => array(64,61) ),
+
+  // array contains sub arrays
+  4 => array ( 3 => array(33,-5,6), 1 => array(11),
+               2 => array(22,-55), 0  => array() )
+);
+
+
+$count = 1;
+echo "\n-- Testing ksort() by supplying various arrays containing sub arrays --\n";
+
+// loop through to test ksort() with different arrays
+foreach ($various_arrays as $array) {
+
+  echo "\n-- Iteration $count --\n";
+  echo "- With default sort flag -\n";
+  $temp_array = $array;
+  var_dump( ksort($temp_array) );
+  var_dump($temp_array);
+
+  echo "- Sort flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump( ksort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing ksort() : usage variations ***
+
+-- Testing ksort() by supplying various arrays containing sub arrays --
+
+-- Iteration 1 --
+- With default sort flag -
+bool(true)
+array(0) {
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(0) {
+}
+
+-- Iteration 2 --
+- With default sort flag -
+bool(true)
+array(1) {
+  [1]=>
+  array(0) {
+  }
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(1) {
+  [1]=>
+  array(0) {
+  }
+}
+
+-- Iteration 3 --
+- With default sort flag -
+bool(true)
+array(3) {
+  [1]=>
+  int(11)
+  [3]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+  [4]=>
+  int(44)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  [1]=>
+  int(11)
+  [3]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+  [4]=>
+  int(44)
+}
+
+-- Iteration 4 --
+- With default sort flag -
+bool(true)
+array(4) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  [3]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  [3]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+}
+Done
diff --git a/tests/std/array/ksort_variation8.phpt b/tests/std/array/ksort_variation8.phpt
new file mode 100644
index 00000000..0a788726
--- /dev/null
+++ b/tests/std/array/ksort_variation8.phpt
@@ -0,0 +1,155 @@
+--TEST--
+Test ksort() function : usage variations - sort mixed values, 'sort_flags' as default/SORT_REGULAR (OK to fail as result is unpredectable)
+--SKIPIF--
+<?php die("skip AOT sort order may differ from PHP (SORT_REGULAR on mixed types)"); ?>
+--FILE--
+<?php
+/*
+ * testing ksort() by providing array of mixed values for $array argument with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing ksort() : usage variations ***\n";
+
+// mixed value array with different key values
+$mixed_values = array (
+  "array1" => array(),
+  "array2" => array ( "sub_array[2,1]" => array(33,-5,6), "sub_array[2,2]" => array(11),
+                      "sub_array[2,3]" => array(22,-55), "sub_array[2,4]" => array()
+                    ),
+  4 => 4, "4" => "4", 4 => 4.01, "b" => "b", "5" => "5", -2 => -2, -2 => -2.01,
+  -2 => -2.98989, "-.9" => "-.9", "True" => "True", "" =>  "", NULL => NULL,
+  "ab" => "ab", "abcd" => "abcd", 0 => 0.01, -0 => -0, '' => '' ,
+  "abcd\x00abcd\x00abcd" => "abcd\x00abcd\x00abcd", 0 => 0.001
+);
+
+echo "\n-- Testing ksort() by supplying mixed value array, 'flag' value is default --\n";
+$temp_array = $mixed_values;
+var_dump( ksort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing ksort() by supplying mixed value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $mixed_values;
+var_dump( ksort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing ksort() : usage variations ***
+
+-- Testing ksort() by supplying mixed value array, 'flag' value is default --
+bool(true)
+array(13) {
+  [""]=>
+  string(0) ""
+  [-2]=>
+  float(-2.98989)
+  ["-.9"]=>
+  string(3) "-.9"
+  [0]=>
+  float(0.001)
+  [4]=>
+  float(4.01)
+  [5]=>
+  string(1) "5"
+  ["True"]=>
+  string(4) "True"
+  ["ab"]=>
+  string(2) "ab"
+  ["abcd"]=>
+  string(4) "abcd"
+  ["abcd%0abcd%0abcd"]=>
+  string(14) "abcd%0abcd%0abcd"
+  ["array1"]=>
+  array(0) {
+  }
+  ["array2"]=>
+  array(4) {
+    ["sub_array[2,1]"]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    ["sub_array[2,2]"]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    ["sub_array[2,3]"]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    ["sub_array[2,4]"]=>
+    array(0) {
+    }
+  }
+  ["b"]=>
+  string(1) "b"
+}
+
+-- Testing ksort() by supplying mixed value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(13) {
+  [""]=>
+  string(0) ""
+  [-2]=>
+  float(-2.98989)
+  ["-.9"]=>
+  string(3) "-.9"
+  [0]=>
+  float(0.001)
+  [4]=>
+  float(4.01)
+  [5]=>
+  string(1) "5"
+  ["True"]=>
+  string(4) "True"
+  ["ab"]=>
+  string(2) "ab"
+  ["abcd"]=>
+  string(4) "abcd"
+  ["abcd%0abcd%0abcd"]=>
+  string(14) "abcd%0abcd%0abcd"
+  ["array1"]=>
+  array(0) {
+  }
+  ["array2"]=>
+  array(4) {
+    ["sub_array[2,1]"]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    ["sub_array[2,2]"]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    ["sub_array[2,3]"]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    ["sub_array[2,4]"]=>
+    array(0) {
+    }
+  }
+  ["b"]=>
+  string(1) "b"
+}
+Done
diff --git a/tests/std/array/ksort_variation9.phpt b/tests/std/array/ksort_variation9.phpt
new file mode 100644
index 00000000..0023a9e0
--- /dev/null
+++ b/tests/std/array/ksort_variation9.phpt
@@ -0,0 +1,251 @@
+--TEST--
+Test ksort() function : usage variations - sorting arrays with/without keys
+--FILE--
+<?php
+/*
+ * Testing ksort() by providing arrays  with/without key values for $array argument with following flag values:
+ *  1.flag value as default
+ *  2.SORT_REGULAR - compare items normally
+ */
+
+echo "*** Testing ksort() : usage variations ***\n";
+
+// list of arrays with/without key values
+$various_arrays = array (
+  array(5 => 55,  66, 22, 33, 11),
+  array ("a" => "orange",  "banana", "c" => "apple"),
+  array(1, 2, 3, 4, 5, 6),
+  array("first", 5 => "second", 1 => "third"),
+  array(1, 1, 8 => 1,  4 => 1, 19, 3 => 13),
+  array('bar' => 'baz', "foo" => 1),
+  array('a' => 1,'b' => array('e' => 2,'f' => 3),'c' => array('g' => 4),'d' => 5),
+);
+
+$count = 1;
+echo "\n-- Testing ksort() by supplying various arrays with/without key values --\n";
+
+// loop through to test ksort() with different arrays,
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With default sort flag -\n";
+  $temp_array = $array;
+  var_dump( ksort($temp_array) );
+  var_dump($temp_array);
+
+  echo "- Sort flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump( ksort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing ksort() : usage variations ***
+
+-- Testing ksort() by supplying various arrays with/without key values --
+
+-- Iteration 1 --
+- With default sort flag -
+bool(true)
+array(5) {
+  [5]=>
+  int(55)
+  [6]=>
+  int(66)
+  [7]=>
+  int(22)
+  [8]=>
+  int(33)
+  [9]=>
+  int(11)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(5) {
+  [5]=>
+  int(55)
+  [6]=>
+  int(66)
+  [7]=>
+  int(22)
+  [8]=>
+  int(33)
+  [9]=>
+  int(11)
+}
+
+-- Iteration 2 --
+- With default sort flag -
+bool(true)
+array(3) {
+  [0]=>
+  string(6) "banana"
+  ["a"]=>
+  string(6) "orange"
+  ["c"]=>
+  string(5) "apple"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  [0]=>
+  string(6) "banana"
+  ["a"]=>
+  string(6) "orange"
+  ["c"]=>
+  string(5) "apple"
+}
+
+-- Iteration 3 --
+- With default sort flag -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+}
+
+-- Iteration 4 --
+- With default sort flag -
+bool(true)
+array(3) {
+  [0]=>
+  string(5) "first"
+  [1]=>
+  string(5) "third"
+  [5]=>
+  string(6) "second"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  [0]=>
+  string(5) "first"
+  [1]=>
+  string(5) "third"
+  [5]=>
+  string(6) "second"
+}
+
+-- Iteration 5 --
+- With default sort flag -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [3]=>
+  int(13)
+  [4]=>
+  int(1)
+  [8]=>
+  int(1)
+  [9]=>
+  int(19)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [3]=>
+  int(13)
+  [4]=>
+  int(1)
+  [8]=>
+  int(1)
+  [9]=>
+  int(19)
+}
+
+-- Iteration 6 --
+- With default sort flag -
+bool(true)
+array(2) {
+  ["bar"]=>
+  string(3) "baz"
+  ["foo"]=>
+  int(1)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(2) {
+  ["bar"]=>
+  string(3) "baz"
+  ["foo"]=>
+  int(1)
+}
+
+-- Iteration 7 --
+- With default sort flag -
+bool(true)
+array(4) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+  ["c"]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  ["d"]=>
+  int(5)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+  ["c"]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  ["d"]=>
+  int(5)
+}
+Done
diff --git a/tests/std/array/locale_sort.phpt b/tests/std/array/locale_sort.phpt
new file mode 100644
index 00000000..2caccce7
--- /dev/null
+++ b/tests/std/array/locale_sort.phpt
@@ -0,0 +1,60 @@
+--TEST--
+Sort with SORT_LOCALE_STRING
+--SKIPIF--
+<?php
+if (setlocale(LC_ALL, 'invalid') === 'invalid') { die('skip setlocale() is broken /w musl'); }
+if (substr(PHP_OS, 0, 3) == 'WIN') {
+  die("skip Unix locale name only, not available on windows (and crashes with VC6)\n");
+}
+if (false == setlocale(LC_CTYPE, "fr_FR.ISO8859-1", "fr_FR")) {
+  die("skip setlocale() failed\n");
+}
+?>
+--FILE--
+<?php
+setlocale(LC_ALL, 'fr_FR.ISO8859-1', 'fr_FR');
+$table = array("AB" => "Alberta",
+"BC" => "Colombie-Britannique",
+"MB" => "Manitoba",
+"NB" => "Nouveau-Brunswick",
+"NL" => "Terre-Neuve-et-Labrador",
+"NS" => "Nouvelle-�cosse",
+"ON" => "Ontario",
+"PE" => "�le-du-Prince-�douard",
+"QC" => "Qu�bec",
+"SK" => "Saskatchewan",
+"NT" => "Territoires du Nord-Ouest",
+"NU" => "Nunavut",
+"YT" => "Territoire du Yukon");
+asort($table, SORT_LOCALE_STRING);
+var_dump($table);
+?>
+--EXPECT--
+array(13) {
+  ["AB"]=>
+  string(7) "Alberta"
+  ["BC"]=>
+  string(20) "Colombie-Britannique"
+  ["PE"]=>
+  string(21) "�le-du-Prince-�douard"
+  ["MB"]=>
+  string(8) "Manitoba"
+  ["NB"]=>
+  string(17) "Nouveau-Brunswick"
+  ["NS"]=>
+  string(15) "Nouvelle-�cosse"
+  ["NU"]=>
+  string(7) "Nunavut"
+  ["ON"]=>
+  string(7) "Ontario"
+  ["QC"]=>
+  string(6) "Qu�bec"
+  ["SK"]=>
+  string(12) "Saskatchewan"
+  ["NL"]=>
+  string(23) "Terre-Neuve-et-Labrador"
+  ["YT"]=>
+  string(19) "Territoire du Yukon"
+  ["NT"]=>
+  string(25) "Territoires du Nord-Ouest"
+}
diff --git a/tests/std/array/max.phpt b/tests/std/array/max.phpt
new file mode 100644
index 00000000..06546100
--- /dev/null
+++ b/tests/std/array/max.phpt
@@ -0,0 +1,45 @@
+--TEST--
+max() tests
+--INI--
+precision=14
+--FILE--
+<?php
+
+try {
+    var_dump(max(1));
+} catch (\TypeError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(max(array()));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(max(new stdclass));
+} catch (\TypeError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+var_dump(max(2,1,2));
+var_dump(max(2.1,2.11,2.09));
+var_dump(max("", "t", "b"));
+var_dump(max(false, true, false));
+var_dump(max(true, false, true));
+var_dump(max(1, true, false, true));
+var_dump(max(0, true, false, true));
+
+?>
+--EXPECT--
+max(): Argument #1 ($value) must be of type array, int given
+max(): Argument #1 ($value) must contain at least one element
+max(): Argument #1 ($value) must be of type array, stdClass given
+int(2)
+float(2.11)
+string(1) "t"
+bool(true)
+bool(true)
+int(1)
+bool(true)
diff --git a/tests/std/array/max_basic.phpt b/tests/std/array/max_basic.phpt
new file mode 100644
index 00000000..4880e97d
--- /dev/null
+++ b/tests/std/array/max_basic.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Test return type and value for expected input max()
+--FILE--
+<?php
+/*
+ * Function is implemented in ext/standard/array.c
+*/
+
+echo "\n*** Testing sequences of numbers ***\n";
+
+var_dump(max(2,1,2));
+var_dump(max(-2,1,2));
+var_dump(max(2.1,2.11,2.09));
+var_dump(max("", "t", "b"));
+var_dump(max(false, true, false));
+var_dump(max(true, false, true));
+var_dump(max(1, true, false, true));
+var_dump(max(0, true, false, true));
+var_dump(max(0, 1, array(2,3)));
+
+echo "\nDone\n";
+?>
+--EXPECT--
+*** Testing sequences of numbers ***
+int(2)
+int(2)
+float(2.11)
+string(1) "t"
+bool(true)
+bool(true)
+int(1)
+bool(true)
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+
+Done
diff --git a/tests/std/array/max_basiclong_64bit.phpt b/tests/std/array/max_basiclong_64bit.phpt
new file mode 100644
index 00000000..6d40be03
--- /dev/null
+++ b/tests/std/array/max_basiclong_64bit.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Test max function : 64bit long tests
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only");
+?>
+--FILE--
+<?php
+
+define("MAX_64Bit", 9223372036854775807);
+define("MAX_32Bit", 2147483647);
+define("MIN_64Bit", -MAX_64Bit - 1);
+define("MIN_32Bit", -MAX_32Bit - 1);
+
+$arrayVals = array(
+    MAX_64Bit, MIN_64Bit, MAX_32Bit, MIN_32Bit, MAX_64Bit - MAX_32Bit, MIN_64Bit - MIN_32Bit,
+    MAX_32Bit + 1, MIN_32Bit - 1, MAX_32Bit * 2, (MAX_32Bit * 2) + 1, (MAX_32Bit * 2) - 1,
+    MAX_64Bit -1, MIN_64Bit + 1
+);
+
+$longVals = array(
+    MAX_64Bit, MIN_64Bit, MAX_32Bit, MIN_32Bit, MAX_64Bit - MAX_32Bit, MIN_64Bit - MIN_32Bit,
+    MAX_32Bit + 1, MIN_32Bit - 1, MAX_32Bit * 2, (MAX_32Bit * 2) + 1, (MAX_32Bit * 2) - 1,
+    MAX_64Bit -1, MAX_64Bit + 1, MIN_64Bit + 1, MIN_64Bit - 1
+);
+
+   var_dump(max($arrayVals));
+   var_dump(max($longVals));
+
+?>
+--EXPECT--
+int(9223372036854775807)
+int(9223372036854775807)
diff --git a/tests/std/array/max_int_float_optimisation.phpt b/tests/std/array/max_int_float_optimisation.phpt
new file mode 100644
index 00000000..0f5df35d
--- /dev/null
+++ b/tests/std/array/max_int_float_optimisation.phpt
@@ -0,0 +1,61 @@
+--TEST--
+Check max() optimisation for int and float types
+--SKIPIF--
+<?php if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only"); ?>
+--FILE--
+<?php
+
+echo "Start as int optimisation:\n";
+var_dump(max(10, 5, 3, 2));
+var_dump(max(2, 3, 5, 10));
+var_dump(max(10, 5, 3.5, 2));
+var_dump(max(2, 3.5, 5, 10));
+var_dump(max(10, 5, "3", 2));
+var_dump(max(2, "3", 5, 10));
+var_dump(max(2, 3, "15", 10));
+echo "Check that int not representable as float works:\n";
+var_dump(max(PHP_INT_MIN+1, PHP_INT_MIN, PHP_INT_MIN*2));
+var_dump(max(PHP_INT_MAX-1, PHP_INT_MAX, PHP_INT_MAX*2));
+// Has INF
+var_dump(max(PHP_INT_MAX-1, PHP_INT_MAX, PHP_INT_MAX**20));
+
+echo "Start as float optimisation:\n";
+var_dump(max(10.5, 5.5, 3.5, 2.5));
+var_dump(max(2.5, 3.5, 5.5, 10.5));
+var_dump(max(10.5, 5.5, 3, 2.5));
+var_dump(max(2.5, 3, 5.5, 10.5));
+var_dump(max(10.5, 5.5, "3.5", 2.5));
+var_dump(max(2.5, "3.5", 5.5, 10.5));
+var_dump(max(2.5, 3.5, "15.5", 10.5));
+echo "Check that int not representable as float works:\n";
+var_dump(max(PHP_INT_MIN*2, PHP_INT_MIN, PHP_INT_MIN+1));
+var_dump(max(PHP_INT_MAX*2, PHP_INT_MAX, PHP_INT_MAX-1));
+// Has INF
+var_dump(max(PHP_INT_MAX**20, PHP_INT_MAX, PHP_INT_MAX-1));
+
+?>
+--EXPECT--
+Start as int optimisation:
+int(10)
+int(10)
+int(10)
+int(10)
+int(10)
+int(10)
+string(2) "15"
+Check that int not representable as float works:
+int(-9223372036854775807)
+float(1.8446744073709552E+19)
+float(INF)
+Start as float optimisation:
+float(10.5)
+float(10.5)
+float(10.5)
+float(10.5)
+float(10.5)
+float(10.5)
+string(4) "15.5"
+Check that int not representable as float works:
+int(-9223372036854775807)
+float(1.8446744073709552E+19)
+float(INF)
diff --git a/tests/std/array/max_variation1.phpt b/tests/std/array/max_variation1.phpt
new file mode 100644
index 00000000..a87033ce
--- /dev/null
+++ b/tests/std/array/max_variation1.phpt
@@ -0,0 +1,35 @@
+--TEST--
+Test variations in usage of max()
+--FILE--
+<?php
+/*
+ * Function is implemented in ext/standard/array.c
+*/
+
+echo "\n*** Testing boundary conditions ***\n";
+var_dump(max(2147483645, 2147483646) );
+var_dump(max(2147483647, 2147483648) );
+var_dump(max(2147483646, 2147483648) );
+var_dump(max(-2147483647, -2147483646) );
+var_dump(max(-2147483648, -2147483647) );
+var_dump(max(-2147483649, -2147483647) );
+
+echo "\n*** Testing large number of arguments ***\n";
+
+var_dump(max(0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,21));
+
+echo "\nDone\n";
+?>
+--EXPECTF--
+*** Testing boundary conditions ***
+int(2147483646)
+%s(2147483648)
+%s(2147483648)
+int(-2147483646)
+int(-2147483647)
+int(-2147483647)
+
+*** Testing large number of arguments ***
+int(21)
+
+Done
diff --git a/tests/std/array/max_variation2.phpt b/tests/std/array/max_variation2.phpt
new file mode 100644
index 00000000..8577a095
--- /dev/null
+++ b/tests/std/array/max_variation2.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Test variations in usage of max()
+--FILE--
+<?php
+/*
+ * Function is implemented in ext/standard/array.c
+*/
+
+echo "\n*** Testing arrays  ***\n";
+
+var_dump(max(array(2,1,2)));
+var_dump(max(array(-2,1,2)));
+var_dump(max(array(2.1,2.11,2.09)));
+var_dump(max(array("", "t", "b")));
+var_dump(max(array(false, true, false)));
+var_dump(max(array(true, false, true)));
+var_dump(max(array(1, true, false, true)));
+var_dump(max(array(0, true, false, true)));
+var_dump(max(array(0, 1, array(2,3))));
+var_dump(max(array(2147483645, 2147483646)));
+var_dump(max(array(2147483647, 2147483648)));
+var_dump(max(array(2147483646, 2147483648)));
+var_dump(max(array(-2147483647, -2147483646)));
+var_dump(max(array(-2147483648, -2147483647)));
+var_dump(max(array(-2147483649, -2147483647)));
+
+echo "\nDone\n";
+
+?>
+--EXPECTF--
+*** Testing arrays  ***
+int(2)
+int(2)
+float(2.11)
+string(1) "t"
+bool(true)
+bool(true)
+int(1)
+bool(true)
+array(2) {
+  [0]=>
+  int(2)
+  [1]=>
+  int(3)
+}
+int(2147483646)
+%s(2147483648)
+%s(2147483648)
+int(-2147483646)
+int(-2147483647)
+int(-2147483647)
+
+Done
diff --git a/tests/std/array/min.phpt b/tests/std/array/min.phpt
new file mode 100644
index 00000000..97be4ad6
--- /dev/null
+++ b/tests/std/array/min.phpt
@@ -0,0 +1,45 @@
+--TEST--
+min() tests
+--INI--
+precision=14
+--FILE--
+<?php
+
+try {
+    var_dump(min(1));
+} catch (\TypeError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(min(array()));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+try {
+    var_dump(min(new stdclass));
+} catch (\TypeError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+var_dump(min(2,1,2));
+var_dump(min(2.1,2.11,2.09));
+var_dump(min("", "t", "b"));
+var_dump(min(false, true, false));
+var_dump(min(true, false, true));
+var_dump(min(1, true, false, true));
+var_dump(min(0, true, false, true));
+
+?>
+--EXPECT--
+min(): Argument #1 ($value) must be of type array, int given
+min(): Argument #1 ($value) must contain at least one element
+min(): Argument #1 ($value) must be of type array, stdClass given
+int(1)
+float(2.09)
+string(0) ""
+bool(false)
+bool(false)
+bool(false)
+int(0)
diff --git a/tests/std/array/min_basic.phpt b/tests/std/array/min_basic.phpt
new file mode 100644
index 00000000..6706dd90
--- /dev/null
+++ b/tests/std/array/min_basic.phpt
@@ -0,0 +1,35 @@
+--TEST--
+Test return type and value for expected input min()
+--FILE--
+<?php
+/*
+ * Function is implemented in ext/standard/array.c
+*/
+
+echo "\n*** Testing sequences of numbers ***\n";
+
+var_dump(min(2,1,2));
+var_dump(min(-2,1,2));
+var_dump(min(2.1,2.11,2.09));
+var_dump(min("", "t", "b"));
+var_dump(min(false, true, false));
+var_dump(min(true, false, true));
+var_dump(min(1, true, false, true));
+var_dump(min(0, true, false, true));
+var_dump(min(0, 1, array(2,3)));
+
+echo "\nDone\n";
+?>
+--EXPECT--
+*** Testing sequences of numbers ***
+int(1)
+int(-2)
+float(2.09)
+string(0) ""
+bool(false)
+bool(false)
+bool(false)
+int(0)
+int(0)
+
+Done
diff --git a/tests/std/array/min_basiclong_64bit.phpt b/tests/std/array/min_basiclong_64bit.phpt
new file mode 100644
index 00000000..50e5dda1
--- /dev/null
+++ b/tests/std/array/min_basiclong_64bit.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Test min function : 64bit long tests
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only");
+?>
+--FILE--
+<?php
+
+define("MAX_64Bit", 9223372036854775807);
+define("MAX_32Bit", 2147483647);
+define("MIN_64Bit", -MAX_64Bit - 1);
+define("MIN_32Bit", -MAX_32Bit - 1);
+
+$arrayVals = array(
+    MAX_64Bit, MIN_64Bit, MAX_32Bit, MIN_32Bit, MAX_64Bit - MAX_32Bit, MIN_64Bit - MIN_32Bit,
+    MAX_32Bit + 1, MIN_32Bit - 1, MAX_32Bit * 2, (MAX_32Bit * 2) + 1, (MAX_32Bit * 2) - 1,
+    MAX_64Bit -1, MIN_64Bit + 1
+);
+
+$longVals = array(
+    MAX_64Bit, MIN_64Bit, MAX_32Bit, MIN_32Bit, MAX_64Bit - MAX_32Bit, MIN_64Bit - MIN_32Bit,
+    MAX_32Bit + 1, MIN_32Bit - 1, MAX_32Bit * 2, (MAX_32Bit * 2) + 1, (MAX_32Bit * 2) - 1,
+    MAX_64Bit -1, MAX_64Bit + 1, MIN_64Bit + 1, MIN_64Bit - 1
+);
+
+   var_dump(min($arrayVals));
+   var_dump(min($longVals));
+
+?>
+--EXPECT--
+int(-9223372036854775808)
+int(-9223372036854775808)
diff --git a/tests/std/array/min_int_float_optimisation.phpt b/tests/std/array/min_int_float_optimisation.phpt
new file mode 100644
index 00000000..e383b833
--- /dev/null
+++ b/tests/std/array/min_int_float_optimisation.phpt
@@ -0,0 +1,61 @@
+--TEST--
+Check min() optimisation for int and float types
+--SKIPIF--
+<?php if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only"); ?>
+--FILE--
+<?php
+
+echo "Start as int optimisation:\n";
+var_dump(min(10, 5, 3, 2));
+var_dump(min(2, 3, 5, 10));
+var_dump(min(10, 5, 3.5, 2));
+var_dump(min(2, 3.5, 5, 10));
+var_dump(min(10, 5, "3", 2));
+var_dump(min(2, "3", 5, 10));
+var_dump(min(2, 3, "1", 10));
+echo "Check that int not representable as float works:\n";
+var_dump(min(PHP_INT_MAX-1, PHP_INT_MAX, PHP_INT_MAX*2));
+var_dump(min(PHP_INT_MIN+1, PHP_INT_MIN, PHP_INT_MIN*2));
+// Has INF
+var_dump(min(PHP_INT_MAX-1, PHP_INT_MAX, PHP_INT_MAX**20));
+
+echo "Start as float optimisation:\n";
+var_dump(min(10.5, 5.5, 3.5, 2.5));
+var_dump(min(2.5, 3.5, 5.5, 10.5));
+var_dump(min(10.5, 5.5, 3, 2.5));
+var_dump(min(2.5, 3, 5.5, 10.5));
+var_dump(min(10.5, 5.5, "3.5", 2.5));
+var_dump(min(2.5, "3.5", 5.5, 10.5));
+var_dump(min(2.5, 3.5, "1.5", 10.5));
+echo "Check that int not representable as float works:\n";
+var_dump(min(PHP_INT_MAX*2, PHP_INT_MAX, PHP_INT_MAX-1));
+var_dump(min(PHP_INT_MIN*2, PHP_INT_MIN, PHP_INT_MIN+1));
+// Has INF
+var_dump(min(PHP_INT_MAX**20, PHP_INT_MAX, PHP_INT_MAX-1));
+
+?>
+--EXPECT--
+Start as int optimisation:
+int(2)
+int(2)
+int(2)
+int(2)
+int(2)
+int(2)
+string(1) "1"
+Check that int not representable as float works:
+int(9223372036854775806)
+float(-1.8446744073709552E+19)
+int(9223372036854775806)
+Start as float optimisation:
+float(2.5)
+float(2.5)
+float(2.5)
+float(2.5)
+float(2.5)
+float(2.5)
+string(3) "1.5"
+Check that int not representable as float works:
+int(9223372036854775806)
+float(-1.8446744073709552E+19)
+int(9223372036854775806)
diff --git a/tests/std/array/min_variation1.phpt b/tests/std/array/min_variation1.phpt
new file mode 100644
index 00000000..d09b2196
--- /dev/null
+++ b/tests/std/array/min_variation1.phpt
@@ -0,0 +1,35 @@
+--TEST--
+Test variations in usage of min()
+--FILE--
+<?php
+/*
+ * Function is implemented in ext/standard/array.c
+*/
+
+echo "\n*** Testing boundary conditions ***\n";
+var_dump(min(2147483645, 2147483646) );
+var_dump(min(2147483647, 2147483648) );
+var_dump(min(2147483646, 2147483648) );
+var_dump(min(-2147483647, -2147483646) );
+var_dump(min(-2147483648, -2147483647) );
+var_dump(min(-2147483649, -2147483647) );
+
+echo "\n*** Testing large number of arguments ***\n";
+
+var_dump(min(0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,0, 1 , 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,21));
+
+echo "\nDone\n";
+?>
+--EXPECTF--
+*** Testing boundary conditions ***
+int(2147483645)
+int(2147483647)
+int(2147483646)
+int(-2147483647)
+%s(-2147483648)
+%s(-2147483649)
+
+*** Testing large number of arguments ***
+int(0)
+
+Done
diff --git a/tests/std/array/min_variation2.phpt b/tests/std/array/min_variation2.phpt
new file mode 100644
index 00000000..44acde72
--- /dev/null
+++ b/tests/std/array/min_variation2.phpt
@@ -0,0 +1,48 @@
+--TEST--
+Test variations in usage of min()
+--FILE--
+<?php
+/*
+ * Function is implemented in ext/standard/array.c
+*/
+
+echo "\n*** Testing arrays  ***\n";
+
+var_dump(min(array(2,1,2)));
+var_dump(min(array(-2,1,2)));
+var_dump(min(array(2.1,2.11,2.09)));
+var_dump(min(array("", "t", "b")));
+var_dump(min(array(false, true, false)));
+var_dump(min(array(true, false, true)));
+var_dump(min(array(1, true, false, true)));
+var_dump(min(array(0, true, false, true)));
+var_dump(min(array(0, 1, array(2,3))));
+var_dump(min(array(2147483645, 2147483646)));
+var_dump(min(array(2147483647, 2147483648)));
+var_dump(min(array(2147483646, 2147483648)));
+var_dump(min(array(-2147483647, -2147483646)));
+var_dump(min(array(-2147483648, -2147483647)));
+var_dump(min(array(-2147483649, -2147483647)));
+
+echo "\nDone\n";
+
+?>
+--EXPECTF--
+*** Testing arrays  ***
+int(1)
+int(-2)
+float(2.09)
+string(0) ""
+bool(false)
+bool(false)
+bool(false)
+int(0)
+int(0)
+int(2147483645)
+int(2147483647)
+int(2147483646)
+int(-2147483647)
+%s(-2147483648)
+%s(-2147483649)
+
+Done
diff --git a/tests/std/array/natcasesort_basic.phpt b/tests/std/array/natcasesort_basic.phpt
new file mode 100644
index 00000000..8891d0bb
--- /dev/null
+++ b/tests/std/array/natcasesort_basic.phpt
@@ -0,0 +1,52 @@
+--TEST--
+Test natcasesort() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of natcasesort()
+ */
+
+echo "*** Testing natcasesort() : basic functionality ***\n";
+
+$array = array ('A01', 'a1', 'b10',  'a01', 'b01');
+echo "\n-- Before sorting: --\n";
+var_dump($array);
+
+echo "\n-- After Sorting: --\n";
+var_dump(natcasesort($array));
+var_dump($array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing natcasesort() : basic functionality ***
+
+-- Before sorting: --
+array(5) {
+  [0]=>
+  string(3) "A01"
+  [1]=>
+  string(2) "a1"
+  [2]=>
+  string(3) "b10"
+  [3]=>
+  string(3) "a01"
+  [4]=>
+  string(3) "b01"
+}
+
+-- After Sorting: --
+bool(true)
+array(5) {
+  [0]=>
+  string(3) "A01"
+  [3]=>
+  string(3) "a01"
+  [1]=>
+  string(2) "a1"
+  [4]=>
+  string(3) "b01"
+  [2]=>
+  string(3) "b10"
+}
+Done
diff --git a/tests/std/array/natcasesort_object1.phpt b/tests/std/array/natcasesort_object1.phpt
new file mode 100644
index 00000000..5014b8f3
--- /dev/null
+++ b/tests/std/array/natcasesort_object1.phpt
@@ -0,0 +1,81 @@
+--TEST--
+Test natcasesort() function : object functionality - array of objects
+--FILE--
+<?php
+// class declaration for string objects
+class for_string_natcasesort
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->class_value;
+    }
+}
+function main()
+{
+    /*
+     * Pass natcasesort() an array of objects to test how it re-orders them
+     */
+    echo "*** Testing natcasesort() : object functionality ***\n";
+    // array of string objects
+    $unsorted_str_obj = array(new for_string_natcasesort("axx"), new for_string_natcasesort("t"), new for_string_natcasesort("w"), new for_string_natcasesort("py"), new for_string_natcasesort("apple"), new for_string_natcasesort("Orange"), new for_string_natcasesort("Lemon"), new for_string_natcasesort("aPPle"));
+    echo "\n-- Testing natcasesort() by supplying various object arrays --\n";
+    // testing natcasesort() function by supplying string object array
+    var_dump(natcasesort($unsorted_str_obj));
+    var_dump($unsorted_str_obj);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing natcasesort() : object functionality ***
+
+-- Testing natcasesort() by supplying various object arrays --
+bool(true)
+array(8) {
+  [4]=>
+  object(for_string_natcasesort)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  [7]=>
+  object(for_string_natcasesort)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  [0]=>
+  object(for_string_natcasesort)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  [6]=>
+  object(for_string_natcasesort)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+  [5]=>
+  object(for_string_natcasesort)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  [3]=>
+  object(for_string_natcasesort)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  [1]=>
+  object(for_string_natcasesort)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  [2]=>
+  object(for_string_natcasesort)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+}
+Done
diff --git a/tests/std/array/natcasesort_object2.phpt b/tests/std/array/natcasesort_object2.phpt
new file mode 100644
index 00000000..4e744a2b
--- /dev/null
+++ b/tests/std/array/natcasesort_object2.phpt
@@ -0,0 +1,83 @@
+--TEST--
+Test natcasesort() function : object functionality - mixed visibility within objects
+--FILE--
+<?php
+// class declaration for string objects
+class for_string_natcasesort
+{
+    public $public_class_value;
+    private $private_class_value;
+    protected $protected_class_value;
+    // initializing object member value
+    function __construct($value1, $value2, $value3)
+    {
+        $this->public_class_value = $value1;
+        $this->private_class_value = $value2;
+        $this->protected_class_value = $value3;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->public_class_value;
+    }
+}
+function main()
+{
+    /*
+     * Pass natcasesort() an array of objects which have properties of different
+     * visibilities to test how it re-orders the array.
+     */
+    echo "*** Testing natcasesort() : object functionality ***\n";
+    // array of string objects
+    $unsorted_str_obj = array(new for_string_natcasesort("axx", "AXX", "ass"), new for_string_natcasesort("t", "eee", "abb"), new for_string_natcasesort("w", "W", "c"), new for_string_natcasesort("py", "PY", "pt"));
+    echo "\n-- Testing natcasesort() by supplying object arrays --\n";
+    // testing natcasesort() function by supplying string object array
+    $temp_array = $unsorted_str_obj;
+    var_dump(natcasesort($temp_array));
+    var_dump($temp_array);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing natcasesort() : object functionality ***
+
+-- Testing natcasesort() by supplying object arrays --
+bool(true)
+array(4) {
+  [0]=>
+  object(for_string_natcasesort)#%d (3) {
+    ["public_class_value"]=>
+    string(3) "axx"
+    ["private_class_value":"for_string_natcasesort":private]=>
+    string(3) "AXX"
+    ["protected_class_value":protected]=>
+    string(3) "ass"
+  }
+  [3]=>
+  object(for_string_natcasesort)#%d (3) {
+    ["public_class_value"]=>
+    string(2) "py"
+    ["private_class_value":"for_string_natcasesort":private]=>
+    string(2) "PY"
+    ["protected_class_value":protected]=>
+    string(2) "pt"
+  }
+  [1]=>
+  object(for_string_natcasesort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "t"
+    ["private_class_value":"for_string_natcasesort":private]=>
+    string(3) "eee"
+    ["protected_class_value":protected]=>
+    string(3) "abb"
+  }
+  [2]=>
+  object(for_string_natcasesort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "w"
+    ["private_class_value":"for_string_natcasesort":private]=>
+    string(1) "W"
+    ["protected_class_value":protected]=>
+    string(1) "c"
+  }
+}
+Done
diff --git a/tests/std/array/natcasesort_variation10.phpt b/tests/std/array/natcasesort_variation10.phpt
new file mode 100644
index 00000000..89d54ac8
--- /dev/null
+++ b/tests/std/array/natcasesort_variation10.phpt
@@ -0,0 +1,46 @@
+--TEST--
+Test natcasesort() function : usage variations - position of internal array pointer
+--FILE--
+<?php
+/*
+ * Check position of internal array pointer after calling natcasesort()
+ */
+
+echo "*** Testing natcasesort() : usage variations ***\n";
+
+$array_arg = array ('img13', 'img20', 'img2', 'img1');
+
+echo "\n-- Initial Position of Internal Pointer: --\n";
+echo key($array_arg) . " => " . current ($array_arg) . "\n";
+
+echo "\n-- Call natcasesort() --\n";
+var_dump(natcasesort($array_arg));
+var_dump($array_arg);
+
+echo "\n-- Position of Internal Pointer in Passed Array: --\n";
+echo key($array_arg) . " => " . current ($array_arg) . "\n";
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing natcasesort() : usage variations ***
+
+-- Initial Position of Internal Pointer: --
+0 => img13
+
+-- Call natcasesort() --
+bool(true)
+array(4) {
+  [3]=>
+  string(4) "img1"
+  [2]=>
+  string(4) "img2"
+  [0]=>
+  string(5) "img13"
+  [1]=>
+  string(5) "img20"
+}
+
+-- Position of Internal Pointer in Passed Array: --
+3 => img1
+Done
diff --git a/tests/std/array/natcasesort_variation11.phpt b/tests/std/array/natcasesort_variation11.phpt
new file mode 100644
index 00000000..1a24eae0
--- /dev/null
+++ b/tests/std/array/natcasesort_variation11.phpt
@@ -0,0 +1,199 @@
+--TEST--
+Test natcasesort() function : usage variations - Different array keys
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+/*
+ * Pass arrays where the keys are different data types to test behaviour of natcasesort()
+ */
+
+echo "*** Testing natcasesort() : usage variations ***\n";
+
+//get an unset variable
+$unset_var = 10;
+unset ($unset_var);
+
+// heredoc string
+$heredoc = <<<EOT
+hello world
+EOT;
+
+// arrays with keys as different data types to be passed as $array_arg
+$inputs = array(
+
+       // int data
+/*1*/  'int' => array(
+       0 => 'zero',
+       1 => 'one',
+       12345 => 'positive',
+       -2345 => 'negative',
+       ),
+
+       // null data
+/*4*/  'null uppercase' => array(
+       NULL => 'null 1',
+       ),
+
+/*5*/  'null lowercase' => array(
+       null => 'null 2',
+       ),
+
+       // boolean data
+/*6*/ 'bool lowercase' => array(
+       true => 'lowert',
+       false => 'lowerf',
+       ),
+
+/*7*/  'bool uppercase' => array(
+       TRUE => 'uppert',
+       FALSE => 'upperf',
+       ),
+
+       // empty data
+/*8*/ 'empty double quotes' => array(
+       "" => 'emptyd',
+       ),
+
+/*9*/  'empty single quotes' => array(
+       '' => 'emptys',
+       ),
+
+       // string data
+/*10*/ 'string' => array(
+       "stringd" => 'stringd',
+       'strings' => 'strings',
+       $heredoc => 'stringh',
+       ),
+
+       // undefined data
+/*11*/ 'undefined' => array(
+       @$undefined_var => 'undefined',
+       ),
+
+       // unset data
+/*12*/ 'unset' => array(
+       @$unset_var => 'unset',
+       ),
+
+       // duplicate values
+/*13*/ 'duplicate' => array(
+       'foo' => 'bar',
+       'baz' => 'bar',
+       'hello' => 'world'
+       ),
+
+);
+
+// loop through each element of $inputs to check the behavior of natcasesort()
+$iterator = 1;
+foreach($inputs as $input) {
+    echo "\n-- Iteration $iterator --\n";
+    var_dump( natcasesort($input) );
+    var_dump($input);
+    $iterator++;
+};
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing natcasesort() : usage variations ***
+
+-- Iteration 1 --
+bool(true)
+array(4) {
+  [-2345]=>
+  string(8) "negative"
+  [1]=>
+  string(3) "one"
+  [12345]=>
+  string(8) "positive"
+  [0]=>
+  string(4) "zero"
+}
+
+-- Iteration 2 --
+bool(true)
+array(1) {
+  [""]=>
+  string(6) "null 1"
+}
+
+-- Iteration 3 --
+bool(true)
+array(1) {
+  [""]=>
+  string(6) "null 2"
+}
+
+-- Iteration 4 --
+bool(true)
+array(2) {
+  [0]=>
+  string(6) "lowerf"
+  [1]=>
+  string(6) "lowert"
+}
+
+-- Iteration 5 --
+bool(true)
+array(2) {
+  [0]=>
+  string(6) "upperf"
+  [1]=>
+  string(6) "uppert"
+}
+
+-- Iteration 6 --
+bool(true)
+array(1) {
+  [""]=>
+  string(6) "emptyd"
+}
+
+-- Iteration 7 --
+bool(true)
+array(1) {
+  [""]=>
+  string(6) "emptys"
+}
+
+-- Iteration 8 --
+bool(true)
+array(3) {
+  ["stringd"]=>
+  string(7) "stringd"
+  ["hello world"]=>
+  string(7) "stringh"
+  ["strings"]=>
+  string(7) "strings"
+}
+
+-- Iteration 9 --
+bool(true)
+array(1) {
+  [""]=>
+  string(9) "undefined"
+}
+
+-- Iteration 10 --
+bool(true)
+array(1) {
+  [""]=>
+  string(5) "unset"
+}
+
+-- Iteration 11 --
+bool(true)
+array(3) {
+  ["foo"]=>
+  string(3) "bar"
+  ["baz"]=>
+  string(3) "bar"
+  ["hello"]=>
+  string(5) "world"
+}
+Done
diff --git a/tests/std/array/natcasesort_variation2.phpt b/tests/std/array/natcasesort_variation2.phpt
new file mode 100644
index 00000000..f32c0151
--- /dev/null
+++ b/tests/std/array/natcasesort_variation2.phpt
@@ -0,0 +1,185 @@
+--TEST--
+Test natcasesort() function : usage variations - Pass arrays of 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()
+{
+    /*
+     * Pass arrays of different data types to natcasesort() to test how they are sorted
+     */
+    echo "*** Testing natcasesort() : usage variation ***\n";
+    //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");
+    // arrays of different data types to be passed to $array_arg 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 string' => array("", ''),
+        /*6*/
+        'empty array' => array(),
+        // string data
+        /*7*/
+        'string' => array("string", 'string', $heredoc),
+        // object data
+        /*8*/
+        'object' => array(new classA()),
+        // undefined data
+        /*9*/
+        'undefined' => array(@$undefined_var),
+        // unset data
+        /*10*/
+        'unset' => array(@$unset_var),
+        // resource variable
+        /*11*/
+        'resource' => array($fp),
+    );
+    // loop through each element of $inputs to check the behavior of natcasesort()
+    $iterator = 1;
+    foreach ($inputs as $input) {
+        echo "\n-- Iteration {$iterator} --\n";
+        var_dump(natcasesort($input));
+        var_dump($input);
+        $iterator++;
+    }
+    fclose($fp);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing natcasesort() : usage variation ***
+
+-- Iteration 1 --
+bool(true)
+array(4) {
+  [3]=>
+  int(-2345)
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(12345)
+}
+
+-- Iteration 2 --
+bool(true)
+array(5) {
+  [1]=>
+  float(-10.5)
+  [4]=>
+  float(0.5)
+  [3]=>
+  float(1.23456789E-9)
+  [0]=>
+  float(10.5)
+  [2]=>
+  float(123456789000)
+}
+
+-- Iteration 3 --
+bool(true)
+array(2) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+}
+
+-- Iteration 4 --
+bool(true)
+array(4) {
+  [1]=>
+  bool(false)
+  [3]=>
+  bool(false)
+  [0]=>
+  bool(true)
+  [2]=>
+  bool(true)
+}
+
+-- Iteration 5 --
+bool(true)
+array(2) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(0) ""
+}
+
+-- Iteration 6 --
+bool(true)
+array(0) {
+}
+
+-- Iteration 7 --
+bool(true)
+array(3) {
+  [2]=>
+  string(11) "hello world"
+  [0]=>
+  string(6) "string"
+  [1]=>
+  string(6) "string"
+}
+
+-- Iteration 8 --
+bool(true)
+array(1) {
+  [0]=>
+  object(classA)#%d (0) {
+  }
+}
+
+-- Iteration 9 --
+bool(true)
+array(1) {
+  [0]=>
+  NULL
+}
+
+-- Iteration 10 --
+bool(true)
+array(1) {
+  [0]=>
+  NULL
+}
+
+-- Iteration 11 --
+bool(true)
+array(1) {
+  [0]=>
+  resource(%d) of type (stream)
+}
+Done
diff --git a/tests/std/array/natcasesort_variation3.phpt b/tests/std/array/natcasesort_variation3.phpt
new file mode 100644
index 00000000..3cb87328
--- /dev/null
+++ b/tests/std/array/natcasesort_variation3.phpt
@@ -0,0 +1,129 @@
+--TEST--
+Test natcasesort() function : usage variations - different numeric types
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platform only");
+?>
+--FILE--
+<?php
+/*
+ * Pass arrays of numeric data to test how natcasesort re-orders the array
+ */
+
+echo "*** Testing natcasesort() : usage variation ***\n";
+
+$inputs = array (
+
+  // negative/positive integers array
+  array(11, -11, 21, -21, 31, -31, 0, 41, -41),
+
+  // float value array
+  array(10.5, -10.5, 10.5e2, 10.6E-2, .5, .01, -.1),
+
+  // mixed value array
+  array(.0001, .0021, -.01, -1, 0, .09, 2, -.9, 10.6E-2, -10.6E-2, 33),
+
+  // array values contains minimum and maximum ranges
+  array(2147483647, 2147483648, -2147483647, -2147483648, -0, 0, -2147483649)
+);
+
+$iterator = 1;
+foreach ($inputs as $array_arg) {
+    echo "\n-- Iteration $iterator --\n";
+    var_dump(natcasesort($array_arg));
+    var_dump($array_arg);
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing natcasesort() : usage variation ***
+
+-- Iteration 1 --
+bool(true)
+array(9) {
+  [1]=>
+  int(-11)
+  [3]=>
+  int(-21)
+  [5]=>
+  int(-31)
+  [8]=>
+  int(-41)
+  [6]=>
+  int(0)
+  [0]=>
+  int(11)
+  [2]=>
+  int(21)
+  [4]=>
+  int(31)
+  [7]=>
+  int(41)
+}
+
+-- Iteration 1 --
+bool(true)
+array(7) {
+  [6]=>
+  float(-0.1)
+  [1]=>
+  float(-10.5)
+  [5]=>
+  float(0.01)
+  [4]=>
+  float(0.5)
+  [3]=>
+  float(0.106)
+  [0]=>
+  float(10.5)
+  [2]=>
+  float(1050)
+}
+
+-- Iteration 1 --
+bool(true)
+array(11) {
+  [2]=>
+  float(-0.01)
+  [7]=>
+  float(-0.9)
+  [9]=>
+  float(-0.106)
+  [3]=>
+  int(-1)
+  [4]=>
+  int(0)
+  [0]=>
+  float(0.0001)
+  [1]=>
+  float(0.0021)
+  [5]=>
+  float(0.09)
+  [8]=>
+  float(0.106)
+  [6]=>
+  int(2)
+  [10]=>
+  int(33)
+}
+
+-- Iteration 1 --
+bool(true)
+array(7) {
+  [2]=>
+  int(-2147483647)
+  [3]=>
+  float(-2147483648)
+  [6]=>
+  float(-2147483649)
+  [4]=>
+  int(0)
+  [5]=>
+  int(0)
+  [0]=>
+  int(2147483647)
+  [1]=>
+  float(2147483648)
+}
+Done
diff --git a/tests/std/array/natcasesort_variation4.phpt b/tests/std/array/natcasesort_variation4.phpt
new file mode 100644
index 00000000..4e3477bb
--- /dev/null
+++ b/tests/std/array/natcasesort_variation4.phpt
@@ -0,0 +1,81 @@
+--TEST--
+Test natcasesort() function : usage variations - different string types
+--FILE--
+<?php
+/*
+ * Pass arrays of string data to see how natcasesort() re-orders the array
+ */
+
+echo "*** Testing natcasesort() : usage variation ***\n";
+
+$inputs = array (
+    // group of escape sequences
+    array(null, NULL, "\a", "\cx", "\e", "\f", "\n", "\t", "\xhh", "\ddd", "\v"),
+
+    // array contains combination of capital/small letters
+    array("lemoN", "Orange", "banana", "apple", "Test", "TTTT", "ttt", "ww", "x", "X", "oraNGe", "BANANA")
+);
+
+foreach ($inputs as $array_arg) {
+    var_dump( natcasesort($array_arg) );
+    var_dump($array_arg);
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing natcasesort() : usage variation ***
+bool(true)
+array(11) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [5]=>
+  string(1) ""
+  [6]=>
+  string(1) "
+"
+  [7]=>
+  string(1) "	"
+  [10]=>
+  string(1) ""
+  [4]=>
+  string(1) ""
+  [2]=>
+  string(2) "\a"
+  [3]=>
+  string(3) "\cx"
+  [9]=>
+  string(4) "\ddd"
+  [8]=>
+  string(4) "\xhh"
+}
+bool(true)
+array(12) {
+  [3]=>
+  string(5) "apple"
+  [2]=>
+  string(6) "banana"
+  [11]=>
+  string(6) "BANANA"
+  [0]=>
+  string(5) "lemoN"
+  [1]=>
+  string(6) "Orange"
+  [10]=>
+  string(6) "oraNGe"
+  [4]=>
+  string(4) "Test"
+  [6]=>
+  string(3) "ttt"
+  [5]=>
+  string(4) "TTTT"
+  [7]=>
+  string(2) "ww"
+  [8]=>
+  string(1) "x"
+  [9]=>
+  string(1) "X"
+}
+Done
diff --git a/tests/std/array/natcasesort_variation5.phpt b/tests/std/array/natcasesort_variation5.phpt
new file mode 100644
index 00000000..03025f2c
--- /dev/null
+++ b/tests/std/array/natcasesort_variation5.phpt
@@ -0,0 +1,44 @@
+--TEST--
+Test natcasesort() function : usage variations - different hex values
+--FILE--
+<?php
+/*
+ * Pass an array of different hex values to test how natcasesort() re-orders it
+ */
+
+echo "*** Testing natcasesort() : usage variation ***\n";
+
+$unsorted_hex_array = array(0x1AB, 0xFFF, 0xF, 0xFF, 0x2AA, 0xBB, 0x1ab, 0xff, -0xFF, 0, -0x2aa);
+var_dump( natcasesort($unsorted_hex_array) );
+var_dump($unsorted_hex_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing natcasesort() : usage variation ***
+bool(true)
+array(11) {
+  [8]=>
+  int(-255)
+  [10]=>
+  int(-682)
+  [9]=>
+  int(0)
+  [2]=>
+  int(15)
+  [5]=>
+  int(187)
+  [3]=>
+  int(255)
+  [7]=>
+  int(255)
+  [0]=>
+  int(427)
+  [6]=>
+  int(427)
+  [4]=>
+  int(682)
+  [1]=>
+  int(4095)
+}
+Done
diff --git a/tests/std/array/natcasesort_variation6.phpt b/tests/std/array/natcasesort_variation6.phpt
new file mode 100644
index 00000000..7145f8bf
--- /dev/null
+++ b/tests/std/array/natcasesort_variation6.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Test natcasesort() function : usage variations - referenced variables
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+/*
+ * Pass an array of referenced variables to test how natcasesort() re-orders it
+ */
+
+echo "*** Testing natcasesort() : usage variation ***\n";
+
+$value1 = 100;
+$value2 = 33;
+$value3 = 555;
+
+echo "\n-- Initial test --\n";
+$array =  array( &$value1 , &$value2, &$value3);
+var_dump( natcasesort($array) );
+var_dump($array);
+
+echo "\n-- Change \$value1 --\n";
+$value1 = -29;
+var_dump( natcasesort($array) );
+var_dump($array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing natcasesort() : usage variation ***
+
+-- Initial test --
+bool(true)
+array(3) {
+  [1]=>
+  &int(33)
+  [0]=>
+  &int(100)
+  [2]=>
+  &int(555)
+}
+
+-- Change $value1 --
+bool(true)
+array(3) {
+  [0]=>
+  &int(-29)
+  [1]=>
+  &int(33)
+  [2]=>
+  &int(555)
+}
+Done
diff --git a/tests/std/array/natcasesort_variation7.phpt b/tests/std/array/natcasesort_variation7.phpt
new file mode 100644
index 00000000..70ee9e92
--- /dev/null
+++ b/tests/std/array/natcasesort_variation7.phpt
@@ -0,0 +1,47 @@
+--TEST--
+Test natcasesort() function : usage variations - recursive arrays
+--FILE--
+<?php
+/*
+ * Pass natcasesort() an infinitely recursive array to test how it is re-ordered
+ */
+
+echo "*** Testing natcasesort() : usage variations ***\n";
+
+$array = array (1, 3.00, 'zero', '2');
+$array[] = &$array;
+var_dump($array);
+
+var_dump(@natcasesort($array));
+var_dump($array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing natcasesort() : usage variations ***
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  float(3)
+  [2]=>
+  string(4) "zero"
+  [3]=>
+  string(1) "2"
+  [4]=>
+  *RECURSION*
+}
+bool(true)
+array(5) {
+  [0]=>
+  int(1)
+  [3]=>
+  string(1) "2"
+  [1]=>
+  float(3)
+  [4]=>
+  *RECURSION*
+  [2]=>
+  string(4) "zero"
+}
+Done
diff --git a/tests/std/array/natcasesort_variation8.phpt b/tests/std/array/natcasesort_variation8.phpt
new file mode 100644
index 00000000..d040f228
--- /dev/null
+++ b/tests/std/array/natcasesort_variation8.phpt
@@ -0,0 +1,41 @@
+--TEST--
+Test natcasesort() function : usage variations - octal values
+--FILE--
+<?php
+/*
+ * Pass an array of octal values to test how natcasesort() re-orders it
+ */
+
+echo "*** Testing natcasesort() : usage variation ***\n";
+
+$unsorted_oct_array = array(01235, 0321, 0345, 066, 0772, 077, -066, -0345, 0);
+
+var_dump( natcasesort($unsorted_oct_array) );
+var_dump($unsorted_oct_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing natcasesort() : usage variation ***
+bool(true)
+array(9) {
+  [6]=>
+  int(-54)
+  [7]=>
+  int(-229)
+  [8]=>
+  int(0)
+  [3]=>
+  int(54)
+  [5]=>
+  int(63)
+  [1]=>
+  int(209)
+  [2]=>
+  int(229)
+  [4]=>
+  int(506)
+  [0]=>
+  int(669)
+}
+Done
diff --git a/tests/std/array/natcasesort_variation9.phpt b/tests/std/array/natcasesort_variation9.phpt
new file mode 100644
index 00000000..037db9e7
--- /dev/null
+++ b/tests/std/array/natcasesort_variation9.phpt
@@ -0,0 +1,104 @@
+--TEST--
+Test natcasesort() function : usage variations - mixed array
+--FILE--
+<?php
+/*
+ * Pass an array containing sub-arrays, ints, floats, strings, boolean, null
+ * and escape characters to test how natcasesort() re-orders it
+ */
+
+echo "*** Testing natcasesort() : usage variation ***\n";
+
+$mixed_values = array (
+  array(),
+  array( array(33, -5, 6),
+         array(11),
+         array(22, -55),
+         array()
+       ),
+  -4, "4", 4.00, "b", "5", -2, -2.0, -2.98989, "-.9", "True", "",
+  NULL, "ab", "abcd", 0.0, -0, "abcd\x00abcd\x00abcd", '', true, false
+);
+// suppress errors as is generating a lot of "array to string" notices
+var_dump( @natcasesort($mixed_values) );
+
+var_dump($mixed_values);
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing natcasesort() : usage variation ***
+bool(true)
+array(22) {
+  [12]=>
+  string(0) ""
+  [13]=>
+  NULL
+  [19]=>
+  string(0) ""
+  [21]=>
+  bool(false)
+  [10]=>
+  string(3) "-.9"
+  [7]=>
+  int(-2)
+  [8]=>
+  float(-2)
+  [9]=>
+  float(-2.98989)
+  [2]=>
+  int(-4)
+  [16]=>
+  float(0)
+  [17]=>
+  int(0)
+  [20]=>
+  bool(true)
+  [3]=>
+  string(1) "4"
+  [4]=>
+  float(4)
+  [6]=>
+  string(1) "5"
+  [14]=>
+  string(2) "ab"
+  [15]=>
+  string(4) "abcd"
+  [18]=>
+  string(14) "abcd%0abcd%0abcd"
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(4) {
+    [0]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    [1]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    [2]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    [3]=>
+    array(0) {
+    }
+  }
+  [5]=>
+  string(1) "b"
+  [11]=>
+  string(4) "True"
+}
+Done
diff --git a/tests/std/array/natsort_basic.phpt b/tests/std/array/natsort_basic.phpt
new file mode 100644
index 00000000..555abe1a
--- /dev/null
+++ b/tests/std/array/natsort_basic.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Test natsort(): basic functionality
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+$array1 = $array2 = array("img12.png", "img10.png", "img2.png", "img1.png");
+sort($array1);
+echo "Standard sorting\n";
+print_r($array1);
+natsort($array2);
+echo "\nNatural order sorting\n";
+print_r($array2);
+?>
+--EXPECT--
+Standard sorting
+Array
+(
+    [0] => img1.png
+    [1] => img10.png
+    [2] => img12.png
+    [3] => img2.png
+)
+
+Natural order sorting
+Array
+(
+    [3] => img1.png
+    [2] => img2.png
+    [1] => img10.png
+    [0] => img12.png
+)
diff --git a/tests/std/array/negative_index.phpt b/tests/std/array/negative_index.phpt
new file mode 100644
index 00000000..a9f442ac
--- /dev/null
+++ b/tests/std/array/negative_index.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Test arrays starting with negative indices
+--FILE--
+<?php
+
+$a = array_fill(-2, 3, true);
+$b = [-2 => true, true, true];
+$c = ["string" => true, -2 => true, true, true];
+unset($c["string"]);
+$d[-2] = true;
+$d[] = true;
+$d[] = true;
+$e = [-2 => false];
+array_pop($e);
+$e[] = true;
+$e[] = true;
+$e[] = true;
+
+var_dump($a === $b && $b === $c && $c === $d && $d == $e);
+var_dump($a);
+?>
+--EXPECT--
+bool(true)
+array(3) {
+  [-2]=>
+  bool(true)
+  [-1]=>
+  bool(true)
+  [0]=>
+  bool(true)
+}
diff --git a/tests/std/array/negative_index_empty_array.phpt b/tests/std/array/negative_index_empty_array.phpt
new file mode 100644
index 00000000..322ac6e8
--- /dev/null
+++ b/tests/std/array/negative_index_empty_array.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Test empty arrays with first added index being negative
+--FILE--
+<?php
+
+$a = [];
+$a[-5] = "-5";
+$a[] = "after -5";
+
+var_dump($a);
+?>
+--EXPECT--
+array(2) {
+  [-5]=>
+  string(2) "-5"
+  [-4]=>
+  string(8) "after -5"
+}
diff --git a/tests/std/array/next_basic.phpt b/tests/std/array/next_basic.phpt
new file mode 100644
index 00000000..d006d7d5
--- /dev/null
+++ b/tests/std/array/next_basic.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Test next() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of next()
+ */
+
+echo "*** Testing next() : basic functionality ***\n";
+
+$array = array('zero', 'one', 'two');
+echo key($array) . " => " . current($array) . "\n";
+var_dump(next($array));
+
+echo key($array) . " => " . current($array) . "\n";
+var_dump(next($array));
+
+echo key($array) . " => " . current($array) . "\n";
+var_dump(next($array));
+?>
+--EXPECT--
+*** Testing next() : basic functionality ***
+0 => zero
+string(3) "one"
+1 => one
+string(3) "two"
+2 => two
+bool(false)
diff --git a/tests/std/array/next_variation2.phpt b/tests/std/array/next_variation2.phpt
new file mode 100644
index 00000000..6293652a
--- /dev/null
+++ b/tests/std/array/next_variation2.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Test next() function : usage variation - Mulit-dimensional arrays
+--FILE--
+<?php
+/*
+ * Test next() when passed:
+ * 1. a two-dimensional array
+ * 2. a sub-array
+ * as $array_arg argument.
+ */
+
+echo "*** Testing next() : usage variations ***\n";
+
+$array_arg = array ('a' => 'z', array(9, 8, 7));
+
+echo "\n-- Pass a two-dimensional array as \$array_arg --\n";
+var_dump(next($array_arg));
+var_dump(next($array_arg));
+
+echo "\n-- Pass a sub-array as \$array_arg --\n";
+var_dump(next($array_arg[0]));
+?>
+--EXPECT--
+*** Testing next() : usage variations ***
+
+-- Pass a two-dimensional array as $array_arg --
+array(3) {
+  [0]=>
+  int(9)
+  [1]=>
+  int(8)
+  [2]=>
+  int(7)
+}
+bool(false)
+
+-- Pass a sub-array as $array_arg --
+int(8)
diff --git a/tests/std/array/packed_001.phpt b/tests/std/array/packed_001.phpt
new file mode 100644
index 00000000..7a36ed3f
--- /dev/null
+++ b/tests/std/array/packed_001.phpt
@@ -0,0 +1,85 @@
+--TEST--
+array_keys() and array_values() w/ packed optimization
+--FILE--
+<?php
+
+$x = [1,2,3];
+unset($x[1]);
+
+$inputs = [
+  [],
+  [1,2,3],
+  [0=>1, 1=>2, 2=>3],
+  [1=>1, 2=>2, 3=>3],
+  [0=>1, 2=>3],
+  $x,
+];
+
+foreach ($inputs as $input) {
+  print_r(array_keys($input));
+  print_r(array_values($input));
+}
+?>
+--EXPECT--
+Array
+(
+)
+Array
+(
+)
+Array
+(
+    [0] => 0
+    [1] => 1
+    [2] => 2
+)
+Array
+(
+    [0] => 1
+    [1] => 2
+    [2] => 3
+)
+Array
+(
+    [0] => 0
+    [1] => 1
+    [2] => 2
+)
+Array
+(
+    [0] => 1
+    [1] => 2
+    [2] => 3
+)
+Array
+(
+    [0] => 1
+    [1] => 2
+    [2] => 3
+)
+Array
+(
+    [0] => 1
+    [1] => 2
+    [2] => 3
+)
+Array
+(
+    [0] => 0
+    [1] => 2
+)
+Array
+(
+    [0] => 1
+    [1] => 3
+)
+Array
+(
+    [0] => 0
+    [1] => 2
+)
+Array
+(
+    [0] => 1
+    [1] => 3
+)
diff --git a/tests/std/array/prev_basic.phpt b/tests/std/array/prev_basic.phpt
new file mode 100644
index 00000000..ffbafd4c
--- /dev/null
+++ b/tests/std/array/prev_basic.phpt
@@ -0,0 +1,46 @@
+--TEST--
+Test prev() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of prev()
+ */
+
+echo "*** Testing prev() : basic functionality ***\n";
+
+$array = array('zero', 'one', 'two');
+end($array);
+echo key($array) . " => " . current($array) . "\n";
+var_dump(prev($array));
+
+echo key($array) . " => " . current($array) . "\n";
+var_dump(prev($array));
+
+echo key($array) . " => " . current($array) . "\n";
+var_dump(prev($array));
+
+echo "\n*** Testing an array with differing values/keys ***\n";
+$array2 = array('one', 2 => "help", 3, false, 'stringkey2' => 'val2', 'stringkey1' => 'val1');
+end($array2);
+$length = count($array2);
+for ($i = $length; $i > 0; $i--) {
+    var_dump(prev($array2));
+}
+
+?>
+--EXPECT--
+*** Testing prev() : basic functionality ***
+2 => two
+string(3) "one"
+1 => one
+string(4) "zero"
+0 => zero
+bool(false)
+
+*** Testing an array with differing values/keys ***
+string(4) "val2"
+bool(false)
+int(3)
+string(4) "help"
+string(3) "one"
+bool(false)
diff --git a/tests/std/array/prev_error2.phpt b/tests/std/array/prev_error2.phpt
new file mode 100644
index 00000000..6d9457f8
--- /dev/null
+++ b/tests/std/array/prev_error2.phpt
@@ -0,0 +1,26 @@
+--TEST--
+prev - ensure warning is received when passing an indirect temporary.
+--SKIPIF--
+<?php die("skip AOT prev() error handling differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * Pass temporary variables to prev() to test behaviour
+ */
+function f()
+{
+    $array = array(1, 2);
+    end($array);
+    return $array;
+}
+function main()
+{
+    echo "\n-- Passing an indirect temporary variable --\n";
+    var_dump(prev(f()));
+}
+?>
+--EXPECTF--
+-- Passing an indirect temporary variable --
+
+Notice: Only variables should be passed by reference in %s on line %d
+int(1)
diff --git a/tests/std/array/prev_error3.phpt b/tests/std/array/prev_error3.phpt
new file mode 100644
index 00000000..807de141
--- /dev/null
+++ b/tests/std/array/prev_error3.phpt
@@ -0,0 +1,18 @@
+--TEST--
+prev - ensure we cannot pass a temporary
+--SKIPIF--
+<?php die("skip AOT prev() error handling differs from PHP"); ?>
+--FILE--
+<?php
+/*
+ * Pass temporary variables to prev() to test behaviour
+ */
+
+
+var_dump(prev(array(1, 2)));
+?>
+--EXPECTF--
+Fatal error: Uncaught Error: prev(): Argument #1 ($array) could not be passed by reference in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d
diff --git a/tests/std/array/prev_variation2.phpt b/tests/std/array/prev_variation2.phpt
new file mode 100644
index 00000000..dd7f9b63
--- /dev/null
+++ b/tests/std/array/prev_variation2.phpt
@@ -0,0 +1,42 @@
+--TEST--
+Test prev() function : usage variation - Multi-dimensional arrays
+--FILE--
+<?php
+/*
+ * Test prev() when passed:
+ * 1. a two-dimensional array
+ * 2. a sub-array
+ * as $array_arg argument.
+ */
+
+echo "*** Testing prev() : usage variations ***\n";
+
+$subarray = array(9,8,7);
+end($subarray);
+
+$array_arg = array ($subarray, 'a' => 'z');
+end($array_arg);
+
+echo "\n-- Pass a two-dimensional array as \$array_arg --\n";
+var_dump(prev($array_arg));
+var_dump(prev($array_arg));
+
+echo "\n-- Pass a sub-array as \$array_arg --\n";
+var_dump(prev($array_arg[0]));
+?>
+--EXPECT--
+*** Testing prev() : usage variations ***
+
+-- Pass a two-dimensional array as $array_arg --
+array(3) {
+  [0]=>
+  int(9)
+  [1]=>
+  int(8)
+  [2]=>
+  int(7)
+}
+bool(false)
+
+-- Pass a sub-array as $array_arg --
+int(8)
diff --git a/tests/std/array/range/bug21182.phpt b/tests/std/array/range/bug21182.phpt
new file mode 100644
index 00000000..af4602ab
--- /dev/null
+++ b/tests/std/array/range/bug21182.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Bug #21182 (range modifies arguments)
+--FILE--
+<?php
+$a = "20"; $b = "30";
+echo "a1: $a\n";
+$result = range($a, $b);
+echo "a2: $a : type : " . gettype($a) . "\n";
+?>
+--EXPECT--
+a1: 20
+a2: 20 : type : string
diff --git a/tests/std/array/range/bug24220.phpt b/tests/std/array/range/bug24220.phpt
new file mode 100644
index 00000000..018296aa
--- /dev/null
+++ b/tests/std/array/range/bug24220.phpt
@@ -0,0 +1,91 @@
+--TEST--
+Bug #24220 (range() numeric string handling)
+--FILE--
+<?php
+    var_dump(range("2003", "2004"));
+    var_dump(range("a", "z"));
+    var_dump(range("1", "10"));
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(2003)
+  [1]=>
+  int(2004)
+}
+array(26) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+  [3]=>
+  string(1) "d"
+  [4]=>
+  string(1) "e"
+  [5]=>
+  string(1) "f"
+  [6]=>
+  string(1) "g"
+  [7]=>
+  string(1) "h"
+  [8]=>
+  string(1) "i"
+  [9]=>
+  string(1) "j"
+  [10]=>
+  string(1) "k"
+  [11]=>
+  string(1) "l"
+  [12]=>
+  string(1) "m"
+  [13]=>
+  string(1) "n"
+  [14]=>
+  string(1) "o"
+  [15]=>
+  string(1) "p"
+  [16]=>
+  string(1) "q"
+  [17]=>
+  string(1) "r"
+  [18]=>
+  string(1) "s"
+  [19]=>
+  string(1) "t"
+  [20]=>
+  string(1) "u"
+  [21]=>
+  string(1) "v"
+  [22]=>
+  string(1) "w"
+  [23]=>
+  string(1) "x"
+  [24]=>
+  string(1) "y"
+  [25]=>
+  string(1) "z"
+}
+array(10) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+  [9]=>
+  int(10)
+}
diff --git a/tests/std/array/range/bug32021.phpt b/tests/std/array/range/bug32021.phpt
new file mode 100644
index 00000000..a555b964
--- /dev/null
+++ b/tests/std/array/range/bug32021.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Bug #32021 (Crash caused by range('', 'z'))
+--SKIPIF--
+--FILE--
+<?php
+$foo = range('', 'z');
+var_dump($foo);
+echo "DONE\n";
+?>
+--EXPECTF--
+%s: Argument #1 ($start) must not be empty, casted to 0 in %s on line %d
+
+%s: Argument #1 ($start) must be a single byte string if argument #2 ($end) is a single byte string, argument #2 ($end) converted to 0 in %s on line %d
+array(1) {
+  [0]=>
+  int(0)
+}
+DONE
diff --git a/tests/std/array/range/bug41121.phpt b/tests/std/array/range/bug41121.phpt
new file mode 100644
index 00000000..b2d133ef
--- /dev/null
+++ b/tests/std/array/range/bug41121.phpt
@@ -0,0 +1,128 @@
+--TEST--
+Bug #41121 (range() overflow handling for large numbers on 32bit machines)
+--INI--
+precision=14
+--SKIPIF--
+<?php if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platform only"); ?>
+--FILE--
+<?php
+
+// posotive steps
+var_dump(range(2147483400, 2147483600, 100));
+var_dump( range(2147483646, 2147483648, 1 ) );
+var_dump( range(2147483646, 2147483657, 1 ) );
+var_dump( range(2147483630, 2147483646, 5 ) );
+
+// negative steps
+var_dump( range(-2147483645, -2147483648, 1 ) );
+var_dump( range(-2147483645, -2147483649, 1 ) );
+var_dump( range(-2147483630, -2147483646, 5 ) );
+
+// low > high
+var_dump(range(2147483647, 2147483645, 1 ));
+var_dump(range(2147483648, 2147483645, 1 ));
+
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  int(2147483400)
+  [1]=>
+  int(2147483500)
+  [2]=>
+  int(2147483600)
+}
+array(3) {
+  [0]=>
+  float(2147483646)
+  [1]=>
+  float(2147483647)
+  [2]=>
+  float(2147483648)
+}
+array(12) {
+  [0]=>
+  float(2147483646)
+  [1]=>
+  float(2147483647)
+  [2]=>
+  float(2147483648)
+  [3]=>
+  float(2147483649)
+  [4]=>
+  float(2147483650)
+  [5]=>
+  float(2147483651)
+  [6]=>
+  float(2147483652)
+  [7]=>
+  float(2147483653)
+  [8]=>
+  float(2147483654)
+  [9]=>
+  float(2147483655)
+  [10]=>
+  float(2147483656)
+  [11]=>
+  float(2147483657)
+}
+array(4) {
+  [0]=>
+  int(2147483630)
+  [1]=>
+  int(2147483635)
+  [2]=>
+  int(2147483640)
+  [3]=>
+  int(2147483645)
+}
+array(4) {
+  [0]=>
+  float(-2147483645)
+  [1]=>
+  float(-2147483646)
+  [2]=>
+  float(-2147483647)
+  [3]=>
+  float(-2147483648)
+}
+array(5) {
+  [0]=>
+  float(-2147483645)
+  [1]=>
+  float(-2147483646)
+  [2]=>
+  float(-2147483647)
+  [3]=>
+  float(-2147483648)
+  [4]=>
+  float(-2147483649)
+}
+array(4) {
+  [0]=>
+  int(-2147483630)
+  [1]=>
+  int(-2147483635)
+  [2]=>
+  int(-2147483640)
+  [3]=>
+  int(-2147483645)
+}
+array(3) {
+  [0]=>
+  int(2147483647)
+  [1]=>
+  int(2147483646)
+  [2]=>
+  int(2147483645)
+}
+array(4) {
+  [0]=>
+  float(2147483648)
+  [1]=>
+  float(2147483647)
+  [2]=>
+  float(2147483646)
+  [3]=>
+  float(2147483645)
+}
diff --git a/tests/std/array/range/bug54459.phpt b/tests/std/array/range/bug54459.phpt
new file mode 100644
index 00000000..9eed6dea
--- /dev/null
+++ b/tests/std/array/range/bug54459.phpt
@@ -0,0 +1,219 @@
+--TEST--
+Bug #54459 (Range function accuracy)
+--INI--
+precision=14
+--SKIPIF--
+<?php die("skip AOT float formatting for echo differs from PHP"); ?>
+--FILE--
+<?php
+ini_set('serialize_precision', '14');
+foreach (range(90, 100, .1) as $i => $v){
+  echo $i, ' = ', $v, PHP_EOL;
+}
+foreach (range("90", "100", .1) as $i => $v){
+  echo $i, ' = ', $v, PHP_EOL;
+}
+?>
+--EXPECT--
+0 = 90
+1 = 90.1
+2 = 90.2
+3 = 90.3
+4 = 90.4
+5 = 90.5
+6 = 90.6
+7 = 90.7
+8 = 90.8
+9 = 90.9
+10 = 91
+11 = 91.1
+12 = 91.2
+13 = 91.3
+14 = 91.4
+15 = 91.5
+16 = 91.6
+17 = 91.7
+18 = 91.8
+19 = 91.9
+20 = 92
+21 = 92.1
+22 = 92.2
+23 = 92.3
+24 = 92.4
+25 = 92.5
+26 = 92.6
+27 = 92.7
+28 = 92.8
+29 = 92.9
+30 = 93
+31 = 93.1
+32 = 93.2
+33 = 93.3
+34 = 93.4
+35 = 93.5
+36 = 93.6
+37 = 93.7
+38 = 93.8
+39 = 93.9
+40 = 94
+41 = 94.1
+42 = 94.2
+43 = 94.3
+44 = 94.4
+45 = 94.5
+46 = 94.6
+47 = 94.7
+48 = 94.8
+49 = 94.9
+50 = 95
+51 = 95.1
+52 = 95.2
+53 = 95.3
+54 = 95.4
+55 = 95.5
+56 = 95.6
+57 = 95.7
+58 = 95.8
+59 = 95.9
+60 = 96
+61 = 96.1
+62 = 96.2
+63 = 96.3
+64 = 96.4
+65 = 96.5
+66 = 96.6
+67 = 96.7
+68 = 96.8
+69 = 96.9
+70 = 97
+71 = 97.1
+72 = 97.2
+73 = 97.3
+74 = 97.4
+75 = 97.5
+76 = 97.6
+77 = 97.7
+78 = 97.8
+79 = 97.9
+80 = 98
+81 = 98.1
+82 = 98.2
+83 = 98.3
+84 = 98.4
+85 = 98.5
+86 = 98.6
+87 = 98.7
+88 = 98.8
+89 = 98.9
+90 = 99
+91 = 99.1
+92 = 99.2
+93 = 99.3
+94 = 99.4
+95 = 99.5
+96 = 99.6
+97 = 99.7
+98 = 99.8
+99 = 99.9
+100 = 100
+0 = 90
+1 = 90.1
+2 = 90.2
+3 = 90.3
+4 = 90.4
+5 = 90.5
+6 = 90.6
+7 = 90.7
+8 = 90.8
+9 = 90.9
+10 = 91
+11 = 91.1
+12 = 91.2
+13 = 91.3
+14 = 91.4
+15 = 91.5
+16 = 91.6
+17 = 91.7
+18 = 91.8
+19 = 91.9
+20 = 92
+21 = 92.1
+22 = 92.2
+23 = 92.3
+24 = 92.4
+25 = 92.5
+26 = 92.6
+27 = 92.7
+28 = 92.8
+29 = 92.9
+30 = 93
+31 = 93.1
+32 = 93.2
+33 = 93.3
+34 = 93.4
+35 = 93.5
+36 = 93.6
+37 = 93.7
+38 = 93.8
+39 = 93.9
+40 = 94
+41 = 94.1
+42 = 94.2
+43 = 94.3
+44 = 94.4
+45 = 94.5
+46 = 94.6
+47 = 94.7
+48 = 94.8
+49 = 94.9
+50 = 95
+51 = 95.1
+52 = 95.2
+53 = 95.3
+54 = 95.4
+55 = 95.5
+56 = 95.6
+57 = 95.7
+58 = 95.8
+59 = 95.9
+60 = 96
+61 = 96.1
+62 = 96.2
+63 = 96.3
+64 = 96.4
+65 = 96.5
+66 = 96.6
+67 = 96.7
+68 = 96.8
+69 = 96.9
+70 = 97
+71 = 97.1
+72 = 97.2
+73 = 97.3
+74 = 97.4
+75 = 97.5
+76 = 97.6
+77 = 97.7
+78 = 97.8
+79 = 97.9
+80 = 98
+81 = 98.1
+82 = 98.2
+83 = 98.3
+84 = 98.4
+85 = 98.5
+86 = 98.6
+87 = 98.7
+88 = 98.8
+89 = 98.9
+90 = 99
+91 = 99.1
+92 = 99.2
+93 = 99.3
+94 = 99.4
+95 = 99.5
+96 = 99.6
+97 = 99.7
+98 = 99.8
+99 = 99.9
+100 = 100
diff --git a/tests/std/array/range/gh13094.phpt b/tests/std/array/range/gh13094.phpt
new file mode 100644
index 00000000..2e70adb6
--- /dev/null
+++ b/tests/std/array/range/gh13094.phpt
@@ -0,0 +1,29 @@
+--TEST--
+GH-13094 (range(9.9, '0') causes segmentation fault)
+--FILE--
+<?php
+var_dump(range(9.9, '0'));
+?>
+--EXPECT--
+array(10) {
+  [0]=>
+  float(9.9)
+  [1]=>
+  float(8.9)
+  [2]=>
+  float(7.9)
+  [3]=>
+  float(6.9)
+  [4]=>
+  float(5.9)
+  [5]=>
+  float(4.9)
+  [6]=>
+  float(3.9000000000000004)
+  [7]=>
+  float(2.9000000000000004)
+  [8]=>
+  float(1.9000000000000004)
+  [9]=>
+  float(0.9000000000000004)
+}
diff --git a/tests/std/array/range/range_bug70239_0.phpt b/tests/std/array/range/range_bug70239_0.phpt
new file mode 100644
index 00000000..52f046a7
--- /dev/null
+++ b/tests/std/array/range/range_bug70239_0.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Bug #70239 Creating a huge array doesn't result in exhausted, but segfault, var 1
+--FILE--
+<?php
+try {
+    range(0, pow(2.0, 100000000));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+range(): Argument #2 ($end) must be a finite number, INF provided
diff --git a/tests/std/array/range/range_bug70239_1.phpt b/tests/std/array/range/range_bug70239_1.phpt
new file mode 100644
index 00000000..681d594a
--- /dev/null
+++ b/tests/std/array/range/range_bug70239_1.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Bug #70239 Creating a huge array doesn't result in exhausted, but segfault, var 2
+--FILE--
+<?php
+try {
+    range(pow(2.0, 100000000), pow(2.0, 100000000) + 1);
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+?>
+--EXPECT--
+range(): Argument #1 ($start) must be a finite number, INF provided
diff --git a/tests/std/array/range/range_bug70239_2.phpt b/tests/std/array/range/range_bug70239_2.phpt
new file mode 100644
index 00000000..a4ec3c55
--- /dev/null
+++ b/tests/std/array/range/range_bug70239_2.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Bug #70239 Creating a huge array doesn't result in exhausted, but segfault, var 3
+--FILE--
+<?php
+try {
+    var_dump(range(0, PHP_INT_MAX));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+?>
+--EXPECTF--
+The supplied range exceeds the maximum array size: start=0 end=%d step=1
diff --git a/tests/std/array/range/range_bug70239_3.phpt b/tests/std/array/range/range_bug70239_3.phpt
new file mode 100644
index 00000000..7099eb1e
--- /dev/null
+++ b/tests/std/array/range/range_bug70239_3.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Bug #70239 Creating a huge array doesn't result in exhausted, but segfault, var 4
+--FILE--
+<?php
+try {
+    var_dump(range(PHP_INT_MIN, 0));
+} catch (\ValueError $e) {
+    echo $e->getMessage() . "\n";
+}
+?>
+--EXPECTF--
+The supplied range exceeds the maximum array size: start=-%d end=0 step=1
diff --git a/tests/std/array/range/range_bug71132.phpt b/tests/std/array/range/range_bug71132.phpt
new file mode 100644
index 00000000..5e3bcc8f
--- /dev/null
+++ b/tests/std/array/range/range_bug71132.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Bug #71132 (range function produces 2 segfaults with long integers)
+--FILE--
+<?php
+var_dump(count(range(PHP_INT_MIN + 513, PHP_INT_MIN)));
+var_dump(count(range(PHP_INT_MIN, PHP_INT_MIN + 513)));
+?>
+--EXPECT--
+int(514)
+int(514)
diff --git a/tests/std/array/range/range_bug71197.phpt b/tests/std/array/range/range_bug71197.phpt
new file mode 100644
index 00000000..2031ec7c
--- /dev/null
+++ b/tests/std/array/range/range_bug71197.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Bug #71197 (range function produces another 2 segfaults with long integers)
+--FILE--
+<?php
+range(PHP_INT_MIN, PHP_INT_MIN + 513, .01);
+range(PHP_INT_MIN + 513, PHP_INT_MIN, .01);
+?>
+--EXPECT--
diff --git a/tests/std/array/range/range_bug72017.phpt b/tests/std/array/range/range_bug72017.phpt
new file mode 100644
index 00000000..b5a56d7f
--- /dev/null
+++ b/tests/std/array/range/range_bug72017.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Bug #72017 (incorrect truncation due to floating point precision issue)
+--FILE--
+<?php
+var_dump(range(4.5, 4.2, 0.1));
+?>
+--EXPECT--
+array(4) {
+  [0]=>
+  float(4.5)
+  [1]=>
+  float(4.4)
+  [2]=>
+  float(4.3)
+  [3]=>
+  float(4.2)
+}
diff --git a/tests/std/array/range/range_inputs_float_NAN_values.phpt b/tests/std/array/range/range_inputs_float_NAN_values.phpt
new file mode 100644
index 00000000..03ed069f
--- /dev/null
+++ b/tests/std/array/range/range_inputs_float_NAN_values.phpt
@@ -0,0 +1,69 @@
+--TEST--
+Test range() function with non finite numbers
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+// 0/0 NAN value
+$f1 = fdiv(0, 0);
+var_dump($f1);
+// INF/INF NAN value
+$f2 = fdiv(10.0**400, 9.0**400);
+var_dump($f2);
+// -INF + +INF NAN value
+$f3 = (-10.0**400) + (9.0**400);
+var_dump($f3);
+
+$fs = [$f1, $f2, $f3, 5.5];
+
+foreach ($fs as $s) {
+    foreach ($fs as $e) {
+        echo "range($s, $e);\n";
+        try {
+            var_dump( range($s, $e) );
+        } catch (\ValueError $e) {
+            echo $e->getMessage(), PHP_EOL;
+        }
+    }
+}
+
+?>
+--EXPECT--
+float(NAN)
+float(NAN)
+float(NAN)
+range(NAN, NAN);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, NAN);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, NAN);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, 5.5);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, NAN);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, NAN);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, NAN);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, 5.5);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, NAN);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, NAN);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, NAN);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(NAN, 5.5);
+range(): Argument #1 ($start) must be a finite number, NAN provided
+range(5.5, NAN);
+range(): Argument #2 ($end) must be a finite number, NAN provided
+range(5.5, NAN);
+range(): Argument #2 ($end) must be a finite number, NAN provided
+range(5.5, NAN);
+range(): Argument #2 ($end) must be a finite number, NAN provided
+range(5.5, 5.5);
+array(1) {
+  [0]=>
+  float(5.5)
+}
diff --git a/tests/std/array/range/range_inputs_float_basic.phpt b/tests/std/array/range/range_inputs_float_basic.phpt
new file mode 100644
index 00000000..c6ba7fd7
--- /dev/null
+++ b/tests/std/array/range/range_inputs_float_basic.phpt
@@ -0,0 +1,149 @@
+--TEST--
+range(): float boundary inputs
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+ini_set('serialize_precision', '14');
+echo "Increasing Range\n";
+var_dump( range(1.5, 6.5) );
+
+echo "\nDecreasing range\n";
+var_dump( range(6.5, 1.5) );
+
+echo "\nBoundaries are equal\n";
+var_dump( range(5.5, 5.5) );
+
+echo "\nPassing int step\n";
+var_dump( range(1.5, 10.5, 3) );
+var_dump( range(10.5, 1.5, 3) );
+var_dump( range(1.5, 10.5, "3") );
+
+echo "\nPassing float step\n";
+var_dump( range(1.6, 2.2, 0.1) );
+var_dump( range(2.2, 1.6, 0.1) );
+var_dump( range(1.6, 2.2, "0.1") );
+
+echo "Done\n";
+?>
+--EXPECT--
+Increasing Range
+array(6) {
+  [0]=>
+  float(1.5)
+  [1]=>
+  float(2.5)
+  [2]=>
+  float(3.5)
+  [3]=>
+  float(4.5)
+  [4]=>
+  float(5.5)
+  [5]=>
+  float(6.5)
+}
+
+Decreasing range
+array(6) {
+  [0]=>
+  float(6.5)
+  [1]=>
+  float(5.5)
+  [2]=>
+  float(4.5)
+  [3]=>
+  float(3.5)
+  [4]=>
+  float(2.5)
+  [5]=>
+  float(1.5)
+}
+
+Boundaries are equal
+array(1) {
+  [0]=>
+  float(5.5)
+}
+
+Passing int step
+array(4) {
+  [0]=>
+  float(1.5)
+  [1]=>
+  float(4.5)
+  [2]=>
+  float(7.5)
+  [3]=>
+  float(10.5)
+}
+array(4) {
+  [0]=>
+  float(10.5)
+  [1]=>
+  float(7.5)
+  [2]=>
+  float(4.5)
+  [3]=>
+  float(1.5)
+}
+array(4) {
+  [0]=>
+  float(1.5)
+  [1]=>
+  float(4.5)
+  [2]=>
+  float(7.5)
+  [3]=>
+  float(10.5)
+}
+
+Passing float step
+array(7) {
+  [0]=>
+  float(1.6)
+  [1]=>
+  float(1.7)
+  [2]=>
+  float(1.8)
+  [3]=>
+  float(1.9)
+  [4]=>
+  float(2)
+  [5]=>
+  float(2.1)
+  [6]=>
+  float(2.2)
+}
+array(7) {
+  [0]=>
+  float(2.2)
+  [1]=>
+  float(2.1)
+  [2]=>
+  float(2)
+  [3]=>
+  float(1.9)
+  [4]=>
+  float(1.8)
+  [5]=>
+  float(1.7)
+  [6]=>
+  float(1.6)
+}
+array(7) {
+  [0]=>
+  float(1.6)
+  [1]=>
+  float(1.7)
+  [2]=>
+  float(1.8)
+  [3]=>
+  float(1.9)
+  [4]=>
+  float(2)
+  [5]=>
+  float(2.1)
+  [6]=>
+  float(2.2)
+}
+Done
diff --git a/tests/std/array/range/range_inputs_float_small_step_exhaustion.phpt b/tests/std/array/range/range_inputs_float_small_step_exhaustion.phpt
new file mode 100644
index 00000000..b00b3142
--- /dev/null
+++ b/tests/std/array/range/range_inputs_float_small_step_exhaustion.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Creating a range that exceeds the maximum array size
+--FILE--
+<?php
+try {
+    var_dump(range(0, 100_000_000_000, 0.1));
+} catch (\ValueError $e) {
+    echo $e->getMessage(), \PHP_EOL;
+}
+try {
+    var_dump(range(PHP_INT_MIN, PHP_INT_MAX, 1));
+} catch (\ValueError $e) {
+    echo $e->getMessage(), \PHP_EOL;
+}
+?>
+--EXPECTF--
+The supplied range exceeds the maximum array size: start=0.0 end=100000000000.0 step=0.1
+The supplied range exceeds the maximum array size: start=-%d end=%d step=1
diff --git a/tests/std/array/range/range_inputs_int_basic.phpt b/tests/std/array/range/range_inputs_int_basic.phpt
new file mode 100644
index 00000000..1995470a
--- /dev/null
+++ b/tests/std/array/range/range_inputs_int_basic.phpt
@@ -0,0 +1,189 @@
+--TEST--
+range(): integer boundary inputs
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+ini_set('serialize_precision', '14');
+echo "Increasing Range\n";
+var_dump( range(1, 10) );
+
+echo "\nDecreasing range\n";
+var_dump( range(10, 1) );
+
+echo "\nBoundaries are equal\n";
+var_dump( range(5, 5) );
+
+echo "\nPassing int step\n";
+var_dump( range(1, 10, 3) );
+var_dump( range(10, 1, 3) );
+var_dump( range(1, 10, "3") );
+
+echo "\nPassing float step\n";
+var_dump( range(1, 2, 0.1) );
+var_dump( range(2, 1, 0.1) );
+var_dump( range(1, 2, "0.1") );
+
+echo "Done\n";
+?>
+--EXPECT--
+Increasing Range
+array(10) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+  [9]=>
+  int(10)
+}
+
+Decreasing range
+array(10) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(9)
+  [2]=>
+  int(8)
+  [3]=>
+  int(7)
+  [4]=>
+  int(6)
+  [5]=>
+  int(5)
+  [6]=>
+  int(4)
+  [7]=>
+  int(3)
+  [8]=>
+  int(2)
+  [9]=>
+  int(1)
+}
+
+Boundaries are equal
+array(1) {
+  [0]=>
+  int(5)
+}
+
+Passing int step
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(4)
+  [2]=>
+  int(7)
+  [3]=>
+  int(10)
+}
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(7)
+  [2]=>
+  int(4)
+  [3]=>
+  int(1)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(4)
+  [2]=>
+  int(7)
+  [3]=>
+  int(10)
+}
+
+Passing float step
+array(11) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(1.1)
+  [2]=>
+  float(1.2)
+  [3]=>
+  float(1.3)
+  [4]=>
+  float(1.4)
+  [5]=>
+  float(1.5)
+  [6]=>
+  float(1.6)
+  [7]=>
+  float(1.7)
+  [8]=>
+  float(1.8)
+  [9]=>
+  float(1.9)
+  [10]=>
+  float(2)
+}
+array(11) {
+  [0]=>
+  float(2)
+  [1]=>
+  float(1.9)
+  [2]=>
+  float(1.8)
+  [3]=>
+  float(1.7)
+  [4]=>
+  float(1.6)
+  [5]=>
+  float(1.5)
+  [6]=>
+  float(1.4)
+  [7]=>
+  float(1.3)
+  [8]=>
+  float(1.2)
+  [9]=>
+  float(1.1)
+  [10]=>
+  float(1)
+}
+array(11) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(1.1)
+  [2]=>
+  float(1.2)
+  [3]=>
+  float(1.3)
+  [4]=>
+  float(1.4)
+  [5]=>
+  float(1.5)
+  [6]=>
+  float(1.6)
+  [7]=>
+  float(1.7)
+  [8]=>
+  float(1.8)
+  [9]=>
+  float(1.9)
+  [10]=>
+  float(2)
+}
+Done
diff --git a/tests/std/array/range/range_inputs_int_with_float_step.phpt b/tests/std/array/range/range_inputs_int_with_float_step.phpt
new file mode 100644
index 00000000..2d479ac4
--- /dev/null
+++ b/tests/std/array/range/range_inputs_int_with_float_step.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Test range() function with integer inputs and float step
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+var_dump( range(1, 5, 2.0) );
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(3)
+  [2]=>
+  int(5)
+}
diff --git a/tests/std/array/range/range_inputs_null_variations.phpt b/tests/std/array/range/range_inputs_null_variations.phpt
new file mode 100644
index 00000000..a3ff352c
--- /dev/null
+++ b/tests/std/array/range/range_inputs_null_variations.phpt
@@ -0,0 +1,98 @@
+--TEST--
+Test range() function with null as argument.
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+error_reporting(E_ALL & ~E_DEPRECATED);
+echo "range(null, null)\n";
+var_dump( range(null, null) );
+
+echo "null with int boundary\n";
+var_dump( range(null, 5) );
+var_dump( range(5, null) );
+
+echo "null with float boundary\n";
+var_dump( range(null, 4.5) );
+var_dump( range(4.5, null) );
+
+echo "null with string boundary\n";
+var_dump( range(null, 'e') );
+var_dump( range('e', null) );
+
+echo "Done\n";
+?>
+--EXPECTF--
+range(null, null)
+array(1) {
+  [0]=>
+  int(0)
+}
+null with int boundary
+array(6) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(3)
+  [4]=>
+  int(4)
+  [5]=>
+  int(5)
+}
+array(6) {
+  [0]=>
+  int(5)
+  [1]=>
+  int(4)
+  [2]=>
+  int(3)
+  [3]=>
+  int(2)
+  [4]=>
+  int(1)
+  [5]=>
+  int(0)
+}
+null with float boundary
+array(5) {
+  [0]=>
+  float(0)
+  [1]=>
+  float(1)
+  [2]=>
+  float(2)
+  [3]=>
+  float(3)
+  [4]=>
+  float(4)
+}
+array(5) {
+  [0]=>
+  float(4.5)
+  [1]=>
+  float(3.5)
+  [2]=>
+  float(2.5)
+  [3]=>
+  float(1.5)
+  [4]=>
+  float(0.5)
+}
+null with string boundary
+
+Warning:%S Argument #1 ($start) must be a single byte string if argument #2 ($end) is a single byte string, argument #2 ($end) converted to 0 in %s on line %d
+array(1) {
+  [0]=>
+  int(0)
+}
+
+Warning:%S Argument #2 ($end) must be a single byte string if argument #1 ($start) is a single byte string, argument #1 ($start) converted to 0 in %s on line %d
+array(1) {
+  [0]=>
+  int(0)
+}
+Done
diff --git a/tests/std/array/range/range_inputs_numeric_basic.phpt b/tests/std/array/range/range_inputs_numeric_basic.phpt
new file mode 100644
index 00000000..09e9e415
--- /dev/null
+++ b/tests/std/array/range/range_inputs_numeric_basic.phpt
@@ -0,0 +1,74 @@
+--TEST--
+range(): mixed numeric types boundary inputs
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+var_dump( range(1, "4") );
+var_dump( range("1", 4) );
+var_dump( range(1.5, "4.5") );
+var_dump( range("1.5", 4.5) );
+var_dump( range(9, "12") );
+var_dump( range("9", 12) );
+?>
+--EXPECT--
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+}
+array(4) {
+  [0]=>
+  float(1.5)
+  [1]=>
+  float(2.5)
+  [2]=>
+  float(3.5)
+  [3]=>
+  float(4.5)
+}
+array(4) {
+  [0]=>
+  float(1.5)
+  [1]=>
+  float(2.5)
+  [2]=>
+  float(3.5)
+  [3]=>
+  float(4.5)
+}
+array(4) {
+  [0]=>
+  int(9)
+  [1]=>
+  int(10)
+  [2]=>
+  int(11)
+  [3]=>
+  int(12)
+}
+array(4) {
+  [0]=>
+  int(9)
+  [1]=>
+  int(10)
+  [2]=>
+  int(11)
+  [3]=>
+  int(12)
+}
diff --git a/tests/std/array/range/range_inputs_string_basic.phpt b/tests/std/array/range/range_inputs_string_basic.phpt
new file mode 100644
index 00000000..00ce49e6
--- /dev/null
+++ b/tests/std/array/range/range_inputs_string_basic.phpt
@@ -0,0 +1,153 @@
+--TEST--
+Test range() function with basic/expected string inputs
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+
+echo "-- Chars as Low and High --\n";
+echo "-- An array of elements from low to high --\n";
+var_dump( range("a", "z") );
+echo "\n-- An array of elements from high to low --\n";
+var_dump( range("z", "a") );
+
+echo "\n-- Low and High are equal --\n";
+var_dump( range("q", "q") );
+
+echo "\n-- Testing basic string with step --\n";
+var_dump( range("a", "h", 2) );
+
+echo "Done\n";
+?>
+--EXPECT--
+-- Chars as Low and High --
+-- An array of elements from low to high --
+array(26) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "c"
+  [3]=>
+  string(1) "d"
+  [4]=>
+  string(1) "e"
+  [5]=>
+  string(1) "f"
+  [6]=>
+  string(1) "g"
+  [7]=>
+  string(1) "h"
+  [8]=>
+  string(1) "i"
+  [9]=>
+  string(1) "j"
+  [10]=>
+  string(1) "k"
+  [11]=>
+  string(1) "l"
+  [12]=>
+  string(1) "m"
+  [13]=>
+  string(1) "n"
+  [14]=>
+  string(1) "o"
+  [15]=>
+  string(1) "p"
+  [16]=>
+  string(1) "q"
+  [17]=>
+  string(1) "r"
+  [18]=>
+  string(1) "s"
+  [19]=>
+  string(1) "t"
+  [20]=>
+  string(1) "u"
+  [21]=>
+  string(1) "v"
+  [22]=>
+  string(1) "w"
+  [23]=>
+  string(1) "x"
+  [24]=>
+  string(1) "y"
+  [25]=>
+  string(1) "z"
+}
+
+-- An array of elements from high to low --
+array(26) {
+  [0]=>
+  string(1) "z"
+  [1]=>
+  string(1) "y"
+  [2]=>
+  string(1) "x"
+  [3]=>
+  string(1) "w"
+  [4]=>
+  string(1) "v"
+  [5]=>
+  string(1) "u"
+  [6]=>
+  string(1) "t"
+  [7]=>
+  string(1) "s"
+  [8]=>
+  string(1) "r"
+  [9]=>
+  string(1) "q"
+  [10]=>
+  string(1) "p"
+  [11]=>
+  string(1) "o"
+  [12]=>
+  string(1) "n"
+  [13]=>
+  string(1) "m"
+  [14]=>
+  string(1) "l"
+  [15]=>
+  string(1) "k"
+  [16]=>
+  string(1) "j"
+  [17]=>
+  string(1) "i"
+  [18]=>
+  string(1) "h"
+  [19]=>
+  string(1) "g"
+  [20]=>
+  string(1) "f"
+  [21]=>
+  string(1) "e"
+  [22]=>
+  string(1) "d"
+  [23]=>
+  string(1) "c"
+  [24]=>
+  string(1) "b"
+  [25]=>
+  string(1) "a"
+}
+
+-- Low and High are equal --
+array(1) {
+  [0]=>
+  string(1) "q"
+}
+
+-- Testing basic string with step --
+array(4) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "c"
+  [2]=>
+  string(1) "e"
+  [3]=>
+  string(1) "g"
+}
+Done
diff --git a/tests/std/array/range/range_inputs_string_digits.phpt b/tests/std/array/range/range_inputs_string_digits.phpt
new file mode 100644
index 00000000..b218c582
--- /dev/null
+++ b/tests/std/array/range/range_inputs_string_digits.phpt
@@ -0,0 +1,97 @@
+--TEST--
+Test range() function with string digits
+--FILE--
+<?php
+echo "Only digits\n";
+var_dump( range("1", "9") );
+var_dump( range("9", "1") );
+
+echo "Only digits and char\n";
+var_dump( range("9", "A") );
+var_dump( range("A", "9") );
+echo "Done\n";
+?>
+--EXPECT--
+Only digits
+array(9) {
+  [0]=>
+  string(1) "1"
+  [1]=>
+  string(1) "2"
+  [2]=>
+  string(1) "3"
+  [3]=>
+  string(1) "4"
+  [4]=>
+  string(1) "5"
+  [5]=>
+  string(1) "6"
+  [6]=>
+  string(1) "7"
+  [7]=>
+  string(1) "8"
+  [8]=>
+  string(1) "9"
+}
+array(9) {
+  [0]=>
+  string(1) "9"
+  [1]=>
+  string(1) "8"
+  [2]=>
+  string(1) "7"
+  [3]=>
+  string(1) "6"
+  [4]=>
+  string(1) "5"
+  [5]=>
+  string(1) "4"
+  [6]=>
+  string(1) "3"
+  [7]=>
+  string(1) "2"
+  [8]=>
+  string(1) "1"
+}
+Only digits and char
+array(9) {
+  [0]=>
+  string(1) "9"
+  [1]=>
+  string(1) ":"
+  [2]=>
+  string(1) ";"
+  [3]=>
+  string(1) "<"
+  [4]=>
+  string(1) "="
+  [5]=>
+  string(1) ">"
+  [6]=>
+  string(1) "?"
+  [7]=>
+  string(1) "@"
+  [8]=>
+  string(1) "A"
+}
+array(9) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "@"
+  [2]=>
+  string(1) "?"
+  [3]=>
+  string(1) ">"
+  [4]=>
+  string(1) "="
+  [5]=>
+  string(1) "<"
+  [6]=>
+  string(1) ";"
+  [7]=>
+  string(1) ":"
+  [8]=>
+  string(1) "9"
+}
+Done
diff --git a/tests/std/array/range/range_inputs_string_digits_float_step.phpt b/tests/std/array/range/range_inputs_string_digits_float_step.phpt
new file mode 100644
index 00000000..45a53827
--- /dev/null
+++ b/tests/std/array/range/range_inputs_string_digits_float_step.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Test range() function where boundary are string digits and step is a float
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+ini_set('serialize_precision', '14');
+var_dump( range("1", "2", 0.1) );
+?>
+--EXPECT--
+array(11) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(1.1)
+  [2]=>
+  float(1.2)
+  [3]=>
+  float(1.3)
+  [4]=>
+  float(1.4)
+  [5]=>
+  float(1.5)
+  [6]=>
+  float(1.6)
+  [7]=>
+  float(1.7)
+  [8]=>
+  float(1.8)
+  [9]=>
+  float(1.9)
+  [10]=>
+  float(2)
+}
diff --git a/tests/std/array/range/range_inputs_string_invalid.phpt b/tests/std/array/range/range_inputs_string_invalid.phpt
new file mode 100644
index 00000000..f86d1670
--- /dev/null
+++ b/tests/std/array/range/range_inputs_string_invalid.phpt
@@ -0,0 +1,85 @@
+--TEST--
+Test range() function with unexpected string inputs
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+
+echo "Range will ignore any byte after the first one\n";
+var_dump( range("AA", "BB") );
+
+echo "Range cannot operate on an empty string\n";
+var_dump( range("Z", "") ); // Both strings are cast to int, i.e. 0
+var_dump( range("", "Z") ); // Both strings are cast to int, i.e. 0
+
+echo "Mixing numeric float string and character\n";
+var_dump( range("3.5", "A") ); // The char is cast to a float, i.e. 0
+var_dump( range("?", "3.5") ); // The char is cast to a float, i.e. 0
+
+echo "Fractional step cannot be used on character ranges\n";
+var_dump( range("A", "H", 2.6) ); // Because step is fractional it tries to interpret inputs as floats
+
+echo "Done\n";
+?>
+--EXPECTF--
+Range will ignore any byte after the first one
+
+Warning:%S Argument #1 ($start) must be a single byte, subsequent bytes are ignored in %s on line %d
+
+Warning:%S Argument #2 ($end) must be a single byte, subsequent bytes are ignored in %s on line %d
+array(2) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+}
+Range cannot operate on an empty string
+
+Warning:%S Argument #2 ($end) must not be empty, casted to 0 in %s on line %d
+
+Warning:%S Argument #2 ($end) must be a single byte string if argument #1 ($start) is a single byte string, argument #1 ($start) converted to 0 in %s on line %d
+array(1) {
+  [0]=>
+  int(0)
+}
+
+Warning:%S Argument #1 ($start) must not be empty, casted to 0 in %s on line %d
+
+Warning:%S Argument #1 ($start) must be a single byte string if argument #2 ($end) is a single byte string, argument #2 ($end) converted to 0 in %s on line %d
+array(1) {
+  [0]=>
+  int(0)
+}
+Mixing numeric float string and character
+
+Warning:%S Argument #1 ($start) must be a single byte string if argument #2 ($end) is a single byte string, argument #2 ($end) converted to 0 in %s on line %d
+array(4) {
+  [0]=>
+  float(3.5)
+  [1]=>
+  float(2.5)
+  [2]=>
+  float(1.5)
+  [3]=>
+  float(0.5)
+}
+
+Warning:%S Argument #2 ($end) must be a single byte string if argument #1 ($start) is a single byte string, argument #1 ($start) converted to 0 in %s on line %d
+array(4) {
+  [0]=>
+  float(0)
+  [1]=>
+  float(1)
+  [2]=>
+  float(2)
+  [3]=>
+  float(3)
+}
+Fractional step cannot be used on character ranges
+
+Warning:%S Argument #3 ($step) must be of type int when generating an array of characters, inputs converted to 0 in %s on line %d
+array(1) {
+  [0]=>
+  float(0)
+}
+Done
diff --git a/tests/std/array/range/range_inputs_string_numeric.phpt b/tests/std/array/range/range_inputs_string_numeric.phpt
new file mode 100644
index 00000000..fc45811a
--- /dev/null
+++ b/tests/std/array/range/range_inputs_string_numeric.phpt
@@ -0,0 +1,189 @@
+--TEST--
+range(): numeric string boundary inputs
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+ini_set('serialize_precision', '14');
+echo "Increasing Range\n";
+var_dump( range("1", "10") );
+
+echo "\nDecreasing range\n";
+var_dump( range("10", "1") );
+
+echo "\nBoundaries are equal\n";
+var_dump( range("5", "5") );
+
+echo "\nPassing int step\n";
+var_dump( range("1", "10", 3) );
+var_dump( range("10", "1", 3) );
+var_dump( range("1", "10", "3") );
+
+echo "\nPassing float step\n";
+var_dump( range("1", "2", 0.1) );
+var_dump( range("2", "1", 0.1) );
+var_dump( range("1", "2", "0.1") );
+
+echo "Done\n";
+?>
+--EXPECT--
+Increasing Range
+array(10) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+  [4]=>
+  int(5)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [7]=>
+  int(8)
+  [8]=>
+  int(9)
+  [9]=>
+  int(10)
+}
+
+Decreasing range
+array(10) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(9)
+  [2]=>
+  int(8)
+  [3]=>
+  int(7)
+  [4]=>
+  int(6)
+  [5]=>
+  int(5)
+  [6]=>
+  int(4)
+  [7]=>
+  int(3)
+  [8]=>
+  int(2)
+  [9]=>
+  int(1)
+}
+
+Boundaries are equal
+array(1) {
+  [0]=>
+  string(1) "5"
+}
+
+Passing int step
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(4)
+  [2]=>
+  int(7)
+  [3]=>
+  int(10)
+}
+array(4) {
+  [0]=>
+  int(10)
+  [1]=>
+  int(7)
+  [2]=>
+  int(4)
+  [3]=>
+  int(1)
+}
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(4)
+  [2]=>
+  int(7)
+  [3]=>
+  int(10)
+}
+
+Passing float step
+array(11) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(1.1)
+  [2]=>
+  float(1.2)
+  [3]=>
+  float(1.3)
+  [4]=>
+  float(1.4)
+  [5]=>
+  float(1.5)
+  [6]=>
+  float(1.6)
+  [7]=>
+  float(1.7)
+  [8]=>
+  float(1.8)
+  [9]=>
+  float(1.9)
+  [10]=>
+  float(2)
+}
+array(11) {
+  [0]=>
+  float(2)
+  [1]=>
+  float(1.9)
+  [2]=>
+  float(1.8)
+  [3]=>
+  float(1.7)
+  [4]=>
+  float(1.6)
+  [5]=>
+  float(1.5)
+  [6]=>
+  float(1.4)
+  [7]=>
+  float(1.3)
+  [8]=>
+  float(1.2)
+  [9]=>
+  float(1.1)
+  [10]=>
+  float(1)
+}
+array(11) {
+  [0]=>
+  float(1)
+  [1]=>
+  float(1.1)
+  [2]=>
+  float(1.2)
+  [3]=>
+  float(1.3)
+  [4]=>
+  float(1.4)
+  [5]=>
+  float(1.5)
+  [6]=>
+  float(1.6)
+  [7]=>
+  float(1.7)
+  [8]=>
+  float(1.8)
+  [9]=>
+  float(1.9)
+  [10]=>
+  float(2)
+}
+Done
diff --git a/tests/std/array/range/range_inputs_string_variations.phpt b/tests/std/array/range/range_inputs_string_variations.phpt
new file mode 100644
index 00000000..27dd535f
--- /dev/null
+++ b/tests/std/array/range/range_inputs_string_variations.phpt
@@ -0,0 +1,148 @@
+--TEST--
+Test range() function with unexpected string input variations or unusual step.
+--INI--
+serialize_precision=14
+--FILE--
+<?php
+
+echo "int compatible float as step\n";
+var_dump( range("a", "h", 2.0) );
+
+// What range does is increment the ASCII character code point
+echo "A to z range()\n";
+var_dump( range("A", "z") );
+
+echo "Done\n";
+?>
+--EXPECT--
+int compatible float as step
+array(4) {
+  [0]=>
+  string(1) "a"
+  [1]=>
+  string(1) "c"
+  [2]=>
+  string(1) "e"
+  [3]=>
+  string(1) "g"
+}
+A to z range()
+array(58) {
+  [0]=>
+  string(1) "A"
+  [1]=>
+  string(1) "B"
+  [2]=>
+  string(1) "C"
+  [3]=>
+  string(1) "D"
+  [4]=>
+  string(1) "E"
+  [5]=>
+  string(1) "F"
+  [6]=>
+  string(1) "G"
+  [7]=>
+  string(1) "H"
+  [8]=>
+  string(1) "I"
+  [9]=>
+  string(1) "J"
+  [10]=>
+  string(1) "K"
+  [11]=>
+  string(1) "L"
+  [12]=>
+  string(1) "M"
+  [13]=>
+  string(1) "N"
+  [14]=>
+  string(1) "O"
+  [15]=>
+  string(1) "P"
+  [16]=>
+  string(1) "Q"
+  [17]=>
+  string(1) "R"
+  [18]=>
+  string(1) "S"
+  [19]=>
+  string(1) "T"
+  [20]=>
+  string(1) "U"
+  [21]=>
+  string(1) "V"
+  [22]=>
+  string(1) "W"
+  [23]=>
+  string(1) "X"
+  [24]=>
+  string(1) "Y"
+  [25]=>
+  string(1) "Z"
+  [26]=>
+  string(1) "["
+  [27]=>
+  string(1) "\"
+  [28]=>
+  string(1) "]"
+  [29]=>
+  string(1) "^"
+  [30]=>
+  string(1) "_"
+  [31]=>
+  string(1) "`"
+  [32]=>
+  string(1) "a"
+  [33]=>
+  string(1) "b"
+  [34]=>
+  string(1) "c"
+  [35]=>
+  string(1) "d"
+  [36]=>
+  string(1) "e"
+  [37]=>
+  string(1) "f"
+  [38]=>
+  string(1) "g"
+  [39]=>
+  string(1) "h"
+  [40]=>
+  string(1) "i"
+  [41]=>
+  string(1) "j"
+  [42]=>
+  string(1) "k"
+  [43]=>
+  string(1) "l"
+  [44]=>
+  string(1) "m"
+  [45]=>
+  string(1) "n"
+  [46]=>
+  string(1) "o"
+  [47]=>
+  string(1) "p"
+  [48]=>
+  string(1) "q"
+  [49]=>
+  string(1) "r"
+  [50]=>
+  string(1) "s"
+  [51]=>
+  string(1) "t"
+  [52]=>
+  string(1) "u"
+  [53]=>
+  string(1) "v"
+  [54]=>
+  string(1) "w"
+  [55]=>
+  string(1) "x"
+  [56]=>
+  string(1) "y"
+  [57]=>
+  string(1) "z"
+}
+Done
diff --git a/tests/std/array/range/range_negative_step_decreasing_ranges.phpt b/tests/std/array/range/range_negative_step_decreasing_ranges.phpt
new file mode 100644
index 00000000..6a9ff3a7
--- /dev/null
+++ b/tests/std/array/range/range_negative_step_decreasing_ranges.phpt
@@ -0,0 +1,33 @@
+--TEST--
+range() allows $step parameter to be negative for decreasing ranges
+--INI--
+precision=14
+--FILE--
+<?php
+var_dump(range('c', 'a', -1));
+var_dump(range(3, 1, -1));
+var_dump(range(3.5, 1.5, -1.5));
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  string(1) "c"
+  [1]=>
+  string(1) "b"
+  [2]=>
+  string(1) "a"
+}
+array(3) {
+  [0]=>
+  int(3)
+  [1]=>
+  int(2)
+  [2]=>
+  int(1)
+}
+array(2) {
+  [0]=>
+  float(3.5)
+  [1]=>
+  float(2)
+}
diff --git a/tests/std/array/range/range_step_errors.phpt b/tests/std/array/range/range_step_errors.phpt
new file mode 100644
index 00000000..e950c527
--- /dev/null
+++ b/tests/std/array/range/range_step_errors.phpt
@@ -0,0 +1,134 @@
+--TEST--
+range() programattic errors for the $step parameter
+--INI--
+precision=14
+--FILE--
+<?php
+echo "Step cannot be 0\n";
+try {
+    var_dump( range(1.0, 7.0, 0.0) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump( range(1, 7, 0) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump( range('A', 'H', 0) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump( range('A', 'H', 0.0) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+echo "Step cannot be INF\n";
+try {
+    var_dump( range(1.0, 7.0, 10.0**400) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump( range(1, 7, 10.0**400) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump( range('A', 'H', 10.0**400) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+echo "Step cannot be NAN\n";
+try {
+    var_dump( range(1.0, 7.0, fdiv(0, 0)) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump( range(1, 7, fdiv(0, 0)) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump( range('A', 'H', fdiv(0, 0)) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Step must be within the range of input parameters\n";
+echo "-- Testing ( (low < high) && (high-low < step) ) --\n";
+try {
+    var_dump( range(1.0, 7.0, 6.5) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "-- Testing ( (low > high) && (low-high < step) ) --\n";
+try {
+    var_dump( range(7.0, 1.0, 6.5) );
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "-- Testing ( (low < high) && (high-low < step) ) for characters --\n";
+try {
+    var_dump(range('a', 'z', 100));
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "-- Testing ( (low > high) && (low-high < step) ) for characters --\n";
+try {
+    var_dump(range('z', 'a', 100));
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "Step must not be negative for increasing ranges\n";
+try {
+    var_dump(range('a', 'c', -1));
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump(range(1, 3, -1));
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump(range(1.5, 3.5, -1.5));
+} catch (\ValueError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+Step cannot be 0
+range(): Argument #3 ($step) cannot be 0
+range(): Argument #3 ($step) cannot be 0
+range(): Argument #3 ($step) cannot be 0
+range(): Argument #3 ($step) cannot be 0
+Step cannot be INF
+range(): Argument #3 ($step) must be a finite number, INF provided
+range(): Argument #3 ($step) must be a finite number, INF provided
+range(): Argument #3 ($step) must be a finite number, INF provided
+Step cannot be NAN
+range(): Argument #3 ($step) must be a finite number, NAN provided
+range(): Argument #3 ($step) must be a finite number, NAN provided
+range(): Argument #3 ($step) must be a finite number, NAN provided
+Step must be within the range of input parameters
+-- Testing ( (low < high) && (high-low < step) ) --
+range(): Argument #3 ($step) must be less than the range spanned by argument #1 ($start) and argument #2 ($end)
+-- Testing ( (low > high) && (low-high < step) ) --
+range(): Argument #3 ($step) must be less than the range spanned by argument #1 ($start) and argument #2 ($end)
+-- Testing ( (low < high) && (high-low < step) ) for characters --
+range(): Argument #3 ($step) must be less than the range spanned by argument #1 ($start) and argument #2 ($end)
+-- Testing ( (low > high) && (low-high < step) ) for characters --
+range(): Argument #3 ($step) must be less than the range spanned by argument #1 ($start) and argument #2 ($end)
+Step must not be negative for increasing ranges
+range(): Argument #3 ($step) must be greater than 0 for increasing ranges
+range(): Argument #3 ($step) must be greater than 0 for increasing ranges
+range(): Argument #3 ($step) must be greater than 0 for increasing ranges
diff --git a/tests/std/array/range/range_variation1.phpt b/tests/std/array/range/range_variation1.phpt
new file mode 100644
index 00000000..0747fab3
--- /dev/null
+++ b/tests/std/array/range/range_variation1.phpt
@@ -0,0 +1,60 @@
+--TEST--
+Test range() function (variation-2)
+--INI--
+precision=14
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platform only");
+?>
+--FILE--
+<?php
+
+echo "\n*** Testing max/outof range values ***\n";
+/*var_dump( range("a", "z", 255) );
+var_dump( range("z", "a", 255) ); */
+var_dump( range(2147483645, 2147483646) );
+var_dump( range(2147483646, 2147483648) );
+var_dump( range(-2147483647, -2147483646) );
+var_dump( range(-2147483648, -2147483647) );
+var_dump( range(-2147483649, -2147483647) );
+
+echo "\nDone";
+?>
+--EXPECT--
+*** Testing max/outof range values ***
+array(2) {
+  [0]=>
+  int(2147483645)
+  [1]=>
+  int(2147483646)
+}
+array(3) {
+  [0]=>
+  float(2147483646)
+  [1]=>
+  float(2147483647)
+  [2]=>
+  float(2147483648)
+}
+array(2) {
+  [0]=>
+  int(-2147483647)
+  [1]=>
+  int(-2147483646)
+}
+array(2) {
+  [0]=>
+  float(-2147483648)
+  [1]=>
+  float(-2147483647)
+}
+array(3) {
+  [0]=>
+  float(-2147483649)
+  [1]=>
+  float(-2147483648)
+  [2]=>
+  float(-2147483647)
+}
+
+Done
diff --git a/tests/std/array/range/range_variation1_64bit.phpt b/tests/std/array/range/range_variation1_64bit.phpt
new file mode 100644
index 00000000..555dbc2e
--- /dev/null
+++ b/tests/std/array/range/range_variation1_64bit.phpt
@@ -0,0 +1,60 @@
+--TEST--
+Test range() function (variation-2)
+--INI--
+precision=14
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 8) die("skip this test is for 64bit platform only");
+?>
+--FILE--
+<?php
+
+echo "\n*** Testing max/outof range values ***\n";
+/*var_dump( range("a", "z", 255) );
+var_dump( range("z", "a", 255) ); */
+var_dump( range(2147483645, 2147483646) );
+var_dump( range(2147483646, 2147483648) );
+var_dump( range(-2147483647, -2147483646) );
+var_dump( range(-2147483648, -2147483647) );
+var_dump( range(-2147483649, -2147483647) );
+
+echo "\nDone";
+?>
+--EXPECT--
+*** Testing max/outof range values ***
+array(2) {
+  [0]=>
+  int(2147483645)
+  [1]=>
+  int(2147483646)
+}
+array(3) {
+  [0]=>
+  int(2147483646)
+  [1]=>
+  int(2147483647)
+  [2]=>
+  int(2147483648)
+}
+array(2) {
+  [0]=>
+  int(-2147483647)
+  [1]=>
+  int(-2147483646)
+}
+array(2) {
+  [0]=>
+  int(-2147483648)
+  [1]=>
+  int(-2147483647)
+}
+array(3) {
+  [0]=>
+  int(-2147483649)
+  [1]=>
+  int(-2147483648)
+  [2]=>
+  int(-2147483647)
+}
+
+Done
diff --git a/tests/std/array/rcn_in_place.phpt b/tests/std/array/rcn_in_place.phpt
new file mode 100644
index 00000000..e6a7b5b6
--- /dev/null
+++ b/tests/std/array/rcn_in_place.phpt
@@ -0,0 +1,57 @@
+--TEST--
+RCN check for in-place array modifications
+--FILE--
+<?php
+// Important: do NOT replace range(0, 1) with a variable, these NEED to be TMPVARs!
+var_dump(array_replace(range(0, 1), []));
+var_dump(array_replace_recursive(range(0, 1), []));
+var_dump(array_merge(range(0, 1), []));
+var_dump(array_merge_recursive(range(0, 1), []));
+var_dump(array_unique(range(0, 1)));
+var_dump(array_intersect_ukey(range(0, 1), [], fn () => 0));
+var_dump(array_intersect(range(0, 1), []));
+var_dump(array_uintersect(range(0, 1), [], fn () => 0));
+var_dump(array_intersect_uassoc(range(0, 1), [], fn () => 0));
+var_dump(array_uintersect_uassoc(range(0, 1), [], fn () => 0, fn () => 0));
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(2) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(1)
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
+array(0) {
+}
diff --git a/tests/std/array/reset_basic.phpt b/tests/std/array/reset_basic.phpt
new file mode 100644
index 00000000..d533d28d
--- /dev/null
+++ b/tests/std/array/reset_basic.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Test reset() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of reset()
+ */
+
+echo "*** Testing reset() : basic functionality ***\n";
+
+$array = array('zero', 'one', 200 => 'two');
+
+echo "\n-- Initial Position: --\n";
+echo key($array) . " => " . current($array) . "\n";
+
+echo "\n-- Call to next() --\n";
+var_dump(next($array));
+
+echo "\n-- Current Position: --\n";
+echo key($array) . " => " . current($array) . "\n";
+
+echo "\n-- Call to reset() --\n";
+var_dump(reset($array));
+?>
+--EXPECT--
+*** Testing reset() : basic functionality ***
+
+-- Initial Position: --
+0 => zero
+
+-- Call to next() --
+string(3) "one"
+
+-- Current Position: --
+1 => one
+
+-- Call to reset() --
+string(4) "zero"
diff --git a/tests/std/array/reset_variation2.phpt b/tests/std/array/reset_variation2.phpt
new file mode 100644
index 00000000..13d1347f
--- /dev/null
+++ b/tests/std/array/reset_variation2.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Test reset() function : usage variations - unset first element
+--FILE--
+<?php
+/*
+ * Unset first element of an array and test behaviour of reset()
+ */
+
+echo "*** Testing reset() : usage variations ***\n";
+
+$array = array('a', 'b', 'c');
+
+echo "\n-- Initial Position: --\n";
+echo current($array) . " => " . key($array) . "\n";
+
+echo "\n-- Unset First element in array and check reset() --\n";
+unset($array[0]);
+var_dump(reset($array));
+?>
+--EXPECT--
+*** Testing reset() : usage variations ***
+
+-- Initial Position: --
+a => 0
+
+-- Unset First element in array and check reset() --
+string(1) "b"
diff --git a/tests/std/array/reset_variation3.phpt b/tests/std/array/reset_variation3.phpt
new file mode 100644
index 00000000..9bfc290b
--- /dev/null
+++ b/tests/std/array/reset_variation3.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Test reset() function : usage variations - Referenced variables
+--FILE--
+<?php
+/*
+ * Reference two arrays to each other then call reset() to test position of
+ * internal pointer in both arrays
+ */
+
+echo "*** Testing reset() : usage variations ***\n";
+
+$array1 = array ('zero', 'one', 'two');
+
+echo "\n-- Initial position of internal pointer --\n";
+var_dump(current($array1));
+
+// Test that when two variables are referenced to one another
+// the internal pointer is the same for both
+$array2 = &$array1;
+
+next($array1);
+
+echo "\n-- Position after calling next() --\n";
+echo "\$array1: ";
+var_dump(current($array1));
+echo "\$array2: ";
+var_dump(current($array2));
+
+echo "\n-- Position after calling reset() --\n";
+var_dump(reset($array1));
+echo "\$array1: ";
+var_dump(current($array1));
+echo "\$array2: ";
+var_dump(current($array2));
+?>
+--EXPECT--
+*** Testing reset() : usage variations ***
+
+-- Initial position of internal pointer --
+string(4) "zero"
+
+-- Position after calling next() --
+$array1: string(3) "one"
+$array2: string(3) "one"
+
+-- Position after calling reset() --
+string(4) "zero"
+$array1: string(4) "zero"
+$array2: string(4) "zero"
diff --git a/tests/std/array/rsort_basic.phpt b/tests/std/array/rsort_basic.phpt
new file mode 100644
index 00000000..a7ad5f37
--- /dev/null
+++ b/tests/std/array/rsort_basic.phpt
@@ -0,0 +1,235 @@
+--TEST--
+Test rsort() function : basic functionality
+--FILE--
+<?php
+/*
+ * Test basic functionality of rsort()
+ */
+
+echo "*** Testing rsort() : basic functionality ***\n";
+
+// associative array containing unsorted string values
+$unsorted_strings = array(
+    "l" => "lemon", "o" => "orange",
+    "O" => "Orange", "O1" => "Orange1", "o2" => "orange2", "O3" => "Orange3", "o20" => "orange20",
+    "b" => "banana",
+);
+
+// array with default keys containing unsorted numeric values
+$unsorted_numerics =  array( 100, 33, 555, 22 );
+
+echo "\n-- Testing rsort() by supplying string array, 'flag' value is default --\n";
+$temp_array = $unsorted_strings;
+var_dump( rsort($temp_array) );
+var_dump( $temp_array);
+
+echo "\n-- Testing rsort() by supplying numeric array, 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( rsort($temp_array) );
+var_dump( $temp_array);
+
+echo "\n-- Testing rsort() by supplying string array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_strings;
+var_dump( rsort($temp_array, SORT_REGULAR) );
+var_dump( $temp_array);
+
+echo "\n-- Testing rsort() by supplying numeric array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_numerics;
+var_dump( rsort($temp_array, SORT_REGULAR) );
+var_dump( $temp_array);
+
+echo "\n-- Testing rsort() by supplying string array, 'flag' = SORT_STRING --\n";
+$temp_array = $unsorted_strings;
+var_dump( rsort($temp_array, SORT_STRING) );
+var_dump( $temp_array);
+
+echo "\n-- Testing rsort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( rsort($temp_array, SORT_STRING|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing rsort() by supplying string array (natural), 'flag' = SORT_NATURAL --\n";
+$temp_array = $unsorted_strings;
+var_dump( rsort($temp_array, SORT_NATURAL) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing rsort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( rsort($temp_array, SORT_NATURAL|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing rsort() by supplying numeric array, 'flag' = SORT_NUMERIC --\n";
+$temp_array = $unsorted_numerics;
+var_dump( rsort($temp_array, SORT_NUMERIC) );
+var_dump( $temp_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing rsort() : basic functionality ***
+
+-- Testing rsort() by supplying string array, 'flag' value is default --
+bool(true)
+array(8) {
+  [0]=>
+  string(8) "orange20"
+  [1]=>
+  string(7) "orange2"
+  [2]=>
+  string(6) "orange"
+  [3]=>
+  string(5) "lemon"
+  [4]=>
+  string(6) "banana"
+  [5]=>
+  string(7) "Orange3"
+  [6]=>
+  string(7) "Orange1"
+  [7]=>
+  string(6) "Orange"
+}
+
+-- Testing rsort() by supplying numeric array, 'flag' value is default --
+bool(true)
+array(4) {
+  [0]=>
+  int(555)
+  [1]=>
+  int(100)
+  [2]=>
+  int(33)
+  [3]=>
+  int(22)
+}
+
+-- Testing rsort() by supplying string array, 'flag' = SORT_REGULAR --
+bool(true)
+array(8) {
+  [0]=>
+  string(8) "orange20"
+  [1]=>
+  string(7) "orange2"
+  [2]=>
+  string(6) "orange"
+  [3]=>
+  string(5) "lemon"
+  [4]=>
+  string(6) "banana"
+  [5]=>
+  string(7) "Orange3"
+  [6]=>
+  string(7) "Orange1"
+  [7]=>
+  string(6) "Orange"
+}
+
+-- Testing rsort() by supplying numeric array, 'flag' = SORT_REGULAR --
+bool(true)
+array(4) {
+  [0]=>
+  int(555)
+  [1]=>
+  int(100)
+  [2]=>
+  int(33)
+  [3]=>
+  int(22)
+}
+
+-- Testing rsort() by supplying string array, 'flag' = SORT_STRING --
+bool(true)
+array(8) {
+  [0]=>
+  string(8) "orange20"
+  [1]=>
+  string(7) "orange2"
+  [2]=>
+  string(6) "orange"
+  [3]=>
+  string(5) "lemon"
+  [4]=>
+  string(6) "banana"
+  [5]=>
+  string(7) "Orange3"
+  [6]=>
+  string(7) "Orange1"
+  [7]=>
+  string(6) "Orange"
+}
+
+-- Testing rsort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  [0]=>
+  string(7) "Orange3"
+  [1]=>
+  string(8) "orange20"
+  [2]=>
+  string(7) "orange2"
+  [3]=>
+  string(7) "Orange1"
+  [4]=>
+  string(6) "orange"
+  [5]=>
+  string(6) "Orange"
+  [6]=>
+  string(5) "lemon"
+  [7]=>
+  string(6) "banana"
+}
+
+-- Testing rsort() by supplying string array (natural), 'flag' = SORT_NATURAL --
+bool(true)
+array(8) {
+  [0]=>
+  string(8) "orange20"
+  [1]=>
+  string(7) "orange2"
+  [2]=>
+  string(6) "orange"
+  [3]=>
+  string(5) "lemon"
+  [4]=>
+  string(6) "banana"
+  [5]=>
+  string(7) "Orange3"
+  [6]=>
+  string(7) "Orange1"
+  [7]=>
+  string(6) "Orange"
+}
+
+-- Testing rsort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  [0]=>
+  string(8) "orange20"
+  [1]=>
+  string(7) "Orange3"
+  [2]=>
+  string(7) "orange2"
+  [3]=>
+  string(7) "Orange1"
+  [4]=>
+  string(6) "orange"
+  [5]=>
+  string(6) "Orange"
+  [6]=>
+  string(5) "lemon"
+  [7]=>
+  string(6) "banana"
+}
+
+-- Testing rsort() by supplying numeric array, 'flag' = SORT_NUMERIC --
+bool(true)
+array(4) {
+  [0]=>
+  int(555)
+  [1]=>
+  int(100)
+  [2]=>
+  int(33)
+  [3]=>
+  int(22)
+}
+Done
diff --git a/tests/std/array/rsort_object1.phpt b/tests/std/array/rsort_object1.phpt
new file mode 100644
index 00000000..4dc1feeb
--- /dev/null
+++ b/tests/std/array/rsort_object1.phpt
@@ -0,0 +1,218 @@
+--TEST--
+Test rsort() function : object functionality
+--FILE--
+<?php
+// class declaration for integer objects
+class for_integer_rsort
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+}
+// class declaration for string objects
+class for_string_rsort
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * Test basic functionality of rsort() with objects
+     */
+    echo "*** Testing rsort() : object functionality ***\n";
+    // array of integer objects
+    $unsorted_int_obj = array(new for_integer_rsort(11), new for_integer_rsort(66), new for_integer_rsort(23), new for_integer_rsort(-5), new for_integer_rsort(0.001), new for_integer_rsort(0));
+    // array of string objects
+    $unsorted_str_obj = array(new for_string_rsort("axx"), new for_string_rsort("t"), new for_string_rsort("w"), new for_string_rsort("py"), new for_string_rsort("apple"), new for_string_rsort("Orange"), new for_string_rsort("Lemon"), new for_string_rsort("aPPle"));
+    echo "\n-- Sort flag = default --\n";
+    // testing rsort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(rsort($temp_array));
+    var_dump($temp_array);
+    // testing rsort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(rsort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Sort flag = SORT_REGULAR --\n";
+    // testing rsort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(rsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing rsort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(rsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing rsort() : object functionality ***
+
+-- Sort flag = default --
+bool(true)
+array(6) {
+  [0]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+  [1]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [2]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [3]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [4]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [5]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+}
+bool(true)
+array(8) {
+  [0]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+  [1]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  [2]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  [3]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  [4]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  [5]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  [6]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  [7]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+}
+
+-- Sort flag = SORT_REGULAR --
+bool(true)
+array(6) {
+  [0]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+  [1]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [2]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [3]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [4]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [5]=>
+  object(for_integer_rsort)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+}
+bool(true)
+array(8) {
+  [0]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+  [1]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  [2]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  [3]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  [4]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  [5]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  [6]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  [7]=>
+  object(for_string_rsort)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+}
+Done
diff --git a/tests/std/array/rsort_object2.phpt b/tests/std/array/rsort_object2.phpt
new file mode 100644
index 00000000..a7e4fde7
--- /dev/null
+++ b/tests/std/array/rsort_object2.phpt
@@ -0,0 +1,230 @@
+--TEST--
+Test rsort() function : object functionality - different visibilities
+--FILE--
+<?php
+// class declaration for integer objects
+class for_integer_rsort
+{
+    public $public_class_value;
+    private $private_class_value;
+    protected $protected_class_value;
+    // initializing object member value
+    function __construct($value1, $value2, $value3)
+    {
+        $this->public_class_value = $value1;
+        $this->private_class_value = $value2;
+        $this->protected_class_value = $value3;
+    }
+}
+// class declaration for string objects
+class for_string_rsort
+{
+    public $public_class_value;
+    private $private_class_value;
+    protected $protected_class_value;
+    // initializing object member value
+    function __construct($value1, $value2, $value3)
+    {
+        $this->public_class_value = $value1;
+        $this->private_class_value = $value2;
+        $this->protected_class_value = $value3;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * Test functionality of rsort() with objects where properties have different visibilities
+     */
+    echo "*** Testing rsort() : object functionality ***\n";
+    // array of integer objects
+    $unsorted_int_obj = array(new for_integer_rsort(11, 33, 30), new for_integer_rsort(66, 44, 4), new for_integer_rsort(-88, -5, 5), new for_integer_rsort(0.001, 99.5, 0.1));
+    // array of string objects
+    $unsorted_str_obj = array(new for_string_rsort("axx", "AXX", "ass"), new for_string_rsort("t", "eee", "abb"), new for_string_rsort("w", "W", "c"), new for_string_rsort("py", "PY", "pt"));
+    echo "\n-- Sort flag = default --\n";
+    // testing rsort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(rsort($temp_array));
+    var_dump($temp_array);
+    // testing rsort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(rsort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Sort flag = SORT_REGULAR --\n";
+    // testing rsort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(rsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing rsort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(rsort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing rsort() : object functionality ***
+
+-- Sort flag = default --
+bool(true)
+array(4) {
+  [0]=>
+  object(for_integer_rsort)#%d (3) {
+    ["public_class_value"]=>
+    int(66)
+    ["private_class_value":"for_integer_rsort":private]=>
+    int(44)
+    ["protected_class_value":protected]=>
+    int(4)
+  }
+  [1]=>
+  object(for_integer_rsort)#%d (3) {
+    ["public_class_value"]=>
+    int(11)
+    ["private_class_value":"for_integer_rsort":private]=>
+    int(33)
+    ["protected_class_value":protected]=>
+    int(30)
+  }
+  [2]=>
+  object(for_integer_rsort)#%d (3) {
+    ["public_class_value"]=>
+    float(0.001)
+    ["private_class_value":"for_integer_rsort":private]=>
+    float(99.5)
+    ["protected_class_value":protected]=>
+    float(0.1)
+  }
+  [3]=>
+  object(for_integer_rsort)#%d (3) {
+    ["public_class_value"]=>
+    int(-88)
+    ["private_class_value":"for_integer_rsort":private]=>
+    int(-5)
+    ["protected_class_value":protected]=>
+    int(5)
+  }
+}
+bool(true)
+array(4) {
+  [0]=>
+  object(for_string_rsort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "w"
+    ["private_class_value":"for_string_rsort":private]=>
+    string(1) "W"
+    ["protected_class_value":protected]=>
+    string(1) "c"
+  }
+  [1]=>
+  object(for_string_rsort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "t"
+    ["private_class_value":"for_string_rsort":private]=>
+    string(3) "eee"
+    ["protected_class_value":protected]=>
+    string(3) "abb"
+  }
+  [2]=>
+  object(for_string_rsort)#%d (3) {
+    ["public_class_value"]=>
+    string(2) "py"
+    ["private_class_value":"for_string_rsort":private]=>
+    string(2) "PY"
+    ["protected_class_value":protected]=>
+    string(2) "pt"
+  }
+  [3]=>
+  object(for_string_rsort)#%d (3) {
+    ["public_class_value"]=>
+    string(3) "axx"
+    ["private_class_value":"for_string_rsort":private]=>
+    string(3) "AXX"
+    ["protected_class_value":protected]=>
+    string(3) "ass"
+  }
+}
+
+-- Sort flag = SORT_REGULAR --
+bool(true)
+array(4) {
+  [0]=>
+  object(for_integer_rsort)#%d (3) {
+    ["public_class_value"]=>
+    int(66)
+    ["private_class_value":"for_integer_rsort":private]=>
+    int(44)
+    ["protected_class_value":protected]=>
+    int(4)
+  }
+  [1]=>
+  object(for_integer_rsort)#%d (3) {
+    ["public_class_value"]=>
+    int(11)
+    ["private_class_value":"for_integer_rsort":private]=>
+    int(33)
+    ["protected_class_value":protected]=>
+    int(30)
+  }
+  [2]=>
+  object(for_integer_rsort)#%d (3) {
+    ["public_class_value"]=>
+    float(0.001)
+    ["private_class_value":"for_integer_rsort":private]=>
+    float(99.5)
+    ["protected_class_value":protected]=>
+    float(0.1)
+  }
+  [3]=>
+  object(for_integer_rsort)#%d (3) {
+    ["public_class_value"]=>
+    int(-88)
+    ["private_class_value":"for_integer_rsort":private]=>
+    int(-5)
+    ["protected_class_value":protected]=>
+    int(5)
+  }
+}
+bool(true)
+array(4) {
+  [0]=>
+  object(for_string_rsort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "w"
+    ["private_class_value":"for_string_rsort":private]=>
+    string(1) "W"
+    ["protected_class_value":protected]=>
+    string(1) "c"
+  }
+  [1]=>
+  object(for_string_rsort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "t"
+    ["private_class_value":"for_string_rsort":private]=>
+    string(3) "eee"
+    ["protected_class_value":protected]=>
+    string(3) "abb"
+  }
+  [2]=>
+  object(for_string_rsort)#%d (3) {
+    ["public_class_value"]=>
+    string(2) "py"
+    ["private_class_value":"for_string_rsort":private]=>
+    string(2) "PY"
+    ["protected_class_value":protected]=>
+    string(2) "pt"
+  }
+  [3]=>
+  object(for_string_rsort)#%d (3) {
+    ["public_class_value"]=>
+    string(3) "axx"
+    ["private_class_value":"for_string_rsort":private]=>
+    string(3) "AXX"
+    ["protected_class_value":protected]=>
+    string(3) "ass"
+  }
+}
+Done
diff --git a/tests/std/array/rsort_variation10.phpt b/tests/std/array/rsort_variation10.phpt
new file mode 100644
index 00000000..6f9248c1
--- /dev/null
+++ b/tests/std/array/rsort_variation10.phpt
@@ -0,0 +1,102 @@
+--TEST--
+Test rsort() function : usage variations - Octal values
+--FILE--
+<?php
+/*
+ * Pass rsort() an array containing octal values to test behaviour
+ */
+
+echo "*** Testing rsort() : variation ***\n";
+
+// an array containing unsorted octal values
+$unsorted_oct_array = array(01235, 0321, 0345, 066, 0772, 077, -066, -0345, 0);
+
+echo "\n-- Sort flag = default  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump(rsort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Sort flag = SORT_REGULAR  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump(rsort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "\n-- Sort flag = SORT_NUMERIC  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump(rsort($temp_array, SORT_NUMERIC) );
+var_dump($temp_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing rsort() : variation ***
+
+-- Sort flag = default  --
+bool(true)
+array(9) {
+  [0]=>
+  int(669)
+  [1]=>
+  int(506)
+  [2]=>
+  int(229)
+  [3]=>
+  int(209)
+  [4]=>
+  int(63)
+  [5]=>
+  int(54)
+  [6]=>
+  int(0)
+  [7]=>
+  int(-54)
+  [8]=>
+  int(-229)
+}
+
+-- Sort flag = SORT_REGULAR  --
+bool(true)
+array(9) {
+  [0]=>
+  int(669)
+  [1]=>
+  int(506)
+  [2]=>
+  int(229)
+  [3]=>
+  int(209)
+  [4]=>
+  int(63)
+  [5]=>
+  int(54)
+  [6]=>
+  int(0)
+  [7]=>
+  int(-54)
+  [8]=>
+  int(-229)
+}
+
+-- Sort flag = SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [0]=>
+  int(669)
+  [1]=>
+  int(506)
+  [2]=>
+  int(229)
+  [3]=>
+  int(209)
+  [4]=>
+  int(63)
+  [5]=>
+  int(54)
+  [6]=>
+  int(0)
+  [7]=>
+  int(-54)
+  [8]=>
+  int(-229)
+}
+Done
diff --git a/tests/std/array/rsort_variation11.phpt b/tests/std/array/rsort_variation11.phpt
new file mode 100644
index 00000000..fe91f79e
--- /dev/null
+++ b/tests/std/array/rsort_variation11.phpt
@@ -0,0 +1,187 @@
+--TEST--
+Test rsort() function : usage variations - mixed array
+--FILE--
+<?php
+/*
+ * Pass rsort() an array of different data types to test behaviour
+ */
+
+echo "*** Testing rsort() : variation ***\n";
+
+// mixed value array
+$mixed_values = array (
+  array(),
+  array( array(33, -5, 6),
+         array(11),
+         array(22, -55),
+         array()
+        ),
+  -4, "4", 4.00, "b", "5", -2, -2.0, -2.98989, "-.9", "True", "",
+  NULL, "ab", "abcd", 0.0, -0, "abcd\x00abcd\x00abcd", '', true, false
+);
+
+echo "\n-- Sort flag = default --\n";
+$temp_array = $mixed_values;
+var_dump(rsort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Sort flag = SORT_REGULAR --\n";
+$temp_array = $mixed_values;
+var_dump(rsort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing rsort() : variation ***
+
+-- Sort flag = default --
+bool(true)
+array(22) {
+  [0]=>
+  array(4) {
+    [0]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    [1]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    [2]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    [3]=>
+    array(0) {
+    }
+  }
+  [1]=>
+  array(0) {
+  }
+  [2]=>
+  string(1) "b"
+  [3]=>
+  string(14) "abcd%0abcd%0abcd"
+  [4]=>
+  string(4) "abcd"
+  [5]=>
+  string(2) "ab"
+  [6]=>
+  string(4) "True"
+  [7]=>
+  string(1) "5"
+  [8]=>
+  string(1) "4"
+  [9]=>
+  float(4)
+  [10]=>
+  string(3) "-.9"
+  [11]=>
+  int(-2)
+  [12]=>
+  float(-2)
+  [13]=>
+  float(-2.98989)
+  [14]=>
+  bool(true)
+  [15]=>
+  string(0) ""
+  [16]=>
+  NULL
+  [17]=>
+  float(0)
+  [18]=>
+  int(0)
+  [19]=>
+  int(-4)
+  [20]=>
+  string(0) ""
+  [21]=>
+  bool(false)
+}
+
+-- Sort flag = SORT_REGULAR --
+bool(true)
+array(22) {
+  [0]=>
+  array(4) {
+    [0]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    [1]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    [2]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    [3]=>
+    array(0) {
+    }
+  }
+  [1]=>
+  array(0) {
+  }
+  [2]=>
+  string(1) "b"
+  [3]=>
+  string(14) "abcd%0abcd%0abcd"
+  [4]=>
+  string(4) "abcd"
+  [5]=>
+  string(2) "ab"
+  [6]=>
+  string(4) "True"
+  [7]=>
+  string(1) "5"
+  [8]=>
+  string(1) "4"
+  [9]=>
+  float(4)
+  [10]=>
+  string(3) "-.9"
+  [11]=>
+  int(-2)
+  [12]=>
+  float(-2)
+  [13]=>
+  float(-2.98989)
+  [14]=>
+  bool(true)
+  [15]=>
+  string(0) ""
+  [16]=>
+  NULL
+  [17]=>
+  float(0)
+  [18]=>
+  int(0)
+  [19]=>
+  int(-4)
+  [20]=>
+  string(0) ""
+  [21]=>
+  bool(false)
+}
+Done
diff --git a/tests/std/array/rsort_variation3.phpt b/tests/std/array/rsort_variation3.phpt
new file mode 100644
index 00000000..f2648f04
--- /dev/null
+++ b/tests/std/array/rsort_variation3.phpt
@@ -0,0 +1,319 @@
+--TEST--
+Test rsort() function : usage variations - numeric values
+--SKIPIF--
+<?php
+if (PHP_INT_SIZE != 4) die("skip this test is for 32bit platform only");
+?>
+--FILE--
+<?php
+/*
+ * Pass arrays containing different numeric data to rsort() to test behaviour
+ */
+
+echo "*** Testing rsort() : variation ***\n";
+
+// group of various arrays
+
+$various_arrays = array (
+// negative/positive integers array
+array(11, -11, 21, -21, 31, -31, 0, 41, -41),
+
+// float value array
+array(10.5, -10.5, 10.5e2, 10.6E-2, .5, .01, -.1),
+
+// mixed value array
+array(.0001, .0021, -.01, -1, 0, .09, 2, -.9, 10.6E-2, -10.6E-2, 33),
+
+// array values contains minimum and maximum ranges
+array(2147483647, 2147483648, -2147483647, -2147483648, -0, 0, -2147483649)
+);
+
+// set of possible flag values
+$flag_value = array("SORT_REGULAR" => SORT_REGULAR, "SORT_NUMERIC" => SORT_NUMERIC);
+
+$count = 1;
+
+// loop through to test rsort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With Default sort flag -\n";
+  $temp_array = $array;
+  var_dump(rsort($temp_array) );
+  var_dump($temp_array);
+
+  // loop through $flag_value array and setting all possible flag values
+  foreach($flag_value as $key => $flag){
+    echo "- Sort flag = $key -\n";
+    $temp_array = $array;
+    var_dump(rsort($temp_array, $flag) );
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing rsort() : variation ***
+
+-- Iteration 1 --
+- With Default sort flag -
+bool(true)
+array(9) {
+  [0]=>
+  int(41)
+  [1]=>
+  int(31)
+  [2]=>
+  int(21)
+  [3]=>
+  int(11)
+  [4]=>
+  int(0)
+  [5]=>
+  int(-11)
+  [6]=>
+  int(-21)
+  [7]=>
+  int(-31)
+  [8]=>
+  int(-41)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(9) {
+  [0]=>
+  int(41)
+  [1]=>
+  int(31)
+  [2]=>
+  int(21)
+  [3]=>
+  int(11)
+  [4]=>
+  int(0)
+  [5]=>
+  int(-11)
+  [6]=>
+  int(-21)
+  [7]=>
+  int(-31)
+  [8]=>
+  int(-41)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(9) {
+  [0]=>
+  int(41)
+  [1]=>
+  int(31)
+  [2]=>
+  int(21)
+  [3]=>
+  int(11)
+  [4]=>
+  int(0)
+  [5]=>
+  int(-11)
+  [6]=>
+  int(-21)
+  [7]=>
+  int(-31)
+  [8]=>
+  int(-41)
+}
+
+-- Iteration 2 --
+- With Default sort flag -
+bool(true)
+array(7) {
+  [0]=>
+  float(1050)
+  [1]=>
+  float(10.5)
+  [2]=>
+  float(0.5)
+  [3]=>
+  float(0.106)
+  [4]=>
+  float(0.01)
+  [5]=>
+  float(-0.1)
+  [6]=>
+  float(-10.5)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(7) {
+  [0]=>
+  float(1050)
+  [1]=>
+  float(10.5)
+  [2]=>
+  float(0.5)
+  [3]=>
+  float(0.106)
+  [4]=>
+  float(0.01)
+  [5]=>
+  float(-0.1)
+  [6]=>
+  float(-10.5)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(7) {
+  [0]=>
+  float(1050)
+  [1]=>
+  float(10.5)
+  [2]=>
+  float(0.5)
+  [3]=>
+  float(0.106)
+  [4]=>
+  float(0.01)
+  [5]=>
+  float(-0.1)
+  [6]=>
+  float(-10.5)
+}
+
+-- Iteration 3 --
+- With Default sort flag -
+bool(true)
+array(11) {
+  [0]=>
+  int(33)
+  [1]=>
+  int(2)
+  [2]=>
+  float(0.106)
+  [3]=>
+  float(0.09)
+  [4]=>
+  float(0.0021)
+  [5]=>
+  float(0.0001)
+  [6]=>
+  int(0)
+  [7]=>
+  float(-0.01)
+  [8]=>
+  float(-0.106)
+  [9]=>
+  float(-0.9)
+  [10]=>
+  int(-1)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  [0]=>
+  int(33)
+  [1]=>
+  int(2)
+  [2]=>
+  float(0.106)
+  [3]=>
+  float(0.09)
+  [4]=>
+  float(0.0021)
+  [5]=>
+  float(0.0001)
+  [6]=>
+  int(0)
+  [7]=>
+  float(-0.01)
+  [8]=>
+  float(-0.106)
+  [9]=>
+  float(-0.9)
+  [10]=>
+  int(-1)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(11) {
+  [0]=>
+  int(33)
+  [1]=>
+  int(2)
+  [2]=>
+  float(0.106)
+  [3]=>
+  float(0.09)
+  [4]=>
+  float(0.0021)
+  [5]=>
+  float(0.0001)
+  [6]=>
+  int(0)
+  [7]=>
+  float(-0.01)
+  [8]=>
+  float(-0.106)
+  [9]=>
+  float(-0.9)
+  [10]=>
+  int(-1)
+}
+
+-- Iteration 4 --
+- With Default sort flag -
+bool(true)
+array(7) {
+  [0]=>
+  float(2147483648)
+  [1]=>
+  int(2147483647)
+  [2]=>
+  int(0)
+  [3]=>
+  int(0)
+  [4]=>
+  int(-2147483647)
+  [5]=>
+  float(-2147483648)
+  [6]=>
+  float(-2147483649)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(7) {
+  [0]=>
+  float(2147483648)
+  [1]=>
+  int(2147483647)
+  [2]=>
+  int(0)
+  [3]=>
+  int(0)
+  [4]=>
+  int(-2147483647)
+  [5]=>
+  float(-2147483648)
+  [6]=>
+  float(-2147483649)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(7) {
+  [0]=>
+  float(2147483648)
+  [1]=>
+  int(2147483647)
+  [2]=>
+  int(0)
+  [3]=>
+  int(0)
+  [4]=>
+  int(-2147483647)
+  [5]=>
+  float(-2147483648)
+  [6]=>
+  float(-2147483649)
+}
+Done
diff --git a/tests/std/array/rsort_variation4.phpt b/tests/std/array/rsort_variation4.phpt
new file mode 100644
index 00000000..baea5484
--- /dev/null
+++ b/tests/std/array/rsort_variation4.phpt
@@ -0,0 +1,62 @@
+--TEST--
+Test rsort() function : usage variations - referenced variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference assignment in this context");
+?>
+
+--FILE--
+<?php
+/*
+ * Test behaviour of rsort() when:
+ * 1. passed an array of referenced variables
+ * 2. $array_arg is a reference to another array
+ * 3. $array_arg is passed by reference
+ */
+
+echo "*** Testing rsort() : variation ***\n";
+
+$value1 = 100;
+$value2 = 33;
+$value3 = 555;
+
+// an array containing integer references
+$unsorted_numerics =  array( &$value1 , &$value2, &$value3);
+
+echo "\n-- 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( rsort($temp_array) );
+var_dump( $temp_array);
+
+echo "\n-- 'flag' = SORT_REGULAR --\n";
+$temp_array = &$unsorted_numerics;
+var_dump( rsort($temp_array, SORT_REGULAR) );
+var_dump( $temp_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing rsort() : variation ***
+
+-- 'flag' value is default --
+bool(true)
+array(3) {
+  [0]=>
+  &int(555)
+  [1]=>
+  &int(100)
+  [2]=>
+  &int(33)
+}
+
+-- 'flag' = SORT_REGULAR --
+bool(true)
+array(3) {
+  [0]=>
+  &int(555)
+  [1]=>
+  &int(100)
+  [2]=>
+  &int(33)
+}
+Done
diff --git a/tests/std/array/rsort_variation5.phpt b/tests/std/array/rsort_variation5.phpt
new file mode 100644
index 00000000..6b05443b
--- /dev/null
+++ b/tests/std/array/rsort_variation5.phpt
@@ -0,0 +1,215 @@
+--TEST--
+Test rsort() function : usage variations - String values
+--FILE--
+<?php
+/*
+ * Pass arrays containing different string data to rsort() to test behaviour
+ */
+
+echo "*** Testing rsort() : variation ***\n";
+
+$various_arrays = array (
+// group of escape sequences
+array(null, NULL, "\a", "\cx", "\e", "\f", "\n", "\t", "\xhh", "\ddd", "\v"),
+
+// array contains combination of capital/small letters
+array("lemoN", "Orange", "banana", "apple", "Test", "TTTT", "ttt", "ww", "x", "X", "oraNGe", "BANANA")
+);
+
+$flags = array("SORT_REGULAR" => SORT_REGULAR, "SORT_STRING" => SORT_STRING);
+
+$count = 1;
+// loop through to test rsort() with different arrays
+foreach ($various_arrays as $array) {
+    echo "\n-- Iteration $count --\n";
+
+    echo "- With Default sort flag -\n";
+    $temp_array = $array;
+    var_dump(rsort($temp_array) );
+    var_dump($temp_array);
+
+    // loop through $flags array and setting all possible flag values
+    foreach($flags as $key => $flag){
+        echo "- Sort flag = $key -\n";
+
+        $temp_array = $array;
+        var_dump(rsort($temp_array, $flag) );
+        var_dump($temp_array);
+    }
+    $count++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing rsort() : variation ***
+
+-- Iteration 1 --
+- With Default sort flag -
+bool(true)
+array(11) {
+  [0]=>
+  string(4) "\xhh"
+  [1]=>
+  string(4) "\ddd"
+  [2]=>
+  string(3) "\cx"
+  [3]=>
+  string(2) "\a"
+  [4]=>
+  string(1) ""
+  [5]=>
+  string(1) ""
+  [6]=>
+  string(1) ""
+  [7]=>
+  string(1) "
+"
+  [8]=>
+  string(1) "	"
+  [9]=>
+  NULL
+  [10]=>
+  NULL
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  [0]=>
+  string(4) "\xhh"
+  [1]=>
+  string(4) "\ddd"
+  [2]=>
+  string(3) "\cx"
+  [3]=>
+  string(2) "\a"
+  [4]=>
+  string(1) ""
+  [5]=>
+  string(1) ""
+  [6]=>
+  string(1) ""
+  [7]=>
+  string(1) "
+"
+  [8]=>
+  string(1) "	"
+  [9]=>
+  NULL
+  [10]=>
+  NULL
+}
+- Sort flag = SORT_STRING -
+bool(true)
+array(11) {
+  [0]=>
+  string(4) "\xhh"
+  [1]=>
+  string(4) "\ddd"
+  [2]=>
+  string(3) "\cx"
+  [3]=>
+  string(2) "\a"
+  [4]=>
+  string(1) ""
+  [5]=>
+  string(1) ""
+  [6]=>
+  string(1) ""
+  [7]=>
+  string(1) "
+"
+  [8]=>
+  string(1) "	"
+  [9]=>
+  NULL
+  [10]=>
+  NULL
+}
+
+-- Iteration 2 --
+- With Default sort flag -
+bool(true)
+array(12) {
+  [0]=>
+  string(1) "x"
+  [1]=>
+  string(2) "ww"
+  [2]=>
+  string(3) "ttt"
+  [3]=>
+  string(6) "oraNGe"
+  [4]=>
+  string(5) "lemoN"
+  [5]=>
+  string(6) "banana"
+  [6]=>
+  string(5) "apple"
+  [7]=>
+  string(1) "X"
+  [8]=>
+  string(4) "Test"
+  [9]=>
+  string(4) "TTTT"
+  [10]=>
+  string(6) "Orange"
+  [11]=>
+  string(6) "BANANA"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(12) {
+  [0]=>
+  string(1) "x"
+  [1]=>
+  string(2) "ww"
+  [2]=>
+  string(3) "ttt"
+  [3]=>
+  string(6) "oraNGe"
+  [4]=>
+  string(5) "lemoN"
+  [5]=>
+  string(6) "banana"
+  [6]=>
+  string(5) "apple"
+  [7]=>
+  string(1) "X"
+  [8]=>
+  string(4) "Test"
+  [9]=>
+  string(4) "TTTT"
+  [10]=>
+  string(6) "Orange"
+  [11]=>
+  string(6) "BANANA"
+}
+- Sort flag = SORT_STRING -
+bool(true)
+array(12) {
+  [0]=>
+  string(1) "x"
+  [1]=>
+  string(2) "ww"
+  [2]=>
+  string(3) "ttt"
+  [3]=>
+  string(6) "oraNGe"
+  [4]=>
+  string(5) "lemoN"
+  [5]=>
+  string(6) "banana"
+  [6]=>
+  string(5) "apple"
+  [7]=>
+  string(1) "X"
+  [8]=>
+  string(4) "Test"
+  [9]=>
+  string(4) "TTTT"
+  [10]=>
+  string(6) "Orange"
+  [11]=>
+  string(6) "BANANA"
+}
+Done
diff --git a/tests/std/array/rsort_variation6.phpt b/tests/std/array/rsort_variation6.phpt
new file mode 100644
index 00000000..3394402e
--- /dev/null
+++ b/tests/std/array/rsort_variation6.phpt
@@ -0,0 +1,114 @@
+--TEST--
+Test rsort() function : usage variations - Hexadecimal vales
+--FILE--
+<?php
+/*
+ * Pass rsort() an array of hexadecimal values to test behaviour
+ */
+
+echo "*** Testing rsort() : variation ***\n";
+
+// an array contains unsorted hexadecimal values
+$unsorted_hex_array = array(0x1AB, 0xFFF, 0xF, 0xFF, 0x2AA, 0xBB, 0x1ab, 0xff, -0xFF, 0, -0x2aa);
+
+echo "\n-- 'flag' value is default  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(rsort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(rsort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "\n-- 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(rsort($temp_array, SORT_NUMERIC) );
+var_dump($temp_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing rsort() : variation ***
+
+-- 'flag' value is default  --
+bool(true)
+array(11) {
+  [0]=>
+  int(4095)
+  [1]=>
+  int(682)
+  [2]=>
+  int(427)
+  [3]=>
+  int(427)
+  [4]=>
+  int(255)
+  [5]=>
+  int(255)
+  [6]=>
+  int(187)
+  [7]=>
+  int(15)
+  [8]=>
+  int(0)
+  [9]=>
+  int(-255)
+  [10]=>
+  int(-682)
+}
+
+-- 'flag' value is SORT_REGULAR  --
+bool(true)
+array(11) {
+  [0]=>
+  int(4095)
+  [1]=>
+  int(682)
+  [2]=>
+  int(427)
+  [3]=>
+  int(427)
+  [4]=>
+  int(255)
+  [5]=>
+  int(255)
+  [6]=>
+  int(187)
+  [7]=>
+  int(15)
+  [8]=>
+  int(0)
+  [9]=>
+  int(-255)
+  [10]=>
+  int(-682)
+}
+
+-- 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(11) {
+  [0]=>
+  int(4095)
+  [1]=>
+  int(682)
+  [2]=>
+  int(427)
+  [3]=>
+  int(427)
+  [4]=>
+  int(255)
+  [5]=>
+  int(255)
+  [6]=>
+  int(187)
+  [7]=>
+  int(15)
+  [8]=>
+  int(0)
+  [9]=>
+  int(-255)
+  [10]=>
+  int(-682)
+}
+Done
diff --git a/tests/std/array/rsort_variation7.phpt b/tests/std/array/rsort_variation7.phpt
new file mode 100644
index 00000000..28b02a74
--- /dev/null
+++ b/tests/std/array/rsort_variation7.phpt
@@ -0,0 +1,90 @@
+--TEST--
+Test rsort() function : usage variations - boolean values
+--FILE--
+<?php
+/*
+ * Pass rsort() arrays of boolean values to test behaviour
+ */
+
+echo "*** Testing rsort() : variation ***\n";
+
+// bool value array
+$bool_values = array (true, false, TRUE, FALSE);
+
+echo "\n-- 'flag' value is default --\n";
+$temp_array = $bool_values;
+var_dump(rsort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- 'flag' value is SORT_REGULAR --\n";
+$temp_array = $bool_values;
+var_dump(rsort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "\n-- 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $bool_values;
+var_dump(rsort($temp_array, SORT_NUMERIC) );
+var_dump($temp_array);
+
+echo "\n-- 'flag' value is SORT_STRING --\n";
+$temp_array = $bool_values;
+var_dump(rsort($temp_array, SORT_STRING) );
+var_dump($temp_array);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing rsort() : variation ***
+
+-- 'flag' value is default --
+bool(true)
+array(4) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [3]=>
+  bool(false)
+}
+
+-- 'flag' value is SORT_REGULAR --
+bool(true)
+array(4) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [3]=>
+  bool(false)
+}
+
+-- 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(4) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [3]=>
+  bool(false)
+}
+
+-- 'flag' value is SORT_STRING --
+bool(true)
+array(4) {
+  [0]=>
+  bool(true)
+  [1]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [3]=>
+  bool(false)
+}
+Done
diff --git a/tests/std/array/rsort_variation8.phpt b/tests/std/array/rsort_variation8.phpt
new file mode 100644
index 00000000..8d8aa15f
--- /dev/null
+++ b/tests/std/array/rsort_variation8.phpt
@@ -0,0 +1,174 @@
+--TEST--
+Test rsort() function : usage variations - multi-dimensional arrays
+--FILE--
+<?php
+/*
+ * Pass rsort() multi-dimensional arrays to test behaviour
+ */
+
+echo "*** Testing rsort() : variation ***\n";
+
+// array of arrays
+$various_arrays = array (
+  // null array
+  array(),
+
+  // array contains null sub array
+  array( array() ),
+
+  // array of arrays along with some values
+  array(44, 11, array(64, 61) ),
+
+  // array containing sub arrays
+  array(array(33, -5, 6), array(11), array(22, -55), array() )
+);
+
+
+$count = 1;
+
+// loop through to test rsort() with different arrays
+foreach ($various_arrays as $array) {
+
+  echo "\n-- Iteration $count --\n";
+
+  echo "\n-- 'flag' value is default --\n";
+  $temp_array = $array;
+  var_dump(rsort($temp_array) );
+  var_dump($temp_array);
+
+  echo "\n-- 'flag' value is SORT_REGULAR --\n";
+  $temp_array = $array;
+  var_dump(rsort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing rsort() : variation ***
+
+-- Iteration 1 --
+
+-- 'flag' value is default --
+bool(true)
+array(0) {
+}
+
+-- 'flag' value is SORT_REGULAR --
+bool(true)
+array(0) {
+}
+
+-- Iteration 2 --
+
+-- 'flag' value is default --
+bool(true)
+array(1) {
+  [0]=>
+  array(0) {
+  }
+}
+
+-- 'flag' value is SORT_REGULAR --
+bool(true)
+array(1) {
+  [0]=>
+  array(0) {
+  }
+}
+
+-- Iteration 3 --
+
+-- 'flag' value is default --
+bool(true)
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+  [1]=>
+  int(44)
+  [2]=>
+  int(11)
+}
+
+-- 'flag' value is SORT_REGULAR --
+bool(true)
+array(3) {
+  [0]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+  [1]=>
+  int(44)
+  [2]=>
+  int(11)
+}
+
+-- Iteration 4 --
+
+-- 'flag' value is default --
+bool(true)
+array(4) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  [3]=>
+  array(0) {
+  }
+}
+
+-- 'flag' value is SORT_REGULAR --
+bool(true)
+array(4) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  [3]=>
+  array(0) {
+  }
+}
+Done
diff --git a/tests/std/array/rsort_variation9.phpt b/tests/std/array/rsort_variation9.phpt
new file mode 100644
index 00000000..f46c2270
--- /dev/null
+++ b/tests/std/array/rsort_variation9.phpt
@@ -0,0 +1,254 @@
+--TEST--
+Test rsort() function : usage variations - mixed associative arrays
+--FILE--
+<?php
+/*
+ * Pass rsort() associative arrays to test key re-assignment
+ */
+
+echo "*** Testing rsort() : variation ***\n";
+
+// Associative arrays
+$various_arrays = array(
+    // numeric assoc. only array
+    array(5 => 55, 6 => 66, 2 => 22, 3 => 33, 1 => 11),
+
+    // two-dimensional assoc. and default key array
+    array("fruits"  => array("a" => "orange", "b" => "banana", "c" => "apple"),
+          "numbers" => array(1, 2, 3, 4, 5, 6),
+          "holes"   => array("first", 5 => "second", "third")),
+
+    // numeric assoc. and default key array
+    array(1, 1, 8 => 1,  4 => 1, 19, 3 => 13),
+
+    // mixed assoc. array
+    array('bar' => 'baz', "foo" => 1),
+
+    // assoc. only multi-dimensional array
+    array('a' => 1,'b' => array('e' => 2,'f' => 3),'c' => array('g' => 4),'d' => 5),
+);
+
+$count = 1;
+
+// loop through to test rsort() with different arrays,
+// to test the new keys for the elements in the sorted array
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "-- Sort flag = default --\n";
+  $temp_array = $array;
+  var_dump(rsort($temp_array) );
+  var_dump($temp_array);
+
+  echo "-- Sort flag = SORT_REGULAR --\n";
+  $temp_array = $array;
+  var_dump(rsort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing rsort() : variation ***
+
+-- Iteration 1 --
+-- Sort flag = default --
+bool(true)
+array(5) {
+  [0]=>
+  int(66)
+  [1]=>
+  int(55)
+  [2]=>
+  int(33)
+  [3]=>
+  int(22)
+  [4]=>
+  int(11)
+}
+-- Sort flag = SORT_REGULAR --
+bool(true)
+array(5) {
+  [0]=>
+  int(66)
+  [1]=>
+  int(55)
+  [2]=>
+  int(33)
+  [3]=>
+  int(22)
+  [4]=>
+  int(11)
+}
+
+-- Iteration 2 --
+-- Sort flag = default --
+bool(true)
+array(3) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+  [1]=>
+  array(3) {
+    ["a"]=>
+    string(6) "orange"
+    ["b"]=>
+    string(6) "banana"
+    ["c"]=>
+    string(5) "apple"
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    string(5) "first"
+    [5]=>
+    string(6) "second"
+    [6]=>
+    string(5) "third"
+  }
+}
+-- Sort flag = SORT_REGULAR --
+bool(true)
+array(3) {
+  [0]=>
+  array(6) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+  [1]=>
+  array(3) {
+    ["a"]=>
+    string(6) "orange"
+    ["b"]=>
+    string(6) "banana"
+    ["c"]=>
+    string(5) "apple"
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    string(5) "first"
+    [5]=>
+    string(6) "second"
+    [6]=>
+    string(5) "third"
+  }
+}
+
+-- Iteration 3 --
+-- Sort flag = default --
+bool(true)
+array(6) {
+  [0]=>
+  int(19)
+  [1]=>
+  int(13)
+  [2]=>
+  int(1)
+  [3]=>
+  int(1)
+  [4]=>
+  int(1)
+  [5]=>
+  int(1)
+}
+-- Sort flag = SORT_REGULAR --
+bool(true)
+array(6) {
+  [0]=>
+  int(19)
+  [1]=>
+  int(13)
+  [2]=>
+  int(1)
+  [3]=>
+  int(1)
+  [4]=>
+  int(1)
+  [5]=>
+  int(1)
+}
+
+-- Iteration 4 --
+-- Sort flag = default --
+bool(true)
+array(2) {
+  [0]=>
+  string(3) "baz"
+  [1]=>
+  int(1)
+}
+-- Sort flag = SORT_REGULAR --
+bool(true)
+array(2) {
+  [0]=>
+  string(3) "baz"
+  [1]=>
+  int(1)
+}
+
+-- Iteration 5 --
+-- Sort flag = default --
+bool(true)
+array(4) {
+  [0]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+  [1]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  [2]=>
+  int(5)
+  [3]=>
+  int(1)
+}
+-- Sort flag = SORT_REGULAR --
+bool(true)
+array(4) {
+  [0]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+  [1]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  [2]=>
+  int(5)
+  [3]=>
+  int(1)
+}
+Done
diff --git a/tests/std/array/shuffle_basic1.phpt b/tests/std/array/shuffle_basic1.phpt
new file mode 100644
index 00000000..d2af45db
--- /dev/null
+++ b/tests/std/array/shuffle_basic1.phpt
@@ -0,0 +1,144 @@
+--TEST--
+Test shuffle() function : basic functionality - array with default keys
+--FILE--
+<?php
+/*
+* Test behaviour of shuffle when an array with default keys
+* is passed to the 'array_arg' argument and check for the
+* changes in the input array by printing the input array
+* before and after shuffle() function is applied on it
+*/
+
+echo "*** Testing shuffle() : with arrays having default keys ***\n";
+
+// Initialise the array with integers
+$array_arg_int = array(0, 10, 20, 30, 40, 50, 60, 70, 80);
+
+// Initialise the array with strings
+$array_arg_strings = array("one", 'two', 'three', "four", "five", " ", 'six', ' ', "seven");
+
+/* Testing shuffle() function with array of integers */
+
+// printing the input array with integers before the shuffle operation
+echo "\n-- input array of integers before shuffle() function is applied --\n";
+var_dump( $array_arg_int );
+
+// applying shuffle() function on the input array of integers
+echo "\n-- return value from shuffle() function --\n";
+var_dump( shuffle($array_arg_int) );  // prints the return value from shuffle() function
+
+echo "\n-- resultant array after shuffle() function is applied --\n";
+var_dump( $array_arg_int );
+
+/* Testing shuffle() function with array of strings */
+
+// printing the input array with strings before the shuffle operation
+echo "\n-- input array of strings before shuffle() function is applied --\n";
+var_dump( $array_arg_strings );
+
+// applying shuffle() function on the input array of strings
+echo "\n-- return value from shuffle() function --\n";
+var_dump( shuffle($array_arg_strings) );  // prints the return value from shuffle() function
+
+echo "\n-- resultant array after shuffle() function is applied --\n";
+var_dump( $array_arg_strings );
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing shuffle() : with arrays having default keys ***
+
+-- input array of integers before shuffle() function is applied --
+array(9) {
+  [0]=>
+  int(0)
+  [1]=>
+  int(10)
+  [2]=>
+  int(20)
+  [3]=>
+  int(30)
+  [4]=>
+  int(40)
+  [5]=>
+  int(50)
+  [6]=>
+  int(60)
+  [7]=>
+  int(70)
+  [8]=>
+  int(80)
+}
+
+-- return value from shuffle() function --
+bool(true)
+
+-- resultant array after shuffle() function is applied --
+array(9) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+  [3]=>
+  int(%d)
+  [4]=>
+  int(%d)
+  [5]=>
+  int(%d)
+  [6]=>
+  int(%d)
+  [7]=>
+  int(%d)
+  [8]=>
+  int(%d)
+}
+
+-- input array of strings before shuffle() function is applied --
+array(9) {
+  [0]=>
+  string(3) "one"
+  [1]=>
+  string(3) "two"
+  [2]=>
+  string(5) "three"
+  [3]=>
+  string(4) "four"
+  [4]=>
+  string(4) "five"
+  [5]=>
+  string(1) " "
+  [6]=>
+  string(3) "six"
+  [7]=>
+  string(1) " "
+  [8]=>
+  string(5) "seven"
+}
+
+-- return value from shuffle() function --
+bool(true)
+
+-- resultant array after shuffle() function is applied --
+array(9) {
+  [0]=>
+  string(%d) "%s"
+  [1]=>
+  string(%d) "%s"
+  [2]=>
+  string(%d) "%s"
+  [3]=>
+  string(%d) "%s"
+  [4]=>
+  string(%d) "%s"
+  [5]=>
+  string(%d) "%s"
+  [6]=>
+  string(%d) "%s"
+  [7]=>
+  string(%d) "%s"
+  [8]=>
+  string(%d) "%s"
+}
+Done
diff --git a/tests/std/array/shuffle_basic2.phpt b/tests/std/array/shuffle_basic2.phpt
new file mode 100644
index 00000000..b6c86cb4
--- /dev/null
+++ b/tests/std/array/shuffle_basic2.phpt
@@ -0,0 +1,83 @@
+--TEST--
+Test shuffle() function : basic functionality -  with associative array
+--FILE--
+<?php
+/*
+* Test behaviour of shuffle when an associative array is
+* passed to the 'array_arg' argument and check for the
+* changes in the input array by printing the input array
+* before and after shuffle() function is applied on it
+*/
+
+echo "*** Testing shuffle() : with associative array ***\n";
+
+// Initialise the associative array
+$array_arg = array(
+  'one' => 1, 2 => 02, 'three' => 3,
+   4 => 4, '#5' => 5, 'SIX' => 6,
+  "seven" => 0x7, "#8" => 012, "nine" => 9
+);
+
+// printing the input array before the shuffle operation
+echo "\n-- input array before shuffle() function is applied --\n";
+var_dump( $array_arg );
+
+// applying shuffle() function on the input array
+echo "\n-- return value from shuffle() function --\n";
+var_dump( shuffle($array_arg) );  // prints the return value from shuffle() function
+
+echo "\n-- resultant array after shuffle() function is applied --\n";
+var_dump( $array_arg );
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing shuffle() : with associative array ***
+
+-- input array before shuffle() function is applied --
+array(9) {
+  ["one"]=>
+  int(1)
+  [2]=>
+  int(2)
+  ["three"]=>
+  int(3)
+  [4]=>
+  int(4)
+  ["#5"]=>
+  int(5)
+  ["SIX"]=>
+  int(6)
+  ["seven"]=>
+  int(7)
+  ["#8"]=>
+  int(10)
+  ["nine"]=>
+  int(9)
+}
+
+-- return value from shuffle() function --
+bool(true)
+
+-- resultant array after shuffle() function is applied --
+array(9) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+  [3]=>
+  int(%d)
+  [4]=>
+  int(%d)
+  [5]=>
+  int(%d)
+  [6]=>
+  int(%d)
+  [7]=>
+  int(%d)
+  [8]=>
+  int(%d)
+}
+Done
diff --git a/tests/std/array/shuffle_variation2.phpt b/tests/std/array/shuffle_variation2.phpt
new file mode 100644
index 00000000..ab90db3f
--- /dev/null
+++ b/tests/std/array/shuffle_variation2.phpt
@@ -0,0 +1,206 @@
+--TEST--
+Test shuffle() function : usage variation - with MultiDimensional array
+--FILE--
+<?php
+/*
+* Test behaviour of shuffle() function when multi-dimensional array is
+* passed to 'array_arg' argument
+*/
+
+echo "*** Testing shuffle() : with multi-dimensional array ***\n";
+
+// initialise the multi-dimensional array
+$array_arg = array(
+  array(1, 2, 3),
+  array(4, 5, 6),
+  array(7, 8, 9),
+  array(10000, 20000000, 30000000),
+  array(0, 0, 0),
+  array(012, 023, 034),
+  array(0x1, 0x0, 0xa)
+
+);
+
+// calling shuffle() function with multi-dimensional array
+var_dump( shuffle($array_arg) );
+echo "\nThe output array is:\n";
+var_dump( $array_arg );
+
+
+// looping to test shuffle() with each sub-array in the multi-dimensional array
+echo "\n*** Testing shuffle() with arrays having different types of values ***\n";
+$counter = 1;
+for($i=0; $i<=6; $i++) {
+  echo "\n-- Iteration $counter --\n";
+  var_dump( shuffle($array_arg[$i]) );
+  echo "\nThe output array is:\n";
+  var_dump( $array_arg[$i] );
+  $counter++;
+}
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing shuffle() : with multi-dimensional array ***
+bool(true)
+
+The output array is:
+array(7) {
+  [0]=>
+  array(3) {
+    [0]=>
+    int(%d)
+    [1]=>
+    int(%d)
+    [2]=>
+    int(%d)
+  }
+  [1]=>
+  array(3) {
+    [0]=>
+    int(%d)
+    [1]=>
+    int(%d)
+    [2]=>
+    int(%d)
+  }
+  [2]=>
+  array(3) {
+    [0]=>
+    int(%d)
+    [1]=>
+    int(%d)
+    [2]=>
+    int(%d)
+  }
+  [3]=>
+  array(3) {
+    [0]=>
+    int(%d)
+    [1]=>
+    int(%d)
+    [2]=>
+    int(%d)
+  }
+  [4]=>
+  array(3) {
+    [0]=>
+    int(%d)
+    [1]=>
+    int(%d)
+    [2]=>
+    int(%d)
+  }
+  [5]=>
+  array(3) {
+    [0]=>
+    int(%d)
+    [1]=>
+    int(%d)
+    [2]=>
+    int(%d)
+  }
+  [6]=>
+  array(3) {
+    [0]=>
+    int(%d)
+    [1]=>
+    int(%d)
+    [2]=>
+    int(%d)
+  }
+}
+
+*** Testing shuffle() with arrays having different types of values ***
+
+-- Iteration 1 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 2 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 3 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 4 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 5 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 6 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+
+-- Iteration 7 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+}
+Done
diff --git a/tests/std/array/shuffle_variation3.phpt b/tests/std/array/shuffle_variation3.phpt
new file mode 100644
index 00000000..87abe349
--- /dev/null
+++ b/tests/std/array/shuffle_variation3.phpt
@@ -0,0 +1,227 @@
+--TEST--
+Test shuffle() function : usage variation - arrays with diff types of values
+--FILE--
+<?php
+/*
+* Test behaviour of shuffle() function when arrays having different
+* types of values, are passed to 'array_arg' argument
+*/
+
+echo "*** Testing shuffle() : arrays with diff types of values ***\n";
+
+// initialise different arrays
+$array_arg = array(
+       // array with positive int values
+/*1*/  array(0, 1, 2, 2147483647 ),
+
+       // array with negative int values
+       array(-1, -2, -2147483647 ),
+
+       // array with positive float values
+/*3*/  array(0.23, 1.34, 0e2, 200e-2, 30e2, 10e0, 2147473648.90),
+
+       // array with negative float values
+       array(-0.23, -1.34, -200e-2, -30e2, -10e0, -2147473649.80),
+
+       // array with single quoted and double quoted strings
+/*5*/  array('one', "123numbers", 'hello\tworld', "hello world\0", '12.34floatnum'),
+
+       // array with bool values
+       array(true, TRUE, FALSE, false),
+
+       // array with positive hexa values
+/*7*/  array(0x123, 0xabc, 0xABC, 0xac, 0xAb1, 0x9fa),
+
+       // array with negative hexa values
+       array(-0x123, -0xabc, -0xABC, -0xAb1, -0x9fa),
+
+       // array with positive octal values
+/*9*/  array(0123, 0234, 034, 00),
+
+       // array with negative octal values
+/*10*/ array(-0123, -0234, -034),
+
+);
+
+// looping to test shuffle() with each sub-array in the $array_arg array
+echo "\n*** Testing shuffle() with arrays having different types of values ***\n";
+$counter = 1;
+foreach($array_arg as $arr) {
+  echo "\n-- Iteration $counter --\n";
+  var_dump( shuffle($arr) );
+  echo "\nThe output array is:\n";
+  var_dump( $arr );
+  $counter++;
+}
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing shuffle() : arrays with diff types of values ***
+
+*** Testing shuffle() with arrays having different types of values ***
+
+-- Iteration 1 --
+bool(true)
+
+The output array is:
+array(4) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+  [3]=>
+  int(%d)
+}
+
+-- Iteration 2 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(-%d)
+  [1]=>
+  int(-%d)
+  [2]=>
+  int(-%d)
+}
+
+-- Iteration 3 --
+bool(true)
+
+The output array is:
+array(7) {
+  [0]=>
+  float(%f)
+  [1]=>
+  float(%f)
+  [2]=>
+  float(%f)
+  [3]=>
+  float(%f)
+  [4]=>
+  float(%f)
+  [5]=>
+  float(%f)
+  [6]=>
+  float(%f)
+}
+
+-- Iteration 4 --
+bool(true)
+
+The output array is:
+array(6) {
+  [0]=>
+  float(-%f)
+  [1]=>
+  float(-%f)
+  [2]=>
+  float(-%f)
+  [3]=>
+  float(-%f)
+  [4]=>
+  float(-%f)
+  [5]=>
+  float(-%f)
+}
+
+-- Iteration 5 --
+bool(true)
+
+The output array is:
+array(5) {
+  [0]=>
+  string(%d) "%s"
+  [1]=>
+  string(%d) "%s"
+  [2]=>
+  string(%d) "%s"
+  [3]=>
+  string(%d) "%s"
+  [4]=>
+  string(%d) "%s"
+}
+
+-- Iteration 6 --
+bool(true)
+
+The output array is:
+array(4) {
+  [0]=>
+  bool(%s)
+  [1]=>
+  bool(%s)
+  [2]=>
+  bool(%s)
+  [3]=>
+  bool(%s)
+}
+
+-- Iteration 7 --
+bool(true)
+
+The output array is:
+array(6) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+  [3]=>
+  int(%d)
+  [4]=>
+  int(%d)
+  [5]=>
+  int(%d)
+}
+
+-- Iteration 8 --
+bool(true)
+
+The output array is:
+array(5) {
+  [0]=>
+  int(-%d)
+  [1]=>
+  int(-%d)
+  [2]=>
+  int(-%d)
+  [3]=>
+  int(-%d)
+  [4]=>
+  int(-%d)
+}
+
+-- Iteration 9 --
+bool(true)
+
+The output array is:
+array(4) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+  [3]=>
+  int(%d)
+}
+
+-- Iteration 10 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(-%d)
+  [1]=>
+  int(-%d)
+  [2]=>
+  int(-%d)
+}
+Done
diff --git a/tests/std/array/shuffle_variation4.phpt b/tests/std/array/shuffle_variation4.phpt
new file mode 100644
index 00000000..1d3269e7
--- /dev/null
+++ b/tests/std/array/shuffle_variation4.phpt
@@ -0,0 +1,225 @@
+--TEST--
+Test shuffle() function : usage variation - associative arrays with diff types of values
+--FILE--
+<?php
+/*
+* Test behaviour of shuffle() function when associative arrays
+* having different types of values, are passed to 'array_arg' argument
+*/
+
+echo "*** Testing shuffle() : associative arrays with diff types of values ***\n";
+
+// initialise different arrays
+$array_arg = array(
+       // array with positive int values
+/*1*/  array("zero" => 0, 1 => 1, "two" => 2, "max_int" => 2147483647 ),
+
+       // array with negative int values
+       array("minus_one" => -1, 'minus_two' => -2, "min_int" => -2147483647 ),
+
+       // array with positive float values
+/*3*/  array("float1" => 0.23, 'float2' => 1.34, "exp1" => 0e2, 'exp2' => 200e-2, "exp3" =>  10e0),
+
+       // array with negative float values
+       array(-0 => -0.23, -1 => -1.34, -200 => -200e-2, -30 => -30e0, -2147473649.80),
+
+       // array with single and double quoted strings
+/*5*/  array('1' => 'one', "str1" => "123numbers", '' => 'hello\tworld', "" => "hello world\0", "12.34floatnum"),
+
+       // array with bool values
+       array('1' => TRUE, "1" => TRUE, "0" => FALSE, '0' => FALSE),
+
+       // array with positive hexa values
+/*7*/  array("hex1" => 0x123, 'hex2' => 0xabc, "hex\t3" => 0xABC, "hex\04" => 0xAb1),
+
+       // array with negative hexa values
+       array(NULL => -0x123, "NULL" => -0xabc, "-ABC" => -0xABC, -0xAB1 => -0xAb1),
+
+       // array with positive octal values
+/*9*/  array(0123 => 0123, "0234" => 0234, '034' => 034, 00 => 00),
+
+       // array with negative octal values
+       array(-0123 => -0123, "-0234" => -0234, '-034' => -034),
+
+       // array with null values
+/*11*/ array(NULL => NULL, "null" => NULL, "NULL" => NULL)
+
+);
+
+// looping to test shuffle() with each sub-array in the $array_arg array
+echo "\n*** Testing shuffle() with arrays having different types of values ***\n";
+$counter = 1;
+foreach($array_arg as $arr) {
+  echo "\n-- Iteration $counter --\n";
+  var_dump( shuffle($arr) );
+  echo "\nThe output array is:\n";
+  var_dump( $arr );
+  $counter++;
+}
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing shuffle() : associative arrays with diff types of values ***
+
+*** Testing shuffle() with arrays having different types of values ***
+
+-- Iteration 1 --
+bool(true)
+
+The output array is:
+array(4) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+  [3]=>
+  int(%d)
+}
+
+-- Iteration 2 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(-%d)
+  [1]=>
+  int(-%d)
+  [2]=>
+  int(-%d)
+}
+
+-- Iteration 3 --
+bool(true)
+
+The output array is:
+array(5) {
+  [0]=>
+  float(%f)
+  [1]=>
+  float(%f)
+  [2]=>
+  float(%f)
+  [3]=>
+  float(%f)
+  [4]=>
+  float(%f)
+}
+
+-- Iteration 4 --
+bool(true)
+
+The output array is:
+array(5) {
+  [0]=>
+  float(-%f)
+  [1]=>
+  float(-%f)
+  [2]=>
+  float(-%f)
+  [3]=>
+  float(-%f)
+  [4]=>
+  float(-%f)
+}
+
+-- Iteration 5 --
+bool(true)
+
+The output array is:
+array(4) {
+  [0]=>
+  string(%d) "%s"
+  [1]=>
+  string(%d) "%s"
+  [2]=>
+  string(%d) "%s"
+  [3]=>
+  string(%d) "%s"
+}
+
+-- Iteration 6 --
+bool(true)
+
+The output array is:
+array(2) {
+  [0]=>
+  bool(%s)
+  [1]=>
+  bool(%s)
+}
+
+-- Iteration 7 --
+bool(true)
+
+The output array is:
+array(4) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+  [3]=>
+  int(%d)
+}
+
+-- Iteration 8 --
+bool(true)
+
+The output array is:
+array(4) {
+  [0]=>
+  int(-%d)
+  [1]=>
+  int(-%d)
+  [2]=>
+  int(-%d)
+  [3]=>
+  int(-%d)
+}
+
+-- Iteration 9 --
+bool(true)
+
+The output array is:
+array(4) {
+  [0]=>
+  int(%d)
+  [1]=>
+  int(%d)
+  [2]=>
+  int(%d)
+  [3]=>
+  int(%d)
+}
+
+-- Iteration 10 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  int(-%d)
+  [1]=>
+  int(-%d)
+  [2]=>
+  int(-%d)
+}
+
+-- Iteration 11 --
+bool(true)
+
+The output array is:
+array(3) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  NULL
+}
+Done
diff --git a/tests/std/array/shuffle_variation5.phpt b/tests/std/array/shuffle_variation5.phpt
new file mode 100644
index 00000000..7ad0c016
--- /dev/null
+++ b/tests/std/array/shuffle_variation5.phpt
@@ -0,0 +1,114 @@
+--TEST--
+Test shuffle() function : usage variation - arrays with diff heredoc strings
+--FILE--
+<?php
+/*
+* Test behaviour of shuffle() when an array of heredoc strings is passed to
+* 'array_arg' argument of the function
+*/
+
+echo "*** Testing shuffle() : with array containing heredoc strings ***\n";
+
+// defining different heredoc strings
+$empty_heredoc = <<<EOT
+EOT;
+
+$heredoc_with_newline = <<<EOT
+\n
+EOT;
+
+$heredoc_with_characters = <<<EOT
+first line of heredoc string
+second line of heredoc string
+third line of heredocstring
+EOT;
+
+$heredoc_with_newline_and_tabs = <<<EOT
+hello\tworld\nhello\nworld\n
+EOT;
+
+$heredoc_with_alphanumerics = <<<EOT
+hello123world456
+1234hello\t1234
+EOT;
+
+$heredoc_with_embedded_nulls = <<<EOT
+hello\0world\0hello
+\0hello\0
+EOT;
+
+// defining array with values as heredoc strings
+$heredoc_array = array(
+  $empty_heredoc,
+  $heredoc_with_newline,
+  $heredoc_with_characters,
+  $heredoc_with_newline_and_tabs,
+  $heredoc_with_alphanumerics,
+  $heredoc_with_embedded_nulls
+);
+
+// defining array with keys as heredoc strings
+$heredoc_asso_array = array(
+  $empty_heredoc => "heredoc1",
+  $heredoc_with_newline => "heredoc2",
+  $heredoc_with_characters => "heredoc3",
+  $heredoc_with_newline_and_tabs => "heredoc3",
+  $heredoc_with_alphanumerics => "heredoc4",
+  $heredoc_with_embedded_nulls => "heredoc5"
+);
+
+// test shuffle() with array containing heredoc strings as values
+echo "\n-- with array of heredoc strings --\n";
+var_dump( shuffle($heredoc_array) );
+echo "\nThe output array is:\n";
+var_dump( $heredoc_array );
+
+// test shuffle() with array containing heredoc strings as its keys
+echo "\n-- with array having heredoc strings as keys --\n";
+var_dump( shuffle($heredoc_asso_array) );
+echo "\nThe output array is:\n";
+var_dump( $heredoc_asso_array );
+
+echo "Done";
+?>
+--EXPECTREGEX--
+\*\*\* Testing shuffle\(\) : with array containing heredoc strings \*\*\*
+
+-- with array of heredoc strings --
+bool\(true\)
+
+The output array is:
+array\(6\) {
+  \[0\]=>
+  string\([0-9]*\) "[0-9 a-z \n \0 \t]*"
+  \[1\]=>
+  string\([0-9]*\) "[0-9 a-z \n \0 \t]*"
+  \[2\]=>
+  string\([0-9]*\) "[0-9 a-z \n \0 \t]*"
+  \[3\]=>
+  string\([0-9]*\) "[0-9 a-z \n \0 \t]*"
+  \[4\]=>
+  string\([0-9]*\) "[0-9 a-z \n \0 \t]*"
+  \[5\]=>
+  string\([0-9]*\) "[0-9 a-z \n \0 \t]*"
+}
+
+-- with array having heredoc strings as keys --
+bool\(true\)
+
+The output array is:
+array\(6\) {
+  \[0\]=>
+  string\(8\) "[heredoc 1-5]*"
+  \[1\]=>
+  string\(8\) "[heredoc 1-5]*"
+  \[2\]=>
+  string\(8\) "[heredoc 1-5]*"
+  \[3\]=>
+  string\(8\) "[heredoc 1-5]*"
+  \[4\]=>
+  string\(8\) "[heredoc 1-5]*"
+  \[5\]=>
+  string\(8\) "[heredoc 1-5]*"
+}
+Done
diff --git a/tests/std/array/sizeof_basic2.phpt b/tests/std/array/sizeof_basic2.phpt
new file mode 100644
index 00000000..e77a0d6a
--- /dev/null
+++ b/tests/std/array/sizeof_basic2.phpt
@@ -0,0 +1,92 @@
+--TEST--
+Test sizeof() function : basic functionality - for non-scalar type(array)
+--FILE--
+<?php
+/* Testing the sizeof() for non-scalar type(array) value
+ * in default, COUNT_NORMAL and COUNT_RECURSIVE modes.
+ * Sizeof() has been tested for simple integer, string,
+ * indexed and mixed arrays.
+ */
+
+echo "*** Testing sizeof() : basic functionality ***\n";
+
+$int_array = array(1, 2, 3, 4);
+$string_array = array("Saffron", "White", "Green");
+$indexed_array = array("Aggression" => "Saffron", "Peace" => "White", "Growth" => "Green");
+$mixed_array = array(1, 2, "Aggression" => "Saffron", 10 => "Ten", "Ten" => 10);
+
+echo "-- Testing sizeof() with integer array in default, COUNT_NORMAL, COUNT_RECURSIVE modes --\n";
+echo "default mode: ";
+var_dump( sizeof($int_array) );
+echo "\n";
+echo "COUNT_NORMAL mode: ";
+var_dump( sizeof($int_array, COUNT_NORMAL) );
+echo "\n";
+echo "COUNT_RECURSIVE mode: ";
+var_dump( sizeof($int_array, COUNT_RECURSIVE) );
+echo "\n";
+
+echo "-- Testing sizeof() with string array in default, COUNT_NORMAL, COUNT_RECURSIVE modes --\n";
+echo "default mode: ";
+var_dump( sizeof($string_array) );
+echo "\n";
+echo "COUNT_NORMAL mode: ";
+var_dump( sizeof($string_array, COUNT_NORMAL) );
+echo "\n";
+echo "COUNT_RECURSIVE mode: ";
+var_dump( sizeof($string_array, COUNT_RECURSIVE) );
+echo "\n";
+
+echo "-- Testing sizeof() with indexed array in default, COUNT_NORMAL, COUNT_RECURSIVE modes --\n";
+echo "default mode: ";
+var_dump( sizeof($indexed_array) );
+echo "\n";
+echo "COUNT_NORMAL mode: ";
+var_dump( sizeof($indexed_array, COUNT_NORMAL) );
+echo "\n";
+echo "COUNT_RECURSIVE mode: ";
+var_dump( sizeof($indexed_array, COUNT_RECURSIVE) );
+echo "\n";
+
+echo "-- Testing sizeof() with mixed array in default, COUNT_NORMAL, COUNT_RECURSIVE modes --\n";
+echo "default mode: ";
+var_dump( sizeof($mixed_array) );
+echo "\n";
+echo "COUNT_NORMAL mode: ";
+var_dump( sizeof($mixed_array, COUNT_NORMAL) );
+echo "\n";
+echo "COUNT_RECURSIVE mode: ";
+var_dump( sizeof($mixed_array, COUNT_RECURSIVE) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing sizeof() : basic functionality ***
+-- Testing sizeof() with integer array in default, COUNT_NORMAL, COUNT_RECURSIVE modes --
+default mode: int(4)
+
+COUNT_NORMAL mode: int(4)
+
+COUNT_RECURSIVE mode: int(4)
+
+-- Testing sizeof() with string array in default, COUNT_NORMAL, COUNT_RECURSIVE modes --
+default mode: int(3)
+
+COUNT_NORMAL mode: int(3)
+
+COUNT_RECURSIVE mode: int(3)
+
+-- Testing sizeof() with indexed array in default, COUNT_NORMAL, COUNT_RECURSIVE modes --
+default mode: int(3)
+
+COUNT_NORMAL mode: int(3)
+
+COUNT_RECURSIVE mode: int(3)
+
+-- Testing sizeof() with mixed array in default, COUNT_NORMAL, COUNT_RECURSIVE modes --
+default mode: int(5)
+
+COUNT_NORMAL mode: int(5)
+
+COUNT_RECURSIVE mode: int(5)
+Done
diff --git a/tests/std/array/sizeof_object1.phpt b/tests/std/array/sizeof_object1.phpt
new file mode 100644
index 00000000..681f28f3
--- /dev/null
+++ b/tests/std/array/sizeof_object1.phpt
@@ -0,0 +1,39 @@
+--TEST--
+Test sizeof() function : object functionality - object with Countable interface
+--FILE--
+<?php
+class sizeof_class implements Countable
+{
+    public $member1;
+    private $member2;
+    protected $member3;
+    public function count(): int
+    {
+        return 3;
+        // return the count of member variables in the object
+    }
+}
+function main()
+{
+    echo "*** Testing sizeof() : object functionality ***\n";
+    echo "-- Testing sizeof() with an object which implements Countable interface --\n";
+    $obj = new sizeof_class();
+    echo "-- Testing sizeof() in default mode --\n";
+    var_dump(sizeof($obj));
+    echo "-- Testing sizeof() in COUNT_NORMAL mode --\n";
+    var_dump(sizeof($obj, COUNT_NORMAL));
+    echo "-- Testing sizeof() in COUNT_RECURSIVE mode --\n";
+    var_dump(sizeof($obj, COUNT_RECURSIVE));
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing sizeof() : object functionality ***
+-- Testing sizeof() with an object which implements Countable interface --
+-- Testing sizeof() in default mode --
+int(3)
+-- Testing sizeof() in COUNT_NORMAL mode --
+int(3)
+-- Testing sizeof() in COUNT_RECURSIVE mode --
+int(3)
+Done
diff --git a/tests/std/array/sizeof_object2.phpt b/tests/std/array/sizeof_object2.phpt
new file mode 100644
index 00000000..675ebcab
--- /dev/null
+++ b/tests/std/array/sizeof_object2.phpt
@@ -0,0 +1,112 @@
+--TEST--
+Test sizeof() function : object functionality - objects without Countable interface
+--FILE--
+<?php
+// class without member
+class test
+{
+    // no members
+}
+// class with only members and with out member functions
+class test1
+{
+    public $member1;
+    var $var1;
+    private $member2;
+    protected $member3;
+    // no member functions
+}
+// class with only member functions
+class test2
+{
+    // no data members
+    public function display()
+    {
+        echo " Class Name : test2\n";
+    }
+}
+// child class which inherits parent test2
+class child_test2 extends test2
+{
+    public $child_member1;
+    private $child_member2;
+}
+// abstract class
+abstract class abstract_class
+{
+    public $member1;
+    private $member2;
+    abstract protected function display();
+}
+// implement abstract 'abstract_class' class
+class concrete_class extends abstract_class
+{
+    protected function display()
+    {
+        echo " class name is : concrete_class \n ";
+    }
+}
+function main()
+{
+    echo "*** Testing sizeof() : object functionality ***\n";
+    echo "--- Testing sizeof() with objects which doesn't implement Countable interface ---\n";
+    $objects = array(
+        /* 1  */
+        new test(),
+        new test1(),
+        new test2(),
+        new child_test2(),
+        /* 5  */
+        new concrete_class(),
+    );
+    $counter = 1;
+    for ($i = 0; $i < count($objects); $i++) {
+        echo "-- Iteration {$counter} --\n";
+        $var = $objects[$i];
+        echo "Default Mode: ";
+        try {
+            var_dump(sizeof($var));
+        } catch (\TypeError $e) {
+            echo $e->getMessage() . \PHP_EOL;
+        }
+        echo "COUNT_NORMAL Mode: ";
+        try {
+            var_dump(sizeof($var, COUNT_NORMAL));
+        } catch (\TypeError $e) {
+            echo $e->getMessage() . \PHP_EOL;
+        }
+        echo "COUNT_RECURSIVE Mode: ";
+        try {
+            var_dump(sizeof($var, COUNT_RECURSIVE));
+        } catch (\TypeError $e) {
+            echo $e->getMessage() . \PHP_EOL;
+        }
+        $counter++;
+    }
+    echo "Done";
+}
+?>
+--EXPECT--
+*** Testing sizeof() : object functionality ***
+--- Testing sizeof() with objects which doesn't implement Countable interface ---
+-- Iteration 1 --
+Default Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test given
+-- Iteration 2 --
+Default Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test1 given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test1 given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test1 given
+-- Iteration 3 --
+Default Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test2 given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test2 given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test2 given
+-- Iteration 4 --
+Default Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, child_test2 given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, child_test2 given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, child_test2 given
+-- Iteration 5 --
+Default Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, concrete_class given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, concrete_class given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, concrete_class given
+Done
diff --git a/tests/std/array/sizeof_variation2.phpt b/tests/std/array/sizeof_variation2.phpt
new file mode 100644
index 00000000..baa917a2
--- /dev/null
+++ b/tests/std/array/sizeof_variation2.phpt
@@ -0,0 +1,156 @@
+--TEST--
+Test sizeof() function : usage variations - different array values for 'var' argument
+--FILE--
+<?php
+echo "*** Testing sizeof() : usage variations ***\n";
+
+// get a resource variable
+$fp = fopen(__FILE__, "r");
+
+echo "--- Testing sizeof() with different array values for 'var' argument ---\n";
+
+// array containing different types of array values for 'var' argument
+$values = array (
+  /* 1  */  array($fp, "resource" => $fp),
+            array(1, array(3, 4, array(6, array(8)))),
+            array("a" => 1, 'b' => 2, array( "c" =>3, array( "d" => 5))),
+            array(),
+  /* 5  */  array(1, 2, 3, 4),
+            array("Saffron", "White", "Green"),
+            array('saffron', 'white', 'green'),
+            array(1 => "Hi", 2 => "Hello" ),
+            array("color" => "red", "item" => "pen"),
+  /* 10 */  array('color' => 'red', 'item' => 'pen'),
+            array(TRUE => "red", FALSE => "pen" ),
+            array(false => 'red', true => 'pen' ),
+            array('color' => "red", "item" => 'pen', 1 => "Hi", "" => "Hello" ),
+  /* 14 */  array($fp, "resource1" => $fp, 'resource2' => $fp, array( $fp, 'type' => $fp) )
+);
+
+// loop through each element of the values array for 'var' argument
+// check the working of sizeof()
+$counter = 1;
+for($i = 0; $i < count($values); $i++)
+{
+  echo "-- Iteration $counter --\n";
+  $var = $values[$i];
+
+  echo "Default Mode: ";
+  var_dump( sizeof($var) );
+  echo "\n";
+
+  echo "COUNT_NORMAL Mode: ";
+  var_dump( sizeof($var, COUNT_NORMAL) );
+  echo "\n";
+
+  echo "COUNT_RECURSIVE Mode: ";
+  var_dump( sizeof($var, COUNT_RECURSIVE) );
+  echo "\n";
+
+  $counter++;
+}
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing sizeof() : usage variations ***
+--- Testing sizeof() with different array values for 'var' argument ---
+-- Iteration 1 --
+Default Mode: int(2)
+
+COUNT_NORMAL Mode: int(2)
+
+COUNT_RECURSIVE Mode: int(2)
+
+-- Iteration 2 --
+Default Mode: int(2)
+
+COUNT_NORMAL Mode: int(2)
+
+COUNT_RECURSIVE Mode: int(8)
+
+-- Iteration 3 --
+Default Mode: int(3)
+
+COUNT_NORMAL Mode: int(3)
+
+COUNT_RECURSIVE Mode: int(6)
+
+-- Iteration 4 --
+Default Mode: int(0)
+
+COUNT_NORMAL Mode: int(0)
+
+COUNT_RECURSIVE Mode: int(0)
+
+-- Iteration 5 --
+Default Mode: int(4)
+
+COUNT_NORMAL Mode: int(4)
+
+COUNT_RECURSIVE Mode: int(4)
+
+-- Iteration 6 --
+Default Mode: int(3)
+
+COUNT_NORMAL Mode: int(3)
+
+COUNT_RECURSIVE Mode: int(3)
+
+-- Iteration 7 --
+Default Mode: int(3)
+
+COUNT_NORMAL Mode: int(3)
+
+COUNT_RECURSIVE Mode: int(3)
+
+-- Iteration 8 --
+Default Mode: int(2)
+
+COUNT_NORMAL Mode: int(2)
+
+COUNT_RECURSIVE Mode: int(2)
+
+-- Iteration 9 --
+Default Mode: int(2)
+
+COUNT_NORMAL Mode: int(2)
+
+COUNT_RECURSIVE Mode: int(2)
+
+-- Iteration 10 --
+Default Mode: int(2)
+
+COUNT_NORMAL Mode: int(2)
+
+COUNT_RECURSIVE Mode: int(2)
+
+-- Iteration 11 --
+Default Mode: int(2)
+
+COUNT_NORMAL Mode: int(2)
+
+COUNT_RECURSIVE Mode: int(2)
+
+-- Iteration 12 --
+Default Mode: int(2)
+
+COUNT_NORMAL Mode: int(2)
+
+COUNT_RECURSIVE Mode: int(2)
+
+-- Iteration 13 --
+Default Mode: int(4)
+
+COUNT_NORMAL Mode: int(4)
+
+COUNT_RECURSIVE Mode: int(4)
+
+-- Iteration 14 --
+Default Mode: int(4)
+
+COUNT_NORMAL Mode: int(4)
+
+COUNT_RECURSIVE Mode: int(6)
+
+Done
diff --git a/tests/std/array/sizeof_variation3.phpt b/tests/std/array/sizeof_variation3.phpt
new file mode 100644
index 00000000..4b4a3d7b
--- /dev/null
+++ b/tests/std/array/sizeof_variation3.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Test sizeof() function : usage variations - checking for infinite recursion in COUNT_RECURSIVE mode
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support undefined variables");
+?>
+
+--FILE--
+<?php
+echo "*** Testing sizeof() : usage variations ***\n";
+
+echo "-- Testing sizeof() for infinite recursion with arrays as argument in COUNT_RECURSIVE mode --\n";
+
+$array2 = array ( "Hi", "Hello",@$a);
+$array3 = array( 'hi', 'hello');
+$a = array ( 1, @$array1, $array2, $array3);
+$array1 = array( array(1, 2), $a);
+$array4 = array( 100, @$array4);
+
+var_dump( sizeof($array1, COUNT_RECURSIVE) );
+echo "\n";
+var_dump( sizeof($array4, COUNT_RECURSIVE) );
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing sizeof() : usage variations ***
+-- Testing sizeof() for infinite recursion with arrays as argument in COUNT_RECURSIVE mode --
+int(13)
+
+int(2)
+Done
diff --git a/tests/std/array/sort_basic.phpt b/tests/std/array/sort_basic.phpt
new file mode 100644
index 00000000..8f50c6e1
--- /dev/null
+++ b/tests/std/array/sort_basic.phpt
@@ -0,0 +1,240 @@
+--TEST--
+Test sort() function : basic functionality
+--FILE--
+<?php
+/*
+ * Testing sort() by providing arrays with default keys and assoc arrays
+ * to check the basic functionality with following flag values.
+ *  flag value as default
+ *  SORT_REGULAR - compare items normally
+ *  SORT_NUMERIC - compare items numerically
+ *  SORT_STRING - compare items as strings
+*/
+
+echo "*** Testing sort() : basic functionality ***\n";
+
+// associative array containing unsorted string values
+$unsorted_strings = array(
+    "l" => "lemon", "o" => "orange",
+    "O" => "Orange", "O1" => "Orange1", "o2" => "orange2", "O3" => "Orange3", "o20" => "orange20",
+    "b" => "banana",
+);
+
+// array with default keys containing unsorted numeric values
+$unsorted_numerics =  array( 100, 33, 555, 22 );
+
+echo "\n-- Testing sort() by supplying string array, 'flag' value is default --\n";
+$temp_array = $unsorted_strings;
+var_dump( sort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying numeric array, 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( sort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying string array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_strings;
+var_dump( sort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying numeric array, 'flag' = SORT_REGULAR --\n";
+$temp_array = $unsorted_numerics;
+var_dump( sort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying string array, 'flag' = SORT_STRING --\n";
+$temp_array = $unsorted_strings;
+var_dump( sort($temp_array, SORT_STRING) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( sort($temp_array, SORT_STRING|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying string array (natural), 'flag' = SORT_NATURAL --\n";
+$temp_array = $unsorted_strings;
+var_dump( sort($temp_array, SORT_NATURAL) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --\n";
+$temp_array = $unsorted_strings;
+var_dump( sort($temp_array, SORT_NATURAL|SORT_FLAG_CASE) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying numeric array, 'flag' = SORT_NUMERIC --\n";
+$temp_array = $unsorted_numerics;
+var_dump( sort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing sort() : basic functionality ***
+
+-- Testing sort() by supplying string array, 'flag' value is default --
+bool(true)
+array(8) {
+  [0]=>
+  string(6) "Orange"
+  [1]=>
+  string(7) "Orange1"
+  [2]=>
+  string(7) "Orange3"
+  [3]=>
+  string(6) "banana"
+  [4]=>
+  string(5) "lemon"
+  [5]=>
+  string(6) "orange"
+  [6]=>
+  string(7) "orange2"
+  [7]=>
+  string(8) "orange20"
+}
+
+-- Testing sort() by supplying numeric array, 'flag' value is default --
+bool(true)
+array(4) {
+  [0]=>
+  int(22)
+  [1]=>
+  int(33)
+  [2]=>
+  int(100)
+  [3]=>
+  int(555)
+}
+
+-- Testing sort() by supplying string array, 'flag' = SORT_REGULAR --
+bool(true)
+array(8) {
+  [0]=>
+  string(6) "Orange"
+  [1]=>
+  string(7) "Orange1"
+  [2]=>
+  string(7) "Orange3"
+  [3]=>
+  string(6) "banana"
+  [4]=>
+  string(5) "lemon"
+  [5]=>
+  string(6) "orange"
+  [6]=>
+  string(7) "orange2"
+  [7]=>
+  string(8) "orange20"
+}
+
+-- Testing sort() by supplying numeric array, 'flag' = SORT_REGULAR --
+bool(true)
+array(4) {
+  [0]=>
+  int(22)
+  [1]=>
+  int(33)
+  [2]=>
+  int(100)
+  [3]=>
+  int(555)
+}
+
+-- Testing sort() by supplying string array, 'flag' = SORT_STRING --
+bool(true)
+array(8) {
+  [0]=>
+  string(6) "Orange"
+  [1]=>
+  string(7) "Orange1"
+  [2]=>
+  string(7) "Orange3"
+  [3]=>
+  string(6) "banana"
+  [4]=>
+  string(5) "lemon"
+  [5]=>
+  string(6) "orange"
+  [6]=>
+  string(7) "orange2"
+  [7]=>
+  string(8) "orange20"
+}
+
+-- Testing sort() by supplying string array (case insensitive), 'flag' = SORT_STRING|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  [0]=>
+  string(6) "banana"
+  [1]=>
+  string(5) "lemon"
+  [2]=>
+  string(6) "orange"
+  [3]=>
+  string(6) "Orange"
+  [4]=>
+  string(7) "Orange1"
+  [5]=>
+  string(7) "orange2"
+  [6]=>
+  string(8) "orange20"
+  [7]=>
+  string(7) "Orange3"
+}
+
+-- Testing sort() by supplying string array (natural), 'flag' = SORT_NATURAL --
+bool(true)
+array(8) {
+  [0]=>
+  string(6) "Orange"
+  [1]=>
+  string(7) "Orange1"
+  [2]=>
+  string(7) "Orange3"
+  [3]=>
+  string(6) "banana"
+  [4]=>
+  string(5) "lemon"
+  [5]=>
+  string(6) "orange"
+  [6]=>
+  string(7) "orange2"
+  [7]=>
+  string(8) "orange20"
+}
+
+-- Testing sort() by supplying string array (natural, case insensitive), 'flag' = SORT_NATURAL|SORT_FLAG_CASE --
+bool(true)
+array(8) {
+  [0]=>
+  string(6) "banana"
+  [1]=>
+  string(5) "lemon"
+  [2]=>
+  string(6) "orange"
+  [3]=>
+  string(6) "Orange"
+  [4]=>
+  string(7) "Orange1"
+  [5]=>
+  string(7) "orange2"
+  [6]=>
+  string(7) "Orange3"
+  [7]=>
+  string(8) "orange20"
+}
+
+-- Testing sort() by supplying numeric array, 'flag' = SORT_NUMERIC --
+bool(true)
+array(4) {
+  [0]=>
+  int(22)
+  [1]=>
+  int(33)
+  [2]=>
+  int(100)
+  [3]=>
+  int(555)
+}
+Done
diff --git a/tests/std/array/sort_object1.phpt b/tests/std/array/sort_object1.phpt
new file mode 100644
index 00000000..3a9f2a14
--- /dev/null
+++ b/tests/std/array/sort_object1.phpt
@@ -0,0 +1,218 @@
+--TEST--
+Test sort() function : object functionality - sorting objects, 'sort_flags' as default/SORT_REGULAR
+--FILE--
+<?php
+// class declaration for integer objects
+class for_integer_sort
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+}
+// class declaration for string objects
+class for_string_sort
+{
+    public $class_value;
+    // initializing object member value
+    function __construct($value)
+    {
+        $this->class_value = $value;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * testing sort() by providing integer/string object arrays with flag values are default, SORT_REGULAR
+    */
+    echo "*** Testing sort() : object functionality ***\n";
+    // array of integer objects
+    $unsorted_int_obj = array(new for_integer_sort(11), new for_integer_sort(66), new for_integer_sort(23), new for_integer_sort(-5), new for_integer_sort(0.001), new for_integer_sort(0));
+    // array of string objects
+    $unsorted_str_obj = array(new for_string_sort("axx"), new for_string_sort("t"), new for_string_sort("w"), new for_string_sort("py"), new for_string_sort("apple"), new for_string_sort("Orange"), new for_string_sort("Lemon"), new for_string_sort("aPPle"));
+    echo "\n-- Testing sort() by supplying various object arrays, 'flag' value is default --\n";
+    // testing sort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(sort($temp_array));
+    var_dump($temp_array);
+    // testing sort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(sort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Testing sort() by supplying various object arrays, 'flag' value is SORT_REGULAR --\n";
+    // testing sort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(sort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing sort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(sort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+*** Testing sort() : object functionality ***
+
+-- Testing sort() by supplying various object arrays, 'flag' value is default --
+bool(true)
+array(6) {
+  [0]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+  [1]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [2]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [3]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [4]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [5]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+}
+bool(true)
+array(8) {
+  [0]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+  [1]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  [2]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  [3]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  [4]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  [5]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  [6]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  [7]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+}
+
+-- Testing sort() by supplying various object arrays, 'flag' value is SORT_REGULAR --
+bool(true)
+array(6) {
+  [0]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(-5)
+  }
+  [1]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(0)
+  }
+  [2]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    float(0.001)
+  }
+  [3]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(11)
+  }
+  [4]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(23)
+  }
+  [5]=>
+  object(for_integer_sort)#%d (1) {
+    ["class_value"]=>
+    int(66)
+  }
+}
+bool(true)
+array(8) {
+  [0]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(5) "Lemon"
+  }
+  [1]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(6) "Orange"
+  }
+  [2]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(5) "aPPle"
+  }
+  [3]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(5) "apple"
+  }
+  [4]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(3) "axx"
+  }
+  [5]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(2) "py"
+  }
+  [6]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(1) "t"
+  }
+  [7]=>
+  object(for_string_sort)#%d (1) {
+    ["class_value"]=>
+    string(1) "w"
+  }
+}
+Done
diff --git a/tests/std/array/sort_object2.phpt b/tests/std/array/sort_object2.phpt
new file mode 100644
index 00000000..294078da
--- /dev/null
+++ b/tests/std/array/sort_object2.phpt
@@ -0,0 +1,230 @@
+--TEST--
+Test sort() function : object functionality - sorting objects with diff. accessibility of member vars
+--FILE--
+<?php
+// class declaration for integer objects
+class for_integer_sort
+{
+    public $public_class_value;
+    private $private_class_value;
+    protected $protected_class_value;
+    // initializing object member value
+    function __construct($value1, $value2, $value3)
+    {
+        $this->public_class_value = $value1;
+        $this->private_class_value = $value2;
+        $this->protected_class_value = $value3;
+    }
+}
+// class declaration for string objects
+class for_string_sort
+{
+    public $public_class_value;
+    private $private_class_value;
+    protected $protected_class_value;
+    // initializing object member value
+    function __construct($value1, $value2, $value3)
+    {
+        $this->public_class_value = $value1;
+        $this->private_class_value = $value2;
+        $this->protected_class_value = $value3;
+    }
+    // return string value
+    function __tostring(): string {
+        return (string) $this->value;
+    }
+}
+function main()
+{
+    /*
+     * testing sort() by providing integer/string object arrays with flag values are default, SORT_REGULAR
+    */
+    echo "*** Testing sort() : object functionality ***\n";
+    // array of integer objects
+    $unsorted_int_obj = array(new for_integer_sort(11, 33, 30), new for_integer_sort(66, 44, 4), new for_integer_sort(-88, -5, 5), new for_integer_sort(0.001, 99.5, 0.1));
+    // array of string objects
+    $unsorted_str_obj = array(new for_string_sort("axx", "AXX", "ass"), new for_string_sort("t", "eee", "abb"), new for_string_sort("w", "W", "c"), new for_string_sort("py", "PY", "pt"));
+    echo "\n-- Testing sort() by supplying various object arrays, 'flag' value is default --\n";
+    // testing sort() function by supplying integer object array, flag value is default
+    $temp_array = $unsorted_int_obj;
+    var_dump(sort($temp_array));
+    var_dump($temp_array);
+    // testing sort() function by supplying string object array, flag value is default
+    $temp_array = $unsorted_str_obj;
+    var_dump(sort($temp_array));
+    var_dump($temp_array);
+    echo "\n-- Testing sort() by supplying various object arrays, 'flag' value is SORT_REGULAR --\n";
+    // testing sort() function by supplying integer object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_int_obj;
+    var_dump(sort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    // testing sort() function by supplying string object array, flag value = SORT_REGULAR
+    $temp_array = $unsorted_str_obj;
+    var_dump(sort($temp_array, SORT_REGULAR));
+    var_dump($temp_array);
+    echo "Done\n";
+}
+?>
+--EXPECTF--
+*** Testing sort() : object functionality ***
+
+-- Testing sort() by supplying various object arrays, 'flag' value is default --
+bool(true)
+array(4) {
+  [0]=>
+  object(for_integer_sort)#%d (3) {
+    ["public_class_value"]=>
+    int(-88)
+    ["private_class_value":"for_integer_sort":private]=>
+    int(-5)
+    ["protected_class_value":protected]=>
+    int(5)
+  }
+  [1]=>
+  object(for_integer_sort)#%d (3) {
+    ["public_class_value"]=>
+    float(0.001)
+    ["private_class_value":"for_integer_sort":private]=>
+    float(99.5)
+    ["protected_class_value":protected]=>
+    float(0.1)
+  }
+  [2]=>
+  object(for_integer_sort)#%d (3) {
+    ["public_class_value"]=>
+    int(11)
+    ["private_class_value":"for_integer_sort":private]=>
+    int(33)
+    ["protected_class_value":protected]=>
+    int(30)
+  }
+  [3]=>
+  object(for_integer_sort)#%d (3) {
+    ["public_class_value"]=>
+    int(66)
+    ["private_class_value":"for_integer_sort":private]=>
+    int(44)
+    ["protected_class_value":protected]=>
+    int(4)
+  }
+}
+bool(true)
+array(4) {
+  [0]=>
+  object(for_string_sort)#%d (3) {
+    ["public_class_value"]=>
+    string(3) "axx"
+    ["private_class_value":"for_string_sort":private]=>
+    string(3) "AXX"
+    ["protected_class_value":protected]=>
+    string(3) "ass"
+  }
+  [1]=>
+  object(for_string_sort)#%d (3) {
+    ["public_class_value"]=>
+    string(2) "py"
+    ["private_class_value":"for_string_sort":private]=>
+    string(2) "PY"
+    ["protected_class_value":protected]=>
+    string(2) "pt"
+  }
+  [2]=>
+  object(for_string_sort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "t"
+    ["private_class_value":"for_string_sort":private]=>
+    string(3) "eee"
+    ["protected_class_value":protected]=>
+    string(3) "abb"
+  }
+  [3]=>
+  object(for_string_sort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "w"
+    ["private_class_value":"for_string_sort":private]=>
+    string(1) "W"
+    ["protected_class_value":protected]=>
+    string(1) "c"
+  }
+}
+
+-- Testing sort() by supplying various object arrays, 'flag' value is SORT_REGULAR --
+bool(true)
+array(4) {
+  [0]=>
+  object(for_integer_sort)#%d (3) {
+    ["public_class_value"]=>
+    int(-88)
+    ["private_class_value":"for_integer_sort":private]=>
+    int(-5)
+    ["protected_class_value":protected]=>
+    int(5)
+  }
+  [1]=>
+  object(for_integer_sort)#%d (3) {
+    ["public_class_value"]=>
+    float(0.001)
+    ["private_class_value":"for_integer_sort":private]=>
+    float(99.5)
+    ["protected_class_value":protected]=>
+    float(0.1)
+  }
+  [2]=>
+  object(for_integer_sort)#%d (3) {
+    ["public_class_value"]=>
+    int(11)
+    ["private_class_value":"for_integer_sort":private]=>
+    int(33)
+    ["protected_class_value":protected]=>
+    int(30)
+  }
+  [3]=>
+  object(for_integer_sort)#%d (3) {
+    ["public_class_value"]=>
+    int(66)
+    ["private_class_value":"for_integer_sort":private]=>
+    int(44)
+    ["protected_class_value":protected]=>
+    int(4)
+  }
+}
+bool(true)
+array(4) {
+  [0]=>
+  object(for_string_sort)#%d (3) {
+    ["public_class_value"]=>
+    string(3) "axx"
+    ["private_class_value":"for_string_sort":private]=>
+    string(3) "AXX"
+    ["protected_class_value":protected]=>
+    string(3) "ass"
+  }
+  [1]=>
+  object(for_string_sort)#%d (3) {
+    ["public_class_value"]=>
+    string(2) "py"
+    ["private_class_value":"for_string_sort":private]=>
+    string(2) "PY"
+    ["protected_class_value":protected]=>
+    string(2) "pt"
+  }
+  [2]=>
+  object(for_string_sort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "t"
+    ["private_class_value":"for_string_sort":private]=>
+    string(3) "eee"
+    ["protected_class_value":protected]=>
+    string(3) "abb"
+  }
+  [3]=>
+  object(for_string_sort)#%d (3) {
+    ["public_class_value"]=>
+    string(1) "w"
+    ["private_class_value":"for_string_sort":private]=>
+    string(1) "W"
+    ["protected_class_value":protected]=>
+    string(1) "c"
+  }
+}
+Done
diff --git a/tests/std/array/sort_variation10.phpt b/tests/std/array/sort_variation10.phpt
new file mode 100644
index 00000000..36dfcb85
--- /dev/null
+++ b/tests/std/array/sort_variation10.phpt
@@ -0,0 +1,106 @@
+--TEST--
+Test sort() function : usage variations - sort octal values
+--FILE--
+<?php
+/*
+ * testing sort() by providing different octal array for $array argument
+ * with following flag values
+ * 1.flag value as default
+ * 2.SORT_REGULAR - compare items normally
+ * 3.SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing sort() : usage variations ***\n";
+
+// an array containing unsorted octal values
+$unsorted_oct_array = array(01235, 0321, 0345, 066, 0772, 077, -066, -0345, 0);
+
+echo "\n-- Testing sort() by supplying octal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump(sort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing sort() by supplying octal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump(sort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing sort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_oct_array;
+var_dump(sort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing sort() : usage variations ***
+
+-- Testing sort() by supplying octal value array, 'flag' value is default  --
+bool(true)
+array(9) {
+  [0]=>
+  int(-229)
+  [1]=>
+  int(-54)
+  [2]=>
+  int(0)
+  [3]=>
+  int(54)
+  [4]=>
+  int(63)
+  [5]=>
+  int(209)
+  [6]=>
+  int(229)
+  [7]=>
+  int(506)
+  [8]=>
+  int(669)
+}
+
+-- Testing sort() by supplying octal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(9) {
+  [0]=>
+  int(-229)
+  [1]=>
+  int(-54)
+  [2]=>
+  int(0)
+  [3]=>
+  int(54)
+  [4]=>
+  int(63)
+  [5]=>
+  int(209)
+  [6]=>
+  int(229)
+  [7]=>
+  int(506)
+  [8]=>
+  int(669)
+}
+
+-- Testing sort() by supplying octal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(9) {
+  [0]=>
+  int(-229)
+  [1]=>
+  int(-54)
+  [2]=>
+  int(0)
+  [3]=>
+  int(54)
+  [4]=>
+  int(63)
+  [5]=>
+  int(209)
+  [6]=>
+  int(229)
+  [7]=>
+  int(506)
+  [8]=>
+  int(669)
+}
+Done
diff --git a/tests/std/array/sort_variation11.phpt b/tests/std/array/sort_variation11.phpt
new file mode 100644
index 00000000..909a5546
--- /dev/null
+++ b/tests/std/array/sort_variation11.phpt
@@ -0,0 +1,185 @@
+--TEST--
+Test sort() function : usage variations - sort mixed values, 'sort_flag' as default/SORT_REGULAR (OK to fail as result is unpredectable)
+--FILE--
+<?php
+/*
+ * testing sort() by providing mixed value array for $array argument with following flag values.
+ * flag value as default
+ * SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing sort() : usage variations ***\n";
+
+// mixed value array
+$mixed_values = array (
+  array(),
+  array(array(33, -5, 6), array(11), array(22, -55), array() ),
+  -4, "4", 4.00, "b", "5", -2, -2.0, -2.98989, "-.9", "True", "",
+  NULL, "ab", "abcd", 0.0, -0, "abcd\x00abcd\x00abcd", '', true, false
+);
+
+echo "\n-- Testing sort() by supplying mixed value array, 'flag' value is default --\n";
+$temp_array = $mixed_values;
+var_dump(sort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing sort() by supplying mixed value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $mixed_values;
+var_dump(sort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing sort() : usage variations ***
+
+-- Testing sort() by supplying mixed value array, 'flag' value is default --
+bool(true)
+array(22) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  NULL
+  [2]=>
+  string(0) ""
+  [3]=>
+  float(0)
+  [4]=>
+  bool(false)
+  [5]=>
+  int(-4)
+  [6]=>
+  float(-2.98989)
+  [7]=>
+  int(-2)
+  [8]=>
+  float(-2)
+  [9]=>
+  string(3) "-.9"
+  [10]=>
+  int(0)
+  [11]=>
+  string(1) "4"
+  [12]=>
+  float(4)
+  [13]=>
+  string(1) "5"
+  [14]=>
+  string(4) "True"
+  [15]=>
+  string(2) "ab"
+  [16]=>
+  string(4) "abcd"
+  [17]=>
+  string(14) "abcd%0abcd%0abcd"
+  [18]=>
+  string(1) "b"
+  [19]=>
+  array(0) {
+  }
+  [20]=>
+  array(4) {
+    [0]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    [1]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    [2]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    [3]=>
+    array(0) {
+    }
+  }
+  [21]=>
+  bool(true)
+}
+
+-- Testing sort() by supplying mixed value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(22) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  NULL
+  [2]=>
+  string(0) ""
+  [3]=>
+  float(0)
+  [4]=>
+  bool(false)
+  [5]=>
+  int(-4)
+  [6]=>
+  float(-2.98989)
+  [7]=>
+  int(-2)
+  [8]=>
+  float(-2)
+  [9]=>
+  string(3) "-.9"
+  [10]=>
+  int(0)
+  [11]=>
+  string(1) "4"
+  [12]=>
+  float(4)
+  [13]=>
+  string(1) "5"
+  [14]=>
+  string(4) "True"
+  [15]=>
+  string(2) "ab"
+  [16]=>
+  string(4) "abcd"
+  [17]=>
+  string(14) "abcd%0abcd%0abcd"
+  [18]=>
+  string(1) "b"
+  [19]=>
+  array(0) {
+  }
+  [20]=>
+  array(4) {
+    [0]=>
+    array(3) {
+      [0]=>
+      int(33)
+      [1]=>
+      int(-5)
+      [2]=>
+      int(6)
+    }
+    [1]=>
+    array(1) {
+      [0]=>
+      int(11)
+    }
+    [2]=>
+    array(2) {
+      [0]=>
+      int(22)
+      [1]=>
+      int(-55)
+    }
+    [3]=>
+    array(0) {
+    }
+  }
+  [21]=>
+  bool(true)
+}
+Done
diff --git a/tests/std/array/sort_variation3.phpt b/tests/std/array/sort_variation3.phpt
new file mode 100644
index 00000000..194d2b9f
--- /dev/null
+++ b/tests/std/array/sort_variation3.phpt
@@ -0,0 +1,322 @@
+--TEST--
+Test sort() function : usage variations - sort integer/float values
+--FILE--
+<?php
+/*
+ * Testing sort() by providing different integer/float value arrays for $array argument
+ * with following flag values
+ * 1. flag  value as default
+ * 2. SORT_REGULAR - compare items normally
+ * 3. SORT_NUMERIC - compare items numerically
+ * 4. SORT_STRING - compare items as strings
+*/
+
+echo "*** Testing sort() : usage variations ***\n";
+
+// group of various arrays
+$various_arrays = array (
+  // negative/posative integers array
+  array(11, -11, 21, -21, 31, -31, 0, 41, -41),
+
+  // float value array
+  array(10.5, -10.5, 10.5e2, 10.6E-2, .5, .01, -.1),
+
+  // mixed value array
+  array(.0001, .0021, -.01, -1, 0, .09, 2, -.9, 10.6E-2, -10.6E-2, 33),
+
+  // array values contains minimum and maximum ranges
+  array(2147483647, 2147483648, -2147483647, -2147483648, -0, 0, -2147483649)
+);
+
+// set of possible flag values
+$flag_value = array("SORT_REGULAR" => SORT_REGULAR, "SORT_NUMERIC" => SORT_NUMERIC);
+
+$count = 1;
+echo "\n-- Testing sort() by supplying various integer/float arrays --\n";
+
+// loop through to test sort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With Default sort flag -\n";
+  $temp_array = $array;
+  var_dump(sort($temp_array) );
+  var_dump($temp_array);
+
+  // loop through $flag_value array and setting all possible flag values
+  foreach($flag_value as $key => $flag){
+    echo "- Sort flag = $key -\n";
+    $temp_array = $array;
+    var_dump(sort($temp_array, $flag) );
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECTF--
+*** Testing sort() : usage variations ***
+
+-- Testing sort() by supplying various integer/float arrays --
+
+-- Iteration 1 --
+- With Default sort flag -
+bool(true)
+array(9) {
+  [0]=>
+  int(-41)
+  [1]=>
+  int(-31)
+  [2]=>
+  int(-21)
+  [3]=>
+  int(-11)
+  [4]=>
+  int(0)
+  [5]=>
+  int(11)
+  [6]=>
+  int(21)
+  [7]=>
+  int(31)
+  [8]=>
+  int(41)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(9) {
+  [0]=>
+  int(-41)
+  [1]=>
+  int(-31)
+  [2]=>
+  int(-21)
+  [3]=>
+  int(-11)
+  [4]=>
+  int(0)
+  [5]=>
+  int(11)
+  [6]=>
+  int(21)
+  [7]=>
+  int(31)
+  [8]=>
+  int(41)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(9) {
+  [0]=>
+  int(-41)
+  [1]=>
+  int(-31)
+  [2]=>
+  int(-21)
+  [3]=>
+  int(-11)
+  [4]=>
+  int(0)
+  [5]=>
+  int(11)
+  [6]=>
+  int(21)
+  [7]=>
+  int(31)
+  [8]=>
+  int(41)
+}
+
+-- Iteration 2 --
+- With Default sort flag -
+bool(true)
+array(7) {
+  [0]=>
+  float(-10.5)
+  [1]=>
+  float(-0.1)
+  [2]=>
+  float(0.01)
+  [3]=>
+  float(0.106)
+  [4]=>
+  float(0.5)
+  [5]=>
+  float(10.5)
+  [6]=>
+  float(1050)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(7) {
+  [0]=>
+  float(-10.5)
+  [1]=>
+  float(-0.1)
+  [2]=>
+  float(0.01)
+  [3]=>
+  float(0.106)
+  [4]=>
+  float(0.5)
+  [5]=>
+  float(10.5)
+  [6]=>
+  float(1050)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(7) {
+  [0]=>
+  float(-10.5)
+  [1]=>
+  float(-0.1)
+  [2]=>
+  float(0.01)
+  [3]=>
+  float(0.106)
+  [4]=>
+  float(0.5)
+  [5]=>
+  float(10.5)
+  [6]=>
+  float(1050)
+}
+
+-- Iteration 3 --
+- With Default sort flag -
+bool(true)
+array(11) {
+  [0]=>
+  int(-1)
+  [1]=>
+  float(-0.9)
+  [2]=>
+  float(-0.106)
+  [3]=>
+  float(-0.01)
+  [4]=>
+  int(0)
+  [5]=>
+  float(0.0001)
+  [6]=>
+  float(0.0021)
+  [7]=>
+  float(0.09)
+  [8]=>
+  float(0.106)
+  [9]=>
+  int(2)
+  [10]=>
+  int(33)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(11) {
+  [0]=>
+  int(-1)
+  [1]=>
+  float(-0.9)
+  [2]=>
+  float(-0.106)
+  [3]=>
+  float(-0.01)
+  [4]=>
+  int(0)
+  [5]=>
+  float(0.0001)
+  [6]=>
+  float(0.0021)
+  [7]=>
+  float(0.09)
+  [8]=>
+  float(0.106)
+  [9]=>
+  int(2)
+  [10]=>
+  int(33)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(11) {
+  [0]=>
+  int(-1)
+  [1]=>
+  float(-0.9)
+  [2]=>
+  float(-0.106)
+  [3]=>
+  float(-0.01)
+  [4]=>
+  int(0)
+  [5]=>
+  float(0.0001)
+  [6]=>
+  float(0.0021)
+  [7]=>
+  float(0.09)
+  [8]=>
+  float(0.106)
+  [9]=>
+  int(2)
+  [10]=>
+  int(33)
+}
+
+-- Iteration 4 --
+- With Default sort flag -
+bool(true)
+array(7) {
+  [0]=>
+  %s(-2147483649)
+  [1]=>
+  %s(-2147483648)
+  [2]=>
+  int(-2147483647)
+  [3]=>
+  int(0)
+  [4]=>
+  int(0)
+  [5]=>
+  int(2147483647)
+  [6]=>
+  %s(2147483648)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(7) {
+  [0]=>
+  %s(-2147483649)
+  [1]=>
+  %s(-2147483648)
+  [2]=>
+  int(-2147483647)
+  [3]=>
+  int(0)
+  [4]=>
+  int(0)
+  [5]=>
+  int(2147483647)
+  [6]=>
+  %s(2147483648)
+}
+- Sort flag = SORT_NUMERIC -
+bool(true)
+array(7) {
+  [0]=>
+  %s(-2147483649)
+  [1]=>
+  %s(-2147483648)
+  [2]=>
+  int(-2147483647)
+  [3]=>
+  int(0)
+  [4]=>
+  int(0)
+  [5]=>
+  int(2147483647)
+  [6]=>
+  %s(2147483648)
+}
+Done
diff --git a/tests/std/array/sort_variation4.phpt b/tests/std/array/sort_variation4.phpt
new file mode 100644
index 00000000..9a355065
--- /dev/null
+++ b/tests/std/array/sort_variation4.phpt
@@ -0,0 +1,78 @@
+--TEST--
+Test sort() function : usage variations - sort reference values
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference assignment in this context");
+?>
+
+--FILE--
+<?php
+/*
+ * Testing sort() by providing reference variable array with following flag values
+ *  flag value as default
+ *  SORT_REGULAR - compare items normally
+ *  SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing sort() :usage variations  ***\n";
+
+$value1 = 100;
+$value2 = 33;
+$value3 = 555;
+
+// an array containing integer references
+$unsorted_numerics =  array( &$value1 , &$value2, &$value3);
+
+echo "\n-- Testing sort() by supplying reference variable array, 'flag' value is default --\n";
+$temp_array = $unsorted_numerics;
+var_dump( sort($temp_array) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying reference variable array, 'flag' = SORT_REGULAR --\n";
+$temp_array = &$unsorted_numerics;
+var_dump( sort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "\n-- Testing sort() by supplying reference variable array, 'flag' = SORT_NUMERIC --\n";
+$temp_array = &$unsorted_numerics;
+var_dump( sort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump( $temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing sort() :usage variations  ***
+
+-- Testing sort() by supplying reference variable array, 'flag' value is default --
+bool(true)
+array(3) {
+  [0]=>
+  &int(33)
+  [1]=>
+  &int(100)
+  [2]=>
+  &int(555)
+}
+
+-- Testing sort() by supplying reference variable array, 'flag' = SORT_REGULAR --
+bool(true)
+array(3) {
+  [0]=>
+  &int(33)
+  [1]=>
+  &int(100)
+  [2]=>
+  &int(555)
+}
+
+-- Testing sort() by supplying reference variable array, 'flag' = SORT_NUMERIC --
+bool(true)
+array(3) {
+  [0]=>
+  &int(33)
+  [1]=>
+  &int(100)
+  [2]=>
+  &int(555)
+}
+Done
diff --git a/tests/std/array/sort_variation5.phpt b/tests/std/array/sort_variation5.phpt
new file mode 100644
index 00000000..6c49342d
--- /dev/null
+++ b/tests/std/array/sort_variation5.phpt
@@ -0,0 +1,227 @@
+--TEST--
+Test sort() function : usage variations - sort strings
+--FILE--
+<?php
+/*
+ * testing sort() by providing different string arrays for $array argument with following flag values
+ *  flag  value as default
+ *  SORT_REGULAR - compare items normally
+ *  SORT_STRING  - compare items as strings
+*/
+
+echo "*** Testing sort() : usage variations ***\n";
+
+$various_arrays = array (
+  // group of escape sequences
+  array(null, NULL, "\a", "\cx", "\e", "\f", "\n", "\r", "\t", "\xhh", "\ddd", "\v"),
+
+  // array contains combination of capital/small letters
+  array("lemoN", "Orange", "banana", "apple", "Test", "TTTT", "ttt", "ww", "x", "X", "oraNGe", "BANANA")
+);
+
+$flags = array("SORT_REGULAR" => SORT_REGULAR, "SORT_STRING" => SORT_STRING);
+
+$count = 1;
+echo "\n-- Testing sort() by supplying various string arrays --\n";
+
+// loop through to test sort() with different arrays
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With Default sort flag -\n";
+  $temp_array = $array;
+  var_dump(sort($temp_array) ); // expecting : bool(true)
+  var_dump($temp_array);
+
+  // loop through $flags array and setting all possible flag values
+  foreach($flags as $key => $flag){
+    echo "- Sort flag = $key -\n";
+    $temp_array = $array;
+    var_dump(sort($temp_array, $flag) ); // expecting : bool(true)
+    var_dump($temp_array);
+  }
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing sort() : usage variations ***
+
+-- Testing sort() by supplying various string arrays --
+
+-- Iteration 1 --
+- With Default sort flag -
+bool(true)
+array(12) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  string(1) "	"
+  [3]=>
+  string(1) "
+"
+  [4]=>
+  string(1) ""
+  [5]=>
+  string(1) ""
+  [6]=>
+  string(1) "
"
+  [7]=>
+  string(1) ""
+  [8]=>
+  string(2) "\a"
+  [9]=>
+  string(3) "\cx"
+  [10]=>
+  string(4) "\ddd"
+  [11]=>
+  string(4) "\xhh"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(12) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  string(1) "	"
+  [3]=>
+  string(1) "
+"
+  [4]=>
+  string(1) ""
+  [5]=>
+  string(1) ""
+  [6]=>
+  string(1) "
"
+  [7]=>
+  string(1) ""
+  [8]=>
+  string(2) "\a"
+  [9]=>
+  string(3) "\cx"
+  [10]=>
+  string(4) "\ddd"
+  [11]=>
+  string(4) "\xhh"
+}
+- Sort flag = SORT_STRING -
+bool(true)
+array(12) {
+  [0]=>
+  NULL
+  [1]=>
+  NULL
+  [2]=>
+  string(1) "	"
+  [3]=>
+  string(1) "
+"
+  [4]=>
+  string(1) ""
+  [5]=>
+  string(1) ""
+  [6]=>
+  string(1) "
"
+  [7]=>
+  string(1) ""
+  [8]=>
+  string(2) "\a"
+  [9]=>
+  string(3) "\cx"
+  [10]=>
+  string(4) "\ddd"
+  [11]=>
+  string(4) "\xhh"
+}
+
+-- Iteration 2 --
+- With Default sort flag -
+bool(true)
+array(12) {
+  [0]=>
+  string(6) "BANANA"
+  [1]=>
+  string(6) "Orange"
+  [2]=>
+  string(4) "TTTT"
+  [3]=>
+  string(4) "Test"
+  [4]=>
+  string(1) "X"
+  [5]=>
+  string(5) "apple"
+  [6]=>
+  string(6) "banana"
+  [7]=>
+  string(5) "lemoN"
+  [8]=>
+  string(6) "oraNGe"
+  [9]=>
+  string(3) "ttt"
+  [10]=>
+  string(2) "ww"
+  [11]=>
+  string(1) "x"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(12) {
+  [0]=>
+  string(6) "BANANA"
+  [1]=>
+  string(6) "Orange"
+  [2]=>
+  string(4) "TTTT"
+  [3]=>
+  string(4) "Test"
+  [4]=>
+  string(1) "X"
+  [5]=>
+  string(5) "apple"
+  [6]=>
+  string(6) "banana"
+  [7]=>
+  string(5) "lemoN"
+  [8]=>
+  string(6) "oraNGe"
+  [9]=>
+  string(3) "ttt"
+  [10]=>
+  string(2) "ww"
+  [11]=>
+  string(1) "x"
+}
+- Sort flag = SORT_STRING -
+bool(true)
+array(12) {
+  [0]=>
+  string(6) "BANANA"
+  [1]=>
+  string(6) "Orange"
+  [2]=>
+  string(4) "TTTT"
+  [3]=>
+  string(4) "Test"
+  [4]=>
+  string(1) "X"
+  [5]=>
+  string(5) "apple"
+  [6]=>
+  string(6) "banana"
+  [7]=>
+  string(5) "lemoN"
+  [8]=>
+  string(6) "oraNGe"
+  [9]=>
+  string(3) "ttt"
+  [10]=>
+  string(2) "ww"
+  [11]=>
+  string(1) "x"
+}
+Done
diff --git a/tests/std/array/sort_variation6.phpt b/tests/std/array/sort_variation6.phpt
new file mode 100644
index 00000000..fcde3b3d
--- /dev/null
+++ b/tests/std/array/sort_variation6.phpt
@@ -0,0 +1,117 @@
+--TEST--
+Test sort() function : usage variations - sort hexadecimal values
+--FILE--
+<?php
+/*
+ * testing sort() by providing different hexa-decimal array for $array argument with following flag values
+ * flag  value as default
+ * SORT_REGULAR - compare items normally
+ * SORT_NUMERIC - compare items numerically
+*/
+
+echo "*** Testing sort() : usage variations ***\n";
+
+// an array contains unsorted hexadecimal values
+$unsorted_hex_array = array(0x1AB, 0xFFF, 0xF, 0xFF, 0x2AA, 0xBB, 0x1ab, 0xff, -0xFF, 0, -0x2aa);
+
+echo "\n-- Testing sort() by supplying hexadecimal value array, 'flag' value is default  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(sort($temp_array) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing sort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(sort($temp_array, SORT_REGULAR) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "\n-- Testing sort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $unsorted_hex_array;
+var_dump(sort($temp_array, SORT_NUMERIC) ); // expecting : bool(true)
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing sort() : usage variations ***
+
+-- Testing sort() by supplying hexadecimal value array, 'flag' value is default  --
+bool(true)
+array(11) {
+  [0]=>
+  int(-682)
+  [1]=>
+  int(-255)
+  [2]=>
+  int(0)
+  [3]=>
+  int(15)
+  [4]=>
+  int(187)
+  [5]=>
+  int(255)
+  [6]=>
+  int(255)
+  [7]=>
+  int(427)
+  [8]=>
+  int(427)
+  [9]=>
+  int(682)
+  [10]=>
+  int(4095)
+}
+
+-- Testing sort() by supplying hexadecimal value array, 'flag' value is SORT_REGULAR  --
+bool(true)
+array(11) {
+  [0]=>
+  int(-682)
+  [1]=>
+  int(-255)
+  [2]=>
+  int(0)
+  [3]=>
+  int(15)
+  [4]=>
+  int(187)
+  [5]=>
+  int(255)
+  [6]=>
+  int(255)
+  [7]=>
+  int(427)
+  [8]=>
+  int(427)
+  [9]=>
+  int(682)
+  [10]=>
+  int(4095)
+}
+
+-- Testing sort() by supplying hexadecimal value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(11) {
+  [0]=>
+  int(-682)
+  [1]=>
+  int(-255)
+  [2]=>
+  int(0)
+  [3]=>
+  int(15)
+  [4]=>
+  int(187)
+  [5]=>
+  int(255)
+  [6]=>
+  int(255)
+  [7]=>
+  int(427)
+  [8]=>
+  int(427)
+  [9]=>
+  int(682)
+  [10]=>
+  int(4095)
+}
+Done
diff --git a/tests/std/array/sort_variation7.phpt b/tests/std/array/sort_variation7.phpt
new file mode 100644
index 00000000..75d2dd16
--- /dev/null
+++ b/tests/std/array/sort_variation7.phpt
@@ -0,0 +1,92 @@
+--TEST--
+Test sort() function : usage variations - sort boolean values
+--FILE--
+<?php
+/*
+ * testing sort() by providing bool value array for $array argument with following flag values.
+ * flag  value as default
+ * SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing sort() : usage variations ***\n";
+
+// bool value array
+$bool_values = array (true, false, TRUE, FALSE);
+
+echo "\n-- Testing sort() by supplying bool value array, 'flag' value is default --\n";
+$temp_array = $bool_values;
+var_dump(sort($temp_array) );
+var_dump($temp_array);
+
+echo "\n-- Testing sort() by supplying bool value array, 'flag' value is SORT_REGULAR --\n";
+$temp_array = $bool_values;
+var_dump(sort($temp_array, SORT_REGULAR) );
+var_dump($temp_array);
+
+echo "\n-- Testing sort() by supplying bool value array, 'flag' value is SORT_NUMERIC  --\n";
+$temp_array = $bool_values;
+var_dump(sort($temp_array, SORT_NUMERIC) );
+var_dump($temp_array);
+
+echo "\n-- Testing sort() by supplying bool value array, 'flag' value is SORT_STRING --\n";
+$temp_array = $bool_values;
+var_dump(sort($temp_array, SORT_STRING) );
+var_dump($temp_array);
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing sort() : usage variations ***
+
+-- Testing sort() by supplying bool value array, 'flag' value is default --
+bool(true)
+array(4) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+
+-- Testing sort() by supplying bool value array, 'flag' value is SORT_REGULAR --
+bool(true)
+array(4) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+
+-- Testing sort() by supplying bool value array, 'flag' value is SORT_NUMERIC  --
+bool(true)
+array(4) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+
+-- Testing sort() by supplying bool value array, 'flag' value is SORT_STRING --
+bool(true)
+array(4) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(false)
+  [2]=>
+  bool(true)
+  [3]=>
+  bool(true)
+}
+Done
diff --git a/tests/std/array/sort_variation8.phpt b/tests/std/array/sort_variation8.phpt
new file mode 100644
index 00000000..562766e7
--- /dev/null
+++ b/tests/std/array/sort_variation8.phpt
@@ -0,0 +1,172 @@
+--TEST--
+Test sort() function : usage variations - sort array with diff. sub arrays, 'sort_flags' as default/SORT_REGULAR
+--FILE--
+<?php
+/*
+ * testing sort() by providing arrays contains sub arrays for $array argument with flowing flag values
+ * flag value as default
+ * SORT_REGULAR - compare items normally
+*/
+
+echo "*** Testing sort() : usage variations ***\n";
+
+// array of arrays
+$various_arrays = array (
+  // null array
+  array(),
+
+  // array contains null sub array
+  array( array() ),
+
+  // array of arrays along with some values
+  array(44, 11, array(64, 61) ),
+
+  // array containing sub arrays
+  array(array(33, -5, 6), array(11), array(22, -55), array() )
+);
+
+
+$count = 1;
+echo "\n-- Testing sort() by supplying various arrays containing sub arrays --\n";
+
+// loop through to test sort() with different arrays
+foreach ($various_arrays as $array) {
+
+  echo "\n-- Iteration $count --\n";
+  // testing sort() function by supplying different arrays, flag value is default
+  echo "- With Default sort flag -\n";
+  $temp_array = $array;
+  var_dump(sort($temp_array) );
+  var_dump($temp_array);
+
+  // testing sort() function by supplying different arrays, flag value = SORT_REGULAR
+  echo "- Sort flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump(sort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing sort() : usage variations ***
+
+-- Testing sort() by supplying various arrays containing sub arrays --
+
+-- Iteration 1 --
+- With Default sort flag -
+bool(true)
+array(0) {
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(0) {
+}
+
+-- Iteration 2 --
+- With Default sort flag -
+bool(true)
+array(1) {
+  [0]=>
+  array(0) {
+  }
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(1) {
+  [0]=>
+  array(0) {
+  }
+}
+
+-- Iteration 3 --
+- With Default sort flag -
+bool(true)
+array(3) {
+  [0]=>
+  int(11)
+  [1]=>
+  int(44)
+  [2]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  [0]=>
+  int(11)
+  [1]=>
+  int(44)
+  [2]=>
+  array(2) {
+    [0]=>
+    int(64)
+    [1]=>
+    int(61)
+  }
+}
+
+-- Iteration 4 --
+- With Default sort flag -
+bool(true)
+array(4) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  [3]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(11)
+  }
+  [2]=>
+  array(2) {
+    [0]=>
+    int(22)
+    [1]=>
+    int(-55)
+  }
+  [3]=>
+  array(3) {
+    [0]=>
+    int(33)
+    [1]=>
+    int(-5)
+    [2]=>
+    int(6)
+  }
+}
+Done
diff --git a/tests/std/array/sort_variation9.phpt b/tests/std/array/sort_variation9.phpt
new file mode 100644
index 00000000..7791a81c
--- /dev/null
+++ b/tests/std/array/sort_variation9.phpt
@@ -0,0 +1,253 @@
+--TEST--
+Test sort() function : usage variations - sort diff. associative arrays, 'sort_flags' as default/SORT_REGULAR
+--FILE--
+<?php
+/*
+ * Testing sort() by providing arrays  with key values for $array argument
+ * with following flag values.
+ * 1.flag value as default
+ * 2.SORT_REGULAR - compare items normally
+ * To test the new keys for the elements in the sorted array.
+ */
+
+echo "*** Testing sort() : usage variations ***\n";
+
+// list of arrays with key and values
+$various_arrays = array(
+  array(5 => 55, 6 => 66, 2 => 22, 3 => 33, 1 => 11),
+  array ("fruits"  => array("a" => "orange", "b" => "banana", "c" => "apple"),
+         "numbers" => array(1, 2, 3, 4, 5, 6),
+         "holes"   => array("first", 5 => "second", "third")
+        ),
+  array(1, 1, 8 => 1,  4 => 1, 19, 3 => 13),
+  array('bar' => 'baz', "foo" => 1),
+  array('a' => 1,'b' => array('e' => 2,'f' => 3),'c' => array('g' => 4),'d' => 5),
+);
+
+$count = 1;
+echo "\n-- Testing sort() by supplying various arrays with key values --\n";
+
+// loop through to test sort() with different arrays,
+// to test the new keys for the elements in the sorted array
+foreach ($various_arrays as $array) {
+  echo "\n-- Iteration $count --\n";
+
+  echo "- With Default sort flag -\n";
+  $temp_array = $array;
+  var_dump(sort($temp_array) );
+  var_dump($temp_array);
+
+  echo "- Sort flag = SORT_REGULAR -\n";
+  $temp_array = $array;
+  var_dump(sort($temp_array, SORT_REGULAR) );
+  var_dump($temp_array);
+  $count++;
+}
+
+echo "Done\n";
+?>
+--EXPECT--
+*** Testing sort() : usage variations ***
+
+-- Testing sort() by supplying various arrays with key values --
+
+-- Iteration 1 --
+- With Default sort flag -
+bool(true)
+array(5) {
+  [0]=>
+  int(11)
+  [1]=>
+  int(22)
+  [2]=>
+  int(33)
+  [3]=>
+  int(55)
+  [4]=>
+  int(66)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(5) {
+  [0]=>
+  int(11)
+  [1]=>
+  int(22)
+  [2]=>
+  int(33)
+  [3]=>
+  int(55)
+  [4]=>
+  int(66)
+}
+
+-- Iteration 2 --
+- With Default sort flag -
+bool(true)
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(5) "first"
+    [5]=>
+    string(6) "second"
+    [6]=>
+    string(5) "third"
+  }
+  [1]=>
+  array(3) {
+    ["a"]=>
+    string(6) "orange"
+    ["b"]=>
+    string(6) "banana"
+    ["c"]=>
+    string(5) "apple"
+  }
+  [2]=>
+  array(6) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(3) {
+  [0]=>
+  array(3) {
+    [0]=>
+    string(5) "first"
+    [5]=>
+    string(6) "second"
+    [6]=>
+    string(5) "third"
+  }
+  [1]=>
+  array(3) {
+    ["a"]=>
+    string(6) "orange"
+    ["b"]=>
+    string(6) "banana"
+    ["c"]=>
+    string(5) "apple"
+  }
+  [2]=>
+  array(6) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(2)
+    [2]=>
+    int(3)
+    [3]=>
+    int(4)
+    [4]=>
+    int(5)
+    [5]=>
+    int(6)
+  }
+}
+
+-- Iteration 3 --
+- With Default sort flag -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [2]=>
+  int(1)
+  [3]=>
+  int(1)
+  [4]=>
+  int(13)
+  [5]=>
+  int(19)
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [2]=>
+  int(1)
+  [3]=>
+  int(1)
+  [4]=>
+  int(13)
+  [5]=>
+  int(19)
+}
+
+-- Iteration 4 --
+- With Default sort flag -
+bool(true)
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "baz"
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "baz"
+}
+
+-- Iteration 5 --
+- With Default sort flag -
+bool(true)
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(5)
+  [2]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  [3]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+}
+- Sort flag = SORT_REGULAR -
+bool(true)
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(5)
+  [2]=>
+  array(1) {
+    ["g"]=>
+    int(4)
+  }
+  [3]=>
+  array(2) {
+    ["e"]=>
+    int(2)
+    ["f"]=>
+    int(3)
+  }
+}
+Done
diff --git a/tests/std/array/uasort_basic1.phpt b/tests/std/array/uasort_basic1.phpt
new file mode 100644
index 00000000..9ff9d33d
--- /dev/null
+++ b/tests/std/array/uasort_basic1.phpt
@@ -0,0 +1,106 @@
+--TEST--
+Test uasort() function : basic functionality
+--FILE--
+<?php
+// comparison function
+function cmp($value1, $value2)
+{
+  if($value1 == $value2) {
+    return 0;
+  }
+  else if($value1 > $value2) {
+    return 1;
+  }
+  else
+    return -1;
+}
+
+function main() {
+echo "*** Testing uasort() : basic functionality ***\n";
+
+// Int array with default keys
+$int_values = array(1, 8, 9, 3, 2, 6, 7);
+echo "-- Numeric array with default keys --\n";
+var_dump( uasort($int_values, 'cmp') );
+var_dump($int_values);
+
+// String array with default keys
+$string_values = array("This", "is", 'a', "test");
+echo "-- String array with default keys --\n";
+var_dump( uasort($string_values, 'cmp') );
+var_dump($string_values);
+
+// Associative array with numeric keys
+$numeric_key_arg = array(1=> 1, 2 => 2, 3 => 7, 5 => 4, 4 => 9);
+echo "-- Associative array with numeric keys --\n";
+var_dump( uasort($numeric_key_arg, 'cmp') );
+var_dump($numeric_key_arg);
+
+// Associative array with string keys
+$string_key_arg = array('one' => 4, 'two' => 2, 'three' => 1, 'four' => 10);
+echo "-- Associative array with string keys --\n";
+var_dump( uasort($string_key_arg, 'cmp') );
+var_dump($string_key_arg);
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing uasort() : basic functionality ***
+-- Numeric array with default keys --
+bool(true)
+array(7) {
+  [0]=>
+  int(1)
+  [4]=>
+  int(2)
+  [3]=>
+  int(3)
+  [5]=>
+  int(6)
+  [6]=>
+  int(7)
+  [1]=>
+  int(8)
+  [2]=>
+  int(9)
+}
+-- String array with default keys --
+bool(true)
+array(4) {
+  [0]=>
+  string(4) "This"
+  [2]=>
+  string(1) "a"
+  [1]=>
+  string(2) "is"
+  [3]=>
+  string(4) "test"
+}
+-- Associative array with numeric keys --
+bool(true)
+array(5) {
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [5]=>
+  int(4)
+  [3]=>
+  int(7)
+  [4]=>
+  int(9)
+}
+-- Associative array with string keys --
+bool(true)
+array(4) {
+  ["three"]=>
+  int(1)
+  ["two"]=>
+  int(2)
+  ["one"]=>
+  int(4)
+  ["four"]=>
+  int(10)
+}
+Done
diff --git a/tests/std/array/uasort_basic2.phpt b/tests/std/array/uasort_basic2.phpt
new file mode 100644
index 00000000..49708b30
--- /dev/null
+++ b/tests/std/array/uasort_basic2.phpt
@@ -0,0 +1,92 @@
+--TEST--
+Test uasort() function : basic functionality - duplicate values
+--FILE--
+<?php
+// comparison function
+function cmp($value1, $value2)
+{
+  if($value1 == $value2) {
+    return 0;
+  }
+  else if($value1 > $value2) {
+    return 1;
+  }
+  else
+    return -1;
+}
+
+function main() {
+echo "*** Testing uasort() : basic functionality with duplicate values ***\n";
+
+// increasing values
+$int_values1 = array(1, 1, 2, 2, 3, 3);
+echo "-- Numeric array with increasing values --\n";
+var_dump( uasort($int_values1, 'cmp') );
+var_dump($int_values1);
+
+// decreasing values
+$int_values2 = array(3, 3, 2, 2, 1, 1);
+echo "-- Numeric array with decreasing values --\n";
+var_dump( uasort($int_values2, 'cmp') );
+var_dump($int_values2);
+
+// increasing and decreasing values
+$int_values3 = array(1, 2, 3, 3, 2, 1);
+echo "-- Numeric array with increasing and decreasing values --\n";
+var_dump( uasort($int_values3, 'cmp') );
+var_dump($int_values3);
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing uasort() : basic functionality with duplicate values ***
+-- Numeric array with increasing values --
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(2)
+  [4]=>
+  int(3)
+  [5]=>
+  int(3)
+}
+-- Numeric array with decreasing values --
+bool(true)
+array(6) {
+  [4]=>
+  int(1)
+  [5]=>
+  int(1)
+  [2]=>
+  int(2)
+  [3]=>
+  int(2)
+  [0]=>
+  int(3)
+  [1]=>
+  int(3)
+}
+-- Numeric array with increasing and decreasing values --
+bool(true)
+array(6) {
+  [0]=>
+  int(1)
+  [5]=>
+  int(1)
+  [1]=>
+  int(2)
+  [4]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(3)
+}
+Done
diff --git a/tests/std/array/uasort_object1.phpt b/tests/std/array/uasort_object1.phpt
new file mode 100644
index 00000000..972418fd
--- /dev/null
+++ b/tests/std/array/uasort_object1.phpt
@@ -0,0 +1,140 @@
+--TEST--
+Test uasort() function : object functionality
+--FILE--
+<?php
+/*
+ * Testing uasort() function with the array of objects
+ * array of objects which has only one member variable & more than one member variables
+ */
+
+// comparison function
+function simple_cmp($value1, $value2)
+{
+  if($value1 == $value2) {
+    return 0;
+  }
+  else if($value1 > $value2) {
+    return 1;
+  }
+  else
+    return -1;
+}
+
+// comparison function for SimpleClass2 objects which has more than one members
+function multiple_cmp($value1, $value2)
+{
+  if($value1->getValue() == $value2->getValue())
+    return 0;
+  else if($value1->getValue() > $value2->getValue())
+    return 1;
+  else
+    return -1;
+}
+
+// Simple class with single member variable
+class SimpleClass1
+{
+  private $int_value;
+
+  public function __construct($value) {
+    $this->int_value = $value;
+  }
+}
+
+// Simple class with more than one member variables
+class SimpleClass2
+{
+  private $int_value;
+  protected $float_value;
+  public $string_value;
+  public function __construct($int, $float, $str) {
+    $this->int_value = $int;
+    $this->float_value = $float;
+    $this->string_value = $str;
+  }
+  public function getValue() {
+    return $this->int_value;
+  }
+}
+
+function main() {
+echo "*** Testing uasort() : object functionality ***\n";
+
+// array of SimpleClass objects with only one member
+$array_arg = array(
+  0 => new SimpleClass1(10),
+  1 => new SimpleClass1(1),
+  2 => new SimpleClass1(100),
+  3 => new SimpleClass1(50)
+);
+var_dump( uasort($array_arg, 'simple_cmp') );
+var_dump($array_arg);
+
+// array of SimpleClass objects having more than one members
+$array_arg = array(
+  0 => new SimpleClass2(2, 3.4, "mango"),
+  1 => new SimpleClass2(10, 1.2, "apple"),
+  2 => new SimpleClass2(5, 2.5, "orange"),
+);
+var_dump( uasort($array_arg, 'multiple_cmp') );
+var_dump($array_arg);
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing uasort() : object functionality ***
+bool(true)
+array(4) {
+  [1]=>
+  object(SimpleClass1)#2 (1) {
+    ["int_value":"SimpleClass1":private]=>
+    int(1)
+  }
+  [0]=>
+  object(SimpleClass1)#1 (1) {
+    ["int_value":"SimpleClass1":private]=>
+    int(10)
+  }
+  [3]=>
+  object(SimpleClass1)#4 (1) {
+    ["int_value":"SimpleClass1":private]=>
+    int(50)
+  }
+  [2]=>
+  object(SimpleClass1)#3 (1) {
+    ["int_value":"SimpleClass1":private]=>
+    int(100)
+  }
+}
+bool(true)
+array(3) {
+  [0]=>
+  object(SimpleClass2)#5 (3) {
+    ["int_value":"SimpleClass2":private]=>
+    int(2)
+    ["float_value":protected]=>
+    float(3.4)
+    ["string_value"]=>
+    string(5) "mango"
+  }
+  [2]=>
+  object(SimpleClass2)#7 (3) {
+    ["int_value":"SimpleClass2":private]=>
+    int(5)
+    ["float_value":protected]=>
+    float(2.5)
+    ["string_value"]=>
+    string(6) "orange"
+  }
+  [1]=>
+  object(SimpleClass2)#6 (3) {
+    ["int_value":"SimpleClass2":private]=>
+    int(10)
+    ["float_value":protected]=>
+    float(1.2)
+    ["string_value"]=>
+    string(5) "apple"
+  }
+}
+Done
diff --git a/tests/std/array/uasort_object2.phpt b/tests/std/array/uasort_object2.phpt
new file mode 100644
index 00000000..bb4672db
--- /dev/null
+++ b/tests/std/array/uasort_object2.phpt
@@ -0,0 +1,175 @@
+--TEST--
+Test uasort() function : object functionality - sort diff. objects
+--FILE--
+<?php
+/*
+ * This testcase tests uasort() functionality with different objects
+ * Objects of different classes:
+ *  simple class,
+ *  child class,
+ *  empty class &
+ *  static class
+ */
+
+// comparison function
+function cmp_function($value1, $value2)
+{
+  if($value1 == $value2) {
+    return 0;
+  }
+  else if($value1 > $value2) {
+    return 1;
+  }
+  else
+    return -1;
+}
+
+// Simple class with single member variable
+class SimpleClass
+{
+  private $int_value;
+
+  public function __construct($value) {
+    $this->int_value = $value;
+  }
+}
+
+// Class without any member
+class EmptyClass
+{
+}
+
+// Class with static member
+class StaticClass
+{
+  public static $static_value;
+  public function __construct($value) {
+    StaticClass::$static_value = $value;
+  }
+}
+
+// Abstract class
+abstract class AbstractClass
+{
+  public $pub_value;
+  public abstract function abstractMethod();
+}
+
+// Child class extending abstract class
+class ChildClass extends AbstractClass
+{
+  public $child_value = 100;
+  public function abstractMethod() {
+    $pub_value = 5;
+  }
+  public function __construct($value) {
+    $this->child_value = $value;
+  }
+}
+
+function main() {
+echo "*** Testing uasort() : object functionality ***\n";
+
+// Testing uasort with StaticClass objects as elements of 'array_arg'
+echo "-- Testing uasort() with StaticClass objects --\n";
+$array_arg = array(
+  0 => new StaticClass(20),
+  1 => new StaticClass(50),
+  2 => new StaticClass(15),
+  3 => new StaticClass(70),
+);
+var_dump( uasort($array_arg, 'cmp_function') );
+var_dump($array_arg);
+
+// Testing uasort with EmptyClass objects as elements of 'array_arg'
+echo "-- Testing uasort() with EmptyClass objects --\n";
+$array_arg = array(
+  0 => new EmptyClass(),
+  1 => new EmptyClass(),
+  2 => new EmptyClass(),
+  3 => new EmptyClass(),
+);
+var_dump( uasort($array_arg, 'cmp_function') );
+var_dump($array_arg);
+
+// Testing uasort with ChildClass objects as elements of 'array_arg'
+echo "-- Testing uasort() with ChildClass objects --\n";
+$array_arg = array(
+  0 => new ChildClass(20),
+  1 => new ChildClass(500),
+  2 => new ChildClass(15),
+  3 => new ChildClass(700),
+);
+var_dump( uasort($array_arg, 'cmp_function') );
+var_dump($array_arg);
+
+echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing uasort() : object functionality ***
+-- Testing uasort() with StaticClass objects --
+bool(true)
+array(4) {
+  [0]=>
+  object(StaticClass)#%d (0) {
+  }
+  [1]=>
+  object(StaticClass)#%d (0) {
+  }
+  [2]=>
+  object(StaticClass)#%d (0) {
+  }
+  [3]=>
+  object(StaticClass)#%d (0) {
+  }
+}
+-- Testing uasort() with EmptyClass objects --
+bool(true)
+array(4) {
+  [0]=>
+  object(EmptyClass)#%d (0) {
+  }
+  [1]=>
+  object(EmptyClass)#%d (0) {
+  }
+  [2]=>
+  object(EmptyClass)#%d (0) {
+  }
+  [3]=>
+  object(EmptyClass)#%d (0) {
+  }
+}
+-- Testing uasort() with ChildClass objects --
+bool(true)
+array(4) {
+  [2]=>
+  object(ChildClass)#%d (2) {
+    ["pub_value"]=>
+    NULL
+    ["child_value"]=>
+    int(15)
+  }
+  [0]=>
+  object(ChildClass)#%d (2) {
+    ["pub_value"]=>
+    NULL
+    ["child_value"]=>
+    int(20)
+  }
+  [1]=>
+  object(ChildClass)#%d (2) {
+    ["pub_value"]=>
+    NULL
+    ["child_value"]=>
+    int(500)
+  }
+  [3]=>
+  object(ChildClass)#%d (2) {
+    ["pub_value"]=>
+    NULL
+    ["child_value"]=>
+    int(700)
+  }
+}
+Done
diff --git a/tests/std/array/uasort_variation10.phpt b/tests/std/array/uasort_variation10.phpt
new file mode 100644
index 00000000..507ce5b0
--- /dev/null
+++ b/tests/std/array/uasort_variation10.phpt
@@ -0,0 +1,68 @@
+--TEST--
+Test uasort() function : usage variations - sort array with reference variables
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not fully support references");
+?>
+--FILE--
+<?php
+/*
+* Testing uasort() with 'array_arg' containing different reference variables
+*/
+
+// comparison function
+function cmp_function($value1, $value2)
+{
+  if($value1 == $value2) {
+    return 0;
+  }
+  else if($value1 > $value2) {
+    return 1;
+  }
+  else {
+    return -1;
+  }
+}
+
+function main() {
+echo "*** Testing uasort() : 'array_arg' with elements as reference ***\n";
+
+// different variables which are used as elements of 'array_arg'
+$value1 = -5;
+$value2 = 100;
+$value3 = 0;
+$value4 = &$value1;
+
+// array_args an array containing elements with reference variables
+$array_arg = array(
+  0 => 10,
+  1 => &$value4,
+  2 => &$value2,
+  3 => 200,
+  4 => &$value3,
+);
+
+echo "-- Sorting 'array_arg' containing different references --\n";
+var_dump( uasort($array_arg, 'cmp_function') );  // expecting: bool(true)
+var_dump($array_arg);
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing uasort() : 'array_arg' with elements as reference ***
+-- Sorting 'array_arg' containing different references --
+bool(true)
+array(5) {
+  [1]=>
+  &int(-5)
+  [4]=>
+  &int(0)
+  [0]=>
+  int(10)
+  [2]=>
+  &int(100)
+  [3]=>
+  int(200)
+}
+Done
diff --git a/tests/std/array/uasort_variation11.phpt b/tests/std/array/uasort_variation11.phpt
new file mode 100644
index 00000000..aa8ec3d9
--- /dev/null
+++ b/tests/std/array/uasort_variation11.phpt
@@ -0,0 +1,72 @@
+--TEST--
+Test uasort() function : usage variations - different associative arrays
+--FILE--
+<?php
+/* Testing uasort() with different associative arrays having keys as
+ *   string, integer, default & duplicate keys
+ */
+
+// comparison function
+function cmp($value1, $value2)
+{
+  if($value1 == $value2) {
+    return 0;
+  }
+  else if($value1 > $value2) {
+    return 1;
+  }
+  else
+    return -1;
+}
+
+function main() {
+echo "*** Testing uasort() : sorting different associative arrays ***\n";
+
+// Array with duplicate string and integer keys
+$array_arg = array(0 => 2, "a" => 8, "d" => 9, 3 => 3, 5 => 2, "o" => 6, "z" => -99, 0 => 1, "z" => 3);
+echo "-- Array with duplicate keys --\n";
+var_dump( uasort($array_arg, 'cmp') );
+var_dump($array_arg);
+
+// Array with default and assigned keys
+$array_arg = array(0 => "Banana", 1 => "Mango", "Orange", 2 => "Apple", "Pineapple");
+echo "-- Array with default/assigned keys --\n";
+var_dump( uasort($array_arg, 'cmp') );
+var_dump($array_arg);
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing uasort() : sorting different associative arrays ***
+-- Array with duplicate keys --
+bool(true)
+array(7) {
+  [0]=>
+  int(1)
+  [5]=>
+  int(2)
+  [3]=>
+  int(3)
+  ["z"]=>
+  int(3)
+  ["o"]=>
+  int(6)
+  ["a"]=>
+  int(8)
+  ["d"]=>
+  int(9)
+}
+-- Array with default/assigned keys --
+bool(true)
+array(4) {
+  [2]=>
+  string(5) "Apple"
+  [0]=>
+  string(6) "Banana"
+  [1]=>
+  string(5) "Mango"
+  [3]=>
+  string(9) "Pineapple"
+}
+Done
diff --git a/tests/std/array/uasort_variation3.phpt b/tests/std/array/uasort_variation3.phpt
new file mode 100644
index 00000000..f287841b
--- /dev/null
+++ b/tests/std/array/uasort_variation3.phpt
@@ -0,0 +1,127 @@
+--TEST--
+Test uasort() function : usage variations - sort array with all possible keys
+--SKIPIF--
+<?php
+?>
+--FILE--
+<?php
+/*
+* Testing uasort() with 'array_arg' having different keys
+*/
+
+//comparison function
+function cmp_function($value1, $value2)
+{
+  if($value1 == $value2) {
+    return 0;
+  }
+  else if($value1 > $value2) {
+    return -1;
+  }
+  else {
+    return 1;
+  }
+}
+
+function main() {
+echo "*** Testing uasort() : Sorting array with all possible keys ***\n";
+
+// different heredoc strings
+//empty heredoc string
+$empty_heredoc = <<<EOT1
+EOT1;
+
+// single line heredoc string
+$simple_heredoc = <<<EOT2
+simple
+EOT2;
+
+// multiline heredoc string
+$multiline_heredoc = <<<EOT3
+multiline heredoc with 123
+and speci@! ch@r..\ncheck\talso
+EOT3;
+
+$array_arg = array(
+  // default key
+  1,  //expecting: default key 0, value will be replaced by 'FALSE'
+
+  // numeric keys
+  1 => 10, // expecting: value will be replaced by 'TRUE'
+  -2 => 9,
+  012 => 7,
+  0x34 => 6,
+
+  // string keys
+  'key' => 5,  //single quoted key
+  "two" => 4,  //double quoted key
+  '' => 3,
+  "" => 2,
+  " " => 0,  // space as key
+
+  // bool keys
+  true => 15,
+  false => 5,
+  TRUE => 100,
+  FALSE => 25,
+
+  // null keys
+  null => 20,  // expecting: value will be replaced by 'NULL'
+  NULL => 35,
+
+  // binary key
+  "a".chr(0)."b" => 45,
+  b"binary" => 30,
+
+  //heredoc keys
+  $empty_heredoc => 90,
+  $simple_heredoc => 75,
+  $multiline_heredoc => 200,
+);
+
+var_dump( uasort($array_arg, 'cmp_function') );
+echo "-- Sorted array after uasort() function call --\n";
+var_dump($array_arg);
+
+echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing uasort() : Sorting array with all possible keys ***
+bool(true)
+-- Sorted array after uasort() function call --
+array(15) {
+  ["multiline heredoc with 123
+and speci@! ch@r..
+check	also"]=>
+  int(200)
+  [1]=>
+  int(100)
+  [""]=>
+  int(90)
+  ["simple"]=>
+  int(75)
+  ["a%0b"]=>
+  int(45)
+  [54]=>
+  int(35)
+  ["binary"]=>
+  int(30)
+  [0]=>
+  int(25)
+  [53]=>
+  int(20)
+  [-2]=>
+  int(9)
+  [10]=>
+  int(7)
+  [52]=>
+  int(6)
+  ["key"]=>
+  int(5)
+  ["two"]=>
+  int(4)
+  [" "]=>
+  int(0)
+}
+Done
diff --git a/tests/std/array/uasort_variation4.phpt b/tests/std/array/uasort_variation4.phpt
new file mode 100644
index 00000000..20febefd
--- /dev/null
+++ b/tests/std/array/uasort_variation4.phpt
@@ -0,0 +1,140 @@
+--TEST--
+Test uasort() function : usage variations - sort different numeric values
+--FILE--
+<?php
+/*
+* sorting different types of numeric arrays containing data of following type:
+*  integer, octal, hexadecimal & float
+*/
+
+// comparison function
+function cmp_function($value1, $value2)
+{
+  if($value1 == $value2) {
+    return 0;
+  }
+  else if($value1 > $value2) {
+    return 1;
+  }
+  else {
+    return -1;
+  }
+}
+
+function main() {
+echo "*** Testing uasort() : different numeric arrays as 'array_arg' ***\n";
+
+// Int array
+$int_values = array(0 => 3, 1 => 2, 3 => 100, 4 => 150, 5 => 25, 6 => 350, 7 => 0, 8 => -3, 9 => -1200);
+echo "-- Sorting Integer array --\n";
+var_dump( uasort($int_values, 'cmp_function') );  // expecting: bool(true)
+var_dump($int_values);
+
+// Octal array
+$octal_values = array(0 => 056, 1 => 023, 2 => 00, 3 => 015, 4 => -045, 5 => 01, 6 => -07);
+echo "-- Sorting Octal array --\n";
+var_dump( uasort($octal_values, 'cmp_function') );  // expecting: bool(true)
+var_dump($octal_values);
+
+// Hexadecimal array
+$hex_values = array(0 => 0xAE, 1 => 0x2B, 2 => 0X10, 3 => -0xCF, 4 => 0X12, 5 => -0XF2);
+echo "-- Sorting Hex array --\n";
+var_dump( uasort($hex_values, 'cmp_function') );  // expecting: bool(true)
+var_dump($hex_values);
+
+// Float array
+$float_values = array( 0 => 10.2, 1 => 2.4, 2 => -3.4, 3 => 0, 4 => 0.5, 5 => 7.3e3, 6 => -9.34E-2);
+echo "-- Sorting Float array --\n";
+var_dump( uasort($float_values, 'cmp_function') );  // expecting: bool(true)
+var_dump($float_values);
+
+// empty array
+$empty_array = array();
+echo "-- Sorting empty array --\n";
+var_dump( uasort($empty_array, 'cmp_function') );  // expecting: bool(true)
+var_dump($empty_array);
+
+echo "Done";
+}
+?>
+--EXPECT--
+*** Testing uasort() : different numeric arrays as 'array_arg' ***
+-- Sorting Integer array --
+bool(true)
+array(9) {
+  [9]=>
+  int(-1200)
+  [8]=>
+  int(-3)
+  [7]=>
+  int(0)
+  [1]=>
+  int(2)
+  [0]=>
+  int(3)
+  [5]=>
+  int(25)
+  [3]=>
+  int(100)
+  [4]=>
+  int(150)
+  [6]=>
+  int(350)
+}
+-- Sorting Octal array --
+bool(true)
+array(7) {
+  [4]=>
+  int(-37)
+  [6]=>
+  int(-7)
+  [2]=>
+  int(0)
+  [5]=>
+  int(1)
+  [3]=>
+  int(13)
+  [1]=>
+  int(19)
+  [0]=>
+  int(46)
+}
+-- Sorting Hex array --
+bool(true)
+array(6) {
+  [5]=>
+  int(-242)
+  [3]=>
+  int(-207)
+  [2]=>
+  int(16)
+  [4]=>
+  int(18)
+  [1]=>
+  int(43)
+  [0]=>
+  int(174)
+}
+-- Sorting Float array --
+bool(true)
+array(7) {
+  [2]=>
+  float(-3.4)
+  [6]=>
+  float(-0.0934)
+  [3]=>
+  int(0)
+  [4]=>
+  float(0.5)
+  [1]=>
+  float(2.4)
+  [0]=>
+  float(10.2)
+  [5]=>
+  float(7300)
+}
+-- Sorting empty array --
+bool(true)
+array(0) {
+}
+Done
diff --git a/tests/std/array/uasort_variation5.phpt b/tests/std/array/uasort_variation5.phpt
new file mode 100644
index 00000000..26521981
--- /dev/null
+++ b/tests/std/array/uasort_variation5.phpt
@@ -0,0 +1,135 @@
+--TEST--
+Test uasort() function : usage variations - sort diff. strings
+--FILE--
+<?php
+/*
+* sorting different strings:
+*  single quoted, double quoted and heredoc strings
+*/
+
+// comparison function
+function cmp_function($value1, $value2)
+{
+  if($value1 == $value2) {
+    return 0;
+  }
+  else if($value1 > $value2) {
+    return 1;
+  }
+  else {
+    return -1;
+  }
+}
+
+function main() {
+// Different heredoc strings to be sorted
+$empty_heredoc =<<<EOT
+EOT;
+
+$simple_heredoc1 =<<<EOT
+Heredoc
+EOT;
+
+$simple_heredoc2 =<<<EOT
+HEREDOC
+EOT;
+
+$multiline_heredoc =<<<EOT
+heredoc string\twith!@# and 123
+Test this!!!
+EOT;
+
+
+echo "*** Testing uasort() : different string arrays as 'array_arg' ***\n";
+
+// Single quoted strings
+$single_quoted_values = array(
+  0 => ' ', 1 => 'test', 3 => 'Hello', 4 => 'HELLO',
+  5 => '', 6 => '\t', 7 => '0', 8 => '123Hello', 9 => '\'', 10 => '@#$%'
+);
+echo "-- Sorting Single Quoted String values --\n";
+var_dump( uasort($single_quoted_values, 'cmp_function') );  // expecting: bool(true)
+var_dump($single_quoted_values);
+
+// Double quoted strings
+$double_quoted_values = array(
+  0 => " ", 1 => "test", 3 => "Hello", 4 => "HELLO",
+  5 => "", 6 => "\t", 7 => "0", 8 => "123Hello", 9 => "\"", 10 => "@#$%"
+);
+echo "-- Sorting Double Quoted String values --\n";
+var_dump( uasort($double_quoted_values, 'cmp_function') );  // expecting: bool(true)
+var_dump($double_quoted_values);
+
+// Heredoc strings
+$heredoc_values = array(0 => $empty_heredoc, 1 => $simple_heredoc1, 2 => $simple_heredoc2, 3 => $multiline_heredoc);
+echo "-- Sorting Heredoc String values --\n";
+var_dump( uasort($heredoc_values, 'cmp_function') );  // expecting: bool(true)
+var_dump($heredoc_values);
+
+echo "Done";
+}
+?>
+--EXPECTF--
+*** Testing uasort() : different string arrays as 'array_arg' ***
+-- Sorting Single Quoted String values --
+bool(true)
+array(10) {
+  [5]=>
+  string(0) ""
+  [0]=>
+  string(1) " "
+  [9]=>
+  string(1) "'"
+  [7]=>
+  string(1) "0"
+  [8]=>
+  string(8) "123Hello"
+  [10]=>
+  string(4) "@#$%"
+  [4]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "Hello"
+  [6]=>
+  string(2) "\t"
+  [1]=>
+  string(4) "test"
+}
+-- Sorting Double Quoted String values --
+bool(true)
+array(10) {
+  [5]=>
+  string(0) ""
+  [6]=>
+  string(1) "	"
+  [0]=>
+  string(1) " "
+  [9]=>
+  string(1) """
+  [7]=>
+  string(1) "0"
+  [8]=>
+  string(8) "123Hello"
+  [10]=>
+  string(4) "@#$%"
+  [4]=>
+  string(5) "HELLO"
+  [3]=>
+  string(5) "Hello"
+  [1]=>
+  string(4) "test"
+}
+-- Sorting Heredoc String values --
+bool(true)
+array(4) {
+  [0]=>
+  string(0) ""
+  [2]=>
+  string(7) "HEREDOC"
+  [1]=>
+  string(7) "Heredoc"
+  [3]=>
+  string(4%d) "heredoc string	with!@# and 123
+Test this!!!"
+}
+Done
diff --git a/tests/std/array/uasort_variation6.phpt b/tests/std/array/uasort_variation6.phpt
new file mode 100644
index 00000000..23acfc8e
--- /dev/null
+++ b/tests/std/array/uasort_variation6.phpt
@@ -0,0 +1,92 @@
+--TEST--
+Test uasort() function : usage variations - sort array having subarrays
+--FILE--
+<?php
+/*
+* Testing uasort() with 'array_arg' having different subarrays as array elements
+*/
+// comparison function
+function cmp_function($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+function main()
+{
+    echo "*** Testing uasort() : sorting array having different subarrays ***\n";
+    $array_args = array(0 => array(2, 10, -1), 1 => array(100), 2 => array(), 3 => array(0), 4 => array(-1), 5 => array(-9, 34, 54, 0, 20), 6 => array(''), 7 => array("apple", "Apple", "APPLE", "aPPle", "aPpLe"));
+    $temp_array = $array_args;
+    // sorting array_arg as whole array
+    var_dump(uasort($temp_array, 'cmp_function'));
+    // expecting: bool(true)
+    var_dump($temp_array);
+}
+?>
+--EXPECT--
+*** Testing uasort() : sorting array having different subarrays ***
+bool(true)
+array(8) {
+  [2]=>
+  array(0) {
+  }
+  [6]=>
+  array(1) {
+    [0]=>
+    string(0) ""
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    int(-1)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    int(100)
+  }
+  [0]=>
+  array(3) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(10)
+    [2]=>
+    int(-1)
+  }
+  [5]=>
+  array(5) {
+    [0]=>
+    int(-9)
+    [1]=>
+    int(34)
+    [2]=>
+    int(54)
+    [3]=>
+    int(0)
+    [4]=>
+    int(20)
+  }
+  [7]=>
+  array(5) {
+    [0]=>
+    string(5) "apple"
+    [1]=>
+    string(5) "Apple"
+    [2]=>
+    string(5) "APPLE"
+    [3]=>
+    string(5) "aPPle"
+    [4]=>
+    string(5) "aPpLe"
+  }
+}
diff --git a/tests/std/array/uasort_variation7.phpt b/tests/std/array/uasort_variation7.phpt
new file mode 100644
index 00000000..5340dd90
--- /dev/null
+++ b/tests/std/array/uasort_variation7.phpt
@@ -0,0 +1,86 @@
+--TEST--
+Test uasort() function : usage variations - anonymous function as 'cmp_function'
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference parameters in closures");
+?>
+
+--FILE--
+<?php
+/*
+* Passing different anonymous functions as 'cmp_function'
+*   arguments passed by value
+*   arguments passed by reference
+*/
+
+echo "*** Testing uasort() : anonymous function as 'cmp_function' ***\n";
+
+$cmp_function = function($value1, $value2) {
+    if ($value1 == $value2) { return 0; }
+    else if ($value1 > $value2) { return 1; }
+    else { return -1; }
+};
+
+$array_arg = array(0 => 100, 1 => 3, 2 => -70, 3 => 24, 4 => 90);
+echo "-- Anonymous 'cmp_function' with parameters passed by value --\n";
+var_dump( uasort($array_arg, $cmp_function) );
+var_dump($array_arg);
+
+$cmp_function = function(&$value1, &$value2) {
+    if ($value1 == $value2) { return 0; }
+    else if ($value1 > $value2) { return 1; }
+    else { return -1; }
+};
+
+$array_arg = array("b" => "Banana", "m" => "Mango", "a" => "Apple", "p" => "Pineapple");
+echo "-- Anonymous 'cmp_function' with parameters passed by reference --\n";
+var_dump( uasort($array_arg, $cmp_function ) );
+var_dump($array_arg);
+
+echo "Done";
+?>
+--EXPECTF--
+*** Testing uasort() : anonymous function as 'cmp_function' ***
+-- Anonymous 'cmp_function' with parameters passed by value --
+bool(true)
+array(5) {
+  [2]=>
+  int(-70)
+  [1]=>
+  int(3)
+  [3]=>
+  int(24)
+  [4]=>
+  int(90)
+  [0]=>
+  int(100)
+}
+-- Anonymous 'cmp_function' with parameters passed by reference --
+
+Warning: {closure:%s:%d}(): Argument #1 ($value1) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #2 ($value2) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #1 ($value1) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #2 ($value2) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #1 ($value1) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #2 ($value2) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #1 ($value1) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #2 ($value2) must be passed by reference, value given in %s on line %d
+bool(true)
+array(4) {
+  ["a"]=>
+  string(5) "Apple"
+  ["b"]=>
+  string(6) "Banana"
+  ["m"]=>
+  string(5) "Mango"
+  ["p"]=>
+  string(9) "Pineapple"
+}
+Done
diff --git a/tests/std/array/uasort_variation8.phpt b/tests/std/array/uasort_variation8.phpt
new file mode 100644
index 00000000..9250af55
--- /dev/null
+++ b/tests/std/array/uasort_variation8.phpt
@@ -0,0 +1,57 @@
+--TEST--
+Test uasort() function : usage variations - built-in function as 'cmp_function'
+--FILE--
+<?php
+/*
+* Passing different built-in library functions in place of 'cmp_function'
+*   valid comparison functions: strcmp() & strcasecmp()
+*/
+
+echo "*** Testing uasort() : built in function as 'cmp_function' ***\n";
+// Initializing variables
+$array_arg = array("b" => "Banana", "m" => "Mango", "a" => "apple", "p" => "Pineapple", "o" => "orange");
+$builtin_fun_arg = $array_arg;
+$languageConstruct_fun_arg = $array_arg;
+
+// Testing library functions as comparison function
+echo "-- Testing uasort() with built-in 'cmp_function': strcasecmp() --\n";
+var_dump( uasort($builtin_fun_arg, 'strcasecmp') );  // expecting: bool(true)
+var_dump($builtin_fun_arg);
+
+echo "-- Testing uasort() with built-in 'cmp_function': strcmp() --\n";
+var_dump( uasort($array_arg, 'strcmp') );  // expecting: bool(true)
+var_dump($array_arg);
+
+echo "Done";
+?>
+--EXPECT--
+*** Testing uasort() : built in function as 'cmp_function' ***
+-- Testing uasort() with built-in 'cmp_function': strcasecmp() --
+bool(true)
+array(5) {
+  ["a"]=>
+  string(5) "apple"
+  ["b"]=>
+  string(6) "Banana"
+  ["m"]=>
+  string(5) "Mango"
+  ["o"]=>
+  string(6) "orange"
+  ["p"]=>
+  string(9) "Pineapple"
+}
+-- Testing uasort() with built-in 'cmp_function': strcmp() --
+bool(true)
+array(5) {
+  ["b"]=>
+  string(6) "Banana"
+  ["m"]=>
+  string(5) "Mango"
+  ["p"]=>
+  string(9) "Pineapple"
+  ["a"]=>
+  string(5) "apple"
+  ["o"]=>
+  string(6) "orange"
+}
+Done
diff --git a/tests/std/array/uksort_basic.phpt b/tests/std/array/uksort_basic.phpt
new file mode 100644
index 00000000..12b8c0bc
--- /dev/null
+++ b/tests/std/array/uksort_basic.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test uksort(): basic functionality
+--FILE--
+<?php
+/*
+* Function is implemented in ext/standard/array.c
+*/
+function cmp($a, $b)
+{
+    if ($a == $b) {
+        return 0;
+    }
+    return $a < $b ? -1 : 1;
+}
+function main()
+{
+    $a = array(3, 2, 5, 6, 1);
+    uasort($a, "cmp");
+    foreach ($a as $key => $value) {
+        echo "{$key}: {$value}\n";
+    }
+}
+?>
+--EXPECT--
+4: 1
+1: 2
+0: 3
+2: 5
+3: 6
diff --git a/tests/std/array/unexpected_array_mod_bug.phpt b/tests/std/array/unexpected_array_mod_bug.phpt
new file mode 100644
index 00000000..f211e898
--- /dev/null
+++ b/tests/std/array/unexpected_array_mod_bug.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Crash when function parameter modified via reference
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+function usercompare($a, $b)
+{
+    unset($GLOBALS['my_var'][2]);
+    return $a <=> $b;
+}
+function main()
+{
+    $my_var = array(1 => "entry_1", 2 => "entry_2", 3 => "entry_3", 4 => "entry_4", 5 => "entry_5");
+    usort($my_var, "usercompare");
+    var_dump($my_var);
+}
+?>
+--EXPECT--
+array(5) {
+  [0]=>
+  string(7) "entry_1"
+  [1]=>
+  string(7) "entry_2"
+  [2]=>
+  string(7) "entry_3"
+  [3]=>
+  string(7) "entry_4"
+  [4]=>
+  string(7) "entry_5"
+}
diff --git a/tests/std/array/unexpected_array_mod_bug_variation1.phpt b/tests/std/array/unexpected_array_mod_bug_variation1.phpt
new file mode 100644
index 00000000..b5a1ee24
--- /dev/null
+++ b/tests/std/array/unexpected_array_mod_bug_variation1.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Crash when function parameter modified via reference while keeping orig refcount
+--FILE--
+<?php
+
+$array = array(
+    1 => "entry_1",
+    2 => "entry_2",
+    3 => "entry_3",
+    4 => "entry_4",
+    5 => "entry_5"
+);
+usort($array, function($a, $b) use (&$array, &$ref) {
+    unset($array[2]);
+    $ref = $array;
+    return $a <=> $b;
+});
+var_dump($array);
+
+?>
+--EXPECT--
+array(5) {
+  [0]=>
+  string(7) "entry_1"
+  [1]=>
+  string(7) "entry_2"
+  [2]=>
+  string(7) "entry_3"
+  [3]=>
+  string(7) "entry_4"
+  [4]=>
+  string(7) "entry_5"
+}
diff --git a/tests/std/array/usort_basic.phpt b/tests/std/array/usort_basic.phpt
new file mode 100644
index 00000000..2c98a6de
--- /dev/null
+++ b/tests/std/array/usort_basic.phpt
@@ -0,0 +1,104 @@
+--TEST--
+Test usort() function : basic functionality
+--FILE--
+<?php
+function cmp($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+function main()
+{
+    /*
+     * Test basic functionality of usort() with indexed and associative arrays
+     */
+    echo "*** Testing usort() : basic functionality ***\n";
+    // Int array with default keys
+    $int_values = array(1, 8, 9, 3, 2, 6, 7);
+    echo "\n-- Numeric array with default keys --\n";
+    var_dump(usort($int_values, 'cmp'));
+    var_dump($int_values);
+    // String array with default keys
+    $string_values = array("This", "is", 'a', "test");
+    echo "\n-- String array with default keys --\n";
+    var_dump(usort($string_values, 'cmp'));
+    var_dump($string_values);
+    // Associative array with numeric keys
+    $numeric_key_arg = array(1 => 1, 2 => 2, 3 => 7, 5 => 4, 4 => 9);
+    echo "\n-- Associative array with numeric keys --\n";
+    var_dump(usort($numeric_key_arg, 'cmp'));
+    var_dump($numeric_key_arg);
+    // Associative array with string keys
+    $string_key_arg = array('one' => 4, 'two' => 2, 'three' => 1, 'four' => 10);
+    echo "\n-- Associative array with string keys --\n";
+    var_dump(usort($string_key_arg, 'cmp'));
+    var_dump($string_key_arg);
+}
+?>
+--EXPECT--
+*** Testing usort() : basic functionality ***
+
+-- Numeric array with default keys --
+bool(true)
+array(7) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(6)
+  [4]=>
+  int(7)
+  [5]=>
+  int(8)
+  [6]=>
+  int(9)
+}
+
+-- String array with default keys --
+bool(true)
+array(4) {
+  [0]=>
+  string(4) "This"
+  [1]=>
+  string(1) "a"
+  [2]=>
+  string(2) "is"
+  [3]=>
+  string(4) "test"
+}
+
+-- Associative array with numeric keys --
+bool(true)
+array(5) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(4)
+  [3]=>
+  int(7)
+  [4]=>
+  int(9)
+}
+
+-- Associative array with string keys --
+bool(true)
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(4)
+  [3]=>
+  int(10)
+}
diff --git a/tests/std/array/usort_object1.phpt b/tests/std/array/usort_object1.phpt
new file mode 100644
index 00000000..5c338852
--- /dev/null
+++ b/tests/std/array/usort_object1.phpt
@@ -0,0 +1,123 @@
+--TEST--
+Test usort() function : object functionality - different number of properties
+--FILE--
+<?php
+function simple_cmp($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+// comparison function for SimpleClass2 objects which has more than one member
+function multiple_cmp($value1, $value2)
+{
+    if ($value1->getValue() == $value2->getValue()) {
+        return 0;
+    } else if ($value1->getValue() > $value2->getValue()) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+// Simple class with single property
+class SimpleClass1
+{
+    private $int_value;
+    public function __construct($value)
+    {
+        $this->int_value = $value;
+    }
+}
+// Simple class with more than one property
+class SimpleClass2
+{
+    private $int_value;
+    protected $float_value;
+    public $string_value;
+    public function __construct($int, $float, $str)
+    {
+        $this->int_value = $int;
+        $this->float_value = $float;
+        $this->string_value = $str;
+    }
+    public function getValue()
+    {
+        return $this->int_value;
+    }
+}
+function main()
+{
+    /*
+     * Pass an array of objects which have a different number of properties
+     * to test behaviour of usort()
+     */
+    echo "*** Testing usort() : object functionality ***\n";
+    // array of SimpleClass objects with only one property
+    $array_arg = array(0 => new SimpleClass1(10), 1 => new SimpleClass1(1), 2 => new SimpleClass1(100), 3 => new SimpleClass1(50));
+    var_dump(usort($array_arg, 'simple_cmp'));
+    var_dump($array_arg);
+    // array of SimpleClass objects having more than one properties
+    $array_arg = array(0 => new SimpleClass2(2, 3.4, "mango"), 1 => new SimpleClass2(10, 1.2, "apple"), 2 => new SimpleClass2(5, 2.5, "orange"));
+    var_dump(usort($array_arg, 'multiple_cmp'));
+    var_dump($array_arg);
+}
+?>
+--EXPECTF--
+*** Testing usort() : object functionality ***
+bool(true)
+array(4) {
+  [0]=>
+  object(SimpleClass1)#%d (1) {
+    ["int_value":"SimpleClass1":private]=>
+    int(1)
+  }
+  [1]=>
+  object(SimpleClass1)#%d (1) {
+    ["int_value":"SimpleClass1":private]=>
+    int(10)
+  }
+  [2]=>
+  object(SimpleClass1)#%d (1) {
+    ["int_value":"SimpleClass1":private]=>
+    int(50)
+  }
+  [3]=>
+  object(SimpleClass1)#%d (1) {
+    ["int_value":"SimpleClass1":private]=>
+    int(100)
+  }
+}
+bool(true)
+array(3) {
+  [0]=>
+  object(SimpleClass2)#%d (3) {
+    ["int_value":"SimpleClass2":private]=>
+    int(2)
+    ["float_value":protected]=>
+    float(3.4)
+    ["string_value"]=>
+    string(5) "mango"
+  }
+  [1]=>
+  object(SimpleClass2)#%d (3) {
+    ["int_value":"SimpleClass2":private]=>
+    int(5)
+    ["float_value":protected]=>
+    float(2.5)
+    ["string_value"]=>
+    string(6) "orange"
+  }
+  [2]=>
+  object(SimpleClass2)#%d (3) {
+    ["int_value":"SimpleClass2":private]=>
+    int(10)
+    ["float_value":protected]=>
+    float(1.2)
+    ["string_value"]=>
+    string(5) "apple"
+  }
+}
diff --git a/tests/std/array/usort_object2.phpt b/tests/std/array/usort_object2.phpt
new file mode 100644
index 00000000..661d8390
--- /dev/null
+++ b/tests/std/array/usort_object2.phpt
@@ -0,0 +1,139 @@
+--TEST--
+Test usort() function : object functionality - Different types of classes
+--FILE--
+<?php
+function cmp_function($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+// Class without any member
+class EmptyClass
+{
+}
+// Class with static member
+class StaticClass
+{
+    public static $static_value;
+    public function __construct($value)
+    {
+        StaticClass::$static_value = $value;
+    }
+}
+// Abstract class
+abstract class AbstractClass
+{
+    public $pub_value;
+    abstract public function abstractMethod();
+}
+// Child class extending abstract class
+class ChildClass extends AbstractClass
+{
+    public $child_value = 100;
+    public function abstractMethod()
+    {
+        $pub_value = 5;
+    }
+    public function __construct($value)
+    {
+        $this->child_value = $value;
+    }
+}
+function main()
+{
+    /*
+     * Pass an array of objects which are either:
+     * 1. Empty
+     * 2. Static
+     * 2. Inherited
+     * to test behaviour of usort()
+     */
+    echo "*** Testing usort() : object functionality ***\n";
+    // Testing uasort with StaticClass objects as elements of 'array_arg'
+    echo "-- Testing usort() with StaticClass objects --\n";
+    $array_arg = array(0 => new StaticClass(20), 1 => new StaticClass(50), 2 => new StaticClass(15), 3 => new StaticClass(70));
+    var_dump(usort($array_arg, 'cmp_function'));
+    var_dump($array_arg);
+    // Testing uasort with EmptyClass objects as elements of 'array_arg'
+    echo "-- Testing usort() with EmptyClass objects --\n";
+    $array_arg = array(0 => new EmptyClass(), 1 => new EmptyClass(), 2 => new EmptyClass(), 3 => new EmptyClass());
+    var_dump(usort($array_arg, 'cmp_function'));
+    var_dump($array_arg);
+    // Testing uasort with ChildClass objects as elements of 'array_arg'
+    echo "-- Testing usort() with ChildClass objects --\n";
+    $array_arg = array(0 => new ChildClass(20), 1 => new ChildClass(500), 2 => new ChildClass(15), 3 => new ChildClass(700));
+    var_dump(usort($array_arg, 'cmp_function'));
+    var_dump($array_arg);
+}
+?>
+--EXPECTF--
+*** Testing usort() : object functionality ***
+-- Testing usort() with StaticClass objects --
+bool(true)
+array(4) {
+  [0]=>
+  object(StaticClass)#%d (0) {
+  }
+  [1]=>
+  object(StaticClass)#%d (0) {
+  }
+  [2]=>
+  object(StaticClass)#%d (0) {
+  }
+  [3]=>
+  object(StaticClass)#%d (0) {
+  }
+}
+-- Testing usort() with EmptyClass objects --
+bool(true)
+array(4) {
+  [0]=>
+  object(EmptyClass)#%d (0) {
+  }
+  [1]=>
+  object(EmptyClass)#%d (0) {
+  }
+  [2]=>
+  object(EmptyClass)#%d (0) {
+  }
+  [3]=>
+  object(EmptyClass)#%d (0) {
+  }
+}
+-- Testing usort() with ChildClass objects --
+bool(true)
+array(4) {
+  [0]=>
+  object(ChildClass)#%d (2) {
+    ["pub_value"]=>
+    NULL
+    ["child_value"]=>
+    int(15)
+  }
+  [1]=>
+  object(ChildClass)#%d (2) {
+    ["pub_value"]=>
+    NULL
+    ["child_value"]=>
+    int(20)
+  }
+  [2]=>
+  object(ChildClass)#%d (2) {
+    ["pub_value"]=>
+    NULL
+    ["child_value"]=>
+    int(500)
+  }
+  [3]=>
+  object(ChildClass)#%d (2) {
+    ["pub_value"]=>
+    NULL
+    ["child_value"]=>
+    int(700)
+  }
+}
diff --git a/tests/std/array/usort_stability.phpt b/tests/std/array/usort_stability.phpt
new file mode 100644
index 00000000..e3ca4e16
--- /dev/null
+++ b/tests/std/array/usort_stability.phpt
@@ -0,0 +1,15 @@
+--TEST--
+usort() is stable
+--FILE--
+<?php
+
+$array = range(0, 10000);
+usort($array, function($a, $b) {
+    // Everything is equal!
+    return 0;
+});
+var_dump($array === range(0, 10000));
+
+?>
+--EXPECT--
+bool(true)
diff --git a/tests/std/array/usort_variation10.phpt b/tests/std/array/usort_variation10.phpt
new file mode 100644
index 00000000..6085e6fb
--- /dev/null
+++ b/tests/std/array/usort_variation10.phpt
@@ -0,0 +1,66 @@
+--TEST--
+Test usort() function : usage variations - duplicate keys and values
+--FILE--
+<?php
+function cmp($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+function main()
+{
+    /*
+     * Pass an array with duplicate keys and values to usort() to test behaviour
+     */
+    echo "*** Testing usort() : usage variation ***\n";
+    // Array with duplicate string and integer keys and values
+    $array_arg = array(0 => 2, "a" => 8, "d" => 9, 3 => 3, 5 => 2, "o" => 6, "z" => -99, 0 => 1, "z" => 3);
+    echo "\n-- Array with duplicate keys --\n";
+    var_dump(usort($array_arg, 'cmp'));
+    var_dump($array_arg);
+    // Array with default and assigned keys
+    $array_arg = array(0 => "Banana", 1 => "Mango", "Orange", 2 => "Apple", "Pineapple");
+    echo "\n-- Array with default/assigned keys --\n";
+    var_dump(usort($array_arg, 'cmp'));
+    var_dump($array_arg);
+}
+?>
+--EXPECT--
+*** Testing usort() : usage variation ***
+
+-- Array with duplicate keys --
+bool(true)
+array(7) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(3)
+  [4]=>
+  int(6)
+  [5]=>
+  int(8)
+  [6]=>
+  int(9)
+}
+
+-- Array with default/assigned keys --
+bool(true)
+array(4) {
+  [0]=>
+  string(5) "Apple"
+  [1]=>
+  string(6) "Banana"
+  [2]=>
+  string(5) "Mango"
+  [3]=>
+  string(9) "Pineapple"
+}
diff --git a/tests/std/array/usort_variation11.phpt b/tests/std/array/usort_variation11.phpt
new file mode 100644
index 00000000..fef77fc4
--- /dev/null
+++ b/tests/std/array/usort_variation11.phpt
@@ -0,0 +1,87 @@
+--TEST--
+Test usort() function : usage variations - malformed comparison function returning boolean
+--SKIPIF--
+<?php die("skip AOT does not emit deprecation warnings for bool-returning comparison functions"); ?>
+--FILE--
+<?php
+function ucmp($a, $b)
+{
+    return $a > $b;
+}
+function main()
+{
+    $range = array(2, 4, 8, 16, 32, 64, 128);
+    foreach ($range as $r) {
+        $backup = $array = range(0, $r);
+        shuffle($array);
+        usort($array, "ucmp");
+        if ($array != $backup) {
+            var_dump($array);
+            var_dump($backup);
+            die("Array not sorted (usort)");
+        }
+        shuffle($array);
+        $array = array_flip($array);
+        uksort($array, "ucmp");
+        $array = array_keys($array);
+        if ($array != $backup) {
+            var_dump($array);
+            var_dump($backup);
+            die("Array not sorted (uksort)");
+        }
+        shuffle($array);
+        $array = array_combine($array, $array);
+        uasort($array, "ucmp");
+        $array = array_keys($array);
+        if ($array != $backup) {
+            var_dump($array);
+            var_dump($backup);
+            die("Array not sorted (uasort)");
+        }
+    }
+    echo "okey";
+}
+?>
+--EXPECTF--
+Deprecated: usort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uksort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uasort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: usort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uksort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uasort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: usort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uksort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uasort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: usort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uksort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uasort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: usort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uksort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uasort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: usort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uksort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uasort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: usort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uksort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+
+Deprecated: uasort(): Returning bool from comparison function is deprecated, return an integer less than, equal to, or greater than zero in %s on line %d
+okey
diff --git a/tests/std/array/usort_variation3.phpt b/tests/std/array/usort_variation3.phpt
new file mode 100644
index 00000000..54db46e4
--- /dev/null
+++ b/tests/std/array/usort_variation3.phpt
@@ -0,0 +1,100 @@
+--TEST--
+Test usort() function : usage variations - diff. array values
+--FILE--
+<?php
+function cmp_function($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return -1;
+    } else {
+        return 1;
+    }
+}
+function main()
+{
+    /*
+     * Pass an array with different data types as keys to usort() to test how it is re-ordered
+     */
+    echo "*** Testing usort() : usage variation ***\n";
+    // different heredoc strings
+    // single line heredoc string
+    $simple_heredoc = <<<EOT2
+    simple
+    EOT2;
+    // multiline heredoc string
+    $multiline_heredoc = <<<EOT3
+    multiline heredoc with 123
+    and speci@! ch@r..
+    check\talso
+    EOT3;
+    $array_arg = array(
+        // numeric keys
+        -2 => 9,
+        8 => 8,
+        012 => 7,
+        0x34 => 6,
+        // string keys
+        'key' => 5,
+        //single quoted key
+        "two" => 4,
+        //double quoted key
+        " " => 0,
+        // space as key
+        // bool keys
+        TRUE => 100,
+        FALSE => 25,
+        // null keys
+        NULL => 35,
+        // binary key
+        "a" . chr(0) . "b" => 45,
+        "binary" => 30,
+        //heredoc keys
+        $simple_heredoc => 75,
+        $multiline_heredoc => 200,
+        // default key
+        1,
+    );
+    var_dump(usort($array_arg, 'cmp_function'));
+    echo "\n-- Sorted array after usort() function call --\n";
+    var_dump($array_arg);
+}
+?>
+--EXPECT--
+*** Testing usort() : usage variation ***
+bool(true)
+
+-- Sorted array after usort() function call --
+array(15) {
+  [0]=>
+  int(200)
+  [1]=>
+  int(100)
+  [2]=>
+  int(75)
+  [3]=>
+  int(45)
+  [4]=>
+  int(35)
+  [5]=>
+  int(30)
+  [6]=>
+  int(25)
+  [7]=>
+  int(9)
+  [8]=>
+  int(8)
+  [9]=>
+  int(7)
+  [10]=>
+  int(6)
+  [11]=>
+  int(5)
+  [12]=>
+  int(4)
+  [13]=>
+  int(1)
+  [14]=>
+  int(0)
+}
diff --git a/tests/std/array/usort_variation4.phpt b/tests/std/array/usort_variation4.phpt
new file mode 100644
index 00000000..b8f86003
--- /dev/null
+++ b/tests/std/array/usort_variation4.phpt
@@ -0,0 +1,132 @@
+--TEST--
+Test usort() function : usage variations - numeric data
+--FILE--
+<?php
+function cmp_function($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+function main()
+{
+    /*
+     * Pass arrays of numeric data to usort() to test how it is re-ordered
+     */
+    echo "*** Testing usort() : usage variation ***\n";
+    // Int array
+    $int_values = array(0 => 3, 1 => 2, 3 => 100, 4 => 150, 5 => 25, 6 => 350, 7 => 0, 8 => -3, 9 => -1200);
+    echo "\n-- Sorting Integer array --\n";
+    var_dump(usort($int_values, 'cmp_function'));
+    var_dump($int_values);
+    // Octal array
+    $octal_values = array(0 => 056, 1 => 023, 2 => 00, 3 => 015, 4 => -045, 5 => 01, 6 => -07);
+    echo "\n-- Sorting Octal array --\n";
+    var_dump(usort($octal_values, 'cmp_function'));
+    var_dump($octal_values);
+    // Hexadecimal array
+    $hex_values = array(0 => 0xae, 1 => 0x2b, 2 => 0x10, 3 => -0xcf, 4 => 0x12, 5 => -0xf2);
+    echo "\n-- Sorting Hex array --\n";
+    var_dump(usort($hex_values, 'cmp_function'));
+    var_dump($hex_values);
+    // Float array
+    $float_values = array(0 => 10.2, 1 => 2.4, 2 => -3.4, 3 => 0, 4 => 0.5, 5 => 7300.0, 6 => -0.0934);
+    echo "\n-- Sorting Float array --\n";
+    var_dump(usort($float_values, 'cmp_function'));
+    var_dump($float_values);
+    // empty array
+    $empty_array = array();
+    echo "\n-- Sorting empty array --\n";
+    var_dump(usort($empty_array, 'cmp_function'));
+    var_dump($empty_array);
+}
+?>
+--EXPECT--
+*** Testing usort() : usage variation ***
+
+-- Sorting Integer array --
+bool(true)
+array(9) {
+  [0]=>
+  int(-1200)
+  [1]=>
+  int(-3)
+  [2]=>
+  int(0)
+  [3]=>
+  int(2)
+  [4]=>
+  int(3)
+  [5]=>
+  int(25)
+  [6]=>
+  int(100)
+  [7]=>
+  int(150)
+  [8]=>
+  int(350)
+}
+
+-- Sorting Octal array --
+bool(true)
+array(7) {
+  [0]=>
+  int(-37)
+  [1]=>
+  int(-7)
+  [2]=>
+  int(0)
+  [3]=>
+  int(1)
+  [4]=>
+  int(13)
+  [5]=>
+  int(19)
+  [6]=>
+  int(46)
+}
+
+-- Sorting Hex array --
+bool(true)
+array(6) {
+  [0]=>
+  int(-242)
+  [1]=>
+  int(-207)
+  [2]=>
+  int(16)
+  [3]=>
+  int(18)
+  [4]=>
+  int(43)
+  [5]=>
+  int(174)
+}
+
+-- Sorting Float array --
+bool(true)
+array(7) {
+  [0]=>
+  float(-3.4)
+  [1]=>
+  float(-0.0934)
+  [2]=>
+  int(0)
+  [3]=>
+  float(0.5)
+  [4]=>
+  float(2.4)
+  [5]=>
+  float(10.2)
+  [6]=>
+  float(7300)
+}
+
+-- Sorting empty array --
+bool(true)
+array(0) {
+}
diff --git a/tests/std/array/usort_variation5.phpt b/tests/std/array/usort_variation5.phpt
new file mode 100644
index 00000000..b0b93e20
--- /dev/null
+++ b/tests/std/array/usort_variation5.phpt
@@ -0,0 +1,116 @@
+--TEST--
+Test usort() function : usage variations - string data
+--FILE--
+<?php
+function cmp_function($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+function main()
+{
+    /*
+     * Pass arrays of string data to usort() to test how it is re-ordered
+     */
+    echo "*** Testing usort() : usage variation ***\n";
+    // Different heredoc strings to be sorted
+    $empty_heredoc = <<<EOT
+    EOT;
+    $simple_heredoc1 = <<<EOT
+    Heredoc
+    EOT;
+    $simple_heredoc2 = <<<EOT
+    HEREDOC
+    EOT;
+    $multiline_heredoc = <<<EOT
+    heredoc string\twith!@# and 123
+    Test this!!!
+    EOT;
+    // Single quoted strings
+    $single_quoted_values = array(0 => ' ', 1 => 'test', 3 => 'Hello', 4 => 'HELLO', 5 => '', 6 => '\t', 7 => '0', 8 => '123Hello', 9 => '\'', 10 => '@#$%');
+    echo "\n-- Sorting Single Quoted String values --\n";
+    var_dump(usort($single_quoted_values, 'cmp_function'));
+    var_dump($single_quoted_values);
+    // Double quoted strings
+    $double_quoted_values = array(0 => " ", 1 => "test", 3 => "Hello", 4 => "HELLO", 5 => "", 6 => "\t", 7 => "0", 8 => "123Hello", 9 => "\"", 10 => "@#\$%");
+    echo "\n-- Sorting Double Quoted String values --\n";
+    var_dump(usort($double_quoted_values, 'cmp_function'));
+    var_dump($double_quoted_values);
+    // Heredoc strings
+    $heredoc_values = array(0 => $empty_heredoc, 1 => $simple_heredoc1, 2 => $simple_heredoc2, 3 => $multiline_heredoc);
+    echo "\n-- Sorting Heredoc String values --\n";
+    var_dump(usort($heredoc_values, 'cmp_function'));
+    var_dump($heredoc_values);
+}
+?>
+--EXPECTF--
+*** Testing usort() : usage variation ***
+
+-- Sorting Single Quoted String values --
+bool(true)
+array(10) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(1) " "
+  [2]=>
+  string(1) "'"
+  [3]=>
+  string(1) "0"
+  [4]=>
+  string(8) "123Hello"
+  [5]=>
+  string(4) "@#$%"
+  [6]=>
+  string(5) "HELLO"
+  [7]=>
+  string(5) "Hello"
+  [8]=>
+  string(2) "\t"
+  [9]=>
+  string(4) "test"
+}
+
+-- Sorting Double Quoted String values --
+bool(true)
+array(10) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(1) "	"
+  [2]=>
+  string(1) " "
+  [3]=>
+  string(1) """
+  [4]=>
+  string(1) "0"
+  [5]=>
+  string(8) "123Hello"
+  [6]=>
+  string(4) "@#$%"
+  [7]=>
+  string(5) "HELLO"
+  [8]=>
+  string(5) "Hello"
+  [9]=>
+  string(4) "test"
+}
+
+-- Sorting Heredoc String values --
+bool(true)
+array(4) {
+  [0]=>
+  string(0) ""
+  [1]=>
+  string(7) "HEREDOC"
+  [2]=>
+  string(7) "Heredoc"
+  [3]=>
+  string(%d) "heredoc string	with!@# and 123
+Test this!!!"
+}
diff --git a/tests/std/array/usort_variation6.phpt b/tests/std/array/usort_variation6.phpt
new file mode 100644
index 00000000..b1024907
--- /dev/null
+++ b/tests/std/array/usort_variation6.phpt
@@ -0,0 +1,116 @@
+--TEST--
+Test usort() function : usage variations - multi-dimensional arrays
+--FILE--
+<?php
+function cmp_function($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+function main()
+{
+    /*
+     * Pass a multi-dimensional array as $array_arg argument to usort()
+     * to test how array is re-ordered
+     */
+    echo "*** Testing usort() : usage variation ***\n";
+    $array_args = array(0 => array(2, 10, -1), 1 => array(100), 2 => array(), 3 => array(0), 4 => array(-1), 5 => array(-9, 34, 54, 0, 20), 6 => array(''), 7 => array("apple", "Apple", "APPLE", "aPPle", "aPpLe"));
+    $temp_array = $array_args;
+    echo "\n-- Pass usort() a two-dimensional array --\n";
+    // sorting array_arg as whole array
+    var_dump(usort($temp_array, 'cmp_function'));
+    echo "-- Array after call to usort() --\n";
+    var_dump($temp_array);
+    echo "\n-- Pass usort() a sub-array --\n";
+    var_dump(usort($array_args[5], 'cmp_function'));
+    echo "-- Array after call to usort() --\n";
+    var_dump($array_args[5]);
+}
+?>
+--EXPECT--
+*** Testing usort() : usage variation ***
+
+-- Pass usort() a two-dimensional array --
+bool(true)
+-- Array after call to usort() --
+array(8) {
+  [0]=>
+  array(0) {
+  }
+  [1]=>
+  array(1) {
+    [0]=>
+    string(0) ""
+  }
+  [2]=>
+  array(1) {
+    [0]=>
+    int(-1)
+  }
+  [3]=>
+  array(1) {
+    [0]=>
+    int(0)
+  }
+  [4]=>
+  array(1) {
+    [0]=>
+    int(100)
+  }
+  [5]=>
+  array(3) {
+    [0]=>
+    int(2)
+    [1]=>
+    int(10)
+    [2]=>
+    int(-1)
+  }
+  [6]=>
+  array(5) {
+    [0]=>
+    int(-9)
+    [1]=>
+    int(34)
+    [2]=>
+    int(54)
+    [3]=>
+    int(0)
+    [4]=>
+    int(20)
+  }
+  [7]=>
+  array(5) {
+    [0]=>
+    string(5) "apple"
+    [1]=>
+    string(5) "Apple"
+    [2]=>
+    string(5) "APPLE"
+    [3]=>
+    string(5) "aPPle"
+    [4]=>
+    string(5) "aPpLe"
+  }
+}
+
+-- Pass usort() a sub-array --
+bool(true)
+-- Array after call to usort() --
+array(5) {
+  [0]=>
+  int(-9)
+  [1]=>
+  int(0)
+  [2]=>
+  int(20)
+  [3]=>
+  int(34)
+  [4]=>
+  int(54)
+}
diff --git a/tests/std/array/usort_variation7.phpt b/tests/std/array/usort_variation7.phpt
new file mode 100644
index 00000000..ae036a58
--- /dev/null
+++ b/tests/std/array/usort_variation7.phpt
@@ -0,0 +1,85 @@
+--TEST--
+Test usort() function : usage variations - Anonymous comparison function
+--SKIPIF--
+<?php
+if (true) die("skip AOT does not support reference parameters in closures");
+?>
+
+--FILE--
+<?php
+/*
+ * Pass an anonymous comparison function as $cmp_function argument to test behaviour()
+ */
+
+echo "*** Testing usort() : usage variation ***\n";
+
+$cmp_function = function($value1, $value2) {
+    if ($value1 == $value2) { return 0; }
+    else if ($value1 > $value2) { return 1; }
+    else { return -1; }
+};
+
+$array_arg = array(0 => 100, 1 => 3, 2 => -70, 3 => 24, 4 => 90);
+
+echo "\n-- Anonymous 'cmp_function' with parameters passed by value --\n";
+var_dump( usort($array_arg, $cmp_function) );
+var_dump($array_arg);
+
+$array_arg = array("b" => "Banana", "m" => "Mango", "a" => "Apple", "p" => "Pineapple");
+
+$cmp_function = function(&$value1, &$value2) {
+    if ($value1 == $value2) { return 0; }
+    else if ($value1 > $value2) { return 1; }
+    else { return -1; }
+};
+
+echo "\n-- Anonymous 'cmp_function' with parameters passed by reference --\n";
+var_dump( usort($array_arg, $cmp_function) );
+var_dump($array_arg);
+?>
+--EXPECTF--
+*** Testing usort() : usage variation ***
+
+-- Anonymous 'cmp_function' with parameters passed by value --
+bool(true)
+array(5) {
+  [0]=>
+  int(-70)
+  [1]=>
+  int(3)
+  [2]=>
+  int(24)
+  [3]=>
+  int(90)
+  [4]=>
+  int(100)
+}
+
+-- Anonymous 'cmp_function' with parameters passed by reference --
+
+Warning: {closure:%s:%d}(): Argument #1 ($value1) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #2 ($value2) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #1 ($value1) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #2 ($value2) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #1 ($value1) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #2 ($value2) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #1 ($value1) must be passed by reference, value given in %s on line %d
+
+Warning: {closure:%s:%d}(): Argument #2 ($value2) must be passed by reference, value given in %s on line %d
+bool(true)
+array(4) {
+  [0]=>
+  string(5) "Apple"
+  [1]=>
+  string(6) "Banana"
+  [2]=>
+  string(5) "Mango"
+  [3]=>
+  string(9) "Pineapple"
+}
diff --git a/tests/std/array/usort_variation8.phpt b/tests/std/array/usort_variation8.phpt
new file mode 100644
index 00000000..2775e097
--- /dev/null
+++ b/tests/std/array/usort_variation8.phpt
@@ -0,0 +1,60 @@
+--TEST--
+Test usort() function : usage variations - use built in functions as $cmp_function arg
+--FILE--
+<?php
+/*
+ * Test usort() when comparison function is:
+ * 1. a built in comparison function
+ * 2. a language construct
+ */
+
+echo "*** Testing usort() : usage variation ***\n";
+
+// Initializing variables
+$array_arg = array("b" => "Banana", "m" => "Mango", "a" => "apple",
+                   "p" => "Pineapple", "o" => "orange");
+
+// Testing library functions as comparison function
+echo "\n-- Testing usort() with built-in 'cmp_function': strcasecmp() --\n";
+$temp_array1 = $array_arg;
+var_dump( usort($temp_array1, 'strcasecmp') );
+var_dump($temp_array1);
+
+echo "\n-- Testing usort() with built-in 'cmp_function': strcmp() --\n";
+$temp_array2 = $array_arg;
+var_dump( usort($temp_array2, 'strcmp') );
+var_dump($temp_array2);
+
+?>
+--EXPECT--
+*** Testing usort() : usage variation ***
+
+-- Testing usort() with built-in 'cmp_function': strcasecmp() --
+bool(true)
+array(5) {
+  [0]=>
+  string(5) "apple"
+  [1]=>
+  string(6) "Banana"
+  [2]=>
+  string(5) "Mango"
+  [3]=>
+  string(6) "orange"
+  [4]=>
+  string(9) "Pineapple"
+}
+
+-- Testing usort() with built-in 'cmp_function': strcmp() --
+bool(true)
+array(5) {
+  [0]=>
+  string(6) "Banana"
+  [1]=>
+  string(5) "Mango"
+  [2]=>
+  string(9) "Pineapple"
+  [3]=>
+  string(5) "apple"
+  [4]=>
+  string(6) "orange"
+}
diff --git a/tests/std/array/usort_variation9.phpt b/tests/std/array/usort_variation9.phpt
new file mode 100644
index 00000000..a28bb4a4
--- /dev/null
+++ b/tests/std/array/usort_variation9.phpt
@@ -0,0 +1,51 @@
+--TEST--
+Test usort() function : usage variations - referenced variables
+--SKIPIF--
+<?php die("skip AOT does not fully support references"); ?>
+--FILE--
+<?php
+function cmp_function($value1, $value2)
+{
+    if ($value1 == $value2) {
+        return 0;
+    } else if ($value1 > $value2) {
+        return 1;
+    } else {
+        return -1;
+    }
+}
+function main()
+{
+    /*
+     * Pass an array of referenced variables as $array_arg to test behaviour
+     */
+    echo "*** Testing usort() : usage variation ***\n";
+    // different variables which are used as elements of $array_arg
+    $value1 = -5;
+    $value2 = 100;
+    $value3 = 0;
+    $value4 =& $value1;
+    // array_args an array containing elements with reference variables
+    $array_arg = array(0 => 10, 1 => &$value4, 2 => &$value2, 3 => 200, 4 => &$value3);
+    echo "\n-- Sorting \$array_arg containing different references --\n";
+    var_dump(usort($array_arg, 'cmp_function'));
+    var_dump($array_arg);
+}
+?>
+--EXPECT--
+*** Testing usort() : usage variation ***
+
+-- Sorting $array_arg containing different references --
+bool(true)
+array(5) {
+  [0]=>
+  &int(-5)
+  [1]=>
+  &int(0)
+  [2]=>
+  int(10)
+  [3]=>
+  &int(100)
+  [4]=>
+  int(200)
+}
diff --git a/tests/std/array/var_export.phpt b/tests/std/array/var_export.phpt
new file mode 100644
index 00000000..5c23ad26
--- /dev/null
+++ b/tests/std/array/var_export.phpt
@@ -0,0 +1,13 @@
+--TEST--
+var_export() and objects with numeric indexes properties
+--FILE--
+<?php
+$a = (object) array (1, 3, "foo" => "bar");
+var_export($a);
+?>
+--EXPECT--
+(object) array(
+   '0' => 1,
+   '1' => 3,
+   'foo' => 'bar',
+)
diff --git a/tests/std/array/var_export2.phpt b/tests/std/array/var_export2.phpt
new file mode 100644
index 00000000..6db44d5c
--- /dev/null
+++ b/tests/std/array/var_export2.phpt
@@ -0,0 +1,13 @@
+--TEST--
+var_export() and empty array keys
+--FILE--
+<?php
+$a = array ("\0" => 'null', "" => 'empty', "0" => 'nul');
+var_export($a);
+?>
+--EXPECT--
+array (
+  '' . "\0" . '' => 'null',
+  '' => 'empty',
+  0 => 'nul',
+)
diff --git a/tests/std/array/var_export3.phpt b/tests/std/array/var_export3.phpt
new file mode 100644
index 00000000..76c40155
--- /dev/null
+++ b/tests/std/array/var_export3.phpt
@@ -0,0 +1,25 @@
+--TEST--
+var_export() and classes
+--FILE--
+<?php
+class kake
+{
+    public $mann;
+    protected $kvinne;
+    function __construct()
+    {
+        $this->mann = 42;
+        $this->kvinne = 43;
+    }
+}
+function main()
+{
+    $kake = new kake();
+    var_export($kake);
+}
+?>
+--EXPECT--
+\kake::__set_state(array(
+   'mann' => 42,
+   'kvinne' => 43,
+))