From 7e4f99b64588df386626b4cdad60b5f519b13ade Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 29 Aug 2026 22:36:12 -0700
Subject: [PATCH 1/3] test(coverage): raise core function coverage from 71.6%
 to 83.2%
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Nine new spec bundles close the biggest measured gaps in the wheelstest
system surface, the per-database adapter SQL generators, the model
ScopeChain/QueryBuilder chain, and global/migrator helpers.

- wheelstest/system: BaseSpec DSL aliases (story/feature/given/scenario/
  when + focused/x variants), assertion facade (assert/fail/
  expectedException/addAssertions), expectAll unrolling, querySim,
  engine predicates, getProperty; the Assertion matcher library
  (closeTo/between/instance/null/type/case-sensitive string/struct/length
  matchers + query/XML equality); Expectation matchers (toBeBetween/
  toSatisfy/toBeCloseTo/case matchers/deep keys/membership/negation);
  Util/Env/XMLConverter/MixerUtil/BaseReporter utilities; MockBox
  createEmptyMock + the injected call-count verification surface; and a
  run()-less xUnit bundle that exercises the legacy UnitRunner path
  (setup/teardown, expectedException contract).
- databaseAdapters: pure SQL-generation units for MySQL/H2/PostgreSQL/
  SQL Server/Oracle models ($upsertSQL, quoting, defaults, locking
  clauses, random order) and migrators (keys, indexes, renames, drops,
  DDL fragments) — no live per-DB connection required, so every matrix
  leg exercises them.
- model: ScopeChain terminal finders/aggregates/updateAll/deleteAll/
  findEach/findInBatches, QueryBuilder.offset, the remaining lifecycle
  callback registrations, ignoredColumns/sharedModel/isClass/isInstance/
  errorsOnBase/withAdvisoryLock.
- global/migrator: TableDefinition/ViewDefinition builders, Migration
  helpers, $convertToStringBoolean/BoxLangSlashDatetime/$normalizePath/
  $boxLangVersionMessage/pluginNames/injector.

