namespace ts {

describe("unittests:: createMapShim", () => {

const stringKeys = [

"1",

"3",

"2",

"4",

"0",

"999",

"A",

"B",

"C",

"Z",

"X",

"X1",

"X2",

"Y"

];

const mixedKeys = [

true,

3,

{ toString() { return "2"; } },

"4",

false,

null, // eslint-disable-line no-null/no-null

undefined,

"B",

{ toString() { return "C"; } },

"Z",

"X",

{ toString() { return "X1"; } },

"X2",

"Y"

];

function testMapIterationAddedValues<K>(keys: K[], map: ESMap<K, string>, useForEach: boolean): string {

let resultString = "";

map.set(keys[0], "1");

map.set(keys[1], "3");

map.set(keys[2], "2");

map.set(keys[3], "4");

let addedThree = false;

const doForEach = (value: string, key: K) => {

resultString += `${key}:${value};`;

// Add a new key ("0") - the map should provide this

// one in the next iteration.

if (key === keys[0]) {

map.set(keys[0], "X1");

map.set(keys[4], "X0");

map.set(keys[3], "X4");

}

else if (key === keys[1]) {

if (!addedThree) {

addedThree = true;

// Remove and re-add key "3"; the map should

// visit it after "0".

map.delete(keys[1]);

map.set(keys[1], "Y3");

// Change the value of "2"; the map should provide

// it when visiting the key.

map.set(keys[2], "Y2");

}

else {

// Check that an entry added when we visit the

// currently last entry will still be visited.

map.set(keys[5], "999");

}

}

else if (key === keys[5]) {

// Ensure that clear() behaves correctly same as removing all keys.

map.set(keys[6], "A");

map.set(keys[7], "B");

map.set(keys[8], "C");

}

else if (key === keys[6]) {

map.clear();

map.set(keys[9], "Z");

}

else if (key === keys[9]) {

// Check that the map behaves correctly when two items are

// added and removed immediately.

map.set(keys[10], "X");

map.set(keys[11], "X1");

map.set(keys[12], "X2");

map.delete(keys[11]);

map.delete(keys[12]);

map.set(keys[13], "Y");

}

};

if (useForEach) {

map.forEach(doForEach);

}

else {

// Use an iterator.

const iterator = map.entries();

while (true) {

const iterResult = iterator.next();

if (iterResult.done) {

break;

}

const [key, value] = iterResult.value;

doForEach(value, key);

}

}

return resultString;

}

let MapShim!: MapConstructor;

beforeEach(() => {

function getIterator<I extends readonly any[] | ReadonlySet<any> | ReadonlyESMap<any, any> | undefined>(iterable: I): Iterator<

I extends ReadonlyESMap<infer K, infer V> ? [K, V] :

I extends ReadonlySet<infer T> ? T :

I extends readonly (infer T)[] ? T :

I extends undefined ? undefined :

never>;

function getIterator(iterable: readonly any[] | ReadonlySet<any> | ReadonlyESMap<any, any> | undefined): Iterator<any> | undefined {

// override `ts.getIterator` with a version that allows us to iterate over a `MapShim` in an environment with a native `Map`.

if (iterable instanceof MapShim) return iterable.entries();

return ts.getIterator(iterable);

}

MapShim = ShimCollections.createMapShim(getIterator);

afterEach(() => {

MapShim = undefined!;

});

});

it("iterates values in insertion order and handles changes with string keys", () => {

const expectedResult = "1:1;3:3;2:Y2;4:X4;0:X0;3:Y3;999:999;A:A;Z:Z;X:X;Y:Y;";

// First, ensure the test actually has the same behavior as a native Map.

let nativeMap = new Map<string, string>();

const nativeMapForEachResult = testMapIterationAddedValues(stringKeys, nativeMap, /* useForEach */ true);

assert.equal(nativeMapForEachResult, expectedResult, "nativeMap-forEach");

nativeMap = new Map<string, string>();

const nativeMapIteratorResult = testMapIterationAddedValues(stringKeys, nativeMap, /* useForEach */ false);

assert.equal(nativeMapIteratorResult, expectedResult, "nativeMap-iterator");

// Then, test the map shim.

let localShimMap = new MapShim<string, string>();

const shimMapForEachResult = testMapIterationAddedValues(stringKeys, localShimMap, /* useForEach */ true);

assert.equal(shimMapForEachResult, expectedResult, "shimMap-forEach");

localShimMap = new MapShim<string, string>();

const shimMapIteratorResult = testMapIterationAddedValues(stringKeys, localShimMap, /* useForEach */ false);

assert.equal(shimMapIteratorResult, expectedResult, "shimMap-iterator");

});

it("iterates values in insertion order and handles changes with mixed-type keys", () => {

const expectedResult = "true:1;3:3;2:Y2;4:X4;false:X0;3:Y3;null:999;undefined:A;Z:Z;X:X;Y:Y;";

// First, ensure the test actually has the same behavior as a native Map.

let nativeMap = new Map<any, string>();

const nativeMapForEachResult = testMapIterationAddedValues(mixedKeys, nativeMap, /* useForEach */ true);

assert.equal(nativeMapForEachResult, expectedResult, "nativeMap-forEach");

nativeMap = new Map<any, string>();

const nativeMapIteratorResult = testMapIterationAddedValues(mixedKeys, nativeMap, /* useForEach */ false);

assert.equal(nativeMapIteratorResult, expectedResult, "nativeMap-iterator");

// Then, test the map shim.

let localShimMap = new MapShim<any, string>();

const shimMapForEachResult = testMapIterationAddedValues(mixedKeys, localShimMap, /* useForEach */ true);

assert.equal(shimMapForEachResult, expectedResult, "shimMap-forEach");

localShimMap = new MapShim<any, string>();

const shimMapIteratorResult = testMapIterationAddedValues(mixedKeys, localShimMap, /* useForEach */ false);

assert.equal(shimMapIteratorResult, expectedResult, "shimMap-iterator");

});

it("create from Array", () => {

const map = new MapShim([["a", "b"]]);

assert.equal(map.size, 1);

assert.isTrue(map.has("a"));

assert.equal(map.get("a"), "b");

});

it("create from Map", () => {

const map1 = new MapShim([["a", "b"]]);

const map2 = new MapShim(map1);

assert.equal(map1.size, 1);

assert.equal(map2.size, 1);

assert.isTrue(map2.has("a"));

assert.equal(map2.get("a"), "b");

});

it("set when not present", () => {

const map = new MapShim<string, string>();

const result = map.set("a", "b");

assert.equal(map.size, 1);

assert.strictEqual(result, map);

assert.isTrue(map.has("a"));

assert.equal(map.get("a"), "b");

});

it("set when present", () => {

const map = new MapShim<string, string>();

map.set("a", "z");

const result = map.set("a", "b");

assert.equal(map.size, 1);

assert.strictEqual(result, map);

assert.isTrue(map.has("a"));

assert.equal(map.get("a"), "b");

});

it("has when not present", () => {

const map = new MapShim<string, string>();

assert.isFalse(map.has("a"));

});

it("has when present", () => {

const map = new MapShim<string, string>();

map.set("a", "b");

assert.isTrue(map.has("a"));

});

it("get when not present", () => {

const map = new MapShim<string, string>();

assert.isUndefined(map.get("a"));

});

it("get when present", () => {

const map = new MapShim<string, string>();

map.set("a", "b");

assert.equal(map.get("a"), "b");

});

it("delete when not present", () => {

const map = new MapShim<string, string>();

assert.isFalse(map.delete("a"));

});

it("delete when present", () => {

const map = new MapShim<string, string>();

map.set("a", "b");

assert.isTrue(map.delete("a"));

});

it("delete twice when present", () => {

const map = new MapShim<string, string>();

map.set("a", "b");

assert.isTrue(map.delete("a"));

assert.isFalse(map.delete("a"));

});

it("remove only item and iterate", () => {

const map = new MapShim<string, string>();

map.set("a", "b");

map.delete("a");

const actual = arrayFrom(map.keys());

assert.deepEqual(actual, []);

});

it("remove first item and iterate", () => {

const map = new MapShim<string, string>();

map.set("a", "b");

map.set("c", "d");

map.delete("a");

assert.deepEqual(arrayFrom(map.keys()), ["c"]);

assert.deepEqual(arrayFrom(map.values()), ["d"]);

assert.deepEqual(arrayFrom(map.entries()), [["c", "d"]]);

});

it("remove last item and iterate", () => {

const map = new MapShim<string, string>();

map.set("a", "b");

map.set("c", "d");

map.delete("c");

assert.deepEqual(arrayFrom(map.keys()), ["a"]);

assert.deepEqual(arrayFrom(map.values()), ["b"]);

assert.deepEqual(arrayFrom(map.entries()), [["a", "b"]]);

});

it("remove middle item and iterate", () => {

const map = new MapShim<string, string>();

map.set("a", "b");

map.set("c", "d");

map.set("e", "f");

map.delete("c");

assert.deepEqual(arrayFrom(map.keys()), ["a", "e"]);

assert.deepEqual(arrayFrom(map.values()), ["b", "f"]);

assert.deepEqual(arrayFrom(map.entries()), [["a", "b"], ["e", "f"]]);

});

it("keys", () => {

const map = new MapShim<string, string>();

map.set("c", "d");

map.set("a", "b");

assert.deepEqual(arrayFrom(map.keys()), ["c", "a"]);

});

it("values", () => {

const map = new MapShim<string, string>();

map.set("c", "d");

map.set("a", "b");

assert.deepEqual(arrayFrom(map.values()), ["d", "b"]);

});

it("entries", () => {

const map = new MapShim<string, string>();

map.set("c", "d");

map.set("a", "b");

assert.deepEqual(arrayFrom(map.entries()), [["c", "d"], ["a", "b"]]);

});

it("forEach", () => {

const map = new MapShim<string, string>();

map.set("c", "d");

map.set("a", "b");

const actual: [string, string][] = [];

map.forEach((value, key) => actual.push([key, value]));

assert.deepEqual(actual, [["c", "d"], ["a", "b"]]);

});

});

}