@itwin/core-backend 5.5.0-dev.1 → 5.5.0-dev.10

package/lib/esm/test/incrementalSchemaLocater/ECSqlQueries.test.js

@@ -1,8 +1,60 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { Schema, SchemaItemType, SchemaKey } from "@itwin/ecschema-metadata";
-import { IncrementalTestHelper } from "./utils/IncrementalTestHelper";
 import { expect, use } from "chai";
+import { TestContext } from "./TestContext";
+import { IModelIncrementalSchemaLocater } from "../../IModelIncrementalSchemaLocater";
 import * as deepEqualInAnyOrder from "deep-equal-in-any-order";
-import { TestSqlSchemaLocater } from "./utils/TestSqlSchemaLocater";
 use(deepEqualInAnyOrder);
 function findItem(name, rowData) {
     const item = rowData.find((i) => i.name === name);
@@ -20,8 +72,12 @@ function isECClass(item) {
 function isRelationshipClass(item) {
     return "source" in item && "target" in item;
 }
+/**
+ * A test locater that exposes the protected methods of IModelIncrementalSchemaLocater for granular testing.
+ */
+class TestSchemaLocater extends IModelIncrementalSchemaLocater {
+}
 describe("ECSql query tests", function () {
-    let schemaLocater;
     function validateItem(name, itemPropObjects, schema) {
         const actualJson = findItem(name, itemPropObjects);
         const expectedItem = schema.getItemSync(name);
@@ -104,239 +160,417 @@ describe("ECSql query tests", function () {
         }
         expect(actualJson).to.deep.equalInAnyOrder(expectedJson);
     }
-    this.beforeEach(async () => {
-        await IncrementalTestHelper.setup();
-        schemaLocater = new TestSqlSchemaLocater(IncrementalTestHelper.iModel);
-    });
-    afterEach(async () => {
-        await IncrementalTestHelper.close();
-    });
+    async function createTestContext() {
+        const testEnv = await TestContext.create();
+        return testEnv;
+    }
     it("Schema query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("SchemaTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const expectedSchema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!expectedSchema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const actualSchemaProps = await schemaLocater.getSchemaJson(testKey, IncrementalTestHelper.context);
-        const actualSchema = await Schema.fromJson(actualSchemaProps, IncrementalTestHelper.context);
-        expect(actualSchema.toJSON()).to.deep.equal(expectedSchema?.toJSON());
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testSchemaKey = new SchemaKey("SchemaTest", 1, 0, 0);
+            const env = __addDisposableResource(env_1, await createTestContext(), true);
+            const expectedSchema = await env.importAssetSchema(testSchemaKey);
+            const actualSchemaProps = await env.schemaLocater.getSchemaJson(testSchemaKey, env.schemaContext);
+            expect(actualSchemaProps).to.not.be.undefined;
+            const actualSchema = await Schema.fromJson(actualSchemaProps, env.schemaContext);
+            expect(actualSchema.toJSON()).to.deep.equal(expectedSchema?.toJSON());
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
     });
     it("Property query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("PropertyTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const classPropsObjects = await schemaLocater.getEntities(testKey.name, IncrementalTestHelper.context);
-        const entityOneProps = findItem("EntityOne", classPropsObjects);
-        const entityTwoProps = findItem("EntityTwo", classPropsObjects);
-        const expectedEntityOne = await schema.getEntityClass("EntityOne");
-        const expectedEntityTwo = await schema.getEntityClass("EntityTwo");
-        const validateProperty = (propertyName, actualItem = entityOneProps, expectedItem = expectedEntityOne) => {
-            const actualProperty = findProperty(propertyName, actualItem.properties);
-            const expectedProperty = expectedItem?.getPropertySync(propertyName);
-            // if maxOccurs is the maximum int value in the context Schema,
-            // the property from the DB will not have a value
-            if (expectedProperty.maxOccurs === 2147483647) {
-                expect(actualProperty.maxOccurs).to.be.undefined;
-                // set so comparison will pass
-                actualProperty.maxOccurs = 2147483647;
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("PropertyTest", 1, 0, 0);
+            const env = __addDisposableResource(env_2, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const classPropsObjects = await env.schemaLocater.getEntities(testKey.name, env.schemaContext);
+            const entityOneProps = findItem("EntityOne", classPropsObjects);
+            const entityTwoProps = findItem("EntityTwo", classPropsObjects);
+            const expectedEntityOne = await schema.getEntityClass("EntityOne");
+            const expectedEntityTwo = await schema.getEntityClass("EntityTwo");
+            const validateProperty = (propertyName, actualItem = entityOneProps, expectedItem = expectedEntityOne) => {
+                const actualProperty = findProperty(propertyName, actualItem.properties);
+                const expectedProperty = expectedItem?.getPropertySync(propertyName);
+                // if maxOccurs is the maximum int value in the context Schema,
+                // the property from the DB will not have a value
+                if (expectedProperty.maxOccurs === 2147483647) {
+                    expect(actualProperty.maxOccurs).to.be.undefined;
+                    // set so comparison will pass
+                    actualProperty.maxOccurs = 2147483647;
+                }
+                expect(actualProperty).to.deep.equal(expectedProperty?.toJSON());
+            };
+            // All but one testable property is in EntityOne
+            for (const property of await expectedEntityOne.getProperties(true)) {
+                validateProperty(property.name);
             }
-            expect(actualProperty).to.deep.equal(expectedProperty?.toJSON());
-        };
-        // All but one testable property is in EntityOne
-        for (const property of await expectedEntityOne.getProperties(true)) {
-            validateProperty(property.name);
-        }
-        // Backward direction Navigation property is in EntityTwo
-        validateProperty("EntityTwoParent", entityTwoProps, expectedEntityTwo);
+            // Backward direction Navigation property is in EntityTwo
+            validateProperty("EntityTwoParent", entityTwoProps, expectedEntityTwo);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
     });
     it("Entity query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("EntityTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const classPropsObjects = await schemaLocater.getEntities(testKey.name, IncrementalTestHelper.context);
-        expect(classPropsObjects.length).to.be.greaterThan(0);
-        validateItem("EntityModifierNone", classPropsObjects, schema);
-        validateItem("EntityModifierAbstract", classPropsObjects, schema);
-        validateItem("EntityModifierSealed", classPropsObjects, schema);
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("EntityTest", 1, 0, 0);
+            const env = __addDisposableResource(env_3, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const classPropsObjects = await env.schemaLocater.getEntities(testKey.name, env.schemaContext);
+            expect(classPropsObjects.length).to.be.greaterThan(0);
+            validateItem("EntityModifierNone", classPropsObjects, schema);
+            validateItem("EntityModifierAbstract", classPropsObjects, schema);
+            validateItem("EntityModifierSealed", classPropsObjects, schema);
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            const result_3 = __disposeResources(env_3);
+            if (result_3)
+                await result_3;
+        }
     });
     it("Struct query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("StructTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const classPropsObjects = await schemaLocater.getStructs(testKey.name, IncrementalTestHelper.context);
-        expect(classPropsObjects.length).to.be.greaterThan(0);
-        validateItem("StructModifierNone", classPropsObjects, schema);
-        validateItem("StructModifierAbstract", classPropsObjects, schema);
-        validateItem("StructModifierSealed", classPropsObjects, schema);
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("StructTest", 1, 0, 0);
+            const env = __addDisposableResource(env_4, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const classPropsObjects = await env.schemaLocater.getStructs(testKey.name, env.schemaContext);
+            expect(classPropsObjects.length).to.be.greaterThan(0);
+            validateItem("StructModifierNone", classPropsObjects, schema);
+            validateItem("StructModifierAbstract", classPropsObjects, schema);
+            validateItem("StructModifierSealed", classPropsObjects, schema);
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            const result_4 = __disposeResources(env_4);
+            if (result_4)
+                await result_4;
+        }
     });
     it("Mixin query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("MixinTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const classPropsObjects = await schemaLocater.getMixins(testKey.name, IncrementalTestHelper.context);
-        expect(classPropsObjects.length).to.be.greaterThan(0);
-        validateItem("IBaseMixin", classPropsObjects, schema);
-        validateItem("ITestMixin", classPropsObjects, schema);
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("MixinTest", 1, 0, 0);
+            const env = __addDisposableResource(env_5, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const classPropsObjects = await env.schemaLocater.getMixins(testKey.name, env.schemaContext);
+            expect(classPropsObjects.length).to.be.greaterThan(0);
+            validateItem("IBaseMixin", classPropsObjects, schema);
+            validateItem("ITestMixin", classPropsObjects, schema);
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            const result_5 = __disposeResources(env_5);
+            if (result_5)
+                await result_5;
+        }
     });
     it("Relationship query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("RelationshipTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const classPropsObjects = await schemaLocater.getRelationships(testKey.name, IncrementalTestHelper.context);
-        expect(classPropsObjects.length).to.be.greaterThan(0);
-        validateItem("OwnerOwnsVehicles", classPropsObjects, schema);
-        validateItem("OwnerOwnsCars", classPropsObjects, schema);
-        validateItem("OwnerOwnsAmericanCars", classPropsObjects, schema);
-        validateItem("PhysicalModelBreaksDownCarElement", classPropsObjects, schema);
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("RelationshipTest", 1, 0, 0);
+            const env = __addDisposableResource(env_6, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const classPropsObjects = await env.schemaLocater.getRelationships(testKey.name, env.schemaContext);
+            expect(classPropsObjects.length).to.be.greaterThan(0);
+            validateItem("OwnerOwnsVehicles", classPropsObjects, schema);
+            validateItem("OwnerOwnsCars", classPropsObjects, schema);
+            validateItem("OwnerOwnsAmericanCars", classPropsObjects, schema);
+            validateItem("PhysicalModelBreaksDownCarElement", classPropsObjects, schema);
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            const result_6 = __disposeResources(env_6);
+            if (result_6)
+                await result_6;
+        }
     });
     it("CustomAttributeClass query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("CustomAttributeClassTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const classPropsObjects = await schemaLocater.getCustomAttributeClasses(testKey.name, IncrementalTestHelper.context);
-        expect(classPropsObjects.length).to.be.greaterThan(0);
-        validateItem("CustomAttributeModifierNone", classPropsObjects, schema);
-        validateItem("CustomAttributeModifierSealed", classPropsObjects, schema);
-        validateItem("CustomAttributeModifierAbstract", classPropsObjects, schema);
+        const env_7 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("CustomAttributeClassTest", 1, 0, 0);
+            const env = __addDisposableResource(env_7, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const classPropsObjects = await env.schemaLocater.getCustomAttributeClasses(testKey.name, env.schemaContext);
+            expect(classPropsObjects.length).to.be.greaterThan(0);
+            validateItem("CustomAttributeModifierNone", classPropsObjects, schema);
+            validateItem("CustomAttributeModifierSealed", classPropsObjects, schema);
+            validateItem("CustomAttributeModifierAbstract", classPropsObjects, schema);
+        }
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
+        }
+        finally {
+            const result_7 = __disposeResources(env_7);
+            if (result_7)
+                await result_7;
+        }
     });
     it("KindOfQuantity query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("KindOfQuantityTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getKindOfQuantities(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        validateItem("ACCELERATION", itemPropsObjects, schema);
-        validateItem("ANGLE", itemPropsObjects, schema);
+        const env_8 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("KindOfQuantityTest", 1, 0, 0);
+            const env = __addDisposableResource(env_8, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getKindOfQuantities(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            validateItem("ACCELERATION", itemPropsObjects, schema);
+            validateItem("ANGLE", itemPropsObjects, schema);
+        }
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
+        }
+        finally {
+            const result_8 = __disposeResources(env_8);
+            if (result_8)
+                await result_8;
+        }
     });
     it("PropertyCategory query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("PropertyCategoryTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getPropertyCategories(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        validateItem("PropertyCategory1", itemPropsObjects, schema);
-        validateItem("PropertyCategory2", itemPropsObjects, schema);
+        const env_9 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("PropertyCategoryTest", 1, 0, 0);
+            const env = __addDisposableResource(env_9, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getPropertyCategories(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            validateItem("PropertyCategory1", itemPropsObjects, schema);
+            validateItem("PropertyCategory2", itemPropsObjects, schema);
+        }
+        catch (e_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
+        }
+        finally {
+            const result_9 = __disposeResources(env_9);
+            if (result_9)
+                await result_9;
+        }
     });
     it("Enumeration query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("EnumerationTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getEnumerations(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        validateItem("IntEnumeration", itemPropsObjects, schema);
-        validateItem("StringEnumeration", itemPropsObjects, schema);
+        const env_10 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("EnumerationTest", 1, 0, 0);
+            const env = __addDisposableResource(env_10, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getEnumerations(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            validateItem("IntEnumeration", itemPropsObjects, schema);
+            validateItem("StringEnumeration", itemPropsObjects, schema);
+        }
+        catch (e_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
+        }
+        finally {
+            const result_10 = __disposeResources(env_10);
+            if (result_10)
+                await result_10;
+        }
     });
     it("Unit query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("UnitTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getUnits(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        validateItem("LITRE", itemPropsObjects, schema);
-        validateItem("GALLON", itemPropsObjects, schema);
-        validateItem("ACRE", itemPropsObjects, schema);
-        validateItem("FAHRENHEIT", itemPropsObjects, schema);
+        const env_11 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("UnitTest", 1, 0, 0);
+            const env = __addDisposableResource(env_11, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getUnits(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            validateItem("LITRE", itemPropsObjects, schema);
+            validateItem("GALLON", itemPropsObjects, schema);
+            validateItem("ACRE", itemPropsObjects, schema);
+            validateItem("FAHRENHEIT", itemPropsObjects, schema);
+        }
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
+        }
+        finally {
+            const result_11 = __disposeResources(env_11);
+            if (result_11)
+                await result_11;
+        }
     });
     it("InvertedUnit query, props parsed successfully", async function () {
-        const testKey = new SchemaKey("InvertedUnitTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getInvertedUnits(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        validateItem("FT_HORIZONTAL_PER_FT_VERTICAL", itemPropsObjects, schema);
+        const env_12 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("InvertedUnitTest", 1, 0, 0);
+            const env = __addDisposableResource(env_12, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getInvertedUnits(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            validateItem("FT_HORIZONTAL_PER_FT_VERTICAL", itemPropsObjects, schema);
+        }
+        catch (e_12) {
+            env_12.error = e_12;
+            env_12.hasError = true;
+        }
+        finally {
+            const result_12 = __disposeResources(env_12);
+            if (result_12)
+                await result_12;
+        }
     });
     it("UnitSystem query, props parsed successfully", async function () {
-        // There's a UnitSystem in there.
-        const testKey = new SchemaKey("InvertedUnitTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getUnitSystems(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        validateItem("USCUSTOM", itemPropsObjects, schema);
+        const env_13 = { stack: [], error: void 0, hasError: false };
+        try {
+            // There's a UnitSystem in there.
+            const testKey = new SchemaKey("InvertedUnitTest", 1, 0, 0);
+            const env = __addDisposableResource(env_13, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getUnitSystems(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            validateItem("USCUSTOM", itemPropsObjects, schema);
+        }
+        catch (e_13) {
+            env_13.error = e_13;
+            env_13.hasError = true;
+        }
+        finally {
+            const result_13 = __disposeResources(env_13);
+            if (result_13)
+                await result_13;
+        }
     });
     it("Constant query, props parsed successfully", async function () {
-        // There's a UnitSystem in there.
-        const testKey = new SchemaKey("ConstantTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getConstants(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        validateItem("KILO", itemPropsObjects, schema);
-        validateItem("HALF_PI", itemPropsObjects, schema);
+        const env_14 = { stack: [], error: void 0, hasError: false };
+        try {
+            // There's a UnitSystem in there.
+            const testKey = new SchemaKey("ConstantTest", 1, 0, 0);
+            const env = __addDisposableResource(env_14, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getConstants(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            validateItem("KILO", itemPropsObjects, schema);
+            validateItem("HALF_PI", itemPropsObjects, schema);
+        }
+        catch (e_14) {
+            env_14.error = e_14;
+            env_14.hasError = true;
+        }
+        finally {
+            const result_14 = __disposeResources(env_14);
+            if (result_14)
+                await result_14;
+        }
     });
     it("Phenomenon query, props parsed successfully", async function () {
-        // There's a Phenomenon in there.
-        const testKey = new SchemaKey("ConstantTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getPhenomenon(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        validateItem("NUMBER", itemPropsObjects, schema);
-        validateItem("LENGTH_RATIO", itemPropsObjects, schema);
+        const env_15 = { stack: [], error: void 0, hasError: false };
+        try {
+            // There's a Phenomenon in there.
+            const testKey = new SchemaKey("ConstantTest", 1, 0, 0);
+            const env = __addDisposableResource(env_15, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getPhenomenon(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            validateItem("NUMBER", itemPropsObjects, schema);
+            validateItem("LENGTH_RATIO", itemPropsObjects, schema);
+        }
+        catch (e_15) {
+            env_15.error = e_15;
+            env_15.hasError = true;
+        }
+        finally {
+            const result_15 = __disposeResources(env_15);
+            if (result_15)
+                await result_15;
+        }
     });
     it("Format Schema parses successfully", async function () {
-        // Using installed Formats schema
-        const testKey = new SchemaKey("Formats", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getFormats(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        for (const props of itemPropsObjects) {
-            validateItem(props.name, itemPropsObjects, schema);
+        const env_16 = { stack: [], error: void 0, hasError: false };
+        try {
+            // Using installed Formats schema
+            const testKey = new SchemaKey("Formats", 1, 0, 0);
+            const env = __addDisposableResource(env_16, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getFormats(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            for (const props of itemPropsObjects) {
+                validateItem(props.name, itemPropsObjects, schema);
+            }
+        }
+        catch (e_16) {
+            env_16.error = e_16;
+            env_16.hasError = true;
+        }
+        finally {
+            const result_16 = __disposeResources(env_16);
+            if (result_16)
+                await result_16;
         }
     });
     it("Comprehensive Format parses successfully", async function () {
-        const testKey = new SchemaKey("FormatTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getFormats(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        for (const props of itemPropsObjects) {
-            validateItem(props.name, itemPropsObjects, schema);
+        const env_17 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("FormatTest", 1, 0, 0);
+            const env = __addDisposableResource(env_17, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getFormats(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            for (const props of itemPropsObjects) {
+                validateItem(props.name, itemPropsObjects, schema);
+            }
+        }
+        catch (e_17) {
+            env_17.error = e_17;
+            env_17.hasError = true;
+        }
+        finally {
+            const result_17 = __disposeResources(env_17);
+            if (result_17)
+                await result_17;
         }
     });
     it("CustomAttribute instances parse successfully", async function () {
-        const testKey = new SchemaKey("CustomAttributeInstanceTest", 1, 0, 0);
-        await IncrementalTestHelper.importSchema(testKey);
-        const schema = await IncrementalTestHelper.context.getSchema(testKey);
-        if (!schema)
-            throw new Error(`Could not find schema ${testKey.name}`);
-        const itemPropsObjects = await schemaLocater.getStructs(testKey.name, IncrementalTestHelper.context);
-        expect(itemPropsObjects.length).to.be.greaterThan(0);
-        for (const props of itemPropsObjects) {
-            validateItem(props.name, itemPropsObjects, schema);
+        const env_18 = { stack: [], error: void 0, hasError: false };
+        try {
+            const testKey = new SchemaKey("CustomAttributeInstanceTest", 1, 0, 0);
+            const env = __addDisposableResource(env_18, await createTestContext(), true);
+            const schema = await env.importAssetSchema(testKey);
+            const itemPropsObjects = await env.schemaLocater.getStructs(testKey.name, env.schemaContext);
+            expect(itemPropsObjects.length).to.be.greaterThan(0);
+            for (const props of itemPropsObjects) {
+                validateItem(props.name, itemPropsObjects, schema);
+            }
+        }
+        catch (e_18) {
+            env_18.error = e_18;
+            env_18.hasError = true;
+        }
+        finally {
+            const result_18 = __disposeResources(env_18);
+            if (result_18)
+                await result_18;
         }
     });
 });