// |jit-test| allow-unhandlable-oom

// These tests will be using object literals as keys, and we want some of them
// to be dead after being inserted into a WeakMap. That means we must wrap
// everything in functions because it seems like the toplevel script hangs onto
// its object literals.

// Cross-compartment WeakMap keys work by storing a cross-compartment wrapper
// in the WeakMap, and the actual "delegate" object in the target compartment
// is the thing whose liveness is checked.

gczeal(0);

var g2 = newGlobal({newCompartment: true});
g2.eval('function genObj(name) { return {"name": name} }');

function basicSweeping() {
  var wm1 = new WeakMap();
  wm1.set({'name': 'obj1'}, {'name': 'val1'});
  var hold = g2.genObj('obj2');
  wm1.set(hold, {'name': 'val2'});
  wm1.set({'name': 'obj3'}, {'name': 'val3'});
  var obj4 = g2.genObj('obj4');
  wm1.set(obj4, {'name': 'val3'});
  obj4 = undefined;

  startgc(100000, 'shrinking');
  gcslice();
  assertEq(wm1.get(hold).name, 'val2');
  assertEq(nondeterministicGetWeakMapKeys(wm1).length, 1);
}

basicSweeping();

// Same, but behind an additional WM layer, to avoid ordering problems (not
// that I've checked that basicSweeping even has any problems.)

function basicSweeping2() {
  var wm1 = new WeakMap();
  wm1.set({'name': 'obj1'}, {'name': 'val1'});
  var hold = g2.genObj('obj2');
  wm1.set(hold, {'name': 'val2'});
  wm1.set({'name': 'obj3'}, {'name': 'val3'});
  var obj4 = g2.genObj('obj4');
  wm1.set(obj4, {'name': 'val3'});
  obj4 = undefined;

  var base1 = {'name': 'base1'};
  var base2 = {'name': 'base2'};
  var wm_base1 = new WeakMap();
  var wm_base2 = new WeakMap();
  wm_base1.set(base1, wm_base2);
  wm_base2.set(base2, wm1);
  wm1 = wm_base2 = undefined;

  startgc(100000, 'shrinking');
  gcslice();

  assertEq(nondeterministicGetWeakMapKeys(wm_base1).length, 1);
  wm_base2 = wm_base1.get(base1);
  assertEq(nondeterministicGetWeakMapKeys(wm_base2).length, 1);
  assertEq(nondeterministicGetWeakMapKeys(wm_base1)[0], base1);
  assertEq(nondeterministicGetWeakMapKeys(wm_base2)[0], base2);
  wm_base2 = wm_base1.get(base1);
  wm1 = wm_base2.get(base2);
  assertEq(wm1.get(hold).name, 'val2');
  assertEq(nondeterministicGetWeakMapKeys(wm1).length, 1);
}

basicSweeping2();

// Scatter the weakmap, the keys, and the values among different compartments.

function tripleZoneMarking() {
  var g1 = newGlobal({newCompartment: true});
  var g2 = newGlobal({newCompartment: true});
  var g3 = newGlobal({newCompartment: true});

  var wm = g1.eval("new WeakMap()");
  var key = g2.eval("({'name': 'obj1'})");
  var value = g3.eval("({'name': 'val1'})");
  g1 = g2 = g3 = undefined;
  wm.set(key, value);

  // Make all of it only reachable via a weakmap in the main test compartment,
  // so that all of this happens during weak marking mode. Use the weakmap as
  // its own key, so we know that the weakmap will get traced before the key
  // and therefore will populate the weakKeys table and all of that jazz.
  var base_wm = new WeakMap();
  base_wm.set(base_wm, [ wm, key ]);

  wm = key = value = undefined;

  startgc(100000, 'shrinking');
  gcslice();

  var keys = nondeterministicGetWeakMapKeys(base_wm);
  assertEq(keys.length, 1);
  var [ wm, key ] = base_wm.get(keys[0]);
  assertEq(key.name, "obj1");
  value = wm.get(key);
  assertEq(value.name, "val1");
}

tripleZoneMarking();

// Same as above, but this time use enqueueMark to enforce ordering.

