@itwin/core-backend 5.8.2 → 5.9.0-dev.10

package/lib/esm/test/standalone/GeometryStream.test.js

@@ -4,12 +4,43 @@
 *--------------------------------------------------------------------------------------------*/
 import { assert, expect } from "chai";
 import { BentleyStatus, Id64, IModelStatus } from "@itwin/core-bentley";
+import { EditTxn } from "../../EditTxn";
 import { Angle, AngleSweep, Arc3d, Box, ClipMaskXYZRangePlanes, ClipPlane, ClipPlaneContainment, ClipPrimitive, ClipShape, ClipVector, ConvexClipPlaneSet, CurveCollection, CurvePrimitive, Geometry, IndexedPolyface, InterpolationCurve3d, InterpolationCurve3dOptions, LineSegment3d, LineString3d, Loop, Matrix3d, Plane3dByOriginAndUnitNormal, Point2d, Point3d, Point3dArray, PointString3d, PolyfaceBuilder, Range2d, Range3d, SolidPrimitive, Sphere, StrokeOptions, Transform, Vector3d, YawPitchRollAngles, } from "@itwin/core-geometry";
 import { AreaPattern, BackgroundFill, BRepGeometryOperation, Code, ColorByName, ColorDef, ElementGeometry, ElementGeometryOpcode, FillDisplay, GeometryClass, GeometryParams, GeometryStreamBuilder, GeometryStreamFlags, GeometryStreamIterator, Gradient, ImageGraphicCorners, IModel, LinePixels, LineStyle, MassPropertiesOperation, Placement3d, TextString, ThematicGradientMode, ThematicGradientSettings, ViewFlags, } from "@itwin/core-common";
 import { _nativeDb, DefinitionModel, deleteElementTree, GeometryPart, LineStyleDefinition, PhysicalObject, SubCategory, Subject } from "../../core-backend";
 import { createBRepDataProps } from "../GeometryTestUtil";
 import { IModelTestUtils } from "../IModelTestUtils";
 import { Timer } from "../TestUtils";
+let currentTxn;
+function txnForCurrentTest(iModel, mode = "reuse") {
+    if (currentTxn && (!currentTxn.iModel.isOpen || currentTxn.iModel !== iModel)) {
+        if (currentTxn.isActive && currentTxn.iModel.isOpen)
+            currentTxn.end("abandon");
+        currentTxn = undefined;
+    }
+    if ("reuse" === mode && currentTxn?.isActive)
+        return currentTxn;
+    if (currentTxn?.isActive)
+        currentTxn.end("abandon");
+    currentTxn = new EditTxn(iModel, "geometry stream");
+    currentTxn.start();
+    return currentTxn;
+}
+function saveTestTxn(iModel, closeAfterSave = false) {
+    const txn = txnForCurrentTest(iModel);
+    txn.saveChanges();
+    if (closeAfterSave && txn.isActive) {
+        txn.end();
+        currentTxn = undefined;
+        if (iModel.isOpen)
+            txnForCurrentTest(iModel, "fresh");
+    }
+}
+function closeTestTxn(_iModel) {
+    if (currentTxn?.isActive)
+        currentTxn.end("abandon");
+    currentTxn = undefined;
+}
 function assertTrue(expr) {
     assert.isTrue(expr);
 }
