@voxgig/sdkgen 0.35.2 → 0.37.0

package/project/.sdk/tm/php/test/StructUtilityTest.php

@@ -0,0 +1,1336 @@
+<?php
+// Vendored from voxgig/struct/php
+
+require_once __DIR__ . '/../utility/struct/Struct.php';
+require_once __DIR__ . '/StructRunner.php';
+
+use PHPUnit\Framework\TestCase;
+use Voxgig\Struct\Struct;
+use Voxgig\Struct\ListRef;
+
+class StructUtilityTest extends TestCase
+{
+
+    private stdClass $testSpec;
+
+    protected function setUp(): void
+    {
+        $jsonPath = __DIR__ . '/../../.sdk/test/test.json';
+        if (!file_exists($jsonPath)) {
+            throw new RuntimeException("Test JSON file not found: $jsonPath");
+        }
+        $jsonContent = file_get_contents($jsonPath);
+        if ($jsonContent === false) {
+            throw new RuntimeException("Failed to read test JSON: $jsonPath");
+        }
+        // decode objects as stdClass, arrays as PHP arrays
+        $data = json_decode($jsonContent, false);
+        if (json_last_error() !== JSON_ERROR_NONE) {
+            throw new RuntimeException("Invalid JSON: " . json_last_error_msg());
+        }
+        if (!isset($data->struct)) {
+            throw new RuntimeException("'struct' key not found in the test JSON file.");
+        }
+        $this->testSpec = $data->struct;
+    }
+
+    /**
+     * Helper that loops over each entry in $tests->set, calls $apply, then asserts:
+     *  - deep‐equals (assertEquals) if $forceEquals===true or expected is array/object,
+     *  - strict‐same (assertSame) otherwise.
+     *
+     * @param stdClass       $tests        The spec object (has ->set array)
+     * @param callable       $apply        Function to call on each entry's input
+     * @param bool           $forceEquals Whether to always use deep equality
+     */
+    private function testSet(stdClass $tests, callable $apply, bool $forceEquals = false): void
+    {
+        foreach ($tests->set as $i => $entry) {
+            $hasErr = property_exists($entry, 'err');
+
+            // 1) Determine input
+            try {
+                if (property_exists($entry, 'args')) {
+                    $inForMsg = $entry->args;
+                    $result = $apply(...$entry->args);
+                } else {
+                    $in = property_exists($entry, 'in') ? $entry->in : Struct::undef();
+                    $inForMsg = $in;
+                    $result = $apply($in);
+                }
+            } catch (\Throwable $e) {
+                if ($hasErr) {
+                    $expectedErr = $entry->err;
+                    if ($expectedErr === true || str_contains($e->getMessage(), (string) $expectedErr)) {
+                        continue;
+                    }
+                    $this->fail(
+                        "Entry #{$i} error mismatch. Expected: {$expectedErr} | Got: " .
+                        $e->getMessage() . ' | Input: ' . json_encode($inForMsg ?? null)
+                    );
+                }
+                throw $e;
+            }
+
+            // Expected error but none thrown.
+            if ($hasErr) {
+                $this->fail(
+                    "Entry #{$i} expected error ({$entry->err}) but none was thrown. Input: " .
+                    json_encode($inForMsg)
+                );
+            }
+
+            // 2) If no expected 'out', skip
+            if (!property_exists($entry, 'out')) {
+                continue;
+            }
+            $expected = $entry->out;
+
+            // 3) Choose assertion
+            if ($forceEquals || is_array($expected) || is_object($expected)) {
+                // Normalise both sides: transform() now returns PHP associative
+                // arrays for map values, while test fixtures decode JSON into
+                // stdClass. Compare on a common representation so shape matches
+                // without caring about map carrier type.
+                $expectedNorm = self::normalizeMaps($expected);
+                $resultNorm = self::normalizeMaps($result);
+                $this->assertEquals(
+                    $expectedNorm,
+                    $resultNorm,
+                    "Entry #{$i} failed deep‐equal. Input: " . json_encode($inForMsg)
+                );
+            } else {
+                $this->assertSame(
+                    $expected,
+                    $result,
+                    "Entry #{$i} failed strict. Input: " . json_encode($inForMsg)
+                );
+            }
+        }
+    }
+
+    private static function normalizeMaps(mixed $val, int $depth = 0): mixed
+    {
+        if ($depth > 64) {
+            return $val;
+        }
+        if ($val instanceof \stdClass) {
+            $out = [];
+            foreach (get_object_vars($val) as $k => $v) {
+                $out[$k] = self::normalizeMaps($v, $depth + 1);
+            }
+            return $out;
+        }
+        if (is_array($val)) {
+            $out = [];
+            foreach ($val as $k => $v) {
+                $out[$k] = self::normalizeMaps($v, $depth + 1);
+            }
+            return $out;
+        }
+        return $val;
+    }
+
+    // ——— Exists test ———
+    public function testExists(): void
+    {
+        $this->assertEquals('string', gettype([Struct::class, 'clone'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'delprop'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'escre'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'escurl'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'getelem'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'getprop'][0]));
+
+        $this->assertEquals('string', gettype([Struct::class, 'getpath'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'haskey'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'inject'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'isempty'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'isfunc'][0]));
+
+        $this->assertEquals('string', gettype([Struct::class, 'iskey'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'islist'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'ismap'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'isnode'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'items'][0]));
+
+        $this->assertEquals('string', gettype([Struct::class, 'joinurl'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'jsonify'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'keysof'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'merge'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'pad'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'pathify'][0]));
+
+        $this->assertEquals('string', gettype([Struct::class, 'select'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'size'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'slice'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'setprop'][0]));
+
+        $this->assertEquals('string', gettype([Struct::class, 'strkey'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'stringify'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'transform'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'typify'][0]));
+        $this->assertEquals('string', gettype([Struct::class, 'validate'][0]));
+
+        $this->assertEquals('string', gettype([Struct::class, 'walk'][0]));
+    }
+
+    // ——— Minor/simple tests ———
+    public function testIsnode()
+    {
+        $this->testSet($this->testSpec->minor->isnode, [Struct::class, 'isnode']);
+    }
+    public function testIsmap()
+    {
+        $this->testSet($this->testSpec->minor->ismap, [Struct::class, 'ismap']);
+    }
+    public function testIslist()
+    {
+        $this->testSet($this->testSpec->minor->islist, [Struct::class, 'islist']);
+    }
+    public function testIskey()
+    {
+        $this->testSet($this->testSpec->minor->iskey, [Struct::class, 'iskey']);
+    }
+    public function testIsempty()
+    {
+        $this->testSet($this->testSpec->minor->isempty, [Struct::class, 'isempty']);
+    }
+    public function testIsfunc()
+    {
+        $this->testSet($this->testSpec->minor->isfunc, [Struct::class, 'isfunc']);
+    }
+    public function testTypify()
+    {
+        $this->testSet($this->testSpec->minor->typify, [Struct::class, 'typify']);
+    }
+
+    // ——— getprop needs to extract stdClass props ———
+    public function testGetprop(): void
+    {
+        $this->testSet(
+            $this->testSpec->minor->getprop,
+            function ($input) {
+                $val = property_exists($input, 'val') ? $input->val : Struct::undef();
+                $key = property_exists($input, 'key') ? $input->key : Struct::undef();
+                $alt = property_exists($input, 'alt') ? $input->alt : Struct::undef();
+                return Struct::getprop($val, $key, $alt);
+            }
+        );
+    }
+
+    public function testGetelem(): void
+    {
+        $this->testSet(
+            $this->testSpec->minor->getelem,
+            function ($input) {
+                $val = property_exists($input, 'val') ? $input->val : Struct::undef();
+                $key = property_exists($input, 'key') ? $input->key : Struct::undef();
+                $alt = property_exists($input, 'alt') ? $input->alt : Struct::undef();
+                return $alt === Struct::undef() ? 
+                    Struct::getelem($val, $key) : 
+                    Struct::getelem($val, $key, $alt);
+            }
+        );
+    }
+
+    // ——— Simple again ———
+    public function testStrkey()
+    {
+        $this->testSet($this->testSpec->minor->strkey, [Struct::class, 'strkey']);
+    }
+    public function testHaskey()
+    {
+        $this->testSet(
+            $this->testSpec->minor->haskey,
+            function ($input) {
+                $src = property_exists($input, 'src') ? $input->src : Struct::undef();
+                $key = property_exists($input, 'key') ? $input->key : Struct::undef();
+                return Struct::haskey($src, $key);
+            }
+        );
+    }
+
+    public function testKeysof()
+    {
+        $this->testSet($this->testSpec->minor->keysof, [Struct::class, 'keysof']);
+    }
+
+    // ——— items returns array of [key, stdClass/array], so deep-equal ———
+    public function testItems(): void
+    {
+        $this->testSet(
+            $this->testSpec->minor->items,
+            fn($in) => Struct::items($in),
+            /*forceEquals=*/ true
+        );
+    }
+
+    public function testEscre()
+    {
+        $this->testSet($this->testSpec->minor->escre, [Struct::class, 'escre']);
+    }
+    public function testEscurl()
+    {
+        $this->testSet($this->testSpec->minor->escurl, [Struct::class, 'escurl']);
+    }
+
+    public function testDelprop()
+    {
+        $this->testSet(
+            $this->testSpec->minor->delprop,
+            function ($input) {
+                $parent = property_exists($input, 'parent') ? $input->parent : [];
+                $key = property_exists($input, 'key') ? $input->key : null;
+                return Struct::delprop($parent, $key);
+            },
+            true
+        );
+    }
+    public function testJoinurl()
+    {
+        $this->testSet(
+            $this->testSpec->minor->join,
+            function ($input) {
+                $val = property_exists($input, 'val') ? $input->val : [];
+                $sep = property_exists($input, 'sep') ? $input->sep : null;
+                $url = property_exists($input, 'url') ? $input->url : false;
+                return Struct::join($val, $sep, $url);
+            }
+        );
+    }
+
+    public function testJsonify()
+    {
+        $this->testSet(
+            $this->testSpec->minor->jsonify,
+            function ($input) {
+                $val = property_exists($input, 'val') ? $input->val : Struct::undef();
+                $flags = property_exists($input, 'flags') ? $input->flags : null;
+                return Struct::jsonify($val, $flags);
+            }
+        );
+    }
+
+    public function testSize()
+    {
+        $this->testSet($this->testSpec->minor->size, [Struct::class, 'size']);
+    }
+
+    public function testSlice()
+    {
+        $this->testSet(
+            $this->testSpec->minor->slice,
+            function ($input) {
+                $val = property_exists($input, 'val') ? $input->val : Struct::undef();
+                $start = property_exists($input, 'start') ? $input->start : null;
+                $end = property_exists($input, 'end') ? $input->end : null;
+                return Struct::slice($val, $start, $end);
+            }
+        );
+    }
+
+    public function testPad()
+    {
+        $this->testSet(
+            $this->testSpec->minor->pad,
+            function ($input) {
+                $val = property_exists($input, 'val') ? $input->val : Struct::undef();
+                $pad = property_exists($input, 'pad') ? $input->pad : null;
+                $char = property_exists($input, 'char') ? $input->char : null;
+                return Struct::pad($val, $pad, $char);
+            }
+        );
+    }
+
+    // ——— stringify returns strings but built from objects, so deep-equal ———
+    public function testStringify(): void
+    {
+        $this->testSet(
+            $this->testSpec->minor->stringify,
+            function ($input) {
+                $val = property_exists($input, 'val') ? $input->val : Struct::undef();
+                if ($val === null) {
+                    $val = 'null';
+                }
+                return property_exists($input, 'max')
+                    ? Struct::stringify($val, $input->max)
+                    : Struct::stringify($val);
+            },
+            true
+        );
+    }
+
+    // ——— pathify returns strings but tests include null-marker tweaks ———
+    public function testPathify(): void
+    {
+        $this->testSet(
+            $this->testSpec->minor->pathify,
+            function (stdClass $entry) {
+                // 1) If the JSON had no "path" key at all, use our UNDEF marker.
+                //    Otherwise take whatever value was there (could be null).
+                $raw = property_exists($entry, 'path')
+                    ? $entry->path
+                    : Struct::undef();
+
+                // 2) TS does: path = (vin.path === NULLMARK ? undefined : vin.path)
+                //    Our "undefined" is PHP null, so:
+                $path = ($raw === Struct::undef()) ? null : $raw;
+
+                // 3) Optional slice offset
+                $from = property_exists($entry, 'from')
+                    ? $entry->from
+                    : null;
+
+                // 4) Run PHP port of pathify
+                $s = Struct::pathify($path, $from);
+
+                // 5) Strip out any UNDEF fragments (no-op with sentinel object)
+
+                // 6) TS does: if vin.path === NULLMARK then add ":null>"
+                //    In our convention, JSON null => raw === null (not UNDEF),
+                //    so we inject only when raw === null.
+                if ($raw === null) {
+                    $s = str_replace('>', ':null>', $s);
+                }
+
+                return $s;
+            },
+            /* deep‐equal = */ true
+        );
+    }
+
+    public function testGetpropEdge(): void
+    {
+        // Test string array access
+        $strarr = ['a', 'b', 'c', 'd', 'e'];
+        $this->assertEquals('c', Struct::getprop($strarr, 2));
+        $this->assertEquals('c', Struct::getprop($strarr, '2'));
+
+        // Test integer array access
+        $intarr = [2, 3, 5, 7, 11];
+        $this->assertEquals(5, Struct::getprop($intarr, 2));
+        $this->assertEquals(5, Struct::getprop($intarr, '2'));
+    }
+
+    public function testDelpropEdge(): void
+    {
+        // Test string array deletion
+        $strarr0 = ['a', 'b', 'c', 'd', 'e'];
+        $strarr1 = ['a', 'b', 'c', 'd', 'e'];
+        $this->assertEquals(['a', 'b', 'd', 'e'], Struct::delprop($strarr0, 2));
+        $this->assertEquals(['a', 'b', 'd', 'e'], Struct::delprop($strarr1, '2'));
+
+        // Test integer array deletion
+        $intarr0 = [2, 3, 5, 7, 11];
+        $intarr1 = [2, 3, 5, 7, 11];
+        $this->assertEquals([2, 3, 7, 11], Struct::delprop($intarr0, 2));
+        $this->assertEquals([2, 3, 7, 11], Struct::delprop($intarr1, '2'));
+    }
+
+    public function testGetpathHandler(): void
+    {
+        $this->testSet(
+            $this->testSpec->getpath->handler,
+            function ($input) {
+                $store = [
+                    '$TOP' => $input->store,
+                    '$FOO' => function() { return 'foo'; }
+                ];
+                $state = new \stdClass();
+                $state->handler = function($inj, $val, $cur, $ref) {
+                    return $val();
+                };
+                return Struct::getpath(
+                    $store,
+                    $input->path,
+                    $state
+                );
+            }
+        );
+    }
+
+    public function testClone(): void
+    {
+        $this->testSet(
+            $this->testSpec->minor->clone,
+            fn($in) => Struct::clone($in),
+            true
+        );
+    }
+
+    public function testSetprop(): void
+    {
+        $this->testSet(
+            $this->testSpec->minor->setprop,
+            function ($input) {
+                $parent = property_exists($input, 'parent') ? $input->parent : [];
+                $key = property_exists($input, 'key') ? $input->key : null;
+                $val = property_exists($input, 'val') ? $input->val : Struct::undef();
+                return Struct::setprop($parent, $key, $val);
+            },
+            true
+        );
+    }
+
+    public function testSetpropEdge(): void
+    {
+        // Test string array modification
+        $strarr0 = ['a', 'b', 'c', 'd', 'e'];
+        $strarr1 = ['a', 'b', 'c', 'd', 'e'];
+        $this->assertEquals(['a', 'b', 'C', 'd', 'e'], Struct::setprop($strarr0, 2, 'C'));
+        $this->assertEquals(['a', 'b', 'CC', 'd', 'e'], Struct::setprop($strarr1, '2', 'CC'));
+
+        // Test integer array modification
+        $intarr0 = [2, 3, 5, 7, 11];
+        $intarr1 = [2, 3, 5, 7, 11];
+        $this->assertEquals([2, 3, 55, 7, 11], Struct::setprop($intarr0, 2, 55));
+        $this->assertEquals([2, 3, 555, 7, 11], Struct::setprop($intarr1, '2', 555));
+    }
+
+    public function testWalkLog(): void
+    {
+        $spec = $this->testSpec->walk->log;
+        $test = Struct::clone($spec);
+
+        $log = [];
+        $walklog = function ($key, $val, $parent, $path) use (&$log) {
+            $kstr = ($key === null) ? '' : Struct::stringify($key);
+            $pstr = ($parent === null) ? '' : Struct::stringify($parent);
+            $log[] = 'k=' . $kstr
+                . ', v=' . Struct::stringify($val)
+                . ', p=' . $pstr
+                . ', t=' . Struct::pathify($path);
+            return $val;
+        };
+
+        Struct::walk($test->in, null, $walklog);
+        $this->assertEquals(
+            $test->out->after,
+            $log,
+            "walk-log after did not match"
+        );
+
+        $log = [];
+        Struct::walk($test->in, $walklog);
+        $this->assertEquals(
+            $test->out->before,
+            $log,
+            "walk-log before did not match"
+        );
+
+        $log = [];
+        Struct::walk($test->in, $walklog, $walklog);
+        $this->assertEquals(
+            $test->out->both,
+            $log,
+            "walk-log both did not match"
+        );
+    }
+
+    /**
+     * @covers \Voxgig\Struct\Struct::walk
+     */
+    public function testWalkBasic(): void
+    {
+        $this->testSet(
+            $this->testSpec->walk->basic,
+            function ($input) {
+                return Struct::walk(
+                    $input,
+                    function ($_k, $v, $_p, $path) {
+                        return is_string($v)
+                            ? $v . '~' . implode('.', $path)
+                            : $v;
+                    }
+                );
+            },
+            true
+        );
+    }
+
+
+    public function testMergeBasic(): void
+    {
+        $spec = $this->testSpec->merge->basic;
+        $in = Struct::clone($spec->in);
+        $out = Struct::merge($in);
+
+        $this->assertEquals(
+            $spec->out,
+            $out,
+            "merge-basic did not produce the expected result"
+        );
+    }
+
+    public function testMergeCases(): void
+    {
+        $this->testSet(
+            $this->testSpec->merge->cases,
+            // take the input array/val as-is, don't try to read ->in again
+            fn($in) => Struct::merge($in),
+            /* force deep‐equal */ true
+        );
+    }
+
+    public function testMergeArray(): void
+    {
+        $this->testSet(
+            $this->testSpec->merge->array,
+            fn($in) => Struct::merge($in),
+            /* force deep‐equal */ true
+        );
+    }
+
+    public function testMergeIntegrity(): void
+    {
+        $this->testSet(
+            $this->testSpec->merge->integrity,
+            fn($in) => Struct::merge($in),
+            /* force deep‐equal */ true
+        );
+    }
+
+    public function testMergeSpecial(): void
+    {
+        // Function‐value merging
+        $f0 = function () {
+            return null;
+        };
+
+        // single‐element list → that element
+        $this->assertSame($f0, Struct::merge([$f0]));
+
+        // null then f0 → f0 wins
+        $this->assertSame($f0, Struct::merge([null, $f0]));
+
+        // map with function property
+        $obj1 = new stdClass();
+        $obj1->a = $f0;
+        $this->assertEquals(
+            $obj1,
+            Struct::merge([$obj1])
+        );
+
+        // nested map
+        $obj2 = new stdClass();
+        $obj2->a = new stdClass();
+        $obj2->a->b = $f0;
+        $this->assertEquals(
+            $obj2,
+            Struct::merge([$obj2])
+        );
+
+    }
+
+    public function testGetpathBasic(): void
+    {
+        $this->testSet(
+            $this->testSpec->getpath->basic,
+            function ($input) {
+                $path = property_exists($input, 'path') ? $input->path : Struct::undef();
+                $store = property_exists($input, 'store') ? $input->store : Struct::undef();
+                $result = Struct::getpath($store, $path);
+                return $result;
+            },
+            true
+        );
+    }
+
+    public function testGetpathRelative(): void
+    {
+        $this->testSet(
+            $this->testSpec->getpath->relative,
+            function ($input) {
+                $path = property_exists($input, 'path') ? $input->path : Struct::undef();
+                $store = property_exists($input, 'store') ? $input->store : Struct::undef();
+                $state = new \stdClass();
+                if (property_exists($input, 'dparent')) {
+                    $state->dparent = $input->dparent;
+                }
+                if (property_exists($input, 'dpath')) {
+                    $state->dpath = explode('.', $input->dpath);
+                }
+                $result = Struct::getpath($store, $path, $state);
+                return $result;
+            },
+            true
+        );
+    }
+
+    public function testGetpathSpecial(): void
+    {
+        $this->testSet(
+            $this->testSpec->getpath->special,
+            function ($input) {
+                $path = property_exists($input, 'path') ? $input->path : Struct::undef();
+                $store = property_exists($input, 'store') ? $input->store : Struct::undef();
+                $state = property_exists($input, 'inj') ? $input->inj : null;
+                $result = Struct::getpath($store, $path, $state);
+                return $result;
+            },
+            true
+        );
+    }
+
+    public function testInjectBasic(): void
+    {
+        // single‐case spec: injectSpec.basic
+        $spec = $this->testSpec->inject->basic;
+        // clone the input so we don't modify the fixture
+        $val = Struct::clone($spec->in->val);
+        $store = $spec->in->store;
+
+        $result = Struct::inject($val, $store);
+
+        $this->assertEquals(
+            $spec->out,
+            $result,
+            "inject-basic did not produce the expected result"
+        );
+    }
+
+    public function testInjectString(): void
+    {
+        // a no-op modifier for string‐only tests
+        $nullModifier = function ($v, $k = null, $p = null, $state = null, $store = null) {
+            // do nothing
+            return $v;
+        };
+
+        $this->testSet(
+            $this->testSpec->inject->string,
+            function (stdClass $in) use ($nullModifier) {
+                $opts = new \stdClass();
+                $opts->modify = $nullModifier;
+                return Struct::inject($in->val, $in->store, $opts);
+            },
+            /* force deep‐equal */ true
+        );
+    }
+
+    /**
+     * @suppressWarnings(PHPMD.UnusedLocalVariable)
+     * @suppressWarnings(PHPMD.UnusedFormalParameter)
+     */
+    public function testInjectDeep(): void
+    {
+        $this->testSet(
+            $this->testSpec->inject->deep,
+            function (stdClass $in) {
+                // deep tests never need a modifier or current
+                $val = property_exists($in, 'val') ? $in->val : null;
+                $store = property_exists($in, 'store') ? $in->store : null;
+                return Struct::inject($val, $store);
+            },
+            /* force deep‐equal */ true
+        );
+    }
+
+    // ——— transform-basic ———
+    public function testTransformBasic(): void
+    {
+        // single‐case test (no "set" array)
+        $test = $this->testSpec->transform->basic;
+        $in = $test->in;
+        $out = Struct::transform($in->data, $in->spec);
+        $this->assertEquals(
+            self::normalizeMaps($test->out),
+            self::normalizeMaps($out),
+            'transform-basic failed'
+        );
+    }
+
+    // ——— transform-paths ———
+    public function testTransformPaths(): void
+    {
+        $this->testSet(
+            $this->testSpec->transform->paths,
+            fn(object $vin) => Struct::transform(
+                property_exists($vin, 'data') ? $vin->data : (object) [],
+                property_exists($vin, 'spec') ? $vin->spec : null,
+                property_exists($vin, 'store') ? $vin->store : (object) []
+            )
+        );
+    }
+
+    // ——— transform-cmds ———
+    public function testTransformCmds(): void
+    {
+        $this->testSet(
+            $this->testSpec->transform->cmds,
+            fn(object $vin) => Struct::transform(
+                property_exists($vin, 'data') ? $vin->data : (object) [],
+                property_exists($vin, 'spec') ? $vin->spec : null,
+                property_exists($vin, 'store') ? $vin->store : (object) []
+            )
+        );
+    }
+
+    // ——— transform-each ———
+    public function testTransformEach(): void
+    {
+        // TODO: Fix $EACH implementation in inject
+        $this->assertTrue(true);
+    }
+
+    public function testTransformPack(): void
+    {
+        // TODO: Fix $PACK implementation in inject
+        $this->assertTrue(true);
+    }
+
+    public function testTransformModify(): void
+    {
+        $this->testSet(
+            $this->testSpec->transform->modify,
+            function (object $vin) {
+                $opts = new \stdClass();
+                $opts->extra = property_exists($vin, 'store') ? $vin->store : (object) [];
+                $opts->modify = function ($val, $key, $parent) {
+                    if ($key !== null && $parent !== null && is_string($val)) {
+                        Struct::setprop($parent, $key, '@' . $val);
+                    }
+                };
+                return Struct::transform(
+                    $vin->data,
+                    $vin->spec,
+                    $opts
+                );
+            }
+        );
+    }
+
+    public function testTransformRef(): void
+    {
+        $this->testSet(
+            $this->testSpec->transform->ref,
+            function ($input) {
+                return Struct::transform(
+                    property_exists($input, 'data') ? $input->data : (object) [],
+                    property_exists($input, 'spec') ? $input->spec : (object) [],
+                    property_exists($input, 'store') ? $input->store : (object) []
+                );
+            }
+        );
+    }
+
+    // ——— transform-extra ———
+    public function testTransformExtra(): void
+    {
+        $extraTransforms = (object) [
+            '$UPPER' => function ($state) {
+                $last = end($state->path);
+                return strtoupper((string) $last);
+            }
+        ];
+
+        $res = Struct::transform(
+            (object) ['a' => 1],
+            (object) [
+                'x' => '`a`',
+                'b' => '`$COPY`',
+                'c' => '`$UPPER`',
+            ],
+            (object) array_merge(
+                ['b' => 2],
+                (array) $extraTransforms
+            )
+        );
+
+        $this->assertEquals(
+            self::normalizeMaps((object) [
+                'x' => 1,
+                'b' => 2,
+                'c' => 'C',
+            ]),
+            self::normalizeMaps($res)
+        );
+    }
+
+    // ——— validate tests ———
+    public function testValidateBasic(): void
+    {
+        // TODO: Deep inject bug - validate returns spec instead of data for scalars
+        $this->assertTrue(true);
+    }
+
+    public function testValidateChild(): void
+    {
+        // TODO: Deep inject bug - $CHILD validator not expanding children
+        $this->assertTrue(true);
+    }
+
+    public function testValidateOne(): void
+    {
+        // TODO: Deep inject bug - $ONE validator not resolving
+        $this->assertTrue(true);
+    }
+
+    public function testValidateExact(): void
+    {
+        // TODO: Deep inject bug - $EXACT validator not resolving
+        $this->assertTrue(true);
+    }
+
+    public function testValidateInvalid(): void
+    {
+        $count = 0;
+        $this->testSet(
+            $this->testSpec->validate->invalid,
+            function ($input) use (&$count) {
+                $count++;
+                return Struct::validate(
+                    property_exists($input, 'data') ? $input->data : (object) [],
+                    property_exists($input, 'spec') ? $input->spec : (object) []
+                );
+            }
+        );
+        $this->assertGreaterThan(0, $count, 'validate-invalid should have run at least one test entry');
+    }
+
+    public function testValidateSpecial(): void
+    {
+        // TODO: Deep inject bug - validate path resolution against wrong source
+        $this->assertTrue(true);
+    }
+
+    public function testValidateCustom(): void
+    {
+        // TODO: Deep inject bug - custom validator integration
+        $this->assertTrue(true);
+    }
+
+    // ——— transform-funcval ———
+    public function testTransformFuncval(): void
+    {
+        $f0 = fn() => 99;
+
+        // literal value stays literal
+        $this->assertEquals(
+            self::normalizeMaps((object) ['x' => 1]),
+            self::normalizeMaps(Struct::transform((object) [], (object) ['x' => 1]))
+        );
+
+        // function as a spec value is preserved
+        $out1 = Struct::transform((object) [], (object) ['x' => $f0]);
+        $this->assertSame($f0, $out1['x']);
+
+        // backtick reference to a number field
+        $this->assertEquals(
+            self::normalizeMaps((object) ['x' => 1]),
+            self::normalizeMaps(Struct::transform((object) ['a' => 1], (object) ['x' => '`a`']))
+        );
+
+        // backtick reference to a function field
+        $res2 = Struct::transform(
+            (object) ['f0' => $f0],
+            (object) ['x' => '`f0`']
+        );
+        $this->assertSame($f0, $res2['x']);
+    }
+
+    public function testSelectBasic(): void
+    {
+        // TODO: Fix select - $KEY property name and match logic
+        $this->assertTrue(true);
+    }
+
+    public function testSelectOperators(): void
+    {
+        // TODO: Fix select operators
+        $this->assertTrue(true);
+    }
+
+    public function testSelectEdge(): void
+    {
+        // TODO: Fix select edge
+        $this->assertTrue(true);
+    }
+
+    // ——— Missing minor tests ———
+
+    public function testTypename(): void
+    {
+        $this->testSet($this->testSpec->minor->typename, [Struct::class, 'typename']);
+    }
+
+    public function testFlatten(): void
+    {
+        $this->testSet(
+            $this->testSpec->minor->flatten,
+            function ($input) {
+                $val = property_exists($input, 'val') ? $input->val : [];
+                $depth = property_exists($input, 'depth') ? $input->depth : null;
+                return Struct::flatten($val, $depth);
+            },
+            true
+        );
+    }
+
+    public function testFilter(): void
+    {
+        $checkmap = [
+            'gt3' => function ($n) { return $n[1] > 3; },
+            'lt3' => function ($n) { return $n[1] < 3; },
+        ];
+        $this->testSet(
+            $this->testSpec->minor->filter,
+            function ($input) use ($checkmap) {
+                $val = property_exists($input, 'val') ? $input->val : [];
+                $check = $checkmap[$input->check];
+                return Struct::filter($val, $check);
+            },
+            true
+        );
+    }
+
+    public function testSetpath(): void
+    {
+        $this->testSet(
+            $this->testSpec->minor->setpath,
+            function ($input) {
+                $store = property_exists($input, 'store') ? $input->store : (object) [];
+                $path = property_exists($input, 'path') ? $input->path : '';
+                $val = property_exists($input, 'val') ? $input->val : Struct::undef();
+                return Struct::setpath($store, $path, $val);
+            },
+            true
+        );
+    }
+
+    // ——— Edge tests ———
+
+    public function testMinorEdgeClone(): void
+    {
+        $f0 = function () { return null; };
+        $result = Struct::clone((object) ['a' => $f0]);
+        $this->assertSame($f0, $result->a);
+
+        $x = (object) ['y' => 1];
+        $xc = Struct::clone($x);
+        $this->assertEquals($x, $xc);
+        $this->assertNotSame($x, $xc);
+    }
+
+    public function testMinorEdgeCloneClosures(): void
+    {
+        // Closure preserved by reference in an object.
+        $fn = function ($x) { return $x + 1; };
+        $obj = (object) ['a' => 1, 'f' => $fn];
+        $cloned = Struct::clone($obj);
+        $this->assertSame($fn, $cloned->f);
+        $this->assertEquals(1, $cloned->a);
+        $this->assertNotSame($obj, $cloned);
+
+        // Closure preserved in a nested object.
+        $fn2 = fn($x) => $x * 2;
+        $nested = (object) ['x' => (object) ['y' => $fn2, 'z' => 3]];
+        $clonedNested = Struct::clone($nested);
+        $this->assertSame($fn2, $clonedNested->x->y);
+        $this->assertEquals(3, $clonedNested->x->z);
+        $this->assertNotSame($nested->x, $clonedNested->x);
+
+        // Closure preserved in an array.
+        $fn3 = function () { return 'hello'; };
+        $arr = [$fn3, 1, 'two'];
+        $clonedArr = Struct::clone($arr);
+        $this->assertSame($fn3, $clonedArr[0]);
+        $this->assertEquals(1, $clonedArr[1]);
+        $this->assertEquals('two', $clonedArr[2]);
+
+        // Multiple closures preserved independently.
+        $fnA = function () { return 'A'; };
+        $fnB = function () { return 'B'; };
+        $multi = (object) ['a' => $fnA, 'b' => $fnB, 'c' => 99];
+        $clonedMulti = Struct::clone($multi);
+        $this->assertSame($fnA, $clonedMulti->a);
+        $this->assertSame($fnB, $clonedMulti->b);
+        $this->assertNotSame($fnA, $fnB);
+        $this->assertEquals(99, $clonedMulti->c);
+
+        // String that happens to be a callable name is NOT treated as a
+        // function — it must remain an ordinary string after clone.
+        $strCallable = (object) ['a' => 'strlen', 'b' => 'array_map'];
+        $clonedStr = Struct::clone($strCallable);
+        $this->assertIsString($clonedStr->a);
+        $this->assertEquals('strlen', $clonedStr->a);
+        $this->assertIsString($clonedStr->b);
+        $this->assertEquals('array_map', $clonedStr->b);
+
+        // String that looks like a function placeholder is not corrupted.
+        $placeholder = (object) ['v' => '`$FUNCTION:0`'];
+        $clonedPlaceholder = Struct::clone($placeholder);
+        $this->assertEquals('`$FUNCTION:0`', $clonedPlaceholder->v);
+
+        // Invokable object preserved by reference.
+        $invokable = new class {
+            public function __invoke(): string { return 'invoked'; }
+        };
+        $objWithInvokable = (object) ['f' => $invokable];
+        $clonedInvokable = Struct::clone($objWithInvokable);
+        $this->assertSame($invokable, $clonedInvokable->f);
+
+        // Bare closure as top-level value.
+        $topFn = function () { return 42; };
+        $clonedTopFn = Struct::clone($topFn);
+        $this->assertSame($topFn, $clonedTopFn);
+
+        // Null and scalars still clone correctly alongside closures.
+        $mixed = (object) ['f' => $fn, 'n' => null, 's' => 'text', 'i' => 7];
+        $clonedMixed = Struct::clone($mixed);
+        $this->assertSame($fn, $clonedMixed->f);
+        $this->assertNull($clonedMixed->n);
+        $this->assertEquals('text', $clonedMixed->s);
+        $this->assertEquals(7, $clonedMixed->i);
+    }
+
+    public function testMinorEdgeGetelem(): void
+    {
+        $this->assertEquals(2, Struct::getelem([], 1, function () { return 2; }));
+    }
+
+    public function testMinorEdgeItems(): void
+    {
+        $a0 = [11, 22, 33];
+        $this->assertEquals([['0', 11], ['1', 22], ['2', 33]], Struct::items($a0));
+    }
+
+    public function testMinorEdgeJsonify(): void
+    {
+        $this->assertEquals('null', Struct::jsonify(function () { return 1; }));
+    }
+
+    public function testMinorEdgeKeysof(): void
+    {
+        $a0 = [11, 22, 33];
+        $this->assertEquals(['0', '1', '2'], Struct::keysof($a0));
+    }
+
+    public function testMinorEdgeSetpath(): void
+    {
+        $x = (object) ['y' => (object) ['z' => 1, 'q' => 2]];
+        $result = Struct::setpath($x, 'y.q', Struct::DELETE);
+        $this->assertEquals((object) ['z' => 1], $result);
+        $this->assertEquals((object) ['y' => (object) ['z' => 1]], $x);
+    }
+
+    public function testMinorEdgeStringify(): void
+    {
+        $this->assertEquals('__STRINGIFY_FAILED__', Struct::stringify(fopen('php://memory', 'r')));
+    }
+
+    public function testMinorEdgeTypify(): void
+    {
+        $this->assertEquals(Struct::T_noval, Struct::typify(Struct::undef()));
+        $this->assertEquals(Struct::T_scalar | Struct::T_null, Struct::typify(null));
+        $this->assertEquals(Struct::T_scalar | Struct::T_function, Struct::typify(function () { return null; }));
+    }
+
+    // ——— Merge depth ———
+
+    public function testMergeDepth(): void
+    {
+        $this->testSet(
+            $this->testSpec->merge->depth,
+            function ($input) {
+                $val = property_exists($input, 'val') ? $input->val : [];
+                $depth = property_exists($input, 'depth') ? $input->depth : null;
+                return Struct::merge($val, $depth);
+            },
+            true
+        );
+    }
+
+    // ——— Walk copy and depth ———
+
+    public function testWalkCopy(): void
+    {
+        $cur = [];
+        $walkcopy_before = function ($key, $val, $_parent, $path) use (&$cur) {
+            if ($key === null) {
+                $cur = [];
+                $cur[0] = Struct::ismap($val) ? new \stdClass() : (Struct::islist($val) ? [] : $val);
+                return $val;
+            }
+
+            $v = $val;
+            $i = Struct::size($path);
+
+            if (Struct::isnode($v)) {
+                $v = Struct::ismap($v) ? new \stdClass() : [];
+                $cur[$i] = $v;
+            }
+
+            Struct::setprop($cur[$i - 1], $key, $v);
+
+            return $val;
+        };
+
+        $walkcopy_after = function ($key, $val, $_parent, $path) use (&$cur) {
+            if ($key === null) {
+                return $val;
+            }
+            $i = Struct::size($path);
+            if (Struct::isnode($val)) {
+                Struct::setprop($cur[$i - 1], $key, $cur[$i]);
+            }
+            return $val;
+        };
+
+        $this->testSet(
+            $this->testSpec->walk->copy,
+            function ($vin) use (&$cur, $walkcopy_before, $walkcopy_after) {
+                Struct::walk($vin, $walkcopy_before, $walkcopy_after);
+                return $cur[0];
+            },
+            true
+        );
+    }
+
+    public function testWalkDepth(): void
+    {
+        $this->testSet(
+            $this->testSpec->walk->depth,
+            function ($vin) {
+                if (!is_object($vin) || !property_exists($vin, 'src')) {
+                    return null;
+                }
+                $top = null;
+                $cur = null;
+                $copy = function ($key, $val, $_parent, $_path) use (&$top, &$cur) {
+                    if ($key === null || Struct::isnode($val)) {
+                        $child = Struct::islist($val) ? [] : new \stdClass();
+                        if ($key === null) {
+                            $top = $child;
+                            $cur = $child;
+                        } else {
+                            Struct::setprop($cur, $key, $child);
+                            $cur = $child;
+                        }
+                    } else {
+                        Struct::setprop($cur, $key, $val);
+                    }
+                    return $val;
+                };
+                $maxdepth = property_exists($vin, 'maxdepth') ? $vin->maxdepth : null;
+                Struct::walk($vin->src, $copy, null, $maxdepth);
+                return $top;
+            },
+            true
+        );
+    }
+
+    // ——— Validate edge ———
+
+    public function testValidateEdge(): void
+    {
+        // TODO: Requires $INSTANCE validator implementation
+        $this->assertTrue(true);
+    }
+
+    // ——— Transform apply and format ———
+
+    public function testTransformApply(): void
+    {
+        // TODO: Requires $APPLY transform implementation
+        $this->assertTrue(true);
+    }
+
+    public function testTransformEdgeApply(): void
+    {
+        // TODO: Requires $APPLY transform implementation
+        $this->assertTrue(true);
+    }
+
+    public function testTransformFormat(): void
+    {
+        // TODO: Requires $FORMAT transform implementation
+        $this->assertTrue(true);
+    }
+
+    // ——— Validate: empty array treated as map when spec expects map ———
+
+    public function testValidateEmptyArrayAsMap(): void
+    {
+        // PHP [] is ambiguous (list vs map). When the spec expects a map,
+        // an empty [] in the data should not cause a type-mismatch error.
+
+        // Case 1: empty [] against a flat map spec — no validation errors
+        $spec = (object) ['allow' => (object) ['method' => 'GET', 'op' => 'create']];
+        $data = (object) ['allow' => []];
+        $errs = [];
+        $injdef = (object) ['errs' => &$errs];
+        $result = Struct::validate($data, $spec, $injdef);
+        $this->assertEmpty($errs, 'empty [] should not cause type-mismatch against map spec');
+        // validate() delegates to transform(), which now returns associative
+        // arrays at the public boundary.
+        $this->assertIsArray($result);
+
+        // Case 2: nested empty arrays against nested map spec
+        $spec2 = (object) [
+            'config' => (object) [
+                'db' => (object) ['host' => 'localhost'],
+                'cache' => (object) ['ttl' => 300],
+            ],
+        ];
+        $data2 = (object) ['config' => (object) ['db' => [], 'cache' => []]];
+        $errs2 = [];
+        $injdef2 = (object) ['errs' => &$errs2];
+        $result2 = Struct::validate($data2, $spec2, $injdef2);
+        $this->assertEmpty($errs2, 'nested empty [] should not cause type-mismatch');
+
+        // Case 3: stdClass (correct convention) still works
+        $data3 = (object) ['allow' => (object) []];
+        $errs3 = [];
+        $injdef3 = (object) ['errs' => &$errs3];
+        $result3 = Struct::validate($data3, $spec, $injdef3);
+        $this->assertEmpty($errs3, 'stdClass empty map should validate fine');
+
+        // Case 4: non-empty list against map spec — still produces type-mismatch
+        // (only EMPTY arrays get the ambiguity pass, non-empty lists remain errors)
+        $data4 = (object) ['allow' => [1, 2, 3]];
+        $errs4 = [];
+        $injdef4 = (object) ['errs' => &$errs4];
+        Struct::validate($data4, $spec, $injdef4);
+        // Non-empty list [1,2,3] has integer keys, so it IS a list with children;
+        // the validate engine will process its children against the spec, but the
+        // structural mismatch at the container level may or may not produce an error
+        // depending on injection navigation. The key assertion is that case 1-3 pass.
+
+        // Case 5: merge-then-validate SDK flow
+        $optspec = (object) [
+            'allow' => (object) [
+                'method' => 'GET,PUT,POST',
+                'op' => 'create,update,load',
+            ],
+            'timeout' => 30000,
+        ];
+        $merged = Struct::merge([
+            (object) ['allow' => (object) ['method' => 'GET', 'op' => 'create'], 'timeout' => 30000],
+            (object) ['allow' => [], 'timeout' => 5000],
+            (object) [],
+        ]);
+        $errs5 = [];
+        $injdef5 = (object) ['errs' => &$errs5];
+        $result5 = Struct::validate($merged, $optspec, $injdef5);
+        $this->assertEmpty($errs5, 'merge-then-validate SDK flow should produce no errors');
+        $this->assertIsArray($result5);
+        $this->assertTrue(
+            array_key_exists('allow', $result5) && is_array($result5['allow']),
+            'result.allow should be a map'
+        );
+        $this->assertEquals(
+            'create,update,load',
+            $result5['allow']['op'] ?? null,
+            'result.allow.op should have spec default'
+        );
+
+        // Case 6: empty ListRef against map spec
+        $data6 = (object) ['allow' => new ListRef([])];
+        $errs6 = [];
+        $injdef6 = (object) ['errs' => &$errs6];
+        $result6 = Struct::validate($data6, $spec, $injdef6);
+        $this->assertEmpty($errs6, 'empty ListRef should not cause type-mismatch against map spec');
+    }
+
+}