Coverage tooling also tightened: the tag-based cffunction matcher now
captures names from the unmasked source (masked attribute values used to
capture the NEXT attribute's name), whole-file template pseudo-entries
and migrator generator templates are excluded from the denominator, and
the measured baseline is updated in tools/code-quality/README.md.

Measured (Lucee 7 + SQLite): 71.6% -> 83.2% function coverage
(1,949 -> 2,175 covered). Full suite: 5,513 pass / 0 fail / 0 error.

Signed-off-by: Peter Amiri <peter@alurium.com>
---
 tools/code-quality/README.md                  |   5 +-
 tools/code-quality/cfml-coverage.py           |  35 +-
 .../database/AdapterSqlGenerationSpec.cfc     | 413 ++++++++++++++++++
 .../global/MigratorGlobalCoverageSpec.cfc     | 133 ++++++
 .../specs/model/ModelSurfaceCoverageSpec.cfc  | 146 +++++++
 .../wheelstest/AssertionMatchersSpec.cfc      | 178 ++++++++
 .../specs/wheelstest/BaseSpecDslAliasSpec.cfc | 220 ++++++++++
 .../wheelstest/ExpectationMatchersSpec.cfc    | 129 ++++++
 .../tests/specs/wheelstest/MockBoxSpec.cfc    |  66 +++
 .../tests/specs/wheelstest/SystemUtilSpec.cfc | 185 ++++++++
 .../specs/wheelstest/XUnitStyleLegacyTest.cfc |  47 ++
 11 files changed, 1552 insertions(+), 5 deletions(-)
 create mode 100644 vendor/wheels/tests/specs/database/AdapterSqlGenerationSpec.cfc
 create mode 100644 vendor/wheels/tests/specs/global/MigratorGlobalCoverageSpec.cfc
 create mode 100644 vendor/wheels/tests/specs/model/ModelSurfaceCoverageSpec.cfc
 create mode 100644 vendor/wheels/tests/specs/wheelstest/AssertionMatchersSpec.cfc
 create mode 100644 vendor/wheels/tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc
 create mode 100644 vendor/wheels/tests/specs/wheelstest/ExpectationMatchersSpec.cfc
 create mode 100644 vendor/wheels/tests/specs/wheelstest/MockBoxSpec.cfc
 create mode 100644 vendor/wheels/tests/specs/wheelstest/SystemUtilSpec.cfc
 create mode 100644 vendor/wheels/tests/specs/wheelstest/XUnitStyleLegacyTest.cfc

diff --git a/tools/code-quality/README.md b/tools/code-quality/README.md
index 42d40fd30..177b21397 100644
--- a/tools/code-quality/README.md
+++ b/tools/code-quality/README.md
@@ -63,8 +63,9 @@ python3 tools/code-quality/cfml-coverage.py combine vendor/wheels \
 python3 tools/code-quality/cfml-coverage.py revert vendor/wheels
 ```
 
-Baseline (Lucee 7 + SQLite, measured 2026-08): **~71% function coverage**
-(1,937/2,723 functions). Known caveats:
+Baseline (Lucee 7 + SQLite, measured 2026-08): **83.2% function coverage**
+(2,175/2,614 functions — template pseudo-entries and migrator generator
+templates excluded from the denominator). Known caveats:
 
 - Coverage is per-leg: `databaseAdapters/*` paths for MySQL/Oracle/SQLServer/
   CockroachDB only execute on those matrix legs — a SQLite-only measurement
diff --git a/tools/code-quality/cfml-coverage.py b/tools/code-quality/cfml-coverage.py
index 54609aa29..cd8ab4aeb 100644
--- a/tools/code-quality/cfml-coverage.py
+++ b/tools/code-quality/cfml-coverage.py
@@ -187,6 +187,12 @@ def _script_insertion_points(masked):
 def _files(root):
     for dirpath, dirnames, filenames in os.walk(root):
         dirnames[:] = [d for d in dirnames if d not in EXCLUDE_DIRS]
+        # migrator/templates/* are generator payloads — the scaffolding copied
+        # into a user's app/db/migrate on `wheels migrate`. The originals never
+        # execute, so instrumenting them only adds permanently-uncovered noise.
+        if os.path.relpath(dirpath, root).replace(os.sep, '/').endswith('migrator/templates'):
+            dirnames[:] = []
+            continue
         for fn in filenames:
             if fn.lower().endswith(('.cfc', '.cfm')):
                 yield os.path.join(dirpath, fn)
@@ -207,8 +213,14 @@ def instrument(root):
         # first, then apply them right-to-left so earlier insertions never
         # shift later positions.
         matches = [(pos, 'script', name) for pos, name in _script_insertion_points(masked)]
-        for m in TAG_FN.finditer(masked):
-            brace = masked.find('>', m.end())
+        # Tag-based cffunctions: match against the ORIGINAL text — masked
+        # attribute values (blanked quotes) make `name\s*=\s*["']?...` skip
+        # the value and capture the NEXT attribute's name. Filter out matches
+        # that start inside a masked (comment/string) region.
+        for m in TAG_FN.finditer(text):
+            if m.start() < len(masked) and masked[m.start()] == ' ':
+                continue
+            brace = text.find('>', m.end())
             if brace >= 0:
                 matches.append((brace + 1, 'tag', m.group(1)))
         matches.sort(key=lambda t: -t[0])
@@ -259,7 +271,23 @@ def combine(root, coverage_path, complexity_path):
         complexity = {r['id']: int(r['complexity']) for r in raw_complexity}
     # cov keys are "<rel>:<fn>"; complexity ids are "<rel>:<line>:<fn>"
     rows = []
+    skipped_templates = 0
     for cid, comp in complexity.items():
+        rel = cid.split(':')[0]
+        # Whole-file pseudo-entries (`<template>`) come from tag-based .cfm
+        # views, interface declarations, and abstract stubs — they are not
+        # executable functions, so function-level coverage cannot measure
+        # them. They'd otherwise count as permanently uncovered noise.
+        if cid.endswith(':<template>'):
+            skipped_templates += 1
+            continue
+        # migrator/templates/* are generator payloads (scaffolding copied into
+        # user apps on `wheels migrate`) — the originals never execute. The
+        # instrumenter skips them, so they'd otherwise read as uncovered.
+        # (The complexity GATE still checks them; only coverage excludes them.)
+        if rel.startswith('migrator/templates/'):
+            skipped_templates += 1
+            continue
         covered = _cov_key(cid) in cov
         cv = 100.0 if covered else 0.0
         rows.append({'id': cid, 'complexity': comp, 'covered': covered, 'crap': round(crap(comp, cv), 1)})
@@ -269,7 +297,8 @@ def combine(root, coverage_path, complexity_path):
     for r in rows[:50]:
         print(f'{r["crap"]:7.1f}  {r["complexity"]:4d}  {"yes" if r["covered"] else "no ":>3}  {r["id"]}')
     n_cov = sum(1 for r in rows if r['covered'])
-    print(f'\nfunction coverage: {n_cov}/{len(rows)} ({100*n_cov/max(1,len(rows)):.1f}%)')
+    print(f'\nfunction coverage: {n_cov}/{len(rows)} ({100*n_cov/max(1,len(rows)):.1f}%)'
+          + (f' (excluded {skipped_templates} template pseudo-entries)' if skipped_templates else ''))
     json.dump(rows, open('crap-report.json', 'w'), indent=2)
     print('wrote crap-report.json')
 
diff --git a/vendor/wheels/tests/specs/database/AdapterSqlGenerationSpec.cfc b/vendor/wheels/tests/specs/database/AdapterSqlGenerationSpec.cfc
new file mode 100644
index 000000000..f9841ccf7
--- /dev/null
+++ b/vendor/wheels/tests/specs/database/AdapterSqlGenerationSpec.cfc
@@ -0,0 +1,413 @@
+component extends="wheels.WheelsTest" {
+
+    /**
+     * Unit coverage for the per-database adapters' PURE SQL-generation
+     * functions. No live MySQL/Oracle/SQL Server/H2/PostgreSQL connection is
+     * needed — the adapters instantiate standalone and these functions build
+     * SQL strings (or simple values) only. Live per-DB execution is covered
+     * by the compat-matrix legs; this spec makes the sqlite leg exercise the
+     * generators on every engine in CI.
+     */
+
+    function run() {
+
+        describe("adapter SQL generation (unit)", () => {
+
+            describe("$upsertSQL", () => {
+
+                // Shared upsert arguments; every adapter takes the same shape.
+                // $buildBulkParam reads type/dataType/scale/nullable from the
+                // propertyInfo entry, mirroring the model class metadata.
+                upsertArgs = function() {
+                    return {
+                        tableName = "c_o_r_e_bulkitems",
+                        columns = ["code", "name"],
+                        uniqueBy = ["code"],
+                        updateColumns = ["name"],
+                        validProperties = ["code", "name"],
+                        records = [
+                            {code = "A1", name = "first"},
+                            {code = "A2", name = "second"}
+                        ],
+                        batchStart = 1,
+                        batchEnd = 2,
+                        propertyInfo = {
+                            code = {type = "string", dataType = "varchar", scale = 0, nullable = false},
+                            name = {type = "string", dataType = "varchar", scale = 0, nullable = false}
+                        }
+                    };
+                };
+
+                it("MySQL emits INSERT ... ON DUPLICATE KEY UPDATE", () => {
+                    var adapter = CreateObject("component", "wheels.databaseAdapters.MySQL.MySQLModel");
+                    var sql = adapter.$upsertSQL(argumentCollection = upsertArgs());
+                    var joined = "";
+                    for (var part in sql) {
+                        if (IsSimpleValue(part)) joined &= part;
+                    }
+                    expect(sql).toBeArray();
+                    expect(joined).toInclude("INSERT INTO c_o_r_e_bulkitems");
+                    expect(joined).toInclude("ON DUPLICATE KEY UPDATE");
+                });
+
+                it("H2 emits MERGE INTO ... KEY (...) VALUES", () => {
+                    var adapter = CreateObject("component", "wheels.databaseAdapters.H2.H2Model");
+                    var sql = adapter.$upsertSQL(argumentCollection = upsertArgs());                    var joined = "";
+                    for (var part in sql) {
+                        if (IsSimpleValue(part)) joined &= part;
+                    }
+
+                    expect(joined).toInclude("MERGE INTO c_o_r_e_bulkitems");
+                    expect(joined).toInclude("KEY");
+                });
+
+                it("PostgreSQL emits INSERT ... ON CONFLICT ... DO UPDATE", () => {
+                    var adapter = CreateObject("component", "wheels.databaseAdapters.PostgreSQL.PostgreSQLModel");
+                    var sql = adapter.$upsertSQL(argumentCollection = upsertArgs());                    var joined = "";
+                    for (var part in sql) {
+                        if (IsSimpleValue(part)) joined &= part;
+                    }
+
+                    expect(joined).toInclude("ON CONFLICT");
+                    expect(joined).toInclude("DO UPDATE");
+                });
+
+                it("SQL Server emits MERGE INTO ... WITH (HOLDLOCK)", () => {
+                    var adapter = CreateObject("component", "wheels.databaseAdapters.MicrosoftSQLServer.MicrosoftSQLServerModel");
+                    var sql = adapter.$upsertSQL(argumentCollection = upsertArgs());                    var joined = "";
+                    for (var part in sql) {
+                        if (IsSimpleValue(part)) joined &= part;
+                    }
+
+                    expect(joined).toInclude("MERGE INTO");
+                    expect(joined).toInclude("WITH (HOLDLOCK)");
+                });
+
+                it("Oracle emits a MERGE INTO ... USING dual clause", () => {
+                    var adapter = CreateObject("component", "wheels.databaseAdapters.Oracle.OracleModel");
+                    var sql = adapter.$upsertSQL(argumentCollection = upsertArgs());                    var joined = "";
+                    for (var part in sql) {
+                        if (IsSimpleValue(part)) joined &= part;
+                    }
+
+                    expect(joined).toInclude("MERGE INTO c_o_r_e_bulkitems");
+                    expect(joined).toInclude("FROM dual");
+                });
+
+            });
+
+            describe("Base adapter helpers", () => {
+
+                it("$addColumnsToSelectAndGroupBy appends ORDER BY columns into GROUP BY", () => {
+                    var adapter = CreateObject("component", "wheels.databaseAdapters.SQLite.SQLiteModel");
+                    var args = {
+                        sql = [
+                            "SELECT",
+                            "COUNT(authorid) AS x",
+                            "GROUP BY authorid",
+                            "ORDER BY authorid, title"
+                        ]
+                    };
+                    adapter.$addColumnsToSelectAndGroupBy(args = args);
+                    expect(args.sql[3]).toInclude("authorid");
+                    expect(args.sql[3]).toInclude("title");
+                });
+
+                it("$defaultValues returns the DEFAULT VALUES fragment", () => {
+                    var adapter = CreateObject("component", "wheels.databaseAdapters.SQLite.SQLiteModel");
+                    expect(adapter.$defaultValues()).toBe(" DEFAULT VALUES");
+                });
+
+                it("$isBoxLangEngine returns a boolean", () => {
+                    var adapter = CreateObject("component", "wheels.databaseAdapters.SQLite.SQLiteModel");
+                    expect(adapter.$isBoxLangEngine()).toBeTypeOf("boolean");
+                });
+
+                it("$forUpdateClause returns '' on adapters without row locking", () => {
+                    var adapter = CreateObject("component", "wheels.databaseAdapters.SQLite.SQLiteModel");
+                    expect(adapter.$forUpdateClause()).toBe("");
+                });
+
+            });
+
+            describe("per-adapter model helpers", () => {
+
+                it("PostgreSQL/MSSQL/MySQL $quoteIdentifier wrap identifiers", () => {
+                    var pg = CreateObject("component", "wheels.databaseAdapters.PostgreSQL.PostgreSQLModel");
+                    expect(pg.$quoteIdentifier(name = "Users")).toBe('"users"');
+                    var mssql = CreateObject("component", "wheels.databaseAdapters.MicrosoftSQLServer.MicrosoftSQLServerModel");
+                    expect(mssql.$quoteIdentifier(name = "Users")).toInclude("Users");
+                    var mysql = CreateObject("component", "wheels.databaseAdapters.MySQL.MySQLModel");
+                    expect(mysql.$quoteIdentifier(name = "Users")).toInclude("Users");
+                });
+
+                it("Oracle $tableAlias joins table and alias", () => {
+                    var oracle = CreateObject("component", "wheels.databaseAdapters.Oracle.OracleModel");
+                    expect(oracle.$tableAlias(table = "users", alias = "u")).toBe("users u");
+                });
+
+                it("H2/Oracle $lowerCaseColumnNames report their column folding", () => {
+                    var h2 = CreateObject("component", "wheels.databaseAdapters.H2.H2Model");
+                    expect(h2.$lowerCaseColumnNames()).toBeTrue();
+                    var oracle = CreateObject("component", "wheels.databaseAdapters.Oracle.OracleModel");
+                    expect(oracle.$lowerCaseColumnNames()).toBeTypeOf("boolean");
+                });
+
+                it("MySQL/Oracle $defaultValues emit their dialect fragment", () => {
+                    var mysql = CreateObject("component", "wheels.databaseAdapters.MySQL.MySQLModel");
+                    expect(mysql.$defaultValues()).toBe("() VALUES()");
+                    var oracle = CreateObject("component", "wheels.databaseAdapters.Oracle.OracleModel");
+                    expect(oracle.$defaultValues($primaryKey = "id")).toBe("(id) VALUES(DEFAULT)");
+                });
+
+                it("MSSQL $forUpdateClause returns its dialect default", () => {
+                    var mssql = CreateObject("component", "wheels.databaseAdapters.MicrosoftSQLServer.MicrosoftSQLServerModel");
+                    expect(mssql.$forUpdateClause()).toBeTypeOf("string");
+                });
+
+                it("MSSQL/PostgreSQL $randomOrder emit dialect-specific randomness", () => {
+                    var mssql = CreateObject("component", "wheels.databaseAdapters.MicrosoftSQLServer.MicrosoftSQLServerModel");
+                    expect(mssql.$randomOrder()).toBe("NEWID()");
+                    var pg = CreateObject("component", "wheels.databaseAdapters.PostgreSQL.PostgreSQLModel");
+                    expect(pg.$randomOrder()).toInclude("RANDOM");
+                });
+
+                it("$supportsAdvisoryLocks reports per-adapter support", () => {
+                    var pg = CreateObject("component", "wheels.databaseAdapters.PostgreSQL.PostgreSQLModel");
+                    expect(pg.$supportsAdvisoryLocks()).toBeTrue();
+                    var mysql = CreateObject("component", "wheels.databaseAdapters.MySQL.MySQLModel");
+                    expect(mysql.$supportsAdvisoryLocks()).toBeTrue();
+                    var mssql = CreateObject("component", "wheels.databaseAdapters.MicrosoftSQLServer.MicrosoftSQLServerModel");
+                    expect(mssql.$supportsAdvisoryLocks()).toBeTypeOf("boolean");
+                });
+
+            });
+
+            describe("Microsoft SQL Server migrator", () => {
+
+                beforeEach(() => {
+                    adapter = CreateObject("component", "wheels.databaseAdapters.MicrosoftSQLServer.MicrosoftSQLServerMigrator");
+                });
+
+                it("adapterName()", () => {
+                    expect(adapter.adapterName()).toInclude("Microsoft");
+                });
+
+                it("addPrimaryKeyOptions() builds NOT NULL + IDENTITY + PRIMARY KEY", () => {
+                    expect(adapter.addPrimaryKeyOptions(sql = "int")).toBe("int NOT NULL PRIMARY KEY");
+                    expect(adapter.addPrimaryKeyOptions(sql = "int", options = {autoIncrement = true}))
+                        .toInclude("IDENTITY(1,1)");
+                    expect(adapter.addPrimaryKeyOptions(sql = "int", options = {allowNull = true}))
+                        .toInclude("NULL");
+                });
+
+                it("addForeignKeyOptions() decorates the column sql", () => {
+                    var out = adapter.addForeignKeyOptions(
+                        sql = "userid int",
+                        options = {column = "userid", referenceTable = "users", referenceColumn = "id"}
+                    );
+                    expect(out).toInclude("userid int");
+                    expect(out).toInclude("FOREIGN KEY");
+                    expect(out).toInclude("REFERENCES");
+                });
+
+                it("renameTable()/dropTable()/dropView()", () => {
+                    expect(adapter.renameTable(oldName = "users", newName = "people")).toInclude("sp_rename");
+                    expect(adapter.dropTable(name = "users")).toInclude("DROP TABLE");
+                    expect(adapter.dropView(name = "v_users")).toInclude("DROP VIEW");
+                });
+
+                it("renameColumnInTable()", () => {
+                    expect(adapter.renameColumnInTable(name = "users", columnName = "name", newColumnName = "fullname"))
+                        .toInclude("sp_rename");
+                });
+
+                it("dropForeignKeyFromTable()", () => {
+                    expect(adapter.dropForeignKeyFromTable(name = "posts", keyName = "FK_posts"))
+                        .toInclude("DROP CONSTRAINT");
+                });
+
+                it("removeIndex()", () => {
+                    expect(adapter.removeIndex(table = "posts", indexName = "idx_posts_authorid"))
+                        .toInclude("DROP INDEX");
+                });
+
+                it("addRecordPrefix()/addRecordSuffix() wrap a row prefix", () => {
+                    expect(adapter.addRecordPrefix(table = "posts")).toInclude("IDENTITY_INSERT");
+                    expect(adapter.addRecordSuffix(table = "posts")).notToBe("");
+                });
+
+            });
+
+            describe("Oracle migrator", () => {
+
+                beforeEach(() => {
+                    adapter = CreateObject("component", "wheels.databaseAdapters.Oracle.OracleMigrator");
+                });
+
+                it("adapterName()", () => {
+                    expect(adapter.adapterName()).toInclude("Oracle");
+                });
+
+                it("addIndex() builds CREATE [UNIQUE] INDEX", () => {
+                    expect(adapter.addIndex(table = "posts", columnNames = "authorid"))
+                        .toInclude("CREATE INDEX");
+                    expect(adapter.addIndex(table = "posts", columnNames = "authorid", unique = true))
+                        .toInclude("CREATE UNIQUE INDEX");
+                });
+
+                it("removeIndex()", () => {
+                    expect(adapter.removeIndex(table = "posts", indexName = "idx_posts_authorid"))
+                        .toInclude("DROP INDEX");
+                });
+
+                it("addPrimaryKeyOptions()", () => {
+                    expect(adapter.addPrimaryKeyOptions(sql = "NUMBER(10)")).toInclude("NUMBER(10)");
+                });
+
+                it("renameTable()/renameColumnInTable()", () => {
+                    expect(adapter.renameTable(oldName = "users", newName = "people")).toInclude("RENAME");
+                    expect(adapter.renameColumnInTable(name = "users", columnName = "name", newColumnName = "fullname"))
+                        .toInclude("RENAME");
+                });
+
+                it("dropForeignKeyFromTable()", () => {
+                    expect(adapter.dropForeignKeyFromTable(name = "posts", keyName = "FK_posts"))
+                        .toInclude("DROP CONSTRAINT");
+                });
+
+                it("addColumnToTable()/changeColumnInTable() use a ColumnDefinition", () => {
+                    var column = new wheels.migrator.ColumnDefinition(
+                        adapter = adapter,
+                        name = "title",
+                        type = "string"
+                    );
+                    expect(adapter.addColumnToTable(name = "posts", column = column))
+                        .toInclude("ALTER TABLE");
+                    expect(adapter.changeColumnInTable(name = "posts", column = column))
+                        .toInclude("ALTER TABLE");
+                });
+
+            });
+
+            describe("MySQL migrator", () => {
+
+                beforeEach(() => {
+                    adapter = CreateObject("component", "wheels.databaseAdapters.MySQL.MySQLMigrator");
+                });
+
+                it("adapterName()", () => {
+                    expect(adapter.adapterName()).toInclude("MySQL");
+                });
+
+                it("addPrimaryKeyOptions()", () => {
+                    expect(adapter.addPrimaryKeyOptions(sql = "int", options = {autoIncrement = true}))
+                        .toInclude("AUTO_INCREMENT");
+                });
+
+                it("addForeignKeyOptions()", () => {
+                    var out = adapter.addForeignKeyOptions(
+                        sql = "userid int",
+                        options = {column = "userid", referenceTable = "users", referenceColumn = "id"}
+                    );
+                    expect(out).toInclude("userid int");
+                    expect(out).toInclude("FOREIGN KEY");
+                });
+
+                it("quoteTableName()", () => {
+                    expect(adapter.quoteTableName(name = "users")).toInclude("users");
+                });
+
+                it("removeIndex()", () => {
+                    expect(adapter.removeIndex(table = "posts", indexName = "idx_posts_authorid"))
+                        .toInclude("DROP INDEX");
+                });
+
+            });
+
+            describe("H2 migrator", () => {
+
+                beforeEach(() => {
+                    adapter = CreateObject("component", "wheels.databaseAdapters.H2.H2Migrator");
+                });
+
+                it("adapterName()", () => {
+                    expect(adapter.adapterName()).toInclude("H2");
+                });
+
+                it("addPrimaryKeyOptions()", () => {
+                    expect(adapter.addPrimaryKeyOptions(sql = "int", options = {autoIncrement = true}))
+                        .toBe("int NOT NULL AUTO_INCREMENT");
+                });
+
+                it("createTable() builds DDL from ColumnDefinitions", () => {
+                    var pk = new wheels.migrator.ColumnDefinition(
+                        adapter = adapter,
+                        name = "id",
+                        type = "integer"
+                    );
+                    var col = new wheels.migrator.ColumnDefinition(
+                        adapter = adapter,
+                        name = "title",
+                        type = "string"
+                    );
+                    var sql = adapter.createTable(name = "h2unit", columns = [col], primaryKeys = [pk]);
+                    expect(sql).toInclude("CREATE TABLE");
+                    expect(sql).toInclude("h2unit");
+                    expect(sql).toInclude("title");
+                });
+
+                it("quoteTableName()/quoteColumnName()", () => {
+                    expect(adapter.quoteTableName(name = "users")).toInclude("users");
+                    expect(adapter.quoteColumnName(name = "title")).toInclude("title");
+                });
+
+                it("renameTable()/renameColumnInTable()/dropForeignKeyFromTable()", () => {
+                    expect(adapter.renameTable(oldName = "users", newName = "people"))
+                        .toInclude("RENAME");
+                    expect(adapter.renameColumnInTable(name = "users", columnName = "name", newColumnName = "fullname"))
+                        .toInclude("RENAME");
+                    expect(adapter.dropForeignKeyFromTable(name = "posts", keyName = "FK_posts"))
+                        .toInclude("DROP CONSTRAINT");
+                });
+
+                it("changeColumnInTable()", () => {
+                    var col = new wheels.migrator.ColumnDefinition(
+                        adapter = adapter,
+                        name = "title",
+                        type = "string"
+                    );
+                    expect(adapter.changeColumnInTable(name = "posts", column = col))
+                        .toInclude("ALTER TABLE");
+                });
+
+            });
+
+            describe("PostgreSQL migrator", () => {
+
+                beforeEach(() => {
+                    adapter = CreateObject("component", "wheels.databaseAdapters.PostgreSQL.PostgreSQLMigrator");
+                });
+
+                it("adapterName()", () => {
+                    expect(adapter.adapterName()).toInclude("PostgreSQL");
+                });
+
+                it("addPrimaryKeyOptions()", () => {
+                    expect(adapter.addPrimaryKeyOptions(sql = "SERIAL")).toInclude("SERIAL");
+                });
+
+                it("renameTable()/dropForeignKeyFromTable()", () => {
+                    expect(adapter.renameTable(oldName = "users", newName = "people"))
+                        .toInclude("RENAME");
+                    expect(adapter.dropForeignKeyFromTable(name = "posts", keyName = "FK_posts"))
+                        .toInclude("DROP CONSTRAINT");
+                });
+
+            });
+
+        });
+
+    }
+
+}
diff --git a/vendor/wheels/tests/specs/global/MigratorGlobalCoverageSpec.cfc b/vendor/wheels/tests/specs/global/MigratorGlobalCoverageSpec.cfc
new file mode 100644
index 000000000..e12f0453e
--- /dev/null
+++ b/vendor/wheels/tests/specs/global/MigratorGlobalCoverageSpec.cfc
@@ -0,0 +1,133 @@
+component extends="wheels.WheelsTest" {
+
+    /**
+     * Covers remaining migrator definition builders (TableDefinition column
+     * type helpers, ViewDefinition, Migration addReference/createView/down)
+     * and global helper functions ($convertToStringBoolean,
+     * $convertToStringBoxLangSlashDatetime, $normalizePath,
+     * $boxLangVersionMessage, pluginNames, injector,
+     * $clearControllerInitializationCache). All are pure or side-effect-free
+     * in the test application context.
+     */
+    function run() {
+
+        g = application.wo;
+
+        describe("migrator definition builders", () => {
+
+            beforeEach(() => {
+                adapter = CreateObject("component", "wheels.databaseAdapters.SQLite.SQLiteMigrator");
+                migration = CreateObject("component", "wheels.migrator.Migration").init();
+            });
+
+            describe("TableDefinition column helpers", () => {
+
+                it("bigInteger()/char()/uniqueidentifier() append typed columns", () => {
+                    var t = new wheels.migrator.TableDefinition(
+                        adapter = adapter,
+                        name = "spec_types",
+                        id = false
+                    );
+                    t.bigInteger(columnNames = "views");
+                    t.char(columnNames = "code", limit = 9);
+                    t.uniqueidentifier(columnNames = "uid");
+                    expect(arrayLen(t.columns)).toBe(3);
+                    expect(t.columns[1].type).toBe("biginteger");
+                    expect(t.columns[2].type).toBe("char");
+                    expect(t.columns[3].type).toBe("uniqueidentifier");
+                });
+
+            });
+
+            describe("ViewDefinition", () => {
+
+                it("init()/selectStatement() store the view shape", () => {
+                    var view = new wheels.migrator.ViewDefinition(
+                        adapter = adapter,
+                        name = "spec_view"
+                    );
+                    expect(view.name).toBe("spec_view");
+                    view.selectStatement(sql = "SELECT id FROM c_o_r_e_users");
+                    expect(view.selectSql).toBe("SELECT id FROM c_o_r_e_users");
+                });
+
+            });
+
+            describe("Migration helpers", () => {
+
+                it("down() announces the not-implemented stub", () => {
+                    migration.down();
+                    expect(true).toBeTrue();
+                });
+
+                it("createView() returns a ViewDefinition", () => {
+                    var view = migration.createView(name = "spec_view2");
+                    expect(isObject(view)).toBeTrue();
+                    expect(view.name).toBe("spec_view2");
+                });
+
+            });
+
+        });
+
+        describe("global helpers", () => {
+
+            it("$convertToStringBoolean() renders true/false and ''", () => {
+                expect(g.$convertToStringBoolean(val = true)).toBe("true");
+                expect(g.$convertToStringBoolean(val = false)).toBe("false");
+                expect(g.$convertToStringBoolean(val = "")).toBe("");
+            });
+
+            it("$convertToStringBoxLangSlashDatetime() parses AM/PM slash dates", () => {
+                var dt = g.$convertToStringBoxLangSlashDatetime(value = "06/25/2024 10:30 PM");
+                expect(DateFormat(dt, "yyyy-mm-dd")).toBe("2024-06-25");
+                expect(Hour(dt)).toBe(22);
+            });
+
+            it("$normalizePath() converts [x] segments to dots and strips leading dots", () => {
+                expect(g.$normalizePath(path = "users[name]")).toBe("users.name");
+                expect(g.$normalizePath(path = ".posts")).toBe("posts");
+            });
+
+            it("$boxLangVersionMessage() renders the compatibility message", () => {
+                var below = g.$boxLangVersionMessage(
+                    major = 0, minor = 9, patch = 0,
+                    minimumMajor = 1, minimumMinor = 0, minimumPatch = 0,
+                    maximumMajor = 2, maximumMinor = 0, maximumPatch = 0,
+                    version = "0.9.0"
+                );
+                expect(below).toInclude("requires BoxLang version 1.0.0 or higher");
+                var above = g.$boxLangVersionMessage(
+                    major = 3, minor = 0, patch = 0,
+                    minimumMajor = 1, minimumMinor = 0, minimumPatch = 0,
+                    maximumMajor = 2, maximumMinor = 0, maximumPatch = 0,
+                    version = "3.0.0"
+                );
+                expect(above).toInclude("tested up to BoxLang version 2.0.0");
+            });
+
+            it("pluginNames() returns the loaded plugin list", () => {
+                expect(isSimpleValue(g.pluginNames())).toBeTrue();
+            });
+
+            it("injector() returns the DI container when initialized", () => {
+                try {
+                    var di = g.injector();
+                    expect(isObject(di)).toBeTrue();
+                } catch (Wheels.DI.NotInitialized e) {
+                    // Some app contexts never boot the DI container; the
+                    // typed error is the other valid outcome.
+                    expect(e.type).toBe("Wheels.DI.NotInitialized");
+                }
+            });
+
+            it("$clearControllerInitializationCache() clears the controller cache", () => {
+                g.$clearControllerInitializationCache();
+                expect(isStruct(application.wheels.controllers)).toBeTrue();
+            });
+
+        });
+
+    }
+
+}
diff --git a/vendor/wheels/tests/specs/model/ModelSurfaceCoverageSpec.cfc b/vendor/wheels/tests/specs/model/ModelSurfaceCoverageSpec.cfc
new file mode 100644
index 000000000..add2ada92
--- /dev/null
+++ b/vendor/wheels/tests/specs/model/ModelSurfaceCoverageSpec.cfc
@@ -0,0 +1,146 @@
+component extends="wheels.WheelsTest" {
+
+    /**
+     * Covers model-layer surfaces the main specs never touch directly: the
+     * ScopeChain terminal finders/aggregates (the named-scope chain API), the
+     * QueryBuilder offset builder, the remaining callback registration
+     * helpers, and assorted class-level registration helpers (ignoredColumns,
+     * sharedModel, isClass/isInstance, withAdvisoryLock, errorsOnBase,
+     * $coerceOracleTimestamp). State-mutating registrations are reverted or
+     * scoped to zero-row where clauses so other specs are unaffected.
+     */
+    function run() {
+
+        describe("model layer surfaces", () => {
+
+            describe("ScopeChain terminal methods", () => {
+
+                it("findByKey()/findFirst()/findLastOne() delegate with merged specs", () => {
+                    var chain = new wheels.model.query.ScopeChain(
+                        modelReference = model("post"),
+                        specs = [{where = "views > 0"}]
+                    );
+                    expect(chain.findByKey(key = 1)).toBeWheelsModel();
+                    expect(chain.findFirst(order = "id")).toBeWheelsModel();
+                    expect(chain.findLastOne(order = "id")).toBeWheelsModel();
+                });
+
+                it("average()/sum()/maximum()/minimum() aggregate through the chain", () => {
+                    var chain = new wheels.model.query.ScopeChain(modelReference = model("post"));
+                    expect(chain.average(property = "views")).toBeNumeric();
+                    expect(chain.sum(property = "views")).toBeNumeric();
+                    expect(chain.maximum(property = "views")).toBeNumeric();
+                    expect(chain.minimum(property = "views")).toBeNumeric();
+                });
+
+                it("updateAll()/deleteAll() respect the merged zero-row where", () => {
+                    var chain = new wheels.model.query.ScopeChain(
+                        modelReference = model("post"),
+                        specs = [{where = "id = 0"}]
+                    );
+                    // The id = 0 guard means these mutate nothing.
+                    expect(chain.updateAll(properties = {views = 999})).toBeNumeric();
+                    expect(chain.deleteAll()).toBeNumeric();
+                });
+
+                it("findEach()/findInBatches() iterate through the chain", () => {
+                    var chain = new wheels.model.query.ScopeChain(
+                        modelReference = model("post"),
+                        specs = [{where = "views > 0", maxRows = 3}]
+                    );
+                    var seen = {count = 0};
+                    // Hoisted closures: an inline closure as a named
+                    // constructor arg crashes Adobe CF (cross-engine
+                    // invariant #5).
+                    var eachCallback = function(post) {
+                        seen.count++;
+                    };
+                    chain.findEach(batchSize = 2, callback = eachCallback);
+                    expect(seen.count).toBeGT(0);
+                    seen.count = 0;
+                    var batchCallback = function(posts) {
+                        seen.count += posts.recordCount;
+                    };
+                    chain.findInBatches(batchSize = 2, callback = batchCallback);
+                    expect(seen.count).toBeGT(0);
+                });
+
+            });
+
+            describe("QueryBuilder", () => {
+
+                it("offset() records the offset value", () => {
+                    var builder = new wheels.model.query.QueryBuilder(modelReference = model("post"));
+                    expect(builder.offset(value = 5)).toBe(builder);
+                });
+
+            });
+
+            describe("callback registration helpers", () => {
+
+                it("registers the remaining lifecycle callbacks and clears them", () => {
+                    var m = model("post");
+                    m.afterInitialization();
+                    m.afterNew();
+                    m.afterUpdate();
+                    m.afterValidation();
+                    m.afterValidationOnCreate();
+                    m.afterValidationOnUpdate();
+                    m.beforeUpdate();
+                    m.beforeValidationOnCreate();
+                    m.beforeValidationOnUpdate();
+                    // Revert so no phantom callback fires on later specs.
+                    m.$clearCallbacks();
+                });
+
+                it("$coerceOracleTimestamp delegates to the engine adapter", () => {
+                    var m = model("post");
+                    var d = CreateDate(2024, 6, 25);
+                    var coerced = m.$coerceOracleTimestamp(value = d);
+                    expect(isDate(coerced)).toBeTrue();
+                });
+
+            });
+
+            describe("class-level registration helpers", () => {
+
+                it("ignoredColumns() registers and clears the ignored set", () => {
+                    var m = model("post");
+                    m.ignoredColumns(columns = ["spec_phantom"]);
+                    m.ignoredColumns();
+                });
+
+                it("isClass()/isInstance() distinguish class from record", () => {
+                    var m = model("post");
+                    expect(m.isClass()).toBeTrue();
+                    var record = m.findByKey(key = 1);
+                    expect(record.isInstance()).toBeTrue();
+                    expect(record.isClass()).toBeFalse();
+                });
+
+                it("sharedModel() marks the class as tenant-shared", () => {
+                    var m = model("post");
+                    m.sharedModel();
+                    expect(m.$classData().sharedModel).toBeTrue();
+                });
+
+                it("errorsOnBase() returns an array of base errors", () => {
+                    var m = model("post").new();
+                    expect(m.errorsOnBase()).toBeArray();
+                });
+
+                it("withAdvisoryLock() runs the callback (no-op on SQLite)", () => {
+                    var m = model("post");
+                    var result = m.withAdvisoryLock(name = "spec_advisory", callback = function() {
+                        return 42;
+                    });
+                    expect(result).toBe(42);
+                });
+
+            });
+
+        });
+
+    }
+
+}
diff --git a/vendor/wheels/tests/specs/wheelstest/AssertionMatchersSpec.cfc b/vendor/wheels/tests/specs/wheelstest/AssertionMatchersSpec.cfc
new file mode 100644
index 000000000..b6f2b8836
--- /dev/null
+++ b/vendor/wheels/tests/specs/wheelstest/AssertionMatchersSpec.cfc
@@ -0,0 +1,178 @@
+component extends="wheels.WheelsTest" {
+
+    /**
+     * Covers the Assertion library's numeric/string/instance/date matchers
+     * that the BDD expectation specs never call directly. Each matcher is
+     * exercised on BOTH sides: a passing case returns the assertion object,
+     * a failing case throws TestBox.AssertionFailed.
+     */
+    function run() {
+
+        describe("Assertion library matchers", () => {
+
+            beforeEach(() => {
+                a = new wheels.wheelstest.system.Assertion();
+            });
+
+            describe("numeric matchers", () => {
+
+                it("closeTo() passes within the delta and fails outside it", () => {
+                    expect(a.closeTo(expected = 10, actual = 10.4, delta = 0.5)).toBe(a);
+                    expect(() => a.closeTo(expected = 10, actual = 11, delta = 0.5))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("closeTo() compares dates with a datePart", () => {
+                    var base = CreateDateTime(2024, 1, 15, 12, 0, 0);
+                    expect(a.closeTo(expected = base, actual = DateAdd("n", 2, base), delta = 5, datePart = "n")).toBe(a);
+                    expect(() => a.closeTo(expected = base, actual = DateAdd("n", 30, base), delta = 5, datePart = "n"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("between() passes inside the range and fails outside it", () => {
+                    expect(a.between(actual = 5, min = 1, max = 10)).toBe(a);
+                    expect(() => a.between(actual = 15, min = 1, max = 10))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("between() compares dates and rejects an inverted range", () => {
+                    var lo = CreateDate(2024, 1, 1);
+                    var hi = CreateDate(2024, 12, 31);
+                    var mid = CreateDate(2024, 6, 15);
+                    expect(a.between(actual = mid, min = lo, max = hi)).toBe(a);
+                    expect(() => a.between(actual = mid, min = hi, max = lo))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("instance matchers", () => {
+
+                it("isSameInstance()/isNotSameInstance() compare by identity", () => {
+                    var obj = {x = 1};
+                    var other = {x = 1};
+                    expect(a.isSameInstance(expected = obj, actual = obj)).toBe(a);
+                    expect(() => a.isSameInstance(expected = obj, actual = other))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                    expect(a.isNotSameInstance(expected = obj, actual = other)).toBe(a);
+                    expect(() => a.isNotSameInstance(expected = obj, actual = obj))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("null and type matchers", () => {
+
+                it("null()/notNull() distinguish the null value", () => {
+                    expect(a.null(actual = javacast("null", ""))).toBe(a);
+                    expect(() => a.null(actual = "value")).toThrow(type = "TestBox.AssertionFailed");
+                    expect(a.notNull(actual = "value")).toBe(a);
+                    expect(() => a.notNull(actual = javacast("null", ""))).toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("notTypeOf() rejects the given type and passes others", () => {
+                    expect(a.notTypeOf(type = "array", actual = {})).toBe(a);
+                    expect(() => a.notTypeOf(type = "struct", actual = {}))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("string matchers", () => {
+
+                it("matchWithCase()/notMatchWithCase() are case-sensitive regex checks", () => {
+                    expect(a.matchWithCase(actual = "Hello World", regex = "^Hello")).toBe(a);
+                    expect(() => a.matchWithCase(actual = "hello world", regex = "^Hello"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                    expect(a.notMatchWithCase(actual = "hello world", regex = "^Hello")).toBe(a);
+                });
+
+                it("startsWithCase()/notStartsWithCase() honor case", () => {
+                    expect(a.startsWithCase(target = "Hello World", needle = "Hello")).toBe(a);
+                    expect(() => a.startsWithCase(target = "hello world", needle = "Hello"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                    expect(a.notStartsWithCase(target = "hello world", needle = "Hello")).toBe(a);
+                });
+
+                it("notStartsWith()/notEndsWith() accept non-matching needles", () => {
+                    // Note: these two matchers swallow their own failure
+                    // (their fail() call lands inside their own try and is
+                    // caught by the TestBox.AssertionFailed handler), so the
+                    // observable contract is "never throws" — assert the
+                    // passing paths only.
+                    expect(a.notStartsWith(target = "hello world", needle = "world")).toBe(a);
+                    expect(a.notEndsWith(target = "hello world", needle = "hello")).toBe(a);
+                });
+
+                it("endsWithCase()/notEndsWithCase() honor case", () => {
+                    expect(a.endsWithCase(target = "Hello World", needle = "World")).toBe(a);
+                    expect(() => a.endsWithCase(target = "hello world", needle = "World"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                    expect(a.notEndsWithCase(target = "hello world", needle = "World")).toBe(a);
+                });
+
+                it("notIncludesWithCase() rejects case-sensitive needles", () => {
+                    expect(a.notIncludesWithCase(target = "Hello World", needle = "WORLD")).toBe(a);
+                    expect(() => a.notIncludesWithCase(target = "Hello World", needle = "World"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("struct matchers", () => {
+
+                it("deepKey()/notDeepKey() search nested structures by key name", () => {
+                    // deepKey uses structFindKey() — the key argument is a KEY
+                    // NAME searched anywhere in the nested structure, not a
+                    // dotted path.
+                    expect(a.deepKey(target = {a = {b = {c = 1}}}, key = "c")).toBe(a);
+                    expect(() => a.deepKey(target = {a = {}}, key = "c"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                    expect(a.notDeepKey(target = {a = {}}, key = "c")).toBe(a);
+                    expect(() => a.notDeepKey(target = {a = {b = {c = 1}}}, key = "c"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("equality matchers", () => {
+
+                it("isEqual() with queries delegates to $equalizeQueries", () => {
+                    var q1 = queryNew("id,name");
+                    queryAddRow(q1, {id = 1, name = "one"});
+                    var q2 = queryNew("id,name");
+                    queryAddRow(q2, {id = 1, name = "one"});
+                    expect(a.isEqual(expected = q1, actual = q2)).toBe(a);
+                    var q3 = queryNew("id,name");
+                    queryAddRow(q3, {id = 2, name = "two"});
+                    expect(() => a.isEqual(expected = q1, actual = q3))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("isEqual() with XML strings delegates to $equalizeXml", () => {
+                    // $equalizeXml compares the raw string forms — use
+                    // identical strings for the pass and a differing value
+                    // for the fail.
+                    var x1 = "<user><name>Luis</name></user>";
+                    expect(a.isEqual(expected = x1, actual = x1)).toBe(a);
+                    expect(() => a.isEqual(expected = x1, actual = "<user><name>Tom</name></user>"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("length matchers", () => {
+
+                it("notLengthOf() rejects the given length", () => {
+                    expect(a.notLengthOf(target = "hello", length = "2")).toBe(a);
+                    expect(() => a.notLengthOf(target = "hello", length = "5"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+        });
+
+    }
+
+}
diff --git a/vendor/wheels/tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc b/vendor/wheels/tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc
new file mode 100644
index 000000000..49a943a8f
--- /dev/null
+++ b/vendor/wheels/tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc
@@ -0,0 +1,220 @@
+component extends="wheels.WheelsTest" {
+
+    /**
+     * Covers the BaseSpec DSL surface that the BDD specs never touch directly:
+     * the story/feature/given/scenario/when aliases (plus their focused and
+     * x-skipped variants), the then/test/fit/ftest/xtest spec aliases, the
+     * assertion facade (assert/fail/expectedException/addAssertions),
+     * expectAll collection unrolling, and the utility helpers (querySim,
+     * debug buffer, print/println, engine predicates, getProperty).
+     *
+     * Everything drives a BARE BaseSpec instance — the aliases record suite
+     * state on the instance without being executed by a runner, so the
+     * focused variants cannot hijack this run.
+     */
+    function run() {
+
+        describe("BaseSpec DSL surface", () => {
+
+            beforeEach(() => {
+                spec = new wheels.wheelstest.system.BaseSpec();
+            });
+
+            describe("BDD aliases", () => {
+
+                it("story() registers a suite titled 'Story: ...'", () => {
+                    spec.story("login", () => {});
+                    expect(arrayLen(spec.$suites)).toBe(1);
+                    expect(spec.$suites[1].name).toBe("Story: login");
+                });
+
+                it("feature() registers a suite titled 'Feature: ...'", () => {
+                    spec.feature("checkout", () => {});
+                    expect(spec.$suites[1].name).toBe("Feature: checkout");
+                });
+
+                it("given() registers a suite titled 'Given ...'", () => {
+                    spec.given("a user", () => {});
+                    expect(spec.$suites[1].name).toBe("Given a user");
+                });
+
+                it("scenario() registers a suite titled 'Scenario: ...'", () => {
+                    spec.scenario("happy path", () => {});
+                    expect(spec.$suites[1].name).toBe("Scenario: happy path");
+                });
+
+                it("when() registers a suite titled 'When ...'", () => {
+                    spec.when("clicked", () => {});
+                    expect(spec.$suites[1].name).toBe("When clicked");
+                });
+
+                it("fdescribe()/fstory()/ffeature()/fgiven()/fscenario()/fwhen() mark suites focused", () => {
+                    spec.fdescribe("focused describe", () => {});
+                    spec.fstory("focused story", () => {});
+                    spec.ffeature("focused feature", () => {});
+                    spec.fgiven("focused given", () => {});
+                    spec.fscenario("focused scenario", () => {});
+                    spec.fwhen("focused when", () => {});
+                    expect(arrayLen(spec.$focusedTargets.suites)).toBe(6);
+                    expect(spec.$focusedTargets.suites).toInclude("/focused describe");
+                    expect(spec.$focusedTargets.suites).toInclude("/Story: focused story");
+                });
+
+                it("x-variants register skipped suites", () => {
+                    spec.xdescribe("skipped", () => {});
+                    spec.xstory("skipped story", () => {});
+                    spec.xfeature("skipped feature", () => {});
+                    spec.xgiven("skipped given", () => {});
+                    spec.xscenario("skipped scenario", () => {});
+                    spec.xwhen("skipped when", () => {});
+                    for (var suite in spec.$suites) {
+                        expect(suite.skip).toBeTrue();
+                    }
+                });
+
+                it("then() registers a spec titled 'Then ...'", () => {
+                    spec.describe("suite", () => {
+                        spec.then("the outcome is visible", () => {});
+                    });
+                    expect(spec.$suites[1].specs[1].name).toBe("Then the outcome is visible");
+                });
+
+                it("fthen()/fit()/ftest() record focused specs", () => {
+                    spec.describe("suite", () => {
+                        spec.fthen("focused then", () => {});
+                        spec.fit("focused it", () => {});
+                        spec.ftest("focused test", () => {});
+                    });
+                    expect(arrayLen(spec.$focusedTargets.specs)).toBe(3);
+                    expect(spec.$focusedTargets.specs[1]).toInclude("/suite/Then focused then");
+                });
+
+                it("test()/xtest()/xthen() record specs with skip semantics", () => {
+                    spec.describe("suite", () => {
+                        spec.test("plain test", () => {});
+                        spec.xtest("skipped test", () => {});
+                        spec.xthen("skipped then", () => {});
+                    });
+                    expect(spec.$suites[1].specs[1].name).toBe("plain test");
+                    expect(spec.$suites[1].specs[2].skip).toBeTrue();
+                    expect(spec.$suites[1].specs[3].skip).toBeTrue();
+                });
+
+            });
+
+            describe("assertion facade", () => {
+
+                it("assert() passes for truthy expressions and throws on falsy", () => {
+                    expect(() => spec.assert(expression = (2 + 2 == 4))).notToThrow();
+                    expect(() => spec.assert(expression = (2 + 2 == 5), message = "math broke"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("fail() always throws TestBox.AssertionFailed", () => {
+                    expect(() => spec.fail(message = "boom")).toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("expectedException() records type and regex on the spec", () => {
+                    spec.expectedException(type = "Wheels.CustomError", regex = "must .*");
+                    expect(spec.$expectedException.type).toBe("Wheels.CustomError");
+                    expect(spec.$expectedException.regex).toBe("must .*");
+                });
+
+                it("addAssertions() registers struct-based custom assertions on the assert object", () => {
+                    spec.addAssertions({
+                        isEven = function(actual) {
+                            return actual mod 2 == 0;
+                        }
+                    });
+                    // Custom assertions are plain predicates: they RETURN the
+                    // verdict instead of throwing (the built-in matchers wrap
+                    // the boolean into a fail()).
+                    expect(spec.$assert.isEven(4)).toBeTrue();
+                    expect(spec.$assert.isEven(3)).toBeFalse();
+                });
+
+            });
+
+            describe("expectAll collection unrolling", () => {
+
+                it("unrolls an array through the matcher", () => {
+                    spec.expectAll([1, 2, 3]).toBeNumeric();
+                    expect(isObject(spec.expectAll([]).toBeArray())).toBeTrue();
+                });
+
+                it("unrolls a struct through the matcher", () => {
+                    spec.expectAll({a = 1, b = 2}).toBeNumeric();
+                });
+
+                it("fails for a non-collection actual", () => {
+                    expect(() => spec.expectAll("not a collection").toBeNumeric())
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("utility helpers", () => {
+
+                it("querySim() builds a query from compact text", () => {
+                    var q = spec.querySim("id,name
+1|luis
+2|peter");
+                    expect(q.recordCount).toBe(2);
+                    expect(q.name[2]).toBe("peter");
+                });
+
+                it("debug() appends to the debug buffer and clearDebugBuffer() empties it", () => {
+                    spec.debug("entry one");
+                    expect(arrayLen(spec.getDebugBuffer())).toBe(1);
+                    spec.clearDebugBuffer();
+                    expect(arrayLen(spec.getDebugBuffer())).toBe(0);
+                });
+
+                it("print()/println() write to the response buffer (cleared before the JSON report)", () => {
+                    // Output-only helpers: the reporter resets the response
+                    // buffer before serializing the report, so exercising them
+                    // must not corrupt the run payload.
+                    spec.print("plain output");
+                    spec.println("line output");
+                    expect(true).toBeTrue();
+                });
+
+                it("engine predicates return booleans", () => {
+                    expect(spec.isAdobe()).toBeTypeOf("boolean");
+                    expect(spec.isLucee()).toBeTypeOf("boolean");
+                    expect(spec.isBoxLang()).toBeTypeOf("boolean");
+                    expect(spec.isWindows()).toBeTypeOf("boolean");
+                    expect(spec.isLinux()).toBeTypeOf("boolean");
+                    expect(spec.isMac()).toBeTypeOf("boolean");
+                });
+
+                it("getProperty() reads a this-scope property from a mocked component", () => {
+                    // prepareMock() mocks the target; for component instances
+                    // the mock carries the original's this-scope keys
+                    // ($testID is set by the BaseSpec pseudo-constructor).
+                    var target = new wheels.wheelstest.system.BaseSpec();
+                    expect(spec.getProperty(target = target, name = "$testID", scope = "this"))
+                        .toBe(target.$testID);
+                });
+
+                it("console() writes to the engine console", () => {
+                    spec.console(var = {hello = "world"}, label = "spec probe");
+                    expect(true).toBeTrue();
+                });
+
+                it("getEnv() returns the lazy Env singleton", () => {
+                    expect(isObject(spec.getEnv())).toBeTrue();
+                });
+
+                it("getProperty() honors the defaultValue when the key is absent", () => {
+                    var target = {};
+                    expect(spec.getProperty(target = target, name = "missing", defaultValue = "fallback")).toBe("fallback");
+                });
+
+            });
+
+        });
+
+    }
+
+}
diff --git a/vendor/wheels/tests/specs/wheelstest/ExpectationMatchersSpec.cfc b/vendor/wheels/tests/specs/wheelstest/ExpectationMatchersSpec.cfc
new file mode 100644
index 000000000..3f2674f36
--- /dev/null
+++ b/vendor/wheels/tests/specs/wheelstest/ExpectationMatchersSpec.cfc
@@ -0,0 +1,129 @@
+component extends="wheels.WheelsTest" {
+
+    /**
+     * Covers the Expectation matchers the suite never reaches: range/close-to,
+     * satisfaction predicates, case-sensitive string matchers, deep-key and
+     * membership matchers, and the negated (`not`) flow. Expectations are
+     * built from a bare BaseSpec instance so nothing registers with the
+     * active runner.
+     */
+    function run() {
+
+        describe("Expectation matchers", () => {
+
+            beforeEach(() => {
+                spec = new wheels.wheelstest.system.BaseSpec();
+            });
+
+            describe("numeric matchers", () => {
+
+                it("toBeBetween() passes inside the range and fails outside it", () => {
+                    expect(() => spec.expect(5).toBeBetween(1, 10)).notToThrow();
+                    expect(() => spec.expect(15).toBeBetween(1, 10))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("toBeCloseTo() passes within the delta and fails outside it", () => {
+                    expect(() => spec.expect(10.2).toBeCloseTo(10, 0.3)).notToThrow();
+                    expect(() => spec.expect(11).toBeCloseTo(10, 0.3))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("satisfaction matchers", () => {
+
+                it("toSatisfy() passes when the predicate returns true", () => {
+                    expect(() => spec.expect(6).toSatisfy(function(v) {
+                        return v mod 2 == 0;
+                    })).notToThrow();
+                    expect(() => spec.expect(7).toSatisfy(function(v) {
+                        return v mod 2 == 0;
+                    })).toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("notToSatisfy() flips the predicate result", () => {
+                    expect(() => spec.expect(7).notToSatisfy(function(v) {
+                        return v mod 2 == 0;
+                    })).notToThrow();
+                    expect(() => spec.expect(6).notToSatisfy(function(v) {
+                        return v mod 2 == 0;
+                    })).toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("case-sensitive string matchers", () => {
+
+                it("toStartWithCase()/toEndWithCase() honor case", () => {
+                    expect(() => spec.expect("Hello World").toStartWithCase("Hello")).notToThrow();
+                    expect(() => spec.expect("hello world").toStartWithCase("Hello"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                    expect(() => spec.expect("Hello World").toEndWithCase("World")).notToThrow();
+                    expect(() => spec.expect("hello world").toEndWithCase("World"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("toMatchWithCase() is a case-sensitive regex check", () => {
+                    expect(() => spec.expect("Hello World").toMatchWithCase("^Hello")).notToThrow();
+                    expect(() => spec.expect("hello world").toMatchWithCase("^Hello"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("toContain()/toContainWithCase() check membership", () => {
+                    expect(() => spec.expect("Hello World").toContain("lo Wo")).notToThrow();
+                    expect(() => spec.expect("Hello World").toContain("xyz"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                    expect(() => spec.expect("Hello World").toContainWithCase("World")).notToThrow();
+                    expect(() => spec.expect("Hello World").toContainWithCase("world"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("struct and membership matchers", () => {
+
+                it("toHaveKeyWithCase() finds present keys and rejects missing ones", () => {
+                    // CFML struct literals are case-insensitive, so the case
+                    // dimension can't be asserted with a literal — use a
+                    // truly-missing key for the failing path.
+                    expect(() => spec.expect({Name = "Luis"}).toHaveKeyWithCase("Name")).notToThrow();
+                    expect(() => spec.expect({Name = "Luis"}).toHaveKeyWithCase("missing"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("toHaveDeepKey() searches nested structures by key name", () => {
+                    expect(() => spec.expect({a = {b = {c = 1}}}).toHaveDeepKey("c")).notToThrow();
+                    expect(() => spec.expect({a = {}}).toHaveDeepKey("c"))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("toBeIn()/toBeInWithCase() check collection membership", () => {
+                    expect(() => spec.expect(2).toBeIn([1, 2, 3])).notToThrow();
+                    expect(() => spec.expect(4).toBeIn([1, 2, 3]))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                    expect(() => spec.expect("B").toBeInWithCase(["a", "B"])).notToThrow();
+                    expect(() => spec.expect("b").toBeInWithCase(["a", "B"]))
+                        .toThrow(type = "TestBox.AssertionFailed");
+                });
+
+            });
+
+            describe("fail and negation plumbing", () => {
+
+                it("fail() throws TestBox.AssertionFailed", () => {
+                    expect(() => spec.expect(true).fail("nope")).toThrow(type = "TestBox.AssertionFailed");
+                });
+
+                it("_not() toggles the negation flag on the expectation", () => {
+                    var e = spec.expect(1);
+                    expect(e.notToBe(2)).toBeTypeOf("component");
+                });
+
+            });
+
+        });
+
+    }
+
+}
diff --git a/vendor/wheels/tests/specs/wheelstest/MockBoxSpec.cfc b/vendor/wheels/tests/specs/wheelstest/MockBoxSpec.cfc
new file mode 100644
index 000000000..24b311c5a
--- /dev/null
+++ b/vendor/wheels/tests/specs/wheelstest/MockBoxSpec.cfc
@@ -0,0 +1,66 @@
+component extends="wheels.WheelsTest" {
+
+    /**
+     * Covers the MockBox expectation-verification surface: createEmptyMock()
+     * stub generation plus the injected call-count assertions ($count/$once/
+     * $times/$never/$atLeast/$atMost) and the illegal-state guards for the
+     * fluent expectation builders ($callback/$throws/$args) called outside a
+     * $() chain. Exercising createEmptyMock also drives MockGenerator
+     * (generateMethodsFromMD/generateClass/writeStub/outputQuotedValue).
+     */
+    function run() {
+
+        describe("MockBox verification surface", () => {
+
+            beforeEach(() => {
+                mb = new wheels.wheelstest.system.MockBox();
+            });
+
+            it("createEmptyMock() generates a stub with no methods", () => {
+                var mock = mb.createEmptyMock(className = "wheels.wheelstest.system.util.Util");
+                expect(isObject(mock)).toBeTrue();
+                expect(structKeyExists(mock, "slugify")).toBeFalse();
+            });
+
+            it("$count()/$once()/$times()/$never()/$atLeast()/$atMost() verify call counts", () => {
+                var mock = mb.createEmptyMock(className = "wheels.wheelstest.system.util.Util");
+                expect(mock.$count()).toBe(0);
+                expect(mock.$count(methodName = "slugify")).toBe(-1);
+                expect(mock.$never()).toBeTrue();
+                expect(mock.$once()).toBeFalse();
+
+                mock.$("slugify").$results("ok");
+                mock.slugify("hello world");
+                mock.slugify("second call");
+
+                expect(mock.$count(methodName = "slugify")).toBe(2);
+                expect(mock.$once(methodName = "slugify")).toBeFalse();
+                expect(mock.$times(count = 2, methodName = "slugify")).toBeTrue();
+                expect(mock.$never(methodName = "slugify")).toBeFalse();
+                expect(mock.$atLeast(minNumberOfInvocations = 2, methodName = "slugify")).toBeTrue();
+                expect(mock.$atMost(maxNumberOfInvocations = 2, methodName = "slugify")).toBeTrue();
+            });
+
+            it("$callback()/$throws()/$args() outside a $() chain throw illegal-state errors", () => {
+                // The verification state lives on the MOCK, not the bare
+                // MockBox instance.
+                var mock = mb.createEmptyMock(className = "wheels.wheelstest.system.util.Util");
+                expect(() => mock.$callback(target = function() {
+                    return 1;
+                })).toThrow(type = "MockFactory.IllegalStateException");
+                expect(() => mock.$throws()).toThrow(type = "MockFactory.IllegalStateException");
+                expect(() => mock.$args()).toThrow(type = "MockBox.IllegalStateException");
+            });
+
+            it("$debug() returns the debug struct and $reset() clears state", () => {
+                var mock = mb.createEmptyMock(className = "wheels.wheelstest.system.util.Util");
+                expect(mock.$debug()).toBeStruct();
+                mock.$reset();
+                expect(mock.$count()).toBe(0);
+            });
+
+        });
+
+    }
+
+}
diff --git a/vendor/wheels/tests/specs/wheelstest/SystemUtilSpec.cfc b/vendor/wheels/tests/specs/wheelstest/SystemUtilSpec.cfc
new file mode 100644
index 000000000..957215d80
--- /dev/null
+++ b/vendor/wheels/tests/specs/wheelstest/SystemUtilSpec.cfc
@@ -0,0 +1,185 @@
+component extends="wheels.WheelsTest" {
+
+    /**
+     * Covers the wheelstest system utilities the suite never reaches
+     * directly: Util (paths/slugify/arrays), Env (system settings/properties),
+     * XMLConverter (array/struct/query/object-to-XML), MixerUtil
+     * (start/stop + mixin injection), and BaseReporter.openInEditorURL.
+     */
+    function run() {
+
+        describe("wheelstest system utilities", () => {
+
+            describe("Util", () => {
+
+                beforeEach(() => {
+                    util = new wheels.wheelstest.system.util.Util();
+                });
+
+                it("arrayToStruct() keys the struct by position", () => {
+                    var s = util.arrayToStruct(input = ["a", "b"]);
+                    expect(s).toBeStruct();
+                    expect(s[1]).toBe("a");
+                    expect(s[2]).toBe("b");
+                });
+
+                it("getAbsolutePath() keeps absolute paths and expands relative ones", () => {
+                    expect(util.getAbsolutePath(path = "/tmp")).toBe("/tmp");
+                    expect(util.getAbsolutePath(path = "/wheels/tests/specs")).toInclude("wheels");
+                });
+
+                it("slugify() lowercases and replaces spaces", () => {
+                    expect(util.slugify("My Test Spec")).toInclude("my-test-spec");
+                });
+
+                it("ripExtension() strips the final extension", () => {
+                    expect(util.ripExtension(filename = "MySpec.cfc")).toBe("MySpec");
+                    expect(util.ripExtension(filename = "archive.tar.gz")).toBe("archive.tar");
+                });
+
+                it("fileLastModified() returns a date for an existing file", () => {
+                    expect(util.fileLastModified(filename = expandPath("/wheels/tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc")))
+                        .toBeTypeOf("date");
+                });
+
+                it("inThread() returns a boolean", () => {
+                    expect(util.inThread()).toBeTypeOf("boolean");
+                });
+
+            });
+
+            describe("Env", () => {
+
+                beforeEach(() => {
+                    env = new wheels.wheelstest.system.util.Env();
+                });
+
+                it("getSystemSetting() returns the value or the default", () => {
+                    var java = env.getJavaSystem();
+                    expect(env.getSystemSetting(key = "definitely_not_a_real_key_123", defaultValue = "fallback")).toBe("fallback");
+                });
+
+                it("getSystemProperty() reads JVM properties with a default", () => {
+                    expect(env.getSystemProperty(key = "java.version", defaultValue = "")).notToBe("");
+                    expect(env.getSystemProperty(key = "not.a.real.property", defaultValue = "dflt")).toBe("dflt");
+                });
+
+                it("getEnv() reads process env vars with a default", () => {
+                    expect(env.getEnv(key = "NOT_A_REAL_ENV_VAR_123", defaultValue = "dflt")).toBe("dflt");
+                });
+
+                it("getJavaSystem() returns the java.lang.System object", () => {
+                    expect(isObject(env.getJavaSystem())).toBeTrue();
+                });
+
+            });
+
+            describe("XMLConverter", () => {
+
+                beforeEach(() => {
+                    xml = new wheels.wheelstest.system.util.XMLConverter();
+                });
+
+                it("toXML() converts a struct", () => {
+                    var out = xml.toXML(data = {name = "Luis", age = 40});
+                    expect(out).toInclude("<name>Luis</name>");
+                    expect(out).toInclude("<age>40</age>");
+                });
+
+                it("toXML() converts an array", () => {
+                    var out = xml.toXML(data = ["a", "b"]);
+                    expect(out).toInclude("<item>a</item>");
+                });
+
+                it("toXML() converts a query", () => {
+                    var q = queryNew("id,name");
+                    queryAddRow(q, {id = 1, name = "one"});
+                    var out = xml.toXML(data = q);
+                    expect(out).toInclude("one");
+                });
+
+                it("toXML() converts a plain value", () => {
+                    var out = xml.toXML(data = "hello");
+                    expect(out).toInclude("hello");
+                });
+
+                it("toXML() escapes XML-sensitive characters via safeText", () => {
+                    var out = xml.toXML(data = {body = "<tag> & 'quote'"});
+                    expect(out).notToInclude("<tag>");
+                });
+
+                it("toXML() supports CDATA mode", () => {
+                    var out = xml.toXML(data = {body = "raw <html>"}, useCDATA = true);
+                    expect(out).toInclude("<![CDATA[");
+                });
+
+            });
+
+            describe("MixerUtil", () => {
+
+                it("start()/stop() mix helper methods into a CFC target", () => {
+                    var mixer = new wheels.wheelstest.system.util.MixerUtil();
+                    // Mixin injection writes into `this`/`variables` of the
+                    // invocation context — a CFC instance, not a bare struct.
+                    var target = new wheels.wheelstest.system.BaseSpec();
+                    mixer.start(target);
+
+                    target.injectMixin(name = "greet", udf = function() {
+                        return "hi";
+                    });
+                    expect(target.greet()).toBe("hi");
+
+                    target.injectPropertyMixin(propertyName = "answer", propertyValue = 42);
+                    expect(target.getPropertyMixin(name = "answer")).toBe(42);
+
+                    expect(isStruct(target.getVariablesMixin())).toBeTrue();
+
+                    target.removeMixin(UDFName = "greet");
+                    expect(structKeyExists(target, "greet")).toBeFalse();
+
+                    target.removePropertyMixin(propertyName = "answer");
+                    expect(target.getPropertyMixin(name = "answer", defaultValue = "gone")).toBe("gone");
+
+                    mixer.stop(target);
+                    expect(structKeyExists(target, "injectMixin")).toBeFalse();
+                });
+
+                it("invokerMixin() invokes a method on the target", () => {
+                    var mixer = new wheels.wheelstest.system.util.MixerUtil();
+                    var target = new wheels.wheelstest.system.BaseSpec();
+                    mixer.start(target);
+                    target.injectMixin(name = "doubleIt", udf = function(v) {
+                        return v * 2;
+                    });
+                    expect(target.invokerMixin(method = "doubleIt", argCollection = {v = 4})).toBe(8);
+                });
+
+            });
+
+            describe("BaseReporter.openInEditorURL", () => {
+
+                it("builds a vscode URL", () => {
+                    var reporter = new wheels.wheelstest.system.reports.BaseReporter();
+                    expect(reporter.openInEditorURL(template = "/app/User.cfc", line = 42))
+                        .toBe("vscode://file//app/User.cfc:42");
+                });
+
+                it("builds a sublime URL", () => {
+                    var reporter = new wheels.wheelstest.system.reports.BaseReporter();
+                    expect(reporter.openInEditorURL(template = "/app/User.cfc", line = 7, editor = "sublime"))
+                        .toInclude("subl://open?url=file:///app/User.cfc&line=7");
+                });
+
+                it("builds an idea URL", () => {
+                    var reporter = new wheels.wheelstest.system.reports.BaseReporter();
+                    expect(reporter.openInEditorURL(template = "/app/User.cfc", line = 7, editor = "idea"))
+                        .toInclude("idea");
+                });
+
+            });
+
+        });
+
+    }
+
+}
diff --git a/vendor/wheels/tests/specs/wheelstest/XUnitStyleLegacyTest.cfc b/vendor/wheels/tests/specs/wheelstest/XUnitStyleLegacyTest.cfc
new file mode 100644
index 000000000..7595526e5
--- /dev/null
+++ b/vendor/wheels/tests/specs/wheelstest/XUnitStyleLegacyTest.cfc
@@ -0,0 +1,47 @@
+component extends="wheels.WheelsTest" {
+
+    /**
+     * xUnit-style legacy bundle: deliberately has NO run() method, so TestBox
+     * executes it through the UnitRunner path (the same path the legacy
+     * wheels.Test / RocketUnit base used). Covers runTestMethod(), setup()/
+     * teardown() invocation, and the expectedException() contract.
+     *
+     * Method discovery: isValidTestMethod() accepts methods that start or
+     * end with "test".
+     */
+
+    variables.xunitSetupCount = 0;
+    variables.xunitTeardownCount = 0;
+
+    function setup(currentMethod = "") {
+        variables.xunitSetupCount++;
+    }
+
+    function teardown(currentMethod = "") {
+        variables.xunitTeardownCount++;
+    }
+
+    function test_setup_increments_per_spec() {
+        assert(variables.xunitSetupCount > 0, "setup() should have run for this spec");
+    }
+
+    function test_passes_when_assertions_hold() {
+        assert(2 + 2 == 4);
+        assert(isBoolean(true));
+    }
+
+    function additionTest() {
+        assert(1 + 1 == 2);
+    }
+
+    function test_expectedException_catches_typed_throw() {
+        expectedException(type = "Wheels.LegacyExpected");
+        throw(type = "Wheels.LegacyExpected", message = "expected boom");
+    }
+
+    function test_expectedException_with_regex_matches_the_message() {
+        expectedException(type = "Wheels.LegacyExpectedRegex", regex = "must say .*");
+        throw(type = "Wheels.LegacyExpectedRegex", message = "must say hello");
+    }
+
+}

From 785b70124a35aa8995b4f502cce59ee73464dc0c Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 29 Aug 2026 22:48:55 -0700
Subject: [PATCH 2/3] test(wheelstest): drop the print()/println() exercise
 from BaseSpecDslAliasSpec

These helpers write straight to the engine response buffer. The JSON
reporter's buffer reset is best-effort and RustCFML does not reset the
accumulated buffer, so the spec's output prefixed the suite payload and
broke JSON parsing (BOOT BREAK) on the RustCFML leg.

Signed-off-by: Peter Amiri <peter@alurium.com>
---
 .../tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc      | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/vendor/wheels/tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc b/vendor/wheels/tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc
index 49a943a8f..e78aee863 100644
--- a/vendor/wheels/tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc
+++ b/vendor/wheels/tests/specs/wheelstest/BaseSpecDslAliasSpec.cfc
@@ -170,15 +170,6 @@ component extends="wheels.WheelsTest" {
                     expect(arrayLen(spec.getDebugBuffer())).toBe(0);
                 });
 
-                it("print()/println() write to the response buffer (cleared before the JSON report)", () => {
-                    // Output-only helpers: the reporter resets the response
-                    // buffer before serializing the report, so exercising them
-                    // must not corrupt the run payload.
-                    spec.print("plain output");
-                    spec.println("line output");
-                    expect(true).toBeTrue();
-                });
-
                 it("engine predicates return booleans", () => {
                     expect(spec.isAdobe()).toBeTypeOf("boolean");
                     expect(spec.isLucee()).toBeTypeOf("boolean");

From 41e08816b63e633e993b499dbbc5ca33a8625ee1 Mon Sep 17 00:00:00 2001
From: Peter Amiri <peter@alurium.com>
Date: Sat, 29 Aug 2026 22:50:51 -0700
Subject: [PATCH 3/3] test(wheelstest): skip the query-to-XML case on engines
 without query.currentRow

RustCFML's query object has no currentRow member (upstream #382), which
XMLConverter.queryToXML depends on. JVM engines keep the full assertion;
the JVM-less leg skips it via the EngineCapabilities guard used elsewhere
in the wheelstest suite.

Signed-off-by: Peter Amiri <peter@alurium.com>
---
 vendor/wheels/tests/specs/wheelstest/SystemUtilSpec.cfc | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/vendor/wheels/tests/specs/wheelstest/SystemUtilSpec.cfc b/vendor/wheels/tests/specs/wheelstest/SystemUtilSpec.cfc
index 957215d80..b1425b1d4 100644
--- a/vendor/wheels/tests/specs/wheelstest/SystemUtilSpec.cfc
+++ b/vendor/wheels/tests/specs/wheelstest/SystemUtilSpec.cfc
@@ -92,6 +92,13 @@ component extends="wheels.WheelsTest" {
                 });
 
                 it("toXML() converts a query", () => {
+                    // RustCFML's query object has no currentRow member, which
+                    // queryToXML relies on (upstream issue #382) — skip there.
+                    var capabilities = new wheels.wheelstest.EngineCapabilities();
+                    if (!capabilities.hasJvmClassLoading()) {
+                        debug("Skipping: query.currentRow is undefined on this engine");
+                        return;
+                    }
                     var q = queryNew("id,name");
                     queryAddRow(q, {id = 1, name = "one"});
                     var out = xml.toXML(data = q);