function tripleZoneMarking2() {
  var g1 = newGlobal();
  var g2 = newGlobal();
  var g3 = newGlobal();

  var wm = g1.eval("wm = new WeakMap()");
  var key = g2.eval("key = ({'name': 'obj1'})");
  var value = g3.eval("({'name': 'val1'})");
  wm.set(key, value);

  enqueueMark("enter-weak-marking-mode");
  g1.eval("enqueueMark(wm)"); // weakmap
  g2.eval("enqueueMark(key)"); // delegate
  g1.wm = g2.key = undefined;
  g1 = g2 = g3 = undefined;
  wm = key = value = undefined;

  gc();

  var [ dummy, weakmap, keywrapper ] = getMarkQueue();
  assertEq(keywrapper.name, "obj1");
  value = weakmap.get(keywrapper);
  assertEq(value.name, "val1");

  clearMarkQueue();
}

if (this.enqueueMark)
  tripleZoneMarking2();

function enbugger() {
  var g = newGlobal({newCompartment: true});
  var dbg = new Debugger;
  g.eval("function debuggee_f() { return 1; }");
  g.eval("function debuggee_g() { return 1; }");
  dbg.addDebuggee(g);
  var [ s ] = dbg.findScripts({global: g}).filter(s => s.displayName == "debuggee_f");
  var [ s2 ] = dbg.findScripts({global: g}).filter(s => s.displayName == "debuggee_g");
  g.eval("debuggee_f = null");
  gc();
  dbg.removeAllDebuggees();
  gc();
  assertEq(s.displayName, "debuggee_f");

  var wm = new WeakMap;
  var obj = Object.create(null);
  var obj2 = Object.create(null);
  wm.set(obj, s);
  wm.set(obj2, obj);
  wm.set(s2, obj2);
  s = s2 = obj = obj2 = null;

  gc();
}

enbugger();

// Want to test: zone edges
// Make map with cross-zone delegate. Collect the zones one at a time.
function zone_edges() {
  var g3 = newGlobal();
  g3.eval('function genObj(name) { return {"name": name} }');

  var wm1 = new WeakMap();
  var hold = g2.genObj('obj1');
  var others = [g2.genObj('key2'), g2.genObj('key3')];
  wm1.set(hold, {'name': g3.genObj('val1'), 'others': others});
  others = null;

  var m = new Map;
  m.set(m, hold);
  hold = null;

  const zones = [ this, g2, g3 ];
  for (let zonebits = 0; zonebits < 2 ** zones.length; zonebits++) {
    for (let z in zones) {
      if (zonebits & (1 << z))
        schedulezone(zones[z]);
    }
    startgc(1);
    wm1.set(wm1.get(m.get(m)).others[0], g2.genObj('val2'));
    gcslice(1000000);
    wm1.set(wm1.get(m.get(m)).others[1], g2.genObj('val3'));
    gc();
    assertEq(wm1.get(m.get(m)).name.name, 'val1');
    assertEq(wm1.get(m.get(m)).others[0].name, 'key2');
    assertEq(wm1.get(wm1.get(m.get(m)).others[0]).name, 'val2');
    assertEq(wm1.get(m.get(m)).others[1].name, 'key3');
    assertEq(wm1.get(wm1.get(m.get(m)).others[1]).name, 'val3');
    assertEq(nondeterministicGetWeakMapKeys(wm1).length, 3);
  }

  // Do it again, with nuking.
  const wm2 = g2.eval("new WeakMap");
  wm2.set(wm1.get(m.get(m)).others[0], Object.create(null));
  for (let zonebits = 0; zonebits < 2 ** zones.length; zonebits++) {
    for (let z in zones) {
      if (zonebits & (1 << z))
        schedulezone(zones[z]);
    }
    startgc(1);
    wm1.set(wm1.get(m.get(m)).others[0], g2.genObj('val2'));
    gcslice(1000000);
    wm1.set(wm1.get(m.get(m)).others[1], g2.genObj('val3'));
    nukeCCW(wm1.get(wm1.get(m.get(m)).others[0]));
    nukeCCW(wm1.get(wm1.get(m.get(m)).others[1]));
    gc();
    assertEq(wm1.get(m.get(m)).name.name, 'val1');
    assertEq(wm1.get(m.get(m)).others[0].name, 'key2');
    assertEq(wm1.get(m.get(m)).others[1].name, 'key3');
    assertEq(nondeterministicGetWeakMapKeys(wm1).length, 3);
  }
}

