@itwin/core-backend 5.14.0-dev.8 → 5.15.0-dev.1

package/lib/esm/test/ecdb/ECDb.test.js

@@ -80,6 +80,118 @@ describe("ECDb", () => {
             __disposeResources(env_1);
         }
     });
+    it("supports opt-in fallback for a missing navigation relationship class id", () => {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const ecdb = __addDisposableResource(env_2, ECDbTestHelper.createECDb(outDir, "nav-rel-class-id-fallback.ecdb", `
+      <ECSchema schemaName="NavFallback" alias="nf" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+        <ECEntityClass typeName="Hub" modifier="Sealed">
+          <ECProperty propertyName="Name" typeName="string"/>
+        </ECEntityClass>
+        <ECEntityClass typeName="Spoke" modifier="Sealed">
+          <ECProperty propertyName="Name" typeName="string"/>
+          <ECNavigationProperty propertyName="Owner" relationshipName="HubOwnsSpokes" direction="Backward"/>
+        </ECEntityClass>
+        <ECRelationshipClass typeName="HubOwnsSpokes" strength="Referencing" modifier="Abstract">
+          <Source multiplicity="(0..1)" polymorphic="False" roleLabel="owns">
+            <Class class="Hub"/>
+          </Source>
+          <Target multiplicity="(0..*)" polymorphic="True" roleLabel="is owned by">
+            <Class class="Spoke"/>
+          </Target>
+        </ECRelationshipClass>
+        <ECRelationshipClass typeName="HubOwnsSpoke" strength="Referencing" modifier="Sealed">
+          <BaseClass>HubOwnsSpokes</BaseClass>
+          <Source multiplicity="(0..1)" polymorphic="False" roleLabel="owns">
+            <Class class="Hub"/>
+          </Source>
+          <Target multiplicity="(0..*)" polymorphic="True" roleLabel="is owned by">
+            <Class class="Spoke"/>
+          </Target>
+        </ECRelationshipClass>
+      </ECSchema>`), false);
+            const insert = (ecsql, bind) => ecdb.withCachedWriteStatement(ecsql, (statement) => {
+                bind?.(statement);
+                const result = statement.stepForInsert();
+                assert.equal(result.status, DbResult.BE_SQLITE_DONE);
+                assert.isDefined(result.id);
+                return result.id;
+            });
+            const queryClassId = (className) => {
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
+                return ecdb.withPreparedStatement("SELECT c.ECInstanceId FROM meta.ECClassDef c JOIN meta.ECSchemaDef s ON c.Schema.Id=s.ECInstanceId WHERE s.Name='NavFallback' AND c.Name=?", (statement) => {
+                    statement.bindString(1, className);
+                    assert.equal(statement.step(), DbResult.BE_SQLITE_ROW);
+                    return statement.getValue(0).getId();
+                });
+            };
+            const hubClassId = queryClassId("Hub");
+            const rootRelationshipClassId = queryClassId("HubOwnsSpokes");
+            const derivedRelationshipClassId = queryClassId("HubOwnsSpoke");
+            const hubId = insert("INSERT INTO nf.Hub(Name) VALUES('hub')");
+            const legacySpokeId = insert("INSERT INTO nf.Spoke(Name, Owner.Id, Owner.RelECClassId) VALUES('legacy', ?, NULL)", (statement) => statement.bindId(1, hubId));
+            const normalSpokeId = insert("INSERT INTO nf.Spoke(Name, Owner.Id, Owner.RelECClassId) VALUES('normal', ?, ?)", (statement) => {
+                statement.bindId(1, hubId);
+                statement.bindId(2, derivedRelationshipClassId);
+            });
+            ecdb.saveChanges();
+            const queryCount = (ecsql, ids = []) => {
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
+                return ecdb.withPreparedStatement(ecsql, (statement) => {
+                    ids.forEach((id, index) => statement.bindId(index + 1, id));
+                    assert.equal(statement.step(), DbResult.BE_SQLITE_ROW);
+                    return statement.getValue(0).getInteger();
+                });
+            };
+            assert.equal(queryCount("SELECT COUNT(*) FROM nf.HubOwnsSpokes"), 1);
+            assert.equal(queryCount("SELECT COUNT(*) FROM nf.HubOwnsSpokes ECSQLOPTIONS NAV_REL_CLASSID_FALLBACK"), 2);
+            assert.equal(queryCount("SELECT COUNT(*) FROM nf.HubOwnsSpoke"), 1);
+            assert.equal(queryCount("SELECT COUNT(*) FROM nf.HubOwnsSpoke ECSQLOPTIONS NAV_REL_CLASSID_FALLBACK"), 1);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            ecdb.withPreparedStatement("SELECT ECClassId, SourceECInstanceId, TargetECInstanceId FROM nf.HubOwnsSpokes WHERE TargetECInstanceId=? ECSQLOPTIONS NAV_REL_CLASSID_FALLBACK", (statement) => {
+                statement.bindId(1, legacySpokeId);
+                assert.equal(statement.step(), DbResult.BE_SQLITE_ROW);
+                assert.equal(statement.getValue(0).getId(), rootRelationshipClassId);
+                assert.equal(statement.getValue(1).getId(), hubId);
+                assert.equal(statement.getValue(2).getId(), legacySpokeId);
+                assert.equal(statement.step(), DbResult.BE_SQLITE_DONE);
+            });
+            const relationsCountSql = `SELECT COUNT(*) FROM ECVLib.Relations(?, ?, 'forward')
+      ECSQLOPTIONS ENABLE_EXPERIMENTAL_FEATURES`;
+            assert.equal(queryCount(relationsCountSql, [hubId, hubClassId]), 1);
+            assert.equal(queryCount(`${relationsCountSql} NAV_REL_CLASSID_FALLBACK`, [hubId, hubClassId]), 2);
+            assert.equal(queryCount(relationsCountSql, [hubId, hubClassId]), 1);
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            ecdb.withPreparedStatement(`SELECT RelatedECInstanceId, RelationshipECClassId, RelationshipECInstanceId, NavPropertyName
+       FROM ECVLib.Relations(?, ?, 'forward') WHERE RelatedECInstanceId=?
+       ECSQLOPTIONS ENABLE_EXPERIMENTAL_FEATURES NAV_REL_CLASSID_FALLBACK`, (statement) => {
+                statement.bindId(1, hubId);
+                statement.bindId(2, hubClassId);
+                statement.bindId(3, legacySpokeId);
+                assert.equal(statement.step(), DbResult.BE_SQLITE_ROW);
+                assert.equal(statement.getValue(0).getId(), legacySpokeId);
+                assert.equal(statement.getValue(1).getId(), rootRelationshipClassId);
+                assert.equal(statement.getValue(2).getId(), legacySpokeId);
+                assert.equal(statement.getValue(3).getString(), "Owner");
+                assert.equal(statement.step(), DbResult.BE_SQLITE_DONE);
+            });
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            ecdb.withPreparedStatement(`SELECT Owner.RelECClassId FROM nf.Spoke WHERE ECInstanceId=?
+      ECSQLOPTIONS NAV_REL_CLASSID_FALLBACK`, (statement) => {
+                statement.bindId(1, legacySpokeId);
+                assert.equal(statement.step(), DbResult.BE_SQLITE_ROW);
+                assert.isTrue(statement.getValue(0).isNull);
+            });
+            assert.equal(queryCount("SELECT COUNT(*) FROM nf.HubOwnsSpoke WHERE TargetECInstanceId=?", [normalSpokeId]), 1);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    });
     it("should be able to close an ECDb", () => {
         const ecdb = ECDbTestHelper.createECDb(outDir, "close.ecdb");
         assert.isTrue(ecdb.isOpen);
@@ -87,58 +199,44 @@ describe("ECDb", () => {
         assert.isFalse(ecdb.isOpen);
     });
     it("should be able to open an ECDb", () => {
-        const env_2 = { stack: [], error: void 0, hasError: false };
+        const env_3 = { stack: [], error: void 0, hasError: false };
         try {
             const fileName = "open.ecdb";
             const ecdbPath = path.join(outDir, fileName);
             {
-                const env_3 = { stack: [], error: void 0, hasError: false };
+                const env_4 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const testECDb = __addDisposableResource(env_3, ECDbTestHelper.createECDb(outDir, fileName), false);
+                    const testECDb = __addDisposableResource(env_4, ECDbTestHelper.createECDb(outDir, fileName), false);
                     assert.isTrue(testECDb.isOpen);
                 }
-                catch (e_2) {
-                    env_3.error = e_2;
-                    env_3.hasError = true;
+                catch (e_3) {
+                    env_4.error = e_3;
+                    env_4.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_3);
+                    __disposeResources(env_4);
                 }
             }
-            const ecdb = __addDisposableResource(env_2, new ECDb(), false);
+            const ecdb = __addDisposableResource(env_3, new ECDb(), false);
             ecdb.openDb(ecdbPath, ECDbOpenMode.ReadWrite);
             assert.isTrue(ecdb.isOpen);
         }
-        catch (e_3) {
-            env_2.error = e_3;
-            env_2.hasError = true;
+        catch (e_4) {
+            env_3.error = e_4;
+            env_3.hasError = true;
         }
         finally {
-            __disposeResources(env_2);
+            __disposeResources(env_3);
         }
     });
     it("Open ECDb with upgrade option", () => {
         const fileName = "open.ecdb";
         const ecdbPath = path.join(outDir, fileName);
-        {
-            const env_4 = { stack: [], error: void 0, hasError: false };
-            try {
-                const testECDb = __addDisposableResource(env_4, ECDbTestHelper.createECDb(outDir, fileName), false);
-                assert.isTrue(testECDb.isOpen);
-            }
-            catch (e_4) {
-                env_4.error = e_4;
-                env_4.hasError = true;
-            }
-            finally {
-                __disposeResources(env_4);
-            }
-        }
         {
             const env_5 = { stack: [], error: void 0, hasError: false };
             try {
-                const ecdb = __addDisposableResource(env_5, new ECDb(), false);
-                assert.doesNotThrow(() => ecdb.openDb(ecdbPath, ECDbOpenMode.Readonly));
+                const testECDb = __addDisposableResource(env_5, ECDbTestHelper.createECDb(outDir, fileName), false);
+                assert.isTrue(testECDb.isOpen);
             }
             catch (e_5) {
                 env_5.error = e_5;
@@ -152,7 +250,7 @@ describe("ECDb", () => {
             const env_6 = { stack: [], error: void 0, hasError: false };
             try {
                 const ecdb = __addDisposableResource(env_6, new ECDb(), false);
-                assert.doesNotThrow(() => ecdb.openDb(ecdbPath, ECDbOpenMode.ReadWrite));
+                assert.doesNotThrow(() => ecdb.openDb(ecdbPath, ECDbOpenMode.Readonly));
             }
             catch (e_6) {
                 env_6.error = e_6;
@@ -166,7 +264,7 @@ describe("ECDb", () => {
             const env_7 = { stack: [], error: void 0, hasError: false };
             try {
                 const ecdb = __addDisposableResource(env_7, new ECDb(), false);
-                assert.doesNotThrow(() => ecdb.openDb(ecdbPath, ECDbOpenMode.FileUpgrade));
+                assert.doesNotThrow(() => ecdb.openDb(ecdbPath, ECDbOpenMode.ReadWrite));
             }
             catch (e_7) {
                 env_7.error = e_7;
@@ -176,13 +274,27 @@ describe("ECDb", () => {
                 __disposeResources(env_7);
             }
         }
+        {
+            const env_8 = { stack: [], error: void 0, hasError: false };
+            try {
+                const ecdb = __addDisposableResource(env_8, new ECDb(), false);
+                assert.doesNotThrow(() => ecdb.openDb(ecdbPath, ECDbOpenMode.FileUpgrade));
+            }
+            catch (e_8) {
+                env_8.error = e_8;
+                env_8.hasError = true;
+            }
+            finally {
+                __disposeResources(env_8);
+            }
+        }
     });
     it("attach/detach newer profile version", async () => {
-        const env_8 = { stack: [], error: void 0, hasError: false };
+        const env_9 = { stack: [], error: void 0, hasError: false };
         try {
             const fileName1 = "source_file.ecdb";
             const ecdbPath1 = path.join(outDir, fileName1);
-            const testECDb = __addDisposableResource(env_8, ECDbTestHelper.createECDb(outDir, fileName1, `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+            const testECDb = __addDisposableResource(env_9, ECDbTestHelper.createECDb(outDir, fileName1, `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
       <ECEntityClass typeName="Person" modifier="Sealed">
         <ECProperty propertyName="Name" typeName="string"/>
         <ECProperty propertyName="Age" typeName="int"/>
@@ -221,7 +333,7 @@ describe("ECDb", () => {
                 }
                 return result;
             };
-            const testECDb0 = __addDisposableResource(env_8, ECDbTestHelper.createECDb(outDir, "file2.ecdb"), false);
+            const testECDb0 = __addDisposableResource(env_9, ECDbTestHelper.createECDb(outDir, "file2.ecdb"), false);
             // following call will not fail but unknow ECDb profile will cause it to be attach as SQLite.
             testECDb0.attachDb(ecdbPath1, "source");
             // eslint-disable-next-line @typescript-eslint/no-deprecated
@@ -251,7 +363,7 @@ describe("ECDb", () => {
             ]);
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             expect(() => testECDb0.withPreparedStatement("SELECT Name, Age FROM source.test.Person", () => { })).to.throw("ECClass 'source.test.Person' does not exist or could not be loaded.");
-            const testECDb1 = __addDisposableResource(env_8, ECDbTestHelper.createECDb(outDir, "file4.ecdb"), false);
+            const testECDb1 = __addDisposableResource(env_9, ECDbTestHelper.createECDb(outDir, "file4.ecdb"), false);
             testECDb1.attachDb(ecdbPath1, "source");
             const reader1 = testECDb1.createQueryReader("SELECT Name, Age FROM source.test.Person");
             let expectThrow = false;
@@ -289,20 +401,20 @@ describe("ECDb", () => {
                 },
             ]);
         }
-        catch (e_8) {
-            env_8.error = e_8;
-            env_8.hasError = true;
+        catch (e_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
         }
         finally {
-            __disposeResources(env_8);
+            __disposeResources(env_9);
         }
     });
     it("attach/detach file & db_list pragma", async () => {
-        const env_9 = { stack: [], error: void 0, hasError: false };
+        const env_10 = { stack: [], error: void 0, hasError: false };
         try {
             const fileName1 = "source_file.ecdb";
             const ecdbPath1 = path.join(outDir, fileName1);
-            const testECDb = __addDisposableResource(env_9, ECDbTestHelper.createECDb(outDir, fileName1, `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+            const testECDb = __addDisposableResource(env_10, ECDbTestHelper.createECDb(outDir, fileName1, `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
       <ECEntityClass typeName="Person" modifier="Sealed">
         <ECProperty propertyName="Name" typeName="string"/>
         <ECProperty propertyName="Age" typeName="int"/>
@@ -328,7 +440,7 @@ describe("ECDb", () => {
                     return result;
                 });
             };
-            const testECDb0 = __addDisposableResource(env_9, ECDbTestHelper.createECDb(outDir, "file2.ecdb"), false);
+            const testECDb0 = __addDisposableResource(env_10, ECDbTestHelper.createECDb(outDir, "file2.ecdb"), false);
             testECDb0.attachDb(ecdbPath1, "source");
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             testECDb0.withPreparedStatement("SELECT Name, Age FROM source.test.Person", (stmt) => {
@@ -362,14 +474,14 @@ describe("ECDb", () => {
             ]);
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             expect(() => testECDb0.withPreparedStatement("SELECT Name, Age FROM source.test.Person", () => { })).to.throw("ECClass 'source.test.Person' does not exist or could not be loaded.");
-            const testECDb1 = __addDisposableResource(env_9, ECDbTestHelper.createECDb(outDir, "file3.ecdb"), false);
+            const testECDb1 = __addDisposableResource(env_10, ECDbTestHelper.createECDb(outDir, "file3.ecdb"), false);
             testECDb1.attachDb(ecdbPath1, "source");
             const reader1 = testECDb1.createQueryReader("SELECT Name, Age FROM source.test.Person", undefined, new QueryOptionsBuilder().setUsePrimaryConnection(true).getOptions());
             assert.equal(await reader1.step(), true);
             assert.equal(reader1.current.name, "Mary");
             assert.equal(reader1.current.age, 45);
             testECDb1.detachDb("source");
-            const testECDb2 = __addDisposableResource(env_9, ECDbTestHelper.createECDb(outDir, "file4.ecdb"), false);
+            const testECDb2 = __addDisposableResource(env_10, ECDbTestHelper.createECDb(outDir, "file4.ecdb"), false);
             testECDb2.attachDb(ecdbPath1, "source");
             const reader2 = testECDb2.createQueryReader("SELECT Name, Age FROM source.test.Person");
             assert.equal(await reader2.step(), true);
@@ -389,24 +501,24 @@ describe("ECDb", () => {
             }
             assert.isTrue(expectThrow);
         }
-        catch (e_9) {
-            env_9.error = e_9;
-            env_9.hasError = true;
+        catch (e_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
         }
         finally {
-            __disposeResources(env_9);
+            __disposeResources(env_10);
         }
     });
     it("should be able to import a schema", () => {
-        const env_10 = { stack: [], error: void 0, hasError: false };
+        const env_11 = { stack: [], error: void 0, hasError: false };
         try {
             const fileName = "schemaimport.ecdb";
             const ecdbPath = path.join(outDir, fileName);
             let id;
             {
-                const env_11 = { stack: [], error: void 0, hasError: false };
+                const env_12 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const testECDb = __addDisposableResource(env_11, ECDbTestHelper.createECDb(outDir, fileName, `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+                    const testECDb = __addDisposableResource(env_12, ECDbTestHelper.createECDb(outDir, fileName, `<ECSchema schemaName="Test" alias="test" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
       <ECEntityClass typeName="Person" modifier="Sealed">
       <ECProperty propertyName="Name" typeName="string"/>
         <ECProperty propertyName="Age" typeName="int"/>
@@ -422,15 +534,15 @@ describe("ECDb", () => {
                     });
                     testECDb.saveChanges();
                 }
-                catch (e_10) {
-                    env_11.error = e_10;
-                    env_11.hasError = true;
+                catch (e_11) {
+                    env_12.error = e_11;
+                    env_12.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_11);
+                    __disposeResources(env_12);
                 }
             }
-            const ecdb = __addDisposableResource(env_10, new ECDb(), false);
+            const ecdb = __addDisposableResource(env_11, new ECDb(), false);
             ecdb.openDb(ecdbPath, ECDbOpenMode.Readonly);
             assert.isTrue(ecdb.isOpen);
             // eslint-disable-next-line @typescript-eslint/no-deprecated
@@ -442,55 +554,55 @@ describe("ECDb", () => {
                 assert.equal(row.age, 45);
             });
         }
-        catch (e_11) {
-            env_10.error = e_11;
-            env_10.hasError = true;
+        catch (e_12) {
+            env_11.error = e_12;
+            env_11.hasError = true;
         }
         finally {
-            __disposeResources(env_10);
+            __disposeResources(env_11);
         }
     });
     it("should be able to get schema props", () => {
-        const env_12 = { stack: [], error: void 0, hasError: false };
+        const env_13 = { stack: [], error: void 0, hasError: false };
         try {
             const fileName = "schema-props.ecdb";
             const ecdbPath = path.join(outDir, fileName);
             {
-                const env_13 = { stack: [], error: void 0, hasError: false };
+                const env_14 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const testECDb = __addDisposableResource(env_13, ECDbTestHelper.createECDb(outDir, fileName), false);
+                    const testECDb = __addDisposableResource(env_14, ECDbTestHelper.createECDb(outDir, fileName), false);
                     assert.isTrue(testECDb.isOpen);
                 }
-                catch (e_12) {
-                    env_13.error = e_12;
-                    env_13.hasError = true;
+                catch (e_13) {
+                    env_14.error = e_13;
+                    env_14.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_13);
+                    __disposeResources(env_14);
                 }
             }
-            const ecdb = __addDisposableResource(env_12, new ECDb(), false);
+            const ecdb = __addDisposableResource(env_13, new ECDb(), false);
             ecdb.openDb(ecdbPath);
             const schema = ecdb.getSchemaProps("ECDbMeta");
             assert.equal(schema.name, "ECDbMeta");
         }
-        catch (e_13) {
-            env_12.error = e_13;
-            env_12.hasError = true;
+        catch (e_14) {
+            env_13.error = e_14;
+            env_13.hasError = true;
         }
         finally {
-            __disposeResources(env_12);
+            __disposeResources(env_13);
         }
     });
     it("Run plain SQL", () => {
-        const env_14 = { stack: [], error: void 0, hasError: false };
+        const env_15 = { stack: [], error: void 0, hasError: false };
         try {
             const fileName = "plainseql.ecdb";
             const ecdbPath = path.join(outDir, fileName);
             {
-                const env_15 = { stack: [], error: void 0, hasError: false };
+                const env_16 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const testECDb = __addDisposableResource(env_15, ECDbTestHelper.createECDb(outDir, fileName), false);
+                    const testECDb = __addDisposableResource(env_16, ECDbTestHelper.createECDb(outDir, fileName), false);
                     assert.isTrue(testECDb.isOpen);
                     testECDb.withPreparedSqliteStatement("CREATE TABLE Test(Id INTEGER PRIMARY KEY, Name TEXT NOT NULL, Code INTEGER)", (stmt) => {
                         assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
@@ -515,15 +627,15 @@ describe("ECDb", () => {
                     });
                     testECDb.saveChanges();
                 }
-                catch (e_14) {
-                    env_15.error = e_14;
-                    env_15.hasError = true;
+                catch (e_15) {
+                    env_16.error = e_15;
+                    env_16.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_15);
+                    __disposeResources(env_16);
                 }
             }
-            const ecdb = __addDisposableResource(env_14, new ECDb(), false);
+            const ecdb = __addDisposableResource(env_15, new ECDb(), false);
             ecdb.openDb(ecdbPath, ECDbOpenMode.Readonly);
             assert.isTrue(ecdb.isOpen);
             ecdb.withPreparedSqliteStatement("SELECT Id,Name,Code FROM Test ORDER BY Id", (stmt) => {
@@ -553,12 +665,12 @@ describe("ECDb", () => {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
             });
         }
-        catch (e_15) {
-            env_14.error = e_15;
-            env_14.hasError = true;
+        catch (e_16) {
+            env_15.error = e_16;
+            env_15.hasError = true;
         }
         finally {
-            __disposeResources(env_14);
+            __disposeResources(env_15);
         }
     });
     it("test unit labels in composite formats", () => {
@@ -672,9 +784,9 @@ describe("ECDb", () => {
         ecdb.closeDb();
     });
     it("should drop a single schema", () => {
-        const env_16 = { stack: [], error: void 0, hasError: false };
+        const env_17 = { stack: [], error: void 0, hasError: false };
         try {
-            const ecdb = __addDisposableResource(env_16, ECDbTestHelper.createECDb(outDir, "test.ecdb", `<ECSchema schemaName="Test" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+            const ecdb = __addDisposableResource(env_17, ECDbTestHelper.createECDb(outDir, "test.ecdb", `<ECSchema schemaName="Test" alias="ts" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
         <ECEntityClass typeName="Foo" modifier="Sealed">
           <ECProperty propertyName="n" typeName="int"/>
         </ECEntityClass>
@@ -686,16 +798,16 @@ describe("ECDb", () => {
             ecdb.dropSchemas(["Test"]);
             expect(() => ecdb.getSchemaProps("Test")).to.throw();
         }
-        catch (e_16) {
-            env_16.error = e_16;
-            env_16.hasError = true;
+        catch (e_17) {
+            env_17.error = e_17;
+            env_17.hasError = true;
         }
         finally {
-            __disposeResources(env_16);
+            __disposeResources(env_17);
         }
     });
     it("should drop multiple schemas", () => {
-        const env_17 = { stack: [], error: void 0, hasError: false };
+        const env_18 = { stack: [], error: void 0, hasError: false };
         try {
             const testSchema1Xml = `<?xml version="1.0" encoding="utf-8"?>
       <ECSchema schemaName="TestSchema1" alias="ts1" version="01.00.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
@@ -710,7 +822,7 @@ describe("ECDb", () => {
           <ECProperty propertyName="Prop2" typeName="string"/>
         </ECEntityClass>
       </ECSchema>`;
-            const ecdb = __addDisposableResource(env_17, ECDbTestHelper.createECDb(outDir, "drop-multiple-schemas.ecdb"), false);
+            const ecdb = __addDisposableResource(env_18, ECDbTestHelper.createECDb(outDir, "drop-multiple-schemas.ecdb"), false);
             assert.isTrue(ecdb.isOpen);
             const schema1Path = path.join(outDir, "TestSchema1.ecschema.xml");
             IModelJsFs.writeFileSync(schema1Path, testSchema1Xml);
@@ -732,12 +844,12 @@ describe("ECDb", () => {
             IModelJsFs.removeSync(schema1Path);
             IModelJsFs.removeSync(schema2Path);
         }
-        catch (e_17) {
-            env_17.error = e_17;
-            env_17.hasError = true;
+        catch (e_18) {
+            env_18.error = e_18;
+            env_18.hasError = true;
         }
         finally {
-            __disposeResources(env_17);
+            __disposeResources(env_18);
         }
     });
 });