@@ -35,12 +66,12 @@ function createPhysicalElementProps(seedElement, placement, geom, modelId) {
 }
 function createGeometryPart(geom, imodel) {
     const partProps = createGeometryPartProps(geom);
-    return imodel.elements.insertElement(partProps);
+    return txnForCurrentTest(imodel).insertElement(partProps);
 }
 function createGeometricElem(geom, placement, imodel, seedElement) {
     const elementProps = createPhysicalElementProps(seedElement, placement, geom);
     const el = imodel.elements.createElement(elementProps);
-    return imodel.elements.insertElement(el.toJSON());
+    return txnForCurrentTest(imodel).insertElement(el.toJSON());
 }
 function createPartElem(partId, origin, angles, imodel, seedElement, isRelative = false) {
     const builder = new GeometryStreamBuilder();
@@ -94,7 +125,7 @@ function createStyledLineElem(imodel, seedElement, x, y, length, styleInfo, colo
     builder.appendGeometryParamsChange(params);
     builder.appendGeometry(LineSegment3d.create(Point3d.create(x, y, 0), Point3d.create(x + length, y, 0)));
     const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
-    return imodel.elements.insertElement(elementProps);
+    return txnForCurrentTest(imodel).insertElement(elementProps);
 }
 function validateElementInfo(info, expected, isWorld) {
     assert.isTrue(undefined !== info.entryArray && expected.length === info.entryArray.length);
@@ -245,9 +276,9 @@ function createGeometricElemFromSeed(imodel, seedId, entryArray, placement) {
     assert.exists(seedElement);
     const elementProps = createPhysicalElementProps(seedElement, placement);
     elementProps.elementGeometryBuilderParams = { entryArray };
-    const newId = imodel.elements.insertElement(elementProps);
+    const newId = txnForCurrentTest(imodel).insertElement(elementProps);
     assert.isTrue(Id64.isValidId64(newId));
-    imodel.saveChanges();
+    saveTestTxn(imodel, true);
     return newId;
 }
 describe("GeometryStream", () => {
@@ -258,9 +289,17 @@ describe("GeometryStream", () => {
         imodel = IModelTestUtils.createSnapshotFromSeed(testFileName, seedFileName);
     });
     after(() => {
+        closeTestTxn(imodel);
         imodel.close();
     });
+    beforeEach(() => {
+        txnForCurrentTest(imodel, "fresh");
+    });
+    afterEach(() => {
+        closeTestTxn(imodel);
+    });
     it("create GeometricElement3d using line codes 1-7", async () => {
+        const txn = txnForCurrentTest(imodel);
         // Set up element to be placed in iModel
         const seedElement = imodel.elements.getElement("0x1d");
         assert.exists(seedElement);
@@ -270,12 +309,12 @@ describe("GeometryStream", () => {
         // create new line style definitions for line codes 1-7
         const lsStyles = [];
         lsCodes.forEach((linePixels) => {
-            lsStyles.push(LinePixels.Solid === linePixels ? Id64.invalid : LineStyleDefinition.Utils.getOrCreateLinePixelsStyle(imodel, IModel.dictionaryId, linePixels));
+            lsStyles.push(LinePixels.Solid === linePixels ? Id64.invalid : LineStyleDefinition.Utils.getOrCreateLinePixelsStyle(imodel, IModel.dictionaryId, linePixels, txn));
         });
         // get existing line style definitions for line codes 1-7
         const lsStylesExist = [];
         lsCodes.forEach((linePixels) => {
-            lsStylesExist.push(LinePixels.Solid === linePixels ? Id64.invalid : LineStyleDefinition.Utils.getOrCreateLinePixelsStyle(imodel, IModel.dictionaryId, linePixels));
+            lsStylesExist.push(LinePixels.Solid === linePixels ? Id64.invalid : LineStyleDefinition.Utils.getOrCreateLinePixelsStyle(imodel, IModel.dictionaryId, linePixels, txn));
         });
         // make sure we found existing styles and didn't create a second set
         assert.isTrue(8 === lsStyles.length && lsStyles.length === lsStylesExist.length);
@@ -295,9 +334,9 @@ describe("GeometryStream", () => {
             pointE.y += 0.5;
         });
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         // Extract and test value returned...
         const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(value.geom);
@@ -324,21 +363,22 @@ describe("GeometryStream", () => {
         }
     });
     it("create GeometricElement3d using continuous style", async () => {
+        const txn = txnForCurrentTest(imodel);
         // Set up element to be placed in iModel
         const seedElement = imodel.elements.getElement("0x1d");
         assert.exists(seedElement);
         assert.isTrue(seedElement.federationGuid === "18eb4650-b074-414f-b961-d9cfaa6c8746");
         // create special "internal default" continuous style for drawing curves using width overrides
-        const styleId = LineStyleDefinition.Utils.getOrCreateContinuousStyle(imodel, IModel.dictionaryId);
+        const styleId = LineStyleDefinition.Utils.getOrCreateContinuousStyle(imodel, IModel.dictionaryId, undefined, txn);
         assert.isTrue(Id64.isValidId64(styleId));
         // make sure we found existing style and didn't create a new one
-        const styleIdExists = LineStyleDefinition.Utils.getOrCreateContinuousStyle(imodel, IModel.dictionaryId);
+        const styleIdExists = LineStyleDefinition.Utils.getOrCreateContinuousStyle(imodel, IModel.dictionaryId, undefined, txn);
         assert.isTrue(Id64.isValidId64(styleIdExists) && styleIdExists === (styleId));
         // create continuous style with pre-defined constant width
-        const styleIdWidth = LineStyleDefinition.Utils.getOrCreateContinuousStyle(imodel, IModel.dictionaryId, 0.05);
+        const styleIdWidth = LineStyleDefinition.Utils.getOrCreateContinuousStyle(imodel, IModel.dictionaryId, 0.05, txn);
         assert.isTrue(Id64.isValidId64(styleIdWidth));
         // make sure we found existing style and didn't create a new one
-        const styleIdWidthExists = LineStyleDefinition.Utils.getOrCreateContinuousStyle(imodel, IModel.dictionaryId, 0.05);
+        const styleIdWidthExists = LineStyleDefinition.Utils.getOrCreateContinuousStyle(imodel, IModel.dictionaryId, 0.05, txn);
         assert.isTrue(Id64.isValidId64(styleIdWidthExists) && styleIdWidthExists === (styleIdWidth));
         const builder = new GeometryStreamBuilder();
         const params = new GeometryParams(seedElement.category);
@@ -361,9 +401,9 @@ describe("GeometryStream", () => {
         builder.appendGeometryParamsChange(params);
         builder.appendGeometry(LineSegment3d.create(Point3d.create(1.5, 0, 0), Point3d.create(1.5, 5, 0)));
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         // Extract and test value returned...
         const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(value.geom);
@@ -398,16 +438,16 @@ describe("GeometryStream", () => {
         partBuilder.appendGeometryParamsChange(partParams);
         partBuilder.appendGeometry(Loop.create(LineString3d.create(Point3d.create(0.1, 0, 0), Point3d.create(0, -0.05, 0), Point3d.create(0, 0.05, 0), Point3d.create(0.1, 0, 0))));
         const partProps = createGeometryPartProps(partBuilder.geometryStream, definitionModelId);
-        const partId = imodel.elements.insertElement(partProps);
+        const partId = txnForCurrentTest(imodel).insertElement(partProps);
         assert.isTrue(Id64.isValidId64(partId));
-        const pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(imodel, { geomPartId: partId }); // base and size will be set automatically...
+        const pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(txnForCurrentTest(imodel), { geomPartId: partId }); // base and size will be set automatically...
         assert.isTrue(undefined !== pointSymbolData);
         // Use internal default instead of creating a stroke component for a solid line
-        const strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(imodel, { descr: "TestArrowHead", lcId: 0, lcType: LineStyleDefinition.ComponentType.Internal, symbols: [{ symId: pointSymbolData.compId, strokeNum: -1, mod1: LineStyleDefinition.SymbolOptions.CurveEnd }] });
+        const strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(txnForCurrentTest(imodel), { descr: "TestArrowHead", lcId: 0, lcType: LineStyleDefinition.ComponentType.Internal, symbols: [{ symId: pointSymbolData.compId, strokeNum: -1, mod1: LineStyleDefinition.SymbolOptions.CurveEnd }] });
         assert.isTrue(undefined !== strokePointData);
-        const compoundData = LineStyleDefinition.Utils.createCompoundComponent(imodel, { comps: [{ id: strokePointData.compId, type: strokePointData.compType }, { id: 0, type: LineStyleDefinition.ComponentType.Internal }] });
+        const compoundData = LineStyleDefinition.Utils.createCompoundComponent(txnForCurrentTest(imodel), { comps: [{ id: strokePointData.compId, type: strokePointData.compType }, { id: 0, type: LineStyleDefinition.ComponentType.Internal }] });
         assert.isTrue(undefined !== compoundData);
-        const styleId = LineStyleDefinition.Utils.createStyle(imodel, definitionModelId, "TestArrowStyle", compoundData);
+        const styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), definitionModelId, "TestArrowStyle", compoundData);
         assert.isTrue(Id64.isValidId64(styleId));
         const builder = new GeometryStreamBuilder();
         const params = new GeometryParams(seedElement.category);
@@ -415,9 +455,9 @@ describe("GeometryStream", () => {
         builder.appendGeometryParamsChange(params);
         builder.appendGeometry(LineSegment3d.create(Point3d.createZero(), Point3d.create(-1, -1, 0)));
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream, physicalModelId);
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const usageInfo = imodel[_nativeDb].queryDefinitionElementUsage([partId, styleId]);
         assert.isTrue(usageInfo.geometryPartIds.includes(partId));
         assert.isTrue(usageInfo.lineStyleIds.includes(styleId));
@@ -428,19 +468,19 @@ describe("GeometryStream", () => {
         createGeometricElem3dUsingArrowHeadNoStrokePattern();
     });
     it("create GeometricElement3d using arrow head style w/o using stroke pattern - deleteElementTree fails", async () => {
-        const mySubject = Subject.insert(imodel, IModel.rootSubjectId, "My Subject - fails");
-        const myDefModel = DefinitionModel.insert(imodel, mySubject, "My Definitions - fails");
-        const myPhysicalModel = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(imodel, Code.createEmpty(), false, mySubject)[0];
+        const mySubject = Subject.insert(txnForCurrentTest(imodel), IModel.rootSubjectId, "My Subject - fails");
+        const myDefModel = DefinitionModel.insert(txnForCurrentTest(imodel), mySubject, "My Definitions - fails");
+        const myPhysicalModel = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(txnForCurrentTest(imodel), Code.createEmpty(), false, mySubject)[0];
         createGeometricElem3dUsingArrowHeadNoStrokePattern(myDefModel, myPhysicalModel);
-        deleteElementTree({ iModel: imodel, topElement: mySubject, maxPasses: 1 });
+        deleteElementTree(txnForCurrentTest(imodel), mySubject, 1);
         expect(imodel.elements.tryGetElement(mySubject)).not.undefined;
     });
     it("create GeometricElement3d using arrow head style w/o using stroke pattern - deleteElementTree succeeds with 2 passes", async () => {
-        const mySubject = Subject.insert(imodel, IModel.rootSubjectId, "My Subject - success");
-        const myDefModel = DefinitionModel.insert(imodel, mySubject, "My Definitions - success");
-        const myPhysicalModel = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(imodel, Code.createEmpty(), false, mySubject)[0];
+        const mySubject = Subject.insert(txnForCurrentTest(imodel), IModel.rootSubjectId, "My Subject - success");
+        const myDefModel = DefinitionModel.insert(txnForCurrentTest(imodel), mySubject, "My Definitions - success");
+        const myPhysicalModel = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(txnForCurrentTest(imodel), Code.createEmpty(), false, mySubject)[0];
         createGeometricElem3dUsingArrowHeadNoStrokePattern(myDefModel, myPhysicalModel);
-        deleteElementTree({ iModel: imodel, topElement: mySubject, maxPasses: 2 });
+        deleteElementTree(txnForCurrentTest(imodel), mySubject, 2);
         expect(imodel.elements.tryGetElement(mySubject)).undefined;
     });
     it("create GeometricElement3d using compound style with dash widths and symbol", async () => {
@@ -455,26 +495,26 @@ describe("GeometryStream", () => {
         lsStrokes.push({ length: 0.1 });
         lsStrokes.push({ length: 0.25, orgWidth: 0.025, endWidth: 0.0, strokeMode: LineStyleDefinition.StrokeMode.Dash, widthMode: LineStyleDefinition.StrokeWidth.Right });
         lsStrokes.push({ length: 0.1 });
-        const strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(imodel, { descr: "TestDashDotDashLineCode", strokes: lsStrokes });
+        const strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(txnForCurrentTest(imodel), { descr: "TestDashDotDashLineCode", strokes: lsStrokes });
         assert.isTrue(undefined !== strokePatternData);
         const partBuilder = new GeometryStreamBuilder();
         partBuilder.appendGeometry(Arc3d.createXY(Point3d.createZero(), 0.05));
         const partProps = createGeometryPartProps(partBuilder.geometryStream);
-        const partId = imodel.elements.insertElement(partProps);
+        const partId = txnForCurrentTest(imodel).insertElement(partProps);
         assert.isTrue(Id64.isValidId64(partId));
-        const pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(imodel, { geomPartId: partId }); // base and size will be set automatically...
+        const pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(txnForCurrentTest(imodel), { geomPartId: partId }); // base and size will be set automatically...
         assert.isTrue(undefined !== pointSymbolData);
         const lsSymbols = [];
         lsSymbols.push({ symId: pointSymbolData.compId, strokeNum: 1, mod1: LineStyleDefinition.SymbolOptions.Center });
         lsSymbols.push({ symId: pointSymbolData.compId, strokeNum: 3, mod1: LineStyleDefinition.SymbolOptions.Center });
-        const strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(imodel, { descr: "TestGapSymbolsLinePoint", lcId: strokePatternData.compId, symbols: lsSymbols });
+        const strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(txnForCurrentTest(imodel), { descr: "TestGapSymbolsLinePoint", lcId: strokePatternData.compId, symbols: lsSymbols });
         assert.isTrue(undefined !== strokePointData);
         const lsComponents = [];
         lsComponents.push({ id: strokePointData.compId, type: strokePointData.compType });
         lsComponents.push({ id: strokePatternData.compId, type: strokePatternData.compType });
-        const compoundData = LineStyleDefinition.Utils.createCompoundComponent(imodel, { comps: lsComponents });
+        const compoundData = LineStyleDefinition.Utils.createCompoundComponent(txnForCurrentTest(imodel), { comps: lsComponents });
         assert.isTrue(undefined !== compoundData);
-        const styleId = LineStyleDefinition.Utils.createStyle(imodel, IModel.dictionaryId, "TestDashCircleDotCircleDashStyle", compoundData);
+        const styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), IModel.dictionaryId, "TestDashCircleDotCircleDashStyle", compoundData);
         assert.isTrue(Id64.isValidId64(styleId));
         const builder = new GeometryStreamBuilder();
         const params = new GeometryParams(seedElement.category);
@@ -482,9 +522,9 @@ describe("GeometryStream", () => {
         builder.appendGeometryParamsChange(params);
         builder.appendGeometry(LineSegment3d.create(Point3d.createZero(), Point3d.create(5, 5, 0)));
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const usageInfo = imodel[_nativeDb].queryDefinitionElementUsage([partId, styleId, seedElement.category]);
         assert.isTrue(usageInfo.geometryPartIds.includes(partId));
         assert.isTrue(usageInfo.lineStyleIds.includes(styleId));
@@ -504,17 +544,17 @@ describe("GeometryStream", () => {
         let unitDef = 1.0;
         let widthDef = 0.0;
         let name = `Continuous-${unitDef}-${widthDef}`;
-        let styleId = LineStyleDefinition.Utils.createStyle(imodel, IModel.dictionaryId, name, { compId: 0, compType: LineStyleDefinition.ComponentType.Internal, flags: LineStyleDefinition.StyleFlags.Continuous | LineStyleDefinition.StyleFlags.NoSnap });
+        let styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), IModel.dictionaryId, name, { compId: 0, compType: LineStyleDefinition.ComponentType.Internal, flags: LineStyleDefinition.StyleFlags.Continuous | LineStyleDefinition.StyleFlags.NoSnap });
         assert.isTrue(Id64.isValidId64(styleId));
         // Expect no range padding...
         let newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId));
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.0));
         // Expect range padded by 0.25...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 0.25, physicalWidth: true })), ColorDef.red);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.25));
         // LineStyleDefinition: create continuous style with both width and unit scale specified in definition...
         x = 0.0;
@@ -522,23 +562,23 @@ describe("GeometryStream", () => {
         unitDef = 2.0;
         widthDef = 0.5;
         name = `Continuous-${unitDef}-${widthDef}`;
-        let strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(imodel, { descr: name, strokes: [{ length: 1e37, orgWidth: widthDef, strokeMode: LineStyleDefinition.StrokeMode.Dash, widthMode: LineStyleDefinition.StrokeWidth.Full }] });
-        styleId = LineStyleDefinition.Utils.createStyle(imodel, IModel.dictionaryId, name, { compId: strokePatternData.compId, compType: strokePatternData.compType, flags: LineStyleDefinition.StyleFlags.Continuous | LineStyleDefinition.StyleFlags.NoSnap, unitDef });
+        let strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(txnForCurrentTest(imodel), { descr: name, strokes: [{ length: 1e37, orgWidth: widthDef, strokeMode: LineStyleDefinition.StrokeMode.Dash, widthMode: LineStyleDefinition.StrokeWidth.Full }] });
+        styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), IModel.dictionaryId, name, { compId: strokePatternData.compId, compType: strokePatternData.compType, flags: LineStyleDefinition.StyleFlags.Continuous | LineStyleDefinition.StyleFlags.NoSnap, unitDef });
         assert.isTrue(Id64.isValidId64(styleId));
         // Expect no range padding...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 0.0, physicalWidth: true })));
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.0));
         // Expect range padded by 1.0...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId), ColorDef.red);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), widthDef * unitDef));
         // Expect range padded by 0.25...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 0.25, physicalWidth: true })), ColorDef.green);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.25));
         // LineStyleDefinition: create stroke pattern with dash widths in definition...
         x = 0.0;
@@ -553,18 +593,18 @@ describe("GeometryStream", () => {
         lsStrokes.push({ length: 0.1 });
         lsStrokes.push({ length: 0.25, orgWidth: widthDef, endWidth: widthDef, strokeMode: LineStyleDefinition.StrokeMode.Dash, widthMode: LineStyleDefinition.StrokeWidth.Right });
         lsStrokes.push({ length: 0.1 });
-        strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(imodel, { descr: name, strokes: lsStrokes });
-        styleId = LineStyleDefinition.Utils.createStyle(imodel, IModel.dictionaryId, name, { compId: strokePatternData.compId, compType: strokePatternData.compType, flags: LineStyleDefinition.StyleFlags.NoSnap });
+        strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(txnForCurrentTest(imodel), { descr: name, strokes: lsStrokes });
+        styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), IModel.dictionaryId, name, { compId: strokePatternData.compId, compType: strokePatternData.compType, flags: LineStyleDefinition.StyleFlags.NoSnap });
         assert.isTrue(Id64.isValidId64(styleId));
         // Expect range padded by 0.025...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId));
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), widthDef * unitDef));
         // Expect range padded by 0.25...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 0.25, physicalWidth: true })), ColorDef.red);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.25));
         // LineStyleDefinition: create stroke pattern with dash widths and unit scale specified in definition...
         x = 0.0;
@@ -572,27 +612,27 @@ describe("GeometryStream", () => {
         unitDef = 2.0;
         widthDef = 0.025;
         name = `StrokePattern-${unitDef}-${widthDef}`;
-        styleId = LineStyleDefinition.Utils.createStyle(imodel, IModel.dictionaryId, name, { compId: strokePatternData.compId, compType: strokePatternData.compType, flags: LineStyleDefinition.StyleFlags.NoSnap, unitDef });
+        styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), IModel.dictionaryId, name, { compId: strokePatternData.compId, compType: strokePatternData.compType, flags: LineStyleDefinition.StyleFlags.NoSnap, unitDef });
         assert.isTrue(Id64.isValidId64(styleId));
         // Expect range padded by 0.05...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId));
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), widthDef * unitDef));
         // Expect range padded by 0.25...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 0.25, physicalWidth: true })), ColorDef.red);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.25));
         // Expect range padded by 0.25...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 0.25, scale: 0.5, physicalWidth: true })), ColorDef.green);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.25));
         // Expect range padded by 0.025...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ scale: 0.5 })), ColorDef.blue);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), widthDef * unitDef * 0.5));
         // LineStyleDefinition: create point symbol with internal default instead of a stroke pattern...
         x = 0.0;
@@ -601,25 +641,25 @@ describe("GeometryStream", () => {
         widthDef = 1.0;
         name = `PointSymbol-${unitDef}-${widthDef}`;
         const partId = createCirclePart(0.25, imodel);
-        let pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(imodel, { geomPartId: partId });
-        let strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(imodel, { descr: name, lcId: 0, lcType: LineStyleDefinition.ComponentType.Internal, symbols: [{ symId: pointSymbolData.compId, strokeNum: -1, mod1: LineStyleDefinition.SymbolOptions.CurveOrigin }] });
-        let compoundData = LineStyleDefinition.Utils.createCompoundComponent(imodel, { comps: [{ id: strokePointData.compId, type: strokePointData.compType }, { id: 0, type: LineStyleDefinition.ComponentType.Internal }] });
-        styleId = LineStyleDefinition.Utils.createStyle(imodel, IModel.dictionaryId, name, compoundData);
+        let pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(txnForCurrentTest(imodel), { geomPartId: partId });
+        let strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(txnForCurrentTest(imodel), { descr: name, lcId: 0, lcType: LineStyleDefinition.ComponentType.Internal, symbols: [{ symId: pointSymbolData.compId, strokeNum: -1, mod1: LineStyleDefinition.SymbolOptions.CurveOrigin }] });
+        let compoundData = LineStyleDefinition.Utils.createCompoundComponent(txnForCurrentTest(imodel), { comps: [{ id: strokePointData.compId, type: strokePointData.compType }, { id: 0, type: LineStyleDefinition.ComponentType.Internal }] });
+        styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), IModel.dictionaryId, name, compoundData);
         assert.isTrue(Id64.isValidId64(styleId));
         // Expect range padded by 0.5 (circle radius)...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId));
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.5));
         // Expect range padded by 0.25 (scaled circle radius)...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ scale: 0.5 })), ColorDef.red);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.25));
         // Expect range padded by 1.0 (width override > symbol size)...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 1.0, scale: 0.5, physicalWidth: true })), ColorDef.green);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 1.0));
         // LineStyleDefinition: create scaling point symbol with stroke pattern with width and unit scale specified in definition...
         x = 0.0;
@@ -627,33 +667,33 @@ describe("GeometryStream", () => {
         unitDef = 0.5;
         widthDef = 0.025; // value used for lsStrokes...
         name = `PointSymbol-${unitDef}-${widthDef}}`;
-        strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(imodel, { descr: name, strokes: lsStrokes });
-        pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(imodel, { geomPartId: partId, scale: 2.0 });
+        strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(txnForCurrentTest(imodel), { descr: name, strokes: lsStrokes });
+        pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(txnForCurrentTest(imodel), { geomPartId: partId, scale: 2.0 });
         const lsSymbols = [];
         lsSymbols.push({ symId: pointSymbolData.compId, strokeNum: 1, mod1: LineStyleDefinition.SymbolOptions.Center });
         lsSymbols.push({ symId: pointSymbolData.compId, strokeNum: 3, mod1: LineStyleDefinition.SymbolOptions.Center });
-        strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(imodel, { descr: name, lcId: strokePatternData.compId, symbols: lsSymbols });
+        strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(txnForCurrentTest(imodel), { descr: name, lcId: strokePatternData.compId, symbols: lsSymbols });
         const lsComponents = [];
         lsComponents.push({ id: strokePointData.compId, type: strokePointData.compType });
         lsComponents.push({ id: strokePatternData.compId, type: strokePatternData.compType });
-        compoundData = LineStyleDefinition.Utils.createCompoundComponent(imodel, { comps: lsComponents });
+        compoundData = LineStyleDefinition.Utils.createCompoundComponent(txnForCurrentTest(imodel), { comps: lsComponents });
         compoundData.unitDef = unitDef;
-        styleId = LineStyleDefinition.Utils.createStyle(imodel, IModel.dictionaryId, name, compoundData);
+        styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), IModel.dictionaryId, name, compoundData);
         assert.isTrue(Id64.isValidId64(styleId));
         // Expect range padded by 0.125 (symbol and unit scaled circle radius)......
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId));
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.125));
         // Expect range padded by 0.0625 (symbol and modifier scaled circle radius)...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ scale: 0.5 })), ColorDef.red);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.0625));
         // Expect range padded by 0.75 (width override > symbol and modifier scaled symbol size)...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 0.75, scale: 0.5, physicalWidth: true })), ColorDef.green);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.75));
         // LineStyleDefinition: create non-scaling point symbol with stroke pattern with width and unit scale specified in definition...
         x = 0.0;
@@ -661,33 +701,33 @@ describe("GeometryStream", () => {
         unitDef = 0.5;
         widthDef = 0.025; // value used for lsStrokes...
         name = `NonScalingPointSymbol-${unitDef}-${widthDef}}`;
-        strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(imodel, { descr: name, strokes: lsStrokes });
-        pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(imodel, { geomPartId: partId, scale: 2.0, symFlags: LineStyleDefinition.PointSymbolFlags.NoScale });
+        strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(txnForCurrentTest(imodel), { descr: name, strokes: lsStrokes });
+        pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(txnForCurrentTest(imodel), { geomPartId: partId, scale: 2.0, symFlags: LineStyleDefinition.PointSymbolFlags.NoScale });
         lsSymbols.length = 0;
         lsSymbols.push({ symId: pointSymbolData.compId, strokeNum: 1, mod1: LineStyleDefinition.SymbolOptions.Center });
         lsSymbols.push({ symId: pointSymbolData.compId, strokeNum: 3, mod1: LineStyleDefinition.SymbolOptions.Center });
-        strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(imodel, { descr: name, lcId: strokePatternData.compId, symbols: lsSymbols });
+        strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(txnForCurrentTest(imodel), { descr: name, lcId: strokePatternData.compId, symbols: lsSymbols });
         lsComponents.length = 0;
         lsComponents.push({ id: strokePointData.compId, type: strokePointData.compType });
         lsComponents.push({ id: strokePatternData.compId, type: strokePatternData.compType });
-        compoundData = LineStyleDefinition.Utils.createCompoundComponent(imodel, { comps: lsComponents });
+        compoundData = LineStyleDefinition.Utils.createCompoundComponent(txnForCurrentTest(imodel), { comps: lsComponents });
         compoundData.unitDef = unitDef;
-        styleId = LineStyleDefinition.Utils.createStyle(imodel, IModel.dictionaryId, name, compoundData);
+        styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), IModel.dictionaryId, name, compoundData);
         assert.isTrue(Id64.isValidId64(styleId));
         // Expect range padded by 0.5 (circle radius)......
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId));
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.5));
         // Expect range padded by 0.5 (unscaled circle radius)...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ scale: 0.5 })), ColorDef.red);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.5));
         // Expect range padded by 0.75 (width override > unscaled symbol size)...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 0.75, scale: 0.5, physicalWidth: true })), ColorDef.green);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.75));
         // LineStyleDefinition: create scaling point symbol with offsets with stroke pattern with width and unit scale specified in definition...
         x = 0.0;
@@ -695,33 +735,33 @@ describe("GeometryStream", () => {
         unitDef = 0.5;
         widthDef = 0.025; // value used for lsStrokes...
         name = `OffsetPointSymbol-${unitDef}-${widthDef}}`;
-        strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(imodel, { descr: name, strokes: lsStrokes });
-        pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(imodel, { geomPartId: partId, scale: 2.0 });
+        strokePatternData = LineStyleDefinition.Utils.createStrokePatternComponent(txnForCurrentTest(imodel), { descr: name, strokes: lsStrokes });
+        pointSymbolData = LineStyleDefinition.Utils.createPointSymbolComponent(txnForCurrentTest(imodel), { geomPartId: partId, scale: 2.0 });
         lsSymbols.length = 0;
         lsSymbols.push({ symId: pointSymbolData.compId, strokeNum: 1, mod1: LineStyleDefinition.SymbolOptions.Center, yOffset: -0.1 });
         lsSymbols.push({ symId: pointSymbolData.compId, strokeNum: 3, mod1: LineStyleDefinition.SymbolOptions.Center, yOffset: 0.1 });
-        strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(imodel, { descr: name, lcId: strokePatternData.compId, symbols: lsSymbols });
+        strokePointData = LineStyleDefinition.Utils.createStrokePointComponent(txnForCurrentTest(imodel), { descr: name, lcId: strokePatternData.compId, symbols: lsSymbols });
         lsComponents.length = 0;
         lsComponents.push({ id: strokePointData.compId, type: strokePointData.compType });
         lsComponents.push({ id: strokePatternData.compId, type: strokePatternData.compType });
-        compoundData = LineStyleDefinition.Utils.createCompoundComponent(imodel, { comps: lsComponents });
+        compoundData = LineStyleDefinition.Utils.createCompoundComponent(txnForCurrentTest(imodel), { comps: lsComponents });
         compoundData.unitDef = unitDef;
-        styleId = LineStyleDefinition.Utils.createStyle(imodel, IModel.dictionaryId, name, compoundData);
+        styleId = LineStyleDefinition.Utils.createStyle(txnForCurrentTest(imodel), IModel.dictionaryId, name, compoundData);
         assert.isTrue(Id64.isValidId64(styleId));
         // Expect range padded by 0.225 (offset symbol and unit scaled circle radius)......
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId));
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.225));
         // Expect range padded by 0.1125 (offset symbol and modifier scaled circle radius)...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ scale: 0.5 })), ColorDef.red);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.1125));
         // Expect range padded by 0.75 (width override > symbol and modifier scaled symbol size)...
         newId = createStyledLineElem(imodel, seedElement, x++, y, 1.0, new LineStyle.Info(styleId, new LineStyle.Modifier({ startWidth: 0.75, scale: 0.5, physicalWidth: true })), ColorDef.green);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert.isTrue(Geometry.isSameCoordinate(Placement3d.fromJSON(imodel.elements.getElementProps({ id: newId, wantGeometry: true }).placement).bbox.yLength(), 0.75));
     });
     it("create GeometricElement3d using shapes with fill/gradient", async () => {
@@ -783,9 +823,9 @@ describe("GeometryStream", () => {
         shape.tryTransformInPlace(xOffset);
         builder.appendGeometry(shape);
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         // Extract and test value returned...
         const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(value.geom);
@@ -860,7 +900,7 @@ describe("GeometryStream", () => {
         const partBuilder = new GeometryStreamBuilder();
         partBuilder.appendGeometry(Arc3d.createXY(Point3d.createZero(), 0.05));
         const partProps = createGeometryPartProps(partBuilder.geometryStream);
-        const partId = imodel.elements.insertElement(partProps);
+        const partId = txnForCurrentTest(imodel).insertElement(partProps);
         assert.isTrue(Id64.isValidId64(partId));
         // Area pattern w/o overrides
         params.pattern = new AreaPattern.Params();
@@ -896,9 +936,9 @@ describe("GeometryStream", () => {
         shape.tryTransformInPlace(xOffset);
         builder.appendGeometry(shape);
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         // Extract and test value returned...
         const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(value.geom);
@@ -937,8 +977,8 @@ describe("GeometryStream", () => {
         const seedElement = imodel.elements.getElement("0x1d");
         assert.exists(seedElement);
         const subCategory = SubCategory.create(imodel, seedElement.category, "testSubCat", { weight: 2 });
-        const subCategoryId = imodel.elements.insertElement(subCategory.toJSON());
-        imodel.saveChanges();
+        const subCategoryId = txnForCurrentTest(imodel).insertElement(subCategory.toJSON());
+        saveTestTxn(imodel, true);
         const params = new GeometryParams(seedElement.category);
         params.subCategoryId = subCategoryId;
         params.materialId = "0x5";
@@ -949,9 +989,9 @@ describe("GeometryStream", () => {
         builderF.appendGeometryQuery(shape);
         const elementPropsF = createPhysicalElementProps(seedElement);
         elementPropsF.elementGeometryBuilderParams = { entryArray: builderF.entries };
-        const newIdF = imodel.elements.insertElement(elementPropsF);
+        const newIdF = txnForCurrentTest(imodel).insertElement(elementPropsF);
         assert.isTrue(Id64.isValidId64(newIdF));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const onGeometry = (info) => {
             assert.isTrue(undefined !== info.entryArray);
             const it = new ElementGeometry.Iterator(info);
@@ -970,9 +1010,9 @@ describe("GeometryStream", () => {
         builderJ.appendGeometry(shape);
         const elementPropsJ = createPhysicalElementProps(seedElement);
         elementPropsJ.geom = builderJ.geometryStream;
-        const newIdJ = imodel.elements.insertElement(elementPropsJ);
+        const newIdJ = txnForCurrentTest(imodel).insertElement(elementPropsJ);
         assert.isTrue(Id64.isValidId64(newIdJ));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const value = imodel.elements.getElementProps({ id: newIdJ, wantGeometry: true });
         assert.isDefined(value.geom);
         const itLocal = new GeometryStreamIterator(value.geom, value.category);
@@ -1005,8 +1045,8 @@ describe("GeometryStream", () => {
         assert.isTrue(status);
         const elementProps = createPhysicalElementProps(seedElement, { origin: testOrigin, angles: testAngles }, builder.geometryStream);
         const testElem = imodel.elements.createElement(elementProps);
-        const newId = imodel.elements.insertElement(testElem.toJSON());
-        imodel.saveChanges();
+        const newId = txnForCurrentTest(imodel).insertElement(testElem.toJSON());
+        saveTestTxn(imodel, true);
         // Extract and test value returned, text transform should now be identity as it is accounted for by element's placement...
         const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(value.geom);
@@ -1054,8 +1094,8 @@ describe("GeometryStream", () => {
         }
         const partProps = createGeometryPartProps(partBuilder.geometryStream);
         const testPart = imodel.elements.createElement(partProps);
-        const partId = imodel.elements.insertElement(testPart.toJSON());
-        imodel.saveChanges();
+        const partId = txnForCurrentTest(imodel).insertElement(testPart.toJSON());
+        saveTestTxn(imodel, true);
         // Extract and test value returned
         const value = imodel.elements.getElementProps({ id: partId, wantGeometry: true });
         assert.isDefined(value.geom);
@@ -1090,8 +1130,8 @@ describe("GeometryStream", () => {
         }
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
         const testElem = imodel.elements.createElement(elementProps);
-        const newId = imodel.elements.insertElement(testElem.toJSON());
-        imodel.saveChanges();
+        const newId = txnForCurrentTest(imodel).insertElement(testElem.toJSON());
+        saveTestTxn(imodel, true);
         // Extract and test value returned
         const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(value.geom);
@@ -1117,8 +1157,8 @@ describe("GeometryStream", () => {
         partBuilder.appendGeometry(arc);
         const partProps = createGeometryPartProps(partBuilder.geometryStream);
         const testPart = imodel.elements.createElement(partProps);
-        const partId = imodel.elements.insertElement(testPart.toJSON());
-        imodel.saveChanges();
+        const partId = txnForCurrentTest(imodel).insertElement(testPart.toJSON());
+        saveTestTxn(imodel, true);
         const builder = new GeometryStreamBuilder();
         const shapePts = [Point3d.create(1, 1, 0), Point3d.create(2, 1, 0), Point3d.create(2, 2, 0), Point3d.create(1, 2, 0)];
         const testOrigin = Point3d.create(0.5, 0.5, 0);
@@ -1128,8 +1168,8 @@ describe("GeometryStream", () => {
         shapePts.forEach((pt) => builder.appendGeometryPart3d(partId, pt, undefined, 0.25)); // Position part (arc center) at each vertex...
         const elementProps = createPhysicalElementProps(seedElement, { origin: testOrigin, angles: testAngles }, builder.geometryStream);
         const testElem = imodel.elements.createElement(elementProps);
-        const newId = imodel.elements.insertElement(testElem.toJSON());
-        imodel.saveChanges();
+        const newId = txnForCurrentTest(imodel).insertElement(testElem.toJSON());
+        saveTestTxn(imodel, true);
         // Extract and test value returned
         const valueElem = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(valueElem.geom);
@@ -1165,9 +1205,9 @@ describe("GeometryStream", () => {
         builder.appendGeometryParamsChange(params);
         builder.appendGeometry(shape);
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         // Extract and test value returned...
         const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(value.geom);
@@ -1205,8 +1245,8 @@ describe("GeometryStream", () => {
         builder.appendBRepData(brepProps);
         const elementProps = createPhysicalElementProps(seedElement, { origin: testOrigin, angles: testAngles }, builder.geometryStream);
         const testElem = imodel.elements.createElement(elementProps);
-        const newId = imodel.elements.insertElement(testElem.toJSON());
-        imodel.saveChanges();
+        const newId = txnForCurrentTest(imodel).insertElement(testElem.toJSON());
+        saveTestTxn(imodel, true);
         // Extract and test value returned
         const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true, wantBRepData: true });
         assert.isDefined(value.geom);
@@ -1241,7 +1281,7 @@ describe("GeometryStream", () => {
         const newId = createGeometricElem(builder.geometryStream, { origin: testOrigin, angles: testAngles }, imodel, seedElement);
         timer.end();
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         timer = new Timer("queryGeometricElem");
         const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(value.geom);
@@ -1266,8 +1306,8 @@ describe("GeometryStream", () => {
             expect((iter.flags === GeometryStreamFlags.ViewIndependent)).to.equal(builder.isViewIndependent);
             const partProps = createGeometryPartProps(builder.geometryStream);
             const part = imodel.elements.createElement(partProps);
-            const partId = imodel.elements.insertElement(part.toJSON());
-            imodel.saveChanges();
+            const partId = txnForCurrentTest(imodel).insertElement(part.toJSON());
+            saveTestTxn(imodel, true);
             const json = imodel.elements.getElementProps({ id: partId, wantGeometry: true });
             expect(json.geom).not.to.be.undefined;
             expect(json.geom.length).to.equal(2);
@@ -1301,8 +1341,15 @@ describe("ElementGeometry", () => {
         imodel = IModelTestUtils.createSnapshotFromSeed(testFileName, seedFileName);
     });
     after(() => {
+        closeTestTxn(imodel);
         imodel.close();
     });
+    beforeEach(() => {
+        txnForCurrentTest(imodel, "fresh");
+    });
+    afterEach(() => {
+        closeTestTxn(imodel);
+    });
     it("Exercise using builder/iterator in world coordinates with flatbuffer data", async () => {
         const testOrigin = Point3d.create(5, 10, 0);
         const testAngles = YawPitchRollAngles.createDegrees(90, 0, 0);
@@ -1374,9 +1421,9 @@ describe("ElementGeometry", () => {
         newEntries.push(entryEL);
         expected.push({ opcode: ElementGeometryOpcode.ArcPrimitive, geometryCategory: "curveCollection", geometrySubCategory: "loop" });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expected, false, elementProps));
     });
     it("create GeometricElement3d from local coordinate interpolation curve flatbuffer data", async () => {
@@ -1403,9 +1450,9 @@ describe("ElementGeometry", () => {
         newEntries.push(entry1);
         expected.push({ opcode: ElementGeometryOpcode.CurvePrimitive, geometryCategory: "curvePrimitive" });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expected, false, elementProps));
     });
     it("create GeometricElement3d with local coordinate indexed polyface flatbuffer data", async () => {
@@ -1429,9 +1476,9 @@ describe("ElementGeometry", () => {
         const testAngles = YawPitchRollAngles.createDegrees(90, 0, 0);
         const elementProps = createPhysicalElementProps(seedElement, { origin: testOrigin, angles: testAngles });
         elementProps.elementGeometryBuilderParams = { entryArray: builder.entries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         timer.end();
         const onGeometry = (info) => {
             assert.isTrue(6 === info.entryArray.length); // 3 pairs of sub-range + polyface...
@@ -1478,9 +1525,9 @@ describe("ElementGeometry", () => {
         expectedFacet.push({ opcode: ElementGeometryOpcode.BasicSymbology });
         expectedFacet.push({ opcode: ElementGeometryOpcode.Polyface, geometryCategory: "polyface" });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expected, false, elementProps));
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expectedFacet, false, undefined, 1));
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expectedSkip, false, undefined, 2));
@@ -1514,9 +1561,9 @@ describe("ElementGeometry", () => {
         expectedFacet.push({ opcode: ElementGeometryOpcode.BasicSymbology });
         expectedFacet.push({ opcode: ElementGeometryOpcode.Polyface, geometryCategory: "polyface" });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expectedFacet, false, undefined, 1));
     });
     it("test BRep entity transform", async () => {
@@ -1594,9 +1641,9 @@ describe("ElementGeometry", () => {
         assert.deepEqual(entry ? ElementGeometry.toTextStringGlyphData(entry) : undefined, glyphData);
         expected.push({ opcode: ElementGeometryOpcode.TextString, originalEntry: entry });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expected, false, elementProps));
     });
     it("create GeometricElement3d from local coordinate image flatbuffer data", async () => {
@@ -1619,9 +1666,9 @@ describe("ElementGeometry", () => {
         newEntries.push(entry);
         expected.push({ opcode: ElementGeometryOpcode.Image, originalEntry: entry });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expected, false, elementProps));
     });
     it("create GeometricElement3d with sub-graphic ranges flatbuffer data", async () => {
@@ -1652,9 +1699,9 @@ describe("ElementGeometry", () => {
         newEntries.push(entryL2);
         expected.push({ opcode: ElementGeometryOpcode.PointPrimitive, geometryCategory: "curvePrimitive", geometrySubCategory: "lineString" });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expected, false, elementProps));
     });
     it("create GeometricElement3d with part reference flatbuffer data", async () => {
@@ -1670,9 +1717,9 @@ describe("ElementGeometry", () => {
         newPartEntries.push(entryAR);
         expectedPart.push({ opcode: ElementGeometryOpcode.ArcPrimitive, geometryCategory: "curvePrimitive", geometrySubCategory: "arc" });
         partProps.elementGeometryBuilderParams = { entryArray: newPartEntries };
-        const partId = imodel.elements.insertElement(partProps);
+        const partId = txnForCurrentTest(imodel).insertElement(partProps);
         assert.isTrue(Id64.isValidId64(partId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, partId, expectedPart, false));
         const testOrigin = Point3d.create(5, 10, 0);
         const testAngles = YawPitchRollAngles.createDegrees(90, 0, 0);
@@ -1715,9 +1762,9 @@ describe("ElementGeometry", () => {
         newEntries.push(entryPA);
         expected.push({ opcode: ElementGeometryOpcode.PartReference, originalEntry: entryPA });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expected, false, elementProps));
     });
     it("create GeometricElement3d with appearance flatbuffer data", async () => {
@@ -1822,9 +1869,9 @@ describe("ElementGeometry", () => {
         newEntries.push(entryLN);
         expected.push({ opcode: ElementGeometryOpcode.PointPrimitive, geometryCategory: "curvePrimitive", geometrySubCategory: "lineString" });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expected, false, elementProps));
     });
     it("create GeometricElement3d with pattern flatbuffer data", async () => {
@@ -1916,9 +1963,9 @@ describe("ElementGeometry", () => {
         newEntries.push(entrySH);
         expected.push({ opcode: ElementGeometryOpcode.PointPrimitive, geometryCategory: "curveCollection", geometrySubCategory: "loop" });
         elementProps.elementGeometryBuilderParams = { entryArray: newEntries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         assert(IModelStatus.Success === doElementGeometryValidate(imodel, newId, expected, false, elementProps));
     });
     it("should transform PatternParams", () => {
@@ -1953,7 +2000,7 @@ describe("ElementGeometry", () => {
             // geom: geomBuilder.geometryStream,
             elementGeometryBuilderParams: { entryArray: [entryLN], viewIndependent: false },
         };
-        const spatialElementId = imodel.elements.insertElement(elemProps);
+        const spatialElementId = txnForCurrentTest(imodel).insertElement(elemProps);
         let persistentProps = imodel.elements.getElementProps({ id: spatialElementId, wantGeometry: true });
         assert.isDefined(persistentProps.geom);
         assert.isTrue(persistentProps.placement !== undefined);
@@ -1969,12 +2016,12 @@ describe("ElementGeometry", () => {
         }
         //    Insert - various failure cases
         elemProps.elementGeometryBuilderParams = { entryArray: [{ opcode: 9999 }] };
-        expect(() => imodel.elements.insertElement(elemProps)).to.throw(); // TODO: check error message
+        expect(() => txnForCurrentTest(imodel).insertElement(elemProps)).to.throw(); // TODO: check error message
         elemProps.elementGeometryBuilderParams = { entryArray: [{ opcode: ElementGeometryOpcode.ArcPrimitive, data: undefined }] };
-        expect(() => imodel.elements.insertElement(elemProps)).to.throw(); // TODO: check error message
+        expect(() => txnForCurrentTest(imodel).insertElement(elemProps)).to.throw(); // TODO: check error message
         //    Update
         persistentProps.elementGeometryBuilderParams = { entryArray: [entryAR] };
-        imodel.elements.updateElement(persistentProps);
+        txnForCurrentTest(imodel).updateElement(persistentProps);
         persistentProps = imodel.elements.getElementProps({ id: spatialElementId, wantGeometry: true });
         assert.isDefined(persistentProps.geom);
         assert.isTrue(persistentProps.placement !== undefined);
@@ -1998,7 +2045,7 @@ describe("ElementGeometry", () => {
             code: Code.createEmpty(),
             elementGeometryBuilderParams: { entryArray: [entryLN], is2dPart: false },
         };
-        const partId = imodel.elements.insertElement(partProps);
+        const partId = txnForCurrentTest(imodel).insertElement(partProps);
         let persistentPartProps = imodel.elements.getElementProps({ id: partId, wantGeometry: true });
         assert.isDefined(persistentPartProps.geom);
         for (const entry of new GeometryStreamIterator(persistentPartProps.geom)) {
@@ -2010,7 +2057,7 @@ describe("ElementGeometry", () => {
         }
         //    Update
         persistentPartProps.elementGeometryBuilderParams = { entryArray: [entryAR] };
-        imodel.elements.updateElement(persistentPartProps);
+        txnForCurrentTest(imodel).updateElement(persistentPartProps);
         persistentPartProps = imodel.elements.getElementProps({ id: partId, wantGeometry: true });
         assert.isDefined(persistentPartProps.geom);
         for (const entry of new GeometryStreamIterator(persistentPartProps.geom)) {
@@ -2026,13 +2073,13 @@ describe("ElementGeometry", () => {
         assert.exists(seedElement);
         assert.isTrue(seedElement.federationGuid === "18eb4650-b074-414f-b961-d9cfaa6c8746");
         const newId = createCircleElem(1.0, Point3d.create(5, 5, 0), YawPitchRollAngles.createDegrees(90, 0, 0), imodel, seedElement);
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const newElemProps = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isDefined(newElemProps.geom);
         assert.isTrue(newElemProps.placement !== undefined);
         newElemProps.elementGeometryBuilderParams = { entryArray: [] };
-        imodel.elements.updateElement(newElemProps);
-        imodel.saveChanges();
+        txnForCurrentTest(imodel).updateElement(newElemProps);
+        saveTestTxn(imodel, true);
         const updateElemProps = imodel.elements.getElementProps({ id: newId, wantGeometry: true });
         assert.isUndefined(updateElemProps.geom);
         assert.isTrue(updateElemProps.placement !== undefined);
@@ -2108,9 +2155,9 @@ describe("BRepGeometry", () => {
         const testAngles = YawPitchRollAngles.createDegrees(90, 0, 0);
         const elementProps = createPhysicalElementProps(seedElement, { origin: testOrigin, angles: testAngles });
         elementProps.elementGeometryBuilderParams = { entryArray: builder.entries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
     });
     it("create GeometricElement3d using half-space boolean test", async () => {
         const seedElement = imodel.elements.getElement("0x1d");
@@ -2160,9 +2207,9 @@ describe("BRepGeometry", () => {
         const testAngles = YawPitchRollAngles.createDegrees(90, 0, 0);
         const elementProps = createPhysicalElementProps(seedElement, { origin: testOrigin, angles: testAngles });
         elementProps.elementGeometryBuilderParams = { entryArray: builder.entries };
-        const newId = imodel.elements.insertElement(elementProps);
+        const newId = txnForCurrentTest(imodel).insertElement(elementProps);
         assert.isTrue(Id64.isValidId64(newId));
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
     });
     it("create multiple GeometricElement3d from local coordinate disjoint body result test", async () => {
         const builder = new ElementGeometry.Builder();
@@ -2525,8 +2572,8 @@ describe("BRepGeometry", () => {
             gsBuilder.appendBRepData(brep);
             const elementProps = createPhysicalElementProps(seedElement, { origin: Point3d.create(5, 10, 0), angles: YawPitchRollAngles.createDegrees(45, 0, 0) }, gsBuilder.geometryStream);
             const testElem = imodel.elements.createElement(elementProps);
-            const newId = imodel.elements.insertElement(testElem.toJSON());
-            imodel.saveChanges();
+            const newId = txnForCurrentTest(imodel).insertElement(testElem.toJSON());
+            saveTestTxn(imodel, true);
             // Extract and test value returned
             const value = imodel.elements.getElementProps({ id: newId, wantGeometry: true, wantBRepData: true });
             assert.isDefined(value.geom);
@@ -2570,8 +2617,8 @@ describe("Mass Properties", () => {
         builder.appendGeometry(box);
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
         const testElem = imodel.elements.createElement(elementProps);
-        const newId = imodel.elements.insertElement(testElem.toJSON());
-        imodel.saveChanges();
+        const newId = txnForCurrentTest(imodel).insertElement(testElem.toJSON());
+        saveTestTxn(imodel, true);
         const requestProps = {
             operation: MassPropertiesOperation.AccumulateVolumes,
             candidates: [newId],
@@ -2592,8 +2639,8 @@ describe("Mass Properties", () => {
         builder.appendGeometry(shape);
         const elementProps = createPhysicalElementProps(seedElement, undefined, builder.geometryStream);
         const testElem = imodel.elements.createElement(elementProps);
-        const newId = imodel.elements.insertElement(testElem.toJSON());
-        imodel.saveChanges();
+        const newId = txnForCurrentTest(imodel).insertElement(testElem.toJSON());
+        saveTestTxn(imodel, true);
         const requestProps = {
             operation: MassPropertiesOperation.AccumulateAreas,
             candidates: [newId],
@@ -2626,7 +2673,7 @@ describe("Geometry Containment", () => {
         const cornerOverlapId = createCircleElem(1.0, Point3d.create(10, 10, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOvrGeomOutId = createCircleElem(1.25, Point3d.create(11, -1, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOvrGeomInId = createCircleElem(0.85, Point3d.create(5, 9, 0), YawPitchRollAngles.createDegrees(45, 0, 0), imodel, seedElement);
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const range = Range3d.create(Point3d.create(0, 0, -5), Point3d.create(10, 10, 5));
         const clip = ClipVector.createEmpty();
         const block = ClipShape.createBlock(range, ClipMaskXYZRangePlanes.All, false, false);
@@ -2663,7 +2710,7 @@ describe("Geometry Containment", () => {
         const cornerOverlapId = createSphereElem(1.0, Point3d.create(10, 10, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOvrGeomOutId = createSphereElem(1.25, Point3d.create(11, -1, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOvrGeomInId = createSphereElem(0.85, Point3d.create(5, 9, 0), YawPitchRollAngles.createDegrees(45, 0, 0), imodel, seedElement);
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const range = Range3d.create(Point3d.create(0, 0, -5), Point3d.create(10, 10, 5));
         const clip = ClipVector.createEmpty();
         const block = ClipShape.createBlock(range, ClipMaskXYZRangePlanes.All, false, false);
@@ -2711,7 +2758,7 @@ describe("Geometry Containment", () => {
         const cornerOverlapRId = createPartElem(partAId, Point3d.create(10, 10, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement, true);
         const rangeOvrGeomOutRId = createPartElem(partBId, Point3d.create(11, -1, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement, true);
         const rangeOvrGeomInRId = createPartElem(partCId, Point3d.create(5, 9, 0), YawPitchRollAngles.createDegrees(45, 0, 0), imodel, seedElement, true);
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const range = Range3d.create(Point3d.create(0, 0, -5), Point3d.create(10, 10, 5));
         const clip = ClipVector.createEmpty();
         const block = ClipShape.createBlock(range, ClipMaskXYZRangePlanes.All, false, false);
@@ -2746,7 +2793,7 @@ describe("Geometry Containment", () => {
         const primOutConsInId = createDisjointCirclesElem(1.0, Point3d.create(0, 5, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const primInConsInId = createDisjointCirclesElem(1.0, Point3d.create(5, 5, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const primOvrConsOvrId = createDisjointCirclesElem(1.0, Point3d.create(5, 10, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const range = Range3d.create(Point3d.create(0, 0, -5), Point3d.create(10, 10, 5));
         const clip = ClipVector.createEmpty();
         const block = ClipShape.createBlock(range, ClipMaskXYZRangePlanes.All, false, false);
@@ -2795,7 +2842,7 @@ describe("Geometry Containment", () => {
         const rangeInsideXId = createCircleElem(1.0, Point3d.create(7.5, 2.5, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOutsideId = createCircleElem(1.0, Point3d.create(7.5, 7.5, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOvrGeomOvrId = createCircleElem(1.0, Point3d.create(5, 5, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const clipShapePts = [];
         clipShapePts.push(Point3d.create(0, 0, 0));
         clipShapePts.push(Point3d.create(10, 0, 0));
@@ -2830,7 +2877,7 @@ describe("Geometry Containment", () => {
         const rangeInsideXId = createSphereElem(1.0, Point3d.create(7.5, 2.5, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOutsideId = createSphereElem(1.0, Point3d.create(7.5, 7.5, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOvrGeomOvrId = createSphereElem(1.0, Point3d.create(5, 5, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const clipShapePts = [];
         clipShapePts.push(Point3d.create(0, 0, 0));
         clipShapePts.push(Point3d.create(10, 0, 0));
@@ -2863,7 +2910,7 @@ describe("Geometry Containment", () => {
         const rangeInsideId = createCircleElem(1.0, Point3d.create(0, 0, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOutsideId = createCircleElem(1.0, Point3d.create(10, 0, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOverlapId = createCircleElem(1.0, Point3d.create(5, 0, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const plane = Plane3dByOriginAndUnitNormal.create(Point3d.create(5, 0, 0), Vector3d.create(-1, 0, 0)); // inward normal...
         const planeSet = ConvexClipPlaneSet.createEmpty();
         planeSet.addPlaneToConvexSet(ClipPlane.createPlane(plane));
@@ -2892,7 +2939,7 @@ describe("Geometry Containment", () => {
         const rangeInsideId = createSphereElem(1.0, Point3d.create(0, 0, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOutsideId = createSphereElem(1.0, Point3d.create(10, 0, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
         const rangeOverlapId = createSphereElem(1.0, Point3d.create(5, 0, 0), YawPitchRollAngles.createDegrees(0, 0, 0), imodel, seedElement);
-        imodel.saveChanges();
+        saveTestTxn(imodel, true);
         const plane = Plane3dByOriginAndUnitNormal.create(Point3d.create(5, 0, 0), Vector3d.create(-1, 0, 0)); // inward normal...
         const planeSet = ConvexClipPlaneSet.createEmpty();
         planeSet.addPlaneToConvexSet(ClipPlane.createPlane(plane));