zone_edges();

// Stress test: lots of cross-zone and same-zone cross-compartment edges, and
// exercise the barriers.
function stress(opt) {
  printErr(JSON.stringify(opt));

  var g1 = this;
  var g2 = newGlobal({sameZoneAs: g1});
  var g3 = newGlobal();

  var globals = g1.globals = g2.globals = g3.globals = [ g1, g2, g3 ];
  g1.name = 'main';
  g2.name = 'same-zone';
  g3.name = 'other-zone';
  g1.names = g2.names = g3.names = [ g1.name, g2.name, g3.name ];

  // Basic setup:
  //
  // Three different globals, each with a weakmap and an object. Each global's
  // weakmap contains all 3 objects (1 from each global) as keys. Internally,
  // that means that each weakmap will contain one local object and two
  // cross-compartment wrappers.
  //
  // Now duplicate that 3 times. The first weakmap will be unmodified. The
  // second weakmap will have its keys updated to different values. The third
  // weakmap will have its keys deleted.

  for (const i in globals) {
    const g = globals[i];
    g.eval('function genObj(name) { return {"name": name} }');
    g.eval("weakmap0 = new WeakMap()");
    g.eval("weakmap1 = new WeakMap()");
    g.eval("weakmap2 = new WeakMap()");
    g.eval(`obj = genObj('global-${names[i]}-object')`);
    for (const j in [0, 1, 2]) {
      g.eval(`weakmap${j}.set(genObj('global-${names[i]}-key}'), genObj("value"))`);
    }
  }

  for (const i in globals) {
    const g = globals[i];
    for (const j in globals) {
      for (const k in [0, 1, 2]) {
        g.eval(`weakmap${k}.set(globals[${j}].obj, genObj('value-${i}-${j}'))`);
      }
    }
  }

  // Construct object keys to retrieve the weakmaps with.
  for (const g of globals) {
    g.eval(`plain = genObj("plain")`);
    g.eval(`update = genObj("update")`);
    g.eval(`remove = genObj("remove")`);
  }

  // Put the weakmaps in another WeakMap.
  for (const g of globals) {
      g.eval(`weakmaps = new WeakMap();
            weakmaps.set(plain, weakmap0);
            weakmaps.set(update, weakmap1);
            weakmaps.set(remove, weakmap2);`);
  }

  // Eliminate the edges from the global to the object being used as a key. But
  // assuming we want the key to be live (nothing else points to it), hide it
  // behind another weakmap layer.
  for (const g of globals) {
    if (opt.live) {
      g.eval("keyholder = genObj('key-holder')");
      g.eval("weakmaps.set(keyholder, obj)");
    }
    g.eval("obj = null");
  }

  // If we want a layer of indirection, remove the edges from the globals to
  // their weakmaps. But note that the original purpose of this test *wants*
  // the weakmaps themselves to be visited early, so that gcWeakKeys will be
  // populated with not-yet-marked keys and the barriers will need to update
  // entries there.
  if (opt.indirect) {
    for (const g of globals) {
      g.eval("weakmap0 = weakmap1 = weakmap2 = null");
    }
  }

  // Start an incremental GC. TODO: need a zeal mode to yield before entering
  // weak marking mode.
  startgc(1);

  // Do the mutations.
  if (opt.live) {
    for (const g of globals) {
      g.eval("weakmaps.get(update).set(weakmaps.get(keyholder), genObj('val'))");
      g.eval("weakmaps.get(remove).delete(weakmaps.get(keyholder))");
    }
  }

  if (opt.nuke) {
    for (const g of globals) {
      if (g.name != 'main')
        g.eval("nukeAllCCWs()");
    }
  }

  // Finish the GC.
  gc();
}

for (const live of [true, false]) {
  for (const indirect of [true, false]) {
    for (const nuke of [true, false]) {
      stress({live, indirect, nuke});
    }
  }
}