@agoric/swingset-liveslots 0.10.3-other-dev-1f26562.0 → 0.10.3-other-dev-3eb1a1d.0

package/test/{test-collections.js → collections.test.js}

@@ -1,8 +1,9 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
 import { M } from '@agoric/store';
+import { makeCopyMap, makeCopySet } from '@endo/patterns';
 import { makeFakeCollectionManager } from '../tools/fakeVirtualSupport.js';
 
 const {
@@ -100,6 +101,12 @@ function exerciseMapOperations(t, collectionName, testStore) {
     () => testStore.set(86, 'not work'),
     m(`key 86 not found in collection "${collectionName}"`),
   );
+  t.throws(
+    () => testStore.set(somethingMissing, 'not work'),
+    m(
+      `key "[Alleged: something missing]" not found in collection "${collectionName}"`,
+    ),
+  );
   t.throws(
     () => testStore.init(47, 'already there'),
     m(`key 47 already registered in collection "${collectionName}"`),
@@ -117,11 +124,17 @@ function exerciseMapOperations(t, collectionName, testStore) {
   t.is(testStore.get(somethingElse), something);
 
   testStore.delete(47);
+  testStore.delete(something);
   t.falsy(testStore.has(47));
+  t.falsy(testStore.has(something));
   t.throws(
     () => testStore.get(47),
     m(`key 47 not found in collection "${collectionName}"`),
   );
+  t.throws(
+    () => testStore.get(something),
+    m(`key "[Alleged: something]" not found in collection "${collectionName}"`),
+  );
   t.throws(
     () => testStore.delete(22),
     m(`key 22 not found in collection "${collectionName}"`),
@@ -132,6 +145,14 @@ function exerciseMapOperations(t, collectionName, testStore) {
       `key "[Alleged: something missing]" not found in collection "${collectionName}"`,
     ),
   );
+  if (collectionName === 'map') {
+    // strong map, so we can .clear
+    testStore.clear();
+    for (const [key, _value] of stuff) {
+      t.false(testStore.has(key));
+    }
+    fillBasicMapStore(testStore);
+  }
 }
 
 function exerciseSetOperations(t, collectionName, testStore) {
@@ -146,7 +167,9 @@ function exerciseSetOperations(t, collectionName, testStore) {
   t.notThrows(() => testStore.add(47));
 
   testStore.delete(47);
+  testStore.delete(something);
   t.falsy(testStore.has(47));
+  t.falsy(testStore.has(something));
   t.throws(
     () => testStore.delete(22),
     m(`key 22 not found in collection "${collectionName}"`),
@@ -157,6 +180,14 @@ function exerciseSetOperations(t, collectionName, testStore) {
       `key "[Alleged: something missing]" not found in collection "${collectionName}"`,
     ),
   );
+  if (collectionName === 'set') {
+    // strong set, so we can .clear
+    testStore.clear();
+    for (const [key, _value] of stuff) {
+      t.false(testStore.has(key));
+    }
+    fillBasicSetStore(testStore);
+  }
 }
 
 test('basic map operations', t => {
@@ -191,6 +222,89 @@ test('basic weak set operations', t => {
   );
 });
 
+function exerciseSetAddAll(t, weak, testStore) {
+  const allThatStuff = stuff.map(entry => entry[0]);
+
+  testStore.addAll(allThatStuff);
+  for (const elem of allThatStuff) {
+    t.truthy(testStore.has(elem));
+    testStore.delete(elem);
+  }
+  if (!weak) {
+    t.is(testStore.getSize(), 0);
+  }
+
+  testStore.addAll(makeCopySet(allThatStuff));
+  for (const elem of allThatStuff) {
+    t.truthy(testStore.has(elem));
+    testStore.delete(elem);
+  }
+  if (!weak) {
+    t.is(testStore.getSize(), 0);
+  }
+
+  t.throws(
+    () => testStore.addAll({ bogus: 47 }),
+    m(/provided data source is not iterable/),
+  );
+}
+
+test('set addAll', t => {
+  exerciseSetAddAll(t, false, makeScalarBigSetStore('test set'));
+});
+
+test('weak set addAll', t => {
+  exerciseSetAddAll(t, true, makeScalarBigWeakSetStore('test weak set'));
+});
+
+test('set snapshot', t => {
+  const testStore = makeScalarBigSetStore('test set');
+  const allThatStuff = stuff.map(entry => entry[0]);
+  testStore.addAll(allThatStuff);
+  t.deepEqual(testStore.snapshot(), makeCopySet(allThatStuff));
+});
+
+function exerciseMapAddAll(t, weak, testStore) {
+  testStore.addAll(stuff);
+  for (const [k, v] of stuff) {
+    t.truthy(testStore.has(k));
+    t.is(testStore.get(k), v);
+    testStore.delete(k);
+  }
+  if (!weak) {
+    t.is(testStore.getSize(), 0);
+  }
+
+  testStore.addAll(makeCopyMap(stuff));
+  for (const [k, v] of stuff) {
+    t.truthy(testStore.has(k));
+    t.is(testStore.get(k), v);
+    testStore.delete(k);
+  }
+  if (!weak) {
+    t.is(testStore.getSize(), 0);
+  }
+
+  t.throws(
+    () => testStore.addAll({ bogus: 47 }),
+    m(/provided data source is not iterable/),
+  );
+}
+
+test('map addAll', t => {
+  exerciseMapAddAll(t, false, makeScalarBigMapStore('test map'));
+});
+
+test('weak map addAll', t => {
+  exerciseMapAddAll(t, true, makeScalarBigWeakMapStore('test weak map'));
+});
+
+test('map snapshot', t => {
+  const testStore = makeScalarBigMapStore('test map');
+  testStore.addAll(stuff);
+  t.deepEqual(testStore.snapshot(), makeCopyMap(stuff));
+});
+
 test('constrain map key shape', t => {
   const stringsOnly = makeScalarBigMapStore('map key strings only', {
     keyShape: M.string(),
@@ -389,6 +503,19 @@ test('map clear', t => {
   t.is(testStore.getSize(), 0);
 });
 
+test('map clear with pattern', t => {
+  const testStore = makeScalarBigMapStore('cmap', { keyShape: M.any() });
+  testStore.init('a', 'ax');
+  testStore.init('b', 'bx');
+  testStore.init('c', 'cx');
+  console.log(`M is`, M);
+  testStore.clear(M.eq('c'));
+  t.true(testStore.has('a'));
+  t.true(testStore.has('b'));
+  t.false(testStore.has('c'));
+  t.is(testStore.getSize(), 2);
+});
+
 test('set clear', t => {
   const testStore = makeScalarBigSetStore('cset', { keyShape: M.any() });
   testStore.add('a');
@@ -401,11 +528,25 @@ test('set clear', t => {
   t.is(testStore.getSize(), 0);
 });
 
+test('set clear with pattern', t => {
+  const testStore = makeScalarBigSetStore('cset', { keyShape: M.any() });
+  testStore.add('a');
+  testStore.add('b');
+  testStore.add('c');
+  testStore.clear(M.eq('c'));
+  t.true(testStore.has('a'));
+  t.true(testStore.has('b'));
+  t.false(testStore.has('c'));
+  t.is(testStore.getSize(), 2);
+});
+
 test('map fail on concurrent modification', t => {
   const primeMap = makeScalarBigMapStore('fmap', {
     keyShape: M.number(),
   });
-  primes.forEach((v, i) => primeMap.init(v, `${v} is prime #${i + 1}`));
+  for (const [i, v] of primes.entries()) {
+    primeMap.init(v, `${v} is prime #${i + 1}`);
+  }
 
   let iter = primeMap.keys()[Symbol.iterator]();
   t.deepEqual(iter.next(), { done: false, value: 2 });
@@ -433,7 +574,9 @@ test('set fail on concurrent modification', t => {
   const primeSet = makeScalarBigSetStore('fset', {
     keyShape: M.number(),
   });
-  primes.forEach(v => primeSet.add(v));
+  for (const v of primes) {
+    primeSet.add(v);
+  }
 
   let iter = primeSet.keys()[Symbol.iterator]();
   t.deepEqual(iter.next(), { done: false, value: 2 });
@@ -461,7 +604,9 @@ test('map ok with concurrent deletion', t => {
   const primeMap = makeScalarBigMapStore('fmap', {
     keyShape: M.number(),
   });
-  primes.forEach((v, i) => primeMap.init(v, `${v} is prime #${i + 1}`));
+  for (const [i, v] of primes.entries()) {
+    primeMap.init(v, `${v} is prime #${i + 1}`);
+  }
   const iter = primeMap.keys()[Symbol.iterator]();
   t.deepEqual(iter.next(), { done: false, value: 2 });
   primeMap.delete(3);
@@ -476,7 +621,9 @@ test('set ok with concurrent deletion', t => {
   const primeSet = makeScalarBigSetStore('fset', {
     keyShape: M.number(),
   });
-  primes.forEach(v => primeSet.add(v));
+  for (const v of primes) {
+    primeSet.add(v);
+  }
 
   const iter = primeSet.keys()[Symbol.iterator]();
   t.deepEqual(iter.next(), { done: false, value: 2 });
@@ -766,13 +913,6 @@ test('set queries', t => {
     symbolKrusty,
     undefined,
   ]);
-
-  // @ts-expect-error our BigSetStore has .entries, but not the SetStore type
-  t.deepEqual(Array.from(testStore.entries(M.number())), [
-    [-29, -29],
-    [3, 3],
-    [47, 47],
-  ]);
 });
 
 test('remotable sort order', t => {
@@ -798,7 +938,9 @@ test('complex map queries', t => {
   const primeStore = makeScalarBigMapStore('prime map', {
     keyShape: M.number(),
   });
-  primes.forEach((v, i) => primeStore.init(v, `${v} is prime #${i + 1}`));
+  for (const [i, v] of primes.entries()) {
+    primeStore.init(v, `${v} is prime #${i + 1}`);
+  }
 
   t.deepEqual(Array.from(primeStore.values()), [
     '2 is prime #1',
@@ -973,7 +1115,9 @@ test('complex set queries', t => {
   const primeStore = makeScalarBigSetStore('prime set', {
     keyShape: M.number(),
   });
-  primes.forEach(v => primeStore.add(v));
+  for (const v of primes) {
+    primeStore.add(v);
+  }
 
   t.deepEqual(
     Array.from(primeStore.values()),

package/test/{test-dropped-collection-weakrefs.js → dropped-collection-weakrefs.test.js}

@@ -1,8 +1,7 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 import { Far } from '@endo/marshal';
+import { kser } from '@agoric/kmarshal';
 import { makeLiveSlots } from '../src/liveslots.js';
-import { kser } from './kmarshal.js';
 import { buildSyscall } from './liveslots-helpers.js';
 import { makeStartVat } from './util.js';
 import { makeMockGC } from './mock-gc.js';

package/test/dropped-weakset-9939.test.js

@@ -0,0 +1,80 @@
+import test from 'ava';
+import { Far } from '@endo/marshal';
+import { kser, kslot } from '@agoric/kmarshal';
+import { makeLiveSlots } from '../src/liveslots.js';
+import { buildSyscall } from './liveslots-helpers.js';
+import { makeStartVat, makeMessage, makeBringOutYourDead } from './util.js';
+import { makeMockGC } from './mock-gc.js';
+
+// Test for https://github.com/Agoric/agoric-sdk/issues/9939
+
+test('weakset deletion vs retire', async t => {
+  const { syscall, log } = buildSyscall();
+  const gcTools = makeMockGC();
+
+  // #9939 was a bug in liveslots that caused a vat to emit
+  // syscall.retireImports despite not having done dropImports
+  // first. The setup is:
+  //
+  // * import a Presence (raising the RAM pillar)
+  // * store it in a virtual object (raising the vdata pillar)
+  // * use it as a key of a voAwareWeakMap or voAwareWeakSet
+  // * drop the Presence (dropping the RAM pillar)
+  // * do a BOYD
+  // * delete the voAwareWeakSet
+  // * do a BOYD
+  //
+  // When the voAwareWeakSet is collected, a finalizer callback named
+  // finalizeDroppedCollection is called, which clears the entries,
+  // and adds all its vref keys to possiblyRetiredSet. Later, during
+  // BOYD, a loop examines possiblyRetiredSet and adds qualified vrefs
+  // to importsToRetire, for the syscall.retireImports at the end.
+  //
+  // That qualification check was sufficient to prevent the retirement
+  // of vrefs that still have a RAM pillar, and also vrefs that were
+  // being dropped in this particular BOYD, but it was not sufficient
+  // to protect vrefs that still have a vdata pillar.
+
+  let myVOAwareWeakSet;
+  let myPresence;
+  function buildRootObject(vatPowers, _vatParameters, baggage) {
+    const { WeakSet } = vatPowers;
+    myVOAwareWeakSet = new WeakSet();
+    return Far('root', {
+      store: p => {
+        myPresence = p;
+        myVOAwareWeakSet.add(p);
+        baggage.init('presence', p);
+      },
+    });
+  }
+
+  const makeNS = () => ({ buildRootObject });
+  const ls = makeLiveSlots(syscall, 'vatA', {}, {}, gcTools, undefined, makeNS);
+  const { dispatch } = ls;
+  await dispatch(makeStartVat(kser()));
+  t.truthy(myVOAwareWeakSet);
+
+  await dispatch(makeMessage('o+0', 'store', [kslot('o-1')]));
+  t.truthy(myPresence);
+
+  log.length = 0;
+  gcTools.kill(myPresence);
+  gcTools.flushAllFRs();
+  await dispatch(makeBringOutYourDead());
+
+  log.length = 0;
+  gcTools.kill(myVOAwareWeakSet);
+  gcTools.flushAllFRs();
+  await dispatch(makeBringOutYourDead());
+
+  // The imported vref is still reachable by the 'baggage' durable
+  // store, so it must not be dropped or retired yet. The bug caused
+  // the vref to be retired without first doing a drop, which is a
+  // vat-fatal syscall error
+  const gcCalls = log.filter(
+    l => l.type === 'dropImports' || l.type === 'retireImports',
+  );
+  t.deepEqual(gcCalls, []);
+  log.length = 0;
+});

package/test/dummyMeterControl.js

@@ -1,4 +1,4 @@
-import { assert } from '@agoric/assert';
+import { assert } from '@endo/errors';
 
 export function makeDummyMeterControl() {
   let meteringDisabled = 0;

package/test/{test-durabilityChecks.js → durabilityChecks.test.js}

@@ -1,5 +1,4 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
 import { makeFakeVirtualStuff } from '../tools/fakeVirtualSupport.js';
@@ -16,6 +15,7 @@ async function runDurabilityCheckTest(t, relaxDurabilityRules) {
 
   const durableHolderKind = makeKindHandle('holder');
 
+  /** @param {any} held */
   const initHolder = (held = null) => ({ held });
   const holderBehavior = {
     hold: ({ state }, value) => {
@@ -262,12 +262,12 @@ async function runDurabilityCheckTest(t, relaxDurabilityRules) {
     passVal(() => virtualMap.init('non-scalar key', aNonScalarKey));
     passVal(() => virtualMap.init('non-scalar non-key', aNonScalarNonKey));
 
-    condVal(() => durableMap.init('promise', aPassablePromise));
+    failVal(() => durableMap.init('promise', aPassablePromise));
     passVal(() => durableMap.init('error', aPassableError));
     passVal(() => durableMap.init('non-scalar key', aNonScalarKey));
     passVal(() => durableMap.init('non-scalar non-key', aNonScalarNonKey));
   }
 }
 
-test('durability checks (strict)', t => runDurabilityCheckTest(t, false));
-test('durability checks (relaxed)', t => runDurabilityCheckTest(t, true));
+test('durability checks (strict)', runDurabilityCheckTest, false);
+test('durability checks (relaxed)', runDurabilityCheckTest, true);

package/test/exo-utils.js

@@ -0,0 +1,70 @@
+import { provideLazy as provide } from '@agoric/store';
+
+// Partially duplicates @agoric/vat-data to avoid circular dependencies.
+export const makeExoUtils = VatData => {
+  const { defineDurableKind, makeKindHandle, watchPromise } = VatData;
+
+  const provideKindHandle = (baggage, kindName) =>
+    provide(baggage, `${kindName}_kindHandle`, () => makeKindHandle(kindName));
+
+  const emptyRecord = harden({});
+  const initEmpty = () => emptyRecord;
+
+  const defineDurableExoClass = (
+    kindHandle,
+    interfaceGuard,
+    init,
+    methods,
+    options,
+  ) =>
+    defineDurableKind(kindHandle, init, methods, {
+      ...options,
+      thisfulMethods: true,
+      interfaceGuard,
+    });
+
+  const prepareExoClass = (
+    baggage,
+    kindName,
+    interfaceGuard,
+    init,
+    methods,
+    options = undefined,
+  ) =>
+    defineDurableExoClass(
+      provideKindHandle(baggage, kindName),
+      interfaceGuard,
+      init,
+      methods,
+      options,
+    );
+
+  const prepareExo = (
+    baggage,
+    kindName,
+    interfaceGuard,
+    methods,
+    options = undefined,
+  ) => {
+    const makeSingleton = prepareExoClass(
+      baggage,
+      kindName,
+      interfaceGuard,
+      initEmpty,
+      methods,
+      options,
+    );
+    return provide(baggage, `the_${kindName}`, () => makeSingleton());
+  };
+
+  return {
+    defineDurableKind,
+    makeKindHandle,
+    watchPromise,
+
+    provideKindHandle,
+    defineDurableExoClass,
+    prepareExoClass,
+    prepareExo,
+  };
+};

package/test/{test-facetiousness.js → facetiousness.test.js}

@@ -1,4 +1,3 @@
-import '@endo/init/debug.js';
 import test from 'ava';
 import {
   assessFacetiousness,
@@ -126,7 +125,7 @@ test('checkAndUpdateFacetiousness', t => {
   t.deepEqual(cauf({}, barfoo), barfoo);
 
   // a single Kind can only be redefined as another single
-  t.deepEqual(cauf(desc(), undefined), undefined);
+  t.is(cauf(desc(), undefined), undefined);
   t.throws(() => cauf(desc(), foo), {
     message: 'defineDurableKindMulti called for unfaceted KindHandle "tag"',
   });

package/test/gc-and-finalize.js

@@ -1,4 +1,4 @@
-/* global setImmediate */
+/* global setImmediate, FinalizationRegistry */
 
 /* A note on our GC terminology:
  *
@@ -89,3 +89,32 @@ export function makeGcAndFinalize(gcPower) {
     await new Promise(setImmediate);
   };
 }
+
+const fr = new FinalizationRegistry(({ promise, resolve }) => {
+  promise.result = true;
+  resolve(true);
+});
+
+const makeCollectedResultKit = () => {
+  /** @type {(val: true) => void} */
+  let resolve;
+
+  const promise = /** @type {Promise<true> & {result: boolean}} */ (
+    new Promise(r => {
+      resolve = r;
+    })
+  );
+  promise.result = false;
+  return {
+    promise,
+    // @ts-expect-error
+    resolve,
+  };
+};
+
+export function watchCollected(target) {
+  const kit = makeCollectedResultKit();
+  fr.register(target, kit);
+
+  return kit.promise;
+}