@y/y 14.0.0-16

package/dist/testHelper.mjs

@@ -0,0 +1,617 @@
+import * as t from 'lib0/testing';
+import * as prng from 'lib0/prng';
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+import * as syncProtocol from '@y/protocols/sync';
+import * as object from 'lib0/object';
+import * as map from 'lib0/map';
+import { Y } from './index-DyTeTfmj.js';
+import * as math from 'lib0/math';
+import * as list from 'lib0/list';
+import * as delta from 'lib0/delta';
+import { bb as diffUpdate, a$ as logUpdate, Q as applyUpdate, b4 as mergeUpdates, T as encodeStateAsUpdate, ba as diffUpdateV2, b0 as logUpdateV2, P as applyUpdateV2, b9 as mergeUpdatesV2, S as encodeStateAsUpdateV2, a7 as compareIDs, D as Doc, cs as YXmlElement, by as createIdMap, n as addToIdSet, p as createIdSet, bm as createAttributionItem, bv as encodeIdMap, bU as AbstractType, $ as encodeStateVector, v as equalIdSets, q as createDeleteSetFromStructStore, au as encodeSnapshot, az as snapshot, d4 as Item } from './Skip-wRT7BKFP.js';
+export { ah as AbsolutePosition, bF as AbstractAttributionManager, A as AbstractConnector, cy as AbstractStruct, cf as Array, bl as Attribution, cN as ContentAny, cB as ContentBinary, cD as ContentDeleted, cF as ContentDoc, cH as ContentEmbed, cJ as ContentFormat, cL as ContentJSON, cP as ContentString, cZ as ContentType, bJ as DiffAttributionManager, cA as GC, a6 as ID, bt as IdMap, b as IdSet, ch as Map, ae as RelativePosition, d9 as Skip, ar as Snapshot, co as Text, aS as Transaction, bG as TwosetAttributionManager, aZ as UndoManager, U as UpdateDecoderV1, C as UpdateDecoderV2, F as UpdateEncoderV1, H as UpdateEncoderV2, cq as XmlFragment, cu as XmlHook, cw as XmlText, bh as YEvent, cl as cleanupYTextFormatting, y as cloneDoc, aq as compareRelativePositions, bf as convertUpdateFormatV1ToV2, bg as convertUpdateFormatV2ToV1, ap as createAbsolutePositionFromRelativePosition, bK as createAttributionManagerFromDiff, aC as createDocFromSnapshot, a8 as createID, bs as createIdMapFromIdSet, s as createInsertionSetFromStructStore, ag as createRelativePositionFromJSON, ak as createRelativePositionFromTypeIndex, ax as createSnapshot, bx as decodeIdMap, ao as decodeRelativePosition, aw as decodeSnapshot, av as decodeSnapshotV2, W as decodeStateVector, b1 as decodeUpdate, b2 as decodeUpdateV2, bN as diffDocsToDelta, bA as diffIdMap, j as diffIdSet, ay as emptySnapshot, am as encodeRelativePosition, at as encodeSnapshotV2, b6 as encodeStateVectorFromUpdate, b5 as encodeStateVectorFromUpdateV2, as as equalSnapshots, aK as findIndexSS, ab as findRootTypeKey, aM as getItem, aP as getItemCleanEnd, aO as getItemCleanStart, aH as getState, bS as getTypeChildren, bz as insertIntoIdMap, g as insertIntoIdSet, ac as isParentOf, i as iterateStructsByIdSet, ad as logType, br as mergeIdMaps, m as mergeIdSets, bI as noAttributionsManager, bd as obfuscateUpdate, be as obfuscateUpdateV2, bw as readIdMap, t as readIdSet, O as readUpdate, b8 as readUpdateIdRanges, b7 as readUpdateIdRangesV2, N as readUpdateV2, af as relativePositionToJSON, aE as snapshotContainsUpdate, aX as transact, aW as tryGc, bY as typeListToArraySnapshot, cd as typeMapGetAllSnapshot, cc as typeMapGetSnapshot } from './Skip-wRT7BKFP.js';
+import 'lib0/function';
+import 'lib0/binary';
+import 'lib0/observable';
+import 'lib0/array';
+import 'lib0/traits';
+import 'lib0/random';
+import 'lib0/promise';
+import 'lib0/buffer';
+import 'lib0/error';
+import 'lib0/set';
+import 'lib0/logging';
+import 'lib0/time';
+import 'lib0/string';
+import 'lib0/hash/rabin';
+import 'lib0/iterator';
+import 'lib0/environment';
+import 'lib0/schema';
+
+if (typeof window !== 'undefined') {
+  // @ts-ignore
+  window.Y = Y; // eslint-disable-line
+}
+
+/**
+ * @param {TestYInstance} y // publish message created by `y` to all other online clients
+ * @param {Uint8Array} m
+ */
+const broadcastMessage = (y, m) => {
+  if (y.tc.onlineConns.has(y)) {
+    y.tc.onlineConns.forEach(remoteYInstance => {
+      if (remoteYInstance !== y) {
+        remoteYInstance._receive(m, y);
+      }
+    });
+  }
+};
+
+let useV2 = false;
+
+const encV1 = {
+  encodeStateAsUpdate: encodeStateAsUpdate,
+  mergeUpdates: mergeUpdates,
+  applyUpdate: applyUpdate,
+  logUpdate: logUpdate,
+  updateEventName: /** @type {'update'} */ ('update'),
+  diffUpdate: diffUpdate
+};
+
+const encV2 = {
+  encodeStateAsUpdate: encodeStateAsUpdateV2,
+  mergeUpdates: mergeUpdatesV2,
+  applyUpdate: applyUpdateV2,
+  logUpdate: logUpdateV2,
+  updateEventName: /** @type {'updateV2'} */ ('updateV2'),
+  diffUpdate: diffUpdateV2
+};
+
+let enc = encV1;
+
+const useV1Encoding = () => {
+  useV2 = false;
+  enc = encV1;
+};
+
+const useV2Encoding = () => {
+  console.error('sync protocol doesnt support v2 protocol yet, fallback to v1 encoding'); // @Todo
+  useV2 = false;
+  enc = encV1;
+};
+
+class TestYInstance extends Doc {
+  /**
+   * @param {TestConnector} testConnector
+   * @param {number} clientID
+   */
+  constructor (testConnector, clientID) {
+    super();
+    this.userID = clientID; // overwriting clientID
+    /**
+     * @type {TestConnector}
+     */
+    this.tc = testConnector;
+    /**
+     * @type {Map<TestYInstance, Array<Uint8Array>>}
+     */
+    this.receiving = new Map();
+    testConnector.allConns.add(this);
+    /**
+     * The list of received updates.
+     * We are going to merge them later using Y.mergeUpdates and check if the resulting document is correct.
+     * @type {Array<Uint8Array<ArrayBuffer>>}
+     */
+    this.updates = [];
+    // set up observe on local model
+    this.on(enc.updateEventName, (update, origin) => {
+      if (origin !== testConnector) {
+        const encoder = encoding.createEncoder();
+        syncProtocol.writeUpdate(encoder, update);
+        broadcastMessage(this, encoding.toUint8Array(encoder));
+      }
+      this.updates.push(update);
+    });
+    this.connect();
+  }
+
+  /**
+   * Disconnect from TestConnector.
+   */
+  disconnect () {
+    this.receiving = new Map();
+    this.tc.onlineConns.delete(this);
+  }
+
+  /**
+   * Append yourself to the list of known Y instances in testconnector.
+   * Also initiate sync with all clients.
+   */
+  connect () {
+    if (!this.tc.onlineConns.has(this)) {
+      this.tc.onlineConns.add(this);
+      const encoder = encoding.createEncoder();
+      syncProtocol.writeSyncStep1(encoder, this);
+      // publish SyncStep1
+      broadcastMessage(this, encoding.toUint8Array(encoder));
+      this.tc.onlineConns.forEach(remoteYInstance => {
+        if (remoteYInstance !== this) {
+          // remote instance sends instance to this instance
+          const encoder = encoding.createEncoder();
+          syncProtocol.writeSyncStep1(encoder, remoteYInstance);
+          this._receive(encoding.toUint8Array(encoder), remoteYInstance);
+        }
+      });
+    }
+  }
+
+  /**
+   * Receive a message from another client. This message is only appended to the list of receiving messages.
+   * TestConnector decides when this client actually reads this message.
+   *
+   * @param {Uint8Array} message
+   * @param {TestYInstance} remoteClient
+   */
+  _receive (message, remoteClient) {
+    map.setIfUndefined(this.receiving, remoteClient, () => /** @type {Array<Uint8Array>} */ ([])).push(message);
+  }
+}
+
+/**
+ * Keeps track of TestYInstances.
+ *
+ * The TestYInstances add/remove themselves from the list of connections maiained in this object.
+ * I think it makes sense. Deal with it.
+ */
+class TestConnector {
+  /**
+   * @param {prng.PRNG} gen
+   */
+  constructor (gen) {
+    /**
+     * @type {Set<TestYInstance>}
+     */
+    this.allConns = new Set();
+    /**
+     * @type {Set<TestYInstance>}
+     */
+    this.onlineConns = new Set();
+    /**
+     * @type {prng.PRNG}
+     */
+    this.prng = gen;
+  }
+
+  /**
+   * Create a new Y instance and add it to the list of connections
+   * @param {number} clientID
+   */
+  createY (clientID) {
+    return new TestYInstance(this, clientID)
+  }
+
+  /**
+   * Choose random connection and flush a random message from a random sender.
+   *
+   * If this function was unable to flush a message, because there are no more messages to flush, it returns false. true otherwise.
+   * @return {boolean}
+   */
+  flushRandomMessage () {
+    const gen = this.prng;
+    const conns = Array.from(this.onlineConns).filter(conn => conn.receiving.size > 0);
+    if (conns.length > 0) {
+      const receiver = prng.oneOf(gen, conns);
+      const [sender, messages] = prng.oneOf(gen, Array.from(receiver.receiving));
+      const m = messages.shift();
+      if (messages.length === 0) {
+        receiver.receiving.delete(sender);
+      }
+      if (m === undefined) {
+        return this.flushRandomMessage()
+      }
+      const encoder = encoding.createEncoder();
+      // console.log('receive (' + sender.userID + '->' + receiver.userID + '):\n', syncProtocol.stringifySyncMessage(decoding.createDecoder(m), receiver))
+      // do not publish data created when this function is executed (could be ss2 or update message)
+      syncProtocol.readSyncMessage(decoding.createDecoder(m), encoder, receiver, receiver.tc);
+      if (encoding.length(encoder) > 0) {
+        // send reply message
+        sender._receive(encoding.toUint8Array(encoder), receiver);
+      }
+      return true
+    }
+    return false
+  }
+
+  /**
+   * @return {boolean} True iff this function actually flushed something
+   */
+  flushAllMessages () {
+    let didSomething = false;
+    while (this.flushRandomMessage()) {
+      didSomething = true;
+    }
+    return didSomething
+  }
+
+  reconnectAll () {
+    this.allConns.forEach(conn => conn.connect());
+  }
+
+  disconnectAll () {
+    this.allConns.forEach(conn => conn.disconnect());
+  }
+
+  syncAll () {
+    this.reconnectAll();
+    this.flushAllMessages();
+  }
+
+  /**
+   * @return {boolean} Whether it was possible to disconnect a random connection.
+   */
+  disconnectRandom () {
+    if (this.onlineConns.size === 0) {
+      return false
+    }
+    prng.oneOf(this.prng, Array.from(this.onlineConns)).disconnect();
+    return true
+  }
+
+  /**
+   * @return {boolean} Whether it was possible to reconnect a random connection.
+   */
+  reconnectRandom () {
+    /**
+     * @type {Array<TestYInstance>}
+     */
+    const reconnectable = [];
+    this.allConns.forEach(conn => {
+      if (!this.onlineConns.has(conn)) {
+        reconnectable.push(conn);
+      }
+    });
+    if (reconnectable.length === 0) {
+      return false
+    }
+    prng.oneOf(this.prng, reconnectable).connect();
+    return true
+  }
+}
+
+/**
+ * @template T
+ * @param {t.TestCase} tc
+ * @param {{users?:number}} conf
+ * @param {InitTestObjectCallback<T>} [initTestObject]
+ * @return {{testObjects:Array<any>,testConnector:TestConnector,users:Array<TestYInstance>,array0:Y.Array<any>,array1:Y.Array<any>,array2:Y.Array<any>,map0:Y.Map<any>,map1:Y.Map<any>,map2:Y.Map<any>,map3:Y.Map<any>,text0:Y.Text,text1:Y.Text,text2:Y.Text,xml0:Y.XmlElement,xml1:Y.XmlElement,xml2:Y.XmlElement}}
+ */
+const init = (tc, { users = 5 } = {}, initTestObject) => {
+  /**
+   * @type {Object<string,any>}
+   */
+  const result = {
+    users: []
+  };
+  const gen = tc.prng;
+  // choose an encoding approach at random
+  if (prng.bool(gen)) {
+    useV2Encoding();
+  } else {
+    useV1Encoding();
+  }
+
+  const testConnector = new TestConnector(gen);
+  result.testConnector = testConnector;
+  for (let i = 0; i < users; i++) {
+    const y = testConnector.createY(i);
+    y.clientID = i;
+    result.users.push(y);
+    result['array' + i] = y.getArray('array');
+    result['map' + i] = y.getMap('map');
+    result['xml' + i] = y.get('xml', YXmlElement);
+    result['text' + i] = y.getText('text');
+  }
+  testConnector.syncAll();
+  result.testObjects = result.users.map(initTestObject || (() => null));
+  useV1Encoding();
+  return /** @type {any} */ (result)
+};
+
+/**
+ * @param {Y.IdSet} idSet1
+ * @param {Y.IdSet} idSet2
+ */
+const compareIdSets = (idSet1, idSet2) => {
+  t.assert(idSet1.clients.size === idSet2.clients.size);
+  for (const [client, _items1] of idSet1.clients.entries()) {
+    const items1 = _items1.getIds();
+    const items2 = idSet2.clients.get(client)?.getIds();
+    t.assert(items2 !== undefined && items1.length === items2.length);
+    for (let i = 0; i < items1.length; i++) {
+      const di1 = items1[i];
+      const di2 = /** @type {Array<import('../src/utils/IdSet.js').IdRange>} */ (items2)[i];
+      t.assert(di1.clock === di2.clock && di1.len === di2.len);
+    }
+  }
+  return true
+};
+
+/**
+ * only use for testing
+ *
+ * @template T
+ * @param {Array<Y.Attribution<T>>} attrs
+ * @param {Y.Attribution<T>} attr
+ *
+ */
+const _idmapAttrsHas = (attrs, attr) => {
+  const hash = attr.hash();
+  return attrs.find(a => a.hash() === hash)
+};
+
+/**
+ * only use for testing
+ *
+ * @template T
+ * @param {Array<Y.Attribution<T>>} a
+ * @param {Array<Y.Attribution<T>>} b
+ */
+const _idmapAttrsEqual = (a, b) => a.length === b.length && a.every(v => _idmapAttrsHas(b, v));
+
+/**
+ * Ensure that all attributes exist. Also create a copy and compare it to the original.
+ *
+ * @template T
+ * @param {Y.IdMap<T>} idmap
+ */
+const validateIdMap = idmap => {
+  const copy = createIdMap();
+  idmap.clients.forEach((ranges, client) => {
+    ranges.getIds().forEach(range => {
+      range.attrs.forEach(attr => {
+        t.assert(idmap.attrs.has(attr));
+        t.assert(idmap.attrsH.get(attr.hash()) === attr);
+        copy.add(client, range.clock, range.len, range.attrs.slice());
+      });
+    });
+    t.assert(copy.clients.get(client)?.getIds().length === ranges.getIds().length);
+  });
+  t.assert(idmap.attrsH.size === idmap.attrs.size);
+};
+
+/**
+ * @template T
+ * @param {Y.IdMap<T>} idmap1
+ * @param {Y.IdMap<T>} idmap2
+ */
+const compareIdmaps = (idmap1, idmap2) => {
+  t.assert(idmap1.clients.size === idmap2.clients.size);
+  for (const [client, _items1] of idmap1.clients.entries()) {
+    const items1 = _items1.getIds();
+    const items2 = idmap2.clients.get(client)?.getIds();
+    t.assert(items2 !== undefined && items1.length === items2.length);
+    for (let i = 0; i < items1.length; i++) {
+      const di1 = items1[i];
+      const di2 = /** @type {Array<import('../src/utils/IdMap.js').AttrRange<T>>} */ (items2)[i];
+      t.assert(di1.clock === di2.clock && di1.len === di2.len && _idmapAttrsEqual(di1.attrs, di2.attrs));
+    }
+  }
+  validateIdMap(idmap1);
+  validateIdMap(idmap2);
+};
+
+/**
+ * @param {prng.PRNG} gen
+ * @param {number} clients
+ * @param {number} clockRange (max clock - exclusive - by each client)
+ */
+const createRandomIdSet = (gen, clients, clockRange) => {
+  const maxOpLen = 5;
+  const numOfOps = math.ceil((clients * clockRange) / maxOpLen);
+  const idset = createIdSet();
+  for (let i = 0; i < numOfOps; i++) {
+    const client = prng.uint32(gen, 0, clients - 1);
+    const clockStart = prng.uint32(gen, 0, clockRange);
+    const len = prng.uint32(gen, 0, clockRange - clockStart);
+    addToIdSet(idset, client, clockStart, len);
+  }
+  if (idset.clients.size === clients && clients > 1 && prng.bool(gen)) {
+    idset.clients.delete(prng.uint32(gen, 0, clients));
+  }
+  return idset
+};
+
+/**
+ * @template T
+ * @param {prng.PRNG} gen
+ * @param {number} clients
+ * @param {number} clockRange (max clock - exclusive - by each client)
+ * @param {Array<T>} attrChoices (max clock - exclusive - by each client)
+ * @return {Y.IdMap<T>}
+ */
+const createRandomIdMap = (gen, clients, clockRange, attrChoices) => {
+  const maxOpLen = 5;
+  const numOfOps = math.ceil((clients * clockRange) / maxOpLen);
+  const idMap = createIdMap();
+  for (let i = 0; i < numOfOps; i++) {
+    const client = prng.uint32(gen, 0, clients - 1);
+    const clockStart = prng.uint32(gen, 0, clockRange);
+    const len = prng.uint32(gen, 0, clockRange - clockStart);
+    const attrs = [prng.oneOf(gen, attrChoices)];
+    // maybe add another attr
+    if (prng.bool(gen)) {
+      const a = prng.oneOf(gen, attrChoices);
+      if (attrs.find(attr => attr === a) == null) {
+        attrs.push(a);
+      }
+    }
+    idMap.add(client, clockStart, len, attrs.map(v => createAttributionItem('', v)));
+  }
+  t.info(`Created IdMap with ${numOfOps} ranges and ${attrChoices.length} different attributes. Encoded size: ${encodeIdMap(idMap).byteLength}`);
+  return idMap
+};
+
+/**
+ * 1. reconnect and flush all
+ * 2. user 0 gc
+ * 3. get type content
+ * 4. disconnect & reconnect all (so gc is propagated)
+ * 5. compare os, ds, ss
+ *
+ * @param {Array<TestYInstance>} users
+ */
+const compare = users => {
+  users.forEach(u => u.connect());
+  while (users[0].tc.flushAllMessages()) {} // eslint-disable-line
+  // For each document, merge all received document updates with Y.mergeUpdates and create a new document which will be added to the list of "users"
+  // This ensures that mergeUpdates works correctly
+  const mergedDocs = users.map(user => {
+    const ydoc = new Doc();
+    enc.applyUpdate(ydoc, enc.mergeUpdates(user.updates));
+    return ydoc
+  });
+  users.push(.../** @type {any} */(mergedDocs));
+  const userArrayValues = users.map(u => u.getArray('array').toJSON());
+  const userMapValues = users.map(u => u.getMap('map').toJSON());
+  // @todo fix type error here
+  // @ts-ignore
+  const userXmlValues = users.map(u => /** @type {Y.XmlElement} */ (u.get('xml', YXmlElement)).toString());
+  const userTextValues = users.map(u => u.getText('text').getContentDeep());
+  for (const u of users) {
+    t.assert(u.store.pendingDs === null);
+    t.assert(u.store.pendingStructs === null);
+  }
+  // Test Array iterator
+  t.compare(users[0].getArray('array').toArray(), Array.from(users[0].getArray('array')));
+  // Test Map iterator
+  const ymapkeys = Array.from(users[0].getMap('map').keys());
+  t.assert(ymapkeys.length === Object.keys(userMapValues[0]).length);
+  ymapkeys.forEach(key => t.assert(object.hasProperty(userMapValues[0], key)));
+  /**
+   * @type {Object<string,any>}
+   */
+  const mapRes = {};
+  for (const [k, v] of users[0].getMap('map')) {
+    mapRes[k] = v instanceof AbstractType ? v.toJSON() : v;
+  }
+  t.compare(userMapValues[0], mapRes);
+  // Compare all users
+  for (let i = 0; i < users.length - 1; i++) {
+    t.compare(userArrayValues[i].length, users[i].getArray('array').length);
+    t.compare(userArrayValues[i], userArrayValues[i + 1]);
+    t.compare(userMapValues[i], userMapValues[i + 1]);
+    t.compare(userXmlValues[i], userXmlValues[i + 1]);
+    t.compare(list.toArray(userTextValues[i].children).map(a => (delta.$textOp.check(a) || delta.$insertOp.check(a)) ? a.insert.length : 0).reduce((a, b) => a + b, 0), users[i].getText('text').length);
+    t.compare(userTextValues[i], userTextValues[i + 1], '', (_constructor, a, b) => {
+      if (a instanceof AbstractType) {
+        t.compare(a.toJSON(), b.toJSON());
+      } else if (a !== b) {
+        t.fail('Deltas dont match');
+      }
+      return true
+    });
+    t.compare(encodeStateVector(users[i]), encodeStateVector(users[i + 1]));
+    equalIdSets(createDeleteSetFromStructStore(users[i].store), createDeleteSetFromStructStore(users[i + 1].store));
+    compareStructStores(users[i].store, users[i + 1].store);
+    t.compare(encodeSnapshot(snapshot(users[i])), encodeSnapshot(snapshot(users[i + 1])));
+  }
+  users.forEach(user => {
+    compareIdSets(user.store.ds, createDeleteSetFromStructStore(user.store));
+  });
+  users.map(u => u.destroy());
+};
+
+/**
+ * @param {Y.Item?} a
+ * @param {Y.Item?} b
+ * @return {boolean}
+ */
+const compareItemIDs = (a, b) => a === b || (a !== null && b != null && compareIDs(a.id, b.id));
+
+/**
+ * @param {import('../src/internals.js').StructStore} ss1
+ * @param {import('../src/internals.js').StructStore} ss2
+ */
+const compareStructStores = (ss1, ss2) => {
+  t.assert(ss1.clients.size === ss2.clients.size);
+  for (const [client, structs1] of ss1.clients) {
+    const structs2 = /** @type {Array<Y.AbstractStruct>} */ (ss2.clients.get(client));
+    t.assert(structs2 !== undefined && structs1.length === structs2.length);
+    for (let i = 0; i < structs1.length; i++) {
+      const s1 = structs1[i];
+      const s2 = structs2[i];
+      // checks for abstract struct
+      if (
+        s1.constructor !== s2.constructor ||
+        !compareIDs(s1.id, s2.id) ||
+        s1.deleted !== s2.deleted ||
+        // @ts-ignore
+        s1.length !== s2.length
+      ) {
+        t.fail('Structs dont match');
+      }
+      if (s1 instanceof Item) {
+        if (
+          !(s2 instanceof Item) ||
+          !((s1.left === null && s2.left === null) || (s1.left !== null && s2.left !== null && compareIDs(s1.left.lastId, s2.left.lastId))) ||
+          !compareItemIDs(s1.right, s2.right) ||
+          !compareIDs(s1.origin, s2.origin) ||
+          !compareIDs(s1.rightOrigin, s2.rightOrigin) ||
+          s1.parentSub !== s2.parentSub
+        ) {
+          return t.fail('Items dont match')
+        }
+        // make sure that items are connected correctly
+        t.assert(s1.left === null || s1.left.right === s1);
+        t.assert(s1.right === null || s1.right.left === s1);
+        t.assert(s2.left === null || s2.left.right === s2);
+        t.assert(s2.right === null || s2.right.left === s2);
+      }
+    }
+  }
+};
+
+/**
+ * @template T
+ * @callback InitTestObjectCallback
+ * @param {TestYInstance} y
+ * @return {T}
+ */
+
+/**
+ * @template T
+ * @param {t.TestCase} tc
+ * @param {Array<function(Y.Doc,prng.PRNG,T):void>} mods
+ * @param {number} iterations
+ * @param {InitTestObjectCallback<T>} [initTestObject]
+ */
+const applyRandomTests = (tc, mods, iterations, initTestObject) => {
+  const gen = tc.prng;
+  const result = init(tc, { users: 5 }, initTestObject);
+  const { testConnector, users } = result;
+  for (let i = 0; i < iterations; i++) {
+    if (prng.int32(gen, 0, 100) <= 2) {
+      // 2% chance to disconnect/reconnect a random user
+      if (prng.bool(gen)) {
+        testConnector.disconnectRandom();
+      } else {
+        testConnector.reconnectRandom();
+      }
+    } else if (prng.int32(gen, 0, 100) <= 1) {
+      // 1% chance to flush all
+      testConnector.flushAllMessages();
+    } else if (prng.int32(gen, 0, 100) <= 50) {
+      // 50% chance to flush a random message
+      testConnector.flushRandomMessage();
+    }
+    const user = prng.int32(gen, 0, users.length - 1);
+    const test = prng.oneOf(gen, mods);
+    test(users[user], gen, result.testObjects[user]);
+  }
+  compare(users);
+  return result
+};
+
+export { AbstractType, Doc, Item, TestConnector, TestYInstance, YXmlElement as XmlElement, _idmapAttrsEqual, applyRandomTests, applyUpdate, applyUpdateV2, compare, compareIDs, compareIdSets, compareIdmaps, compareItemIDs, compareStructStores, createAttributionItem, createDeleteSetFromStructStore, createIdMap, createIdSet, createRandomIdMap, createRandomIdSet, diffUpdate, diffUpdateV2, enc, encV1, encV2, encodeIdMap, encodeSnapshot, encodeStateAsUpdate, encodeStateAsUpdateV2, encodeStateVector, equalIdSets, init, logUpdate, logUpdateV2, mergeUpdates, mergeUpdatesV2, snapshot, useV2, validateIdMap };
+//# sourceMappingURL=testHelper.mjs.map