@itwin/core-backend 5.11.0-dev.9 → 5.12.0-dev.2

package/lib/esm/test/annotations/TextAnnotation.test.js

@@ -1,3 +1,55 @@
+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;
+});
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -21,6 +73,7 @@ import { layoutTextBlock, TextStyleResolver } from "../../annotations/TextBlockL
 import { appendTextAnnotationGeometry } from "../../annotations/TextAnnotationGeometry";
 import { IModelElementCloneContext } from "../../IModelElementCloneContext";
 import { EditTxn, withEditTxn } from "../../EditTxn";
+import { DisableNativeAssertions } from "../TestUtils";
 import * as fs from "fs";
 function mockIModel() {
     const iModel = {
@@ -521,24 +574,36 @@ describe("TextAnnotation element", () => {
                         expect(para.children[1].propertyHost.elementId).to.equal("0xabc");
                     });
                     it("leaves default text style intact", async () => {
-                        async function clone(styleId, expectedStyleId) {
-                            const elem = insertStyledElement(styleId, imodel);
-                            const context = new IModelElementCloneContext(imodel);
-                            context.remapElement(createElement2dArgs.model, createElement2dArgs.model);
-                            const props = await context.cloneElement(elem);
-                            expect(props.defaultTextStyle?.id).to.equal(expectedStyleId);
-                            if (styleId) {
-                                // Even an explicit remapping is ignored when cloning within a single iModel
-                                // (per the examples set by most other elements, excluding RenderMaterial).
-                                context.remapElement(styleId, "0x99887");
-                                const props2 = await context.cloneElement(elem);
-                                expect(props2.defaultTextStyle?.id).to.equal(expectedStyleId);
+                        const env_1 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            async function clone(styleId, expectedStyleId) {
+                                const elem = insertStyledElement(styleId, imodel);
+                                const context = new IModelElementCloneContext(imodel);
+                                context.remapElement(createElement2dArgs.model, createElement2dArgs.model);
+                                const props = await context.cloneElement(elem);
+                                expect(props.defaultTextStyle?.id).to.equal(expectedStyleId);
+                                if (styleId) {
+                                    // Even an explicit remapping is ignored when cloning within a single iModel
+                                    // (per the examples set by most other elements, excluding RenderMaterial).
+                                    context.remapElement(styleId, "0x99887");
+                                    const props2 = await context.cloneElement(elem);
+                                    expect(props2.defaultTextStyle?.id).to.equal(expectedStyleId);
+                                }
                             }
+                            await clone(seedStyleId, seedStyleId);
+                            await clone(undefined, undefined);
+                            await clone("0x12345", "0x12345");
+                            // The native code asserts on an invalid ID. Suppress this.
+                            const _disableAssertions = __addDisposableResource(env_1, new DisableNativeAssertions(), false);
+                            await clone(Id64.invalid, undefined);
+                        }
+                        catch (e_1) {
+                            env_1.error = e_1;
+                            env_1.hasError = true;
+                        }
+                        finally {
+                            __disposeResources(env_1);
                         }
-                        await clone(seedStyleId, seedStyleId);
-                        await clone(undefined, undefined);
-                        await clone("0x12345", "0x12345");
-                        await clone(Id64.invalid, undefined);
                     });
                 });
                 describe("between iModels", () => {