@everyonesoftware/common 13.0.0 → 14.0.0

package/outputs/tests/iteratorTests.js

@@ -0,0 +1,728 @@
+import { EmptyError } from "../sources/emptyError.js";
+import { Iterator } from "../sources/iterator.js";
+import { NotFoundError } from "../sources/notFoundError.js";
+import { PreConditionError } from "../sources/preConditionError.js";
+export function test(runner) {
+    runner.testFile("iterator.ts", () => {
+        runner.testType("Iterator<T>", () => {
+            runner.testFunction("create(T[])", () => {
+                function createErrorTest(values, expected) {
+                    runner.test(`with ${runner.toString(values)}`, (test) => {
+                        test.assertThrows(() => Iterator.create(values), expected);
+                    });
+                }
+                createErrorTest(undefined, new PreConditionError("Expression: values", "Expected: not undefined and not null", "Actual: undefined"));
+                createErrorTest(null, new PreConditionError("Expression: values", "Expected: not undefined and not null", "Actual: null"));
+                function createTest(values) {
+                    runner.test(`with ${runner.toString(values)}`, (test) => {
+                        const iterator = Iterator.create(values);
+                        test.assertEqual(iterator.toArray().await(), values);
+                    });
+                }
+                createTest([]);
+                createTest([1, 2, 3]);
+                createTest([false, true]);
+            });
+            runner.testFunction("next()", () => {
+                runner.testGroup("not empty", () => {
+                    runner.test("not started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values);
+                        test.assertFalse(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        for (const value of values) {
+                            test.assertTrue(iterator.next().await());
+                            test.assertTrue(iterator.hasCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertEqual(value, iterator.getCurrent());
+                        }
+                        for (let i = 0; i < 2; i++) {
+                            test.assertFalse(iterator.next().await());
+                            test.assertFalse(iterator.hasCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertThrows(() => iterator.getCurrent(), new PreConditionError("Expression: this.hasCurrent()", "Expected: true", "Actual: false"));
+                        }
+                    });
+                    runner.test("started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values).start().await();
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertTrue(iterator.hasCurrent());
+                        test.assertEqual(1, iterator.getCurrent());
+                        for (const value of values.slice(1)) {
+                            test.assertTrue(iterator.next().await());
+                            test.assertTrue(iterator.hasCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertEqual(value, iterator.getCurrent());
+                        }
+                        for (let i = 0; i < 2; i++) {
+                            test.assertFalse(iterator.next().await());
+                            test.assertFalse(iterator.hasCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertThrows(() => iterator.getCurrent(), new PreConditionError("Expression: this.hasCurrent()", "Expected: true", "Actual: false"));
+                        }
+                    });
+                });
+            });
+            runner.testFunction("start()", (test) => {
+                const iterator = Iterator.create([1, 2, 3]);
+                for (let i = 0; i < 2; i++) {
+                    const startResult = iterator.start().await();
+                    test.assertSame(startResult, iterator);
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertTrue(iterator.hasCurrent());
+                    test.assertEqual(1, iterator.getCurrent());
+                }
+            });
+            runner.testFunction("takeCurrent()", () => {
+                runner.testGroup("with non-empty", () => {
+                    runner.test("not started", (test) => {
+                        const iterator = Iterator.create([1, 2, 3]);
+                        test.assertFalse(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        for (let i = 0; i < 2; i++) {
+                            test.assertThrows(() => iterator.takeCurrent(), new PreConditionError("Expression: iterator.hasCurrent()", "Expected: true", "Actual: false"));
+                            test.assertFalse(iterator.hasStarted());
+                            test.assertFalse(iterator.hasCurrent());
+                        }
+                    });
+                    runner.test("started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values).start().await();
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertTrue(iterator.hasCurrent());
+                        test.assertEqual(1, iterator.getCurrent());
+                        for (let i = 0; i < values.length - 1; i++) {
+                            test.assertEqual(values[i], iterator.takeCurrent().await());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertTrue(iterator.hasCurrent());
+                            test.assertEqual(values[i + 1], iterator.getCurrent());
+                        }
+                        test.assertEqual(values[values.length - 1], iterator.takeCurrent().await());
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                    });
+                });
+            });
+            runner.testFunction("any()", () => {
+                runner.testGroup("with non-empty", () => {
+                    runner.test("not started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values);
+                        test.assertFalse(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        for (let i = 0; i < 2; i++) {
+                            test.assertTrue(iterator.any().await());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertTrue(iterator.hasCurrent());
+                            test.assertEqual(values[0], iterator.getCurrent());
+                        }
+                    });
+                    runner.test("started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values).start().await();
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertTrue(iterator.hasCurrent());
+                        test.assertEqual(values[0], iterator.getCurrent());
+                        for (let i = 0; i < 2; i++) {
+                            test.assertTrue(iterator.any().await());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertTrue(iterator.hasCurrent());
+                            test.assertEqual(values[0], iterator.getCurrent());
+                        }
+                    });
+                });
+            });
+            runner.testFunction("getCount()", () => {
+                runner.testGroup("with non-empty", () => {
+                    runner.test("not started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values);
+                        test.assertFalse(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        test.assertEqual(values.length, iterator.getCount().await());
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        for (let i = 0; i < 2; i++) {
+                            test.assertEqual(iterator.getCount().await(), 0);
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertFalse(iterator.hasCurrent());
+                        }
+                    });
+                    runner.test("started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values).start().await();
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertTrue(iterator.hasCurrent());
+                        test.assertEqual(values[0], iterator.getCurrent());
+                        test.assertEqual(values.length, iterator.getCount().await());
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        for (let i = 0; i < 2; i++) {
+                            test.assertEqual(iterator.getCount().await(), 0);
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertFalse(iterator.hasCurrent());
+                        }
+                    });
+                });
+            });
+            runner.testFunction("toArray()", () => {
+                runner.testGroup("not empty", () => {
+                    runner.test("not started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values);
+                        test.assertEqual(values, iterator.toArray().await());
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        test.assertEqual([], iterator.toArray().await());
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                    });
+                    runner.test("started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values).start().await();
+                        test.assertEqual(values, iterator.toArray().await());
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        test.assertEqual([], iterator.toArray().await());
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                    });
+                });
+            });
+            runner.testGroup("concatenate()", () => {
+                runner.testGroup("with non-started", () => {
+                    runner.testGroup("empty and", () => {
+                        runner.test("empty", (test) => {
+                            const iterator = Iterator.create([]);
+                            const concatenateIterator = iterator.concatenate([]);
+                            test.assertEqual(concatenateIterator.toArray().await(), []);
+                        });
+                        runner.test("non-empty", (test) => {
+                            const iterator = Iterator.create([]);
+                            const concatenateIterator = iterator.concatenate([5]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [5]);
+                        });
+                        runner.test("two non-emptys", (test) => {
+                            const iterator = Iterator.create([]);
+                            const concatenateIterator = iterator.concatenate([5], [6, 7]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [5, 6, 7]);
+                        });
+                    });
+                    runner.testGroup("non-empty and", () => {
+                        runner.test("empty", (test) => {
+                            const iterator = Iterator.create([1, 2]);
+                            const concatenateIterator = iterator.concatenate([]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [1, 2]);
+                        });
+                        runner.test("non-empty", (test) => {
+                            const iterator = Iterator.create([3]);
+                            const concatenateIterator = iterator.concatenate([4, 5, 6]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [3, 4, 5, 6]);
+                        });
+                        runner.test("two non-emptys", (test) => {
+                            const iterator = Iterator.create([7, 8, 9]);
+                            const concatenateIterator = iterator.concatenate([10, 11, 12], [13]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [7, 8, 9, 10, 11, 12, 13]);
+                        });
+                    });
+                });
+                runner.testGroup("with started", () => {
+                    runner.testGroup("empty and", () => {
+                        runner.test("empty", (test) => {
+                            const iterator = Iterator.create([]).start().await();
+                            const concatenateIterator = iterator.concatenate([]);
+                            test.assertEqual(concatenateIterator.toArray().await(), []);
+                        });
+                        runner.test("non-empty", (test) => {
+                            const iterator = Iterator.create([]).start().await();
+                            const concatenateIterator = iterator.concatenate([5]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [5]);
+                        });
+                        runner.test("two non-emptys", (test) => {
+                            const iterator = Iterator.create([]).start().await();
+                            const concatenateIterator = iterator.concatenate([5], [6, 7]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [5, 6, 7]);
+                        });
+                    });
+                    runner.testGroup("non-empty and", () => {
+                        runner.test("empty", (test) => {
+                            const iterator = Iterator.create([1, 2]).start().await();
+                            const concatenateIterator = iterator.concatenate([]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [1, 2]);
+                        });
+                        runner.test("non-empty", (test) => {
+                            const iterator = Iterator.create([3]).start().await();
+                            const concatenateIterator = iterator.concatenate([4, 5, 6]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [3, 4, 5, 6]);
+                        });
+                        runner.test("two non-emptys", (test) => {
+                            const iterator = Iterator.create([7, 8, 9]).start().await();
+                            const concatenateIterator = iterator.concatenate([10, 11, 12], [13]);
+                            test.assertEqual(concatenateIterator.toArray().await(), [7, 8, 9, 10, 11, 12, 13]);
+                        });
+                    });
+                });
+            });
+            runner.testFunction("where()", () => {
+                runner.testGroup("with non-empty", () => {
+                    runner.test("not started", (test) => {
+                        const values = [1, 2, 3, 4, 5];
+                        const iterator = Iterator.create(values);
+                        const result = iterator.where(x => x % 2 === 1);
+                        test.assertNotUndefinedAndNotNull(result);
+                        test.assertNotSame(result, iterator);
+                        test.assertFalse(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        test.assertFalse(result.hasStarted());
+                        test.assertFalse(result.hasCurrent());
+                        for (const expectedValue of [1, 3, 5]) {
+                            test.assertTrue(result.next().await());
+                            test.assertTrue(result.hasStarted());
+                            test.assertTrue(result.hasCurrent());
+                            test.assertEqual(expectedValue, result.getCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertTrue(iterator.hasCurrent());
+                            test.assertEqual(expectedValue, iterator.getCurrent());
+                        }
+                        for (let i = 0; i < 2; i++) {
+                            test.assertFalse(result.next().await());
+                            test.assertTrue(result.hasStarted());
+                            test.assertFalse(result.hasCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertFalse(iterator.hasCurrent());
+                        }
+                    });
+                    runner.test("started", (test) => {
+                        const values = [1, 2, 3, 4, 5];
+                        const iterator = Iterator.create(values).start().await();
+                        const result = iterator.where(x => x % 2 === 1);
+                        test.assertNotUndefinedAndNotNull(result);
+                        test.assertNotSame(result, iterator);
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertTrue(iterator.hasCurrent());
+                        test.assertEqual(values[0], iterator.getCurrent());
+                        test.assertFalse(result.hasStarted());
+                        test.assertFalse(result.hasCurrent());
+                        for (const expectedValue of [1, 3, 5]) {
+                            test.assertTrue(result.next().await());
+                            test.assertTrue(result.hasStarted());
+                            test.assertTrue(result.hasCurrent());
+                            test.assertEqual(expectedValue, result.getCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertTrue(iterator.hasCurrent());
+                            test.assertEqual(expectedValue, iterator.getCurrent());
+                        }
+                        for (let i = 0; i < 2; i++) {
+                            test.assertFalse(result.next().await());
+                            test.assertTrue(result.hasStarted());
+                            test.assertFalse(result.hasCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertFalse(iterator.hasCurrent());
+                        }
+                    });
+                });
+            });
+            runner.testFunction("map()", () => {
+                runner.testGroup("with non-empty", () => {
+                    runner.test("not started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values);
+                        const result = iterator.map(x => x + 10);
+                        test.assertFalse(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                        test.assertFalse(result.hasStarted());
+                        test.assertFalse(result.hasCurrent());
+                        for (const value of values) {
+                            test.assertTrue(result.next().await());
+                            test.assertTrue(result.hasStarted());
+                            test.assertTrue(result.hasCurrent());
+                            test.assertEqual(value + 10, result.getCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertTrue(iterator.hasCurrent());
+                            test.assertEqual(value, iterator.getCurrent());
+                        }
+                        for (let i = 0; i < 2; i++) {
+                            test.assertFalse(result.next().await());
+                            test.assertTrue(result.hasStarted());
+                            test.assertFalse(result.hasCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertFalse(iterator.hasCurrent());
+                        }
+                    });
+                    runner.test("started", (test) => {
+                        const values = [1, 2, 3];
+                        const iterator = Iterator.create(values).start().await();
+                        const result = iterator.map(x => x + 10);
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertTrue(iterator.hasCurrent());
+                        test.assertEqual(values[0], iterator.getCurrent());
+                        test.assertFalse(result.hasStarted());
+                        test.assertFalse(result.hasCurrent());
+                        for (const value of values) {
+                            test.assertTrue(result.next().await());
+                            test.assertTrue(result.hasStarted());
+                            test.assertTrue(result.hasCurrent());
+                            test.assertEqual(value + 10, result.getCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertTrue(iterator.hasCurrent());
+                            test.assertEqual(value, iterator.getCurrent());
+                        }
+                        for (let i = 0; i < 2; i++) {
+                            test.assertFalse(result.next().await());
+                            test.assertTrue(result.hasStarted());
+                            test.assertFalse(result.hasCurrent());
+                            test.assertTrue(iterator.hasStarted());
+                            test.assertFalse(iterator.hasCurrent());
+                        }
+                    });
+                });
+            });
+            runner.testFunction("flatMap()", () => {
+                runner.test("with empty non-started iterator", (test) => {
+                    const iterator = Iterator.create([]);
+                    const flatMapIterator = iterator.flatMap((value) => {
+                        const result = [];
+                        for (let i = 0; i < value; i++) {
+                            result.push(value.toString());
+                        }
+                        return result;
+                    });
+                    test.assertEqual(flatMapIterator.toArray().await(), []);
+                });
+                runner.test("with empty started iterator", (test) => {
+                    const iterator = Iterator.create([]).start().await();
+                    const flatMapIterator = iterator.flatMap((value) => {
+                        const result = [];
+                        for (let i = 0; i < value; i++) {
+                            result.push(value.toString());
+                        }
+                        return result;
+                    });
+                    test.assertEqual(flatMapIterator.toArray().await(), []);
+                });
+                runner.test("with non-empty non-started iterator", (test) => {
+                    const iterator = Iterator.create([1, 2, 3]);
+                    const flatMapIterator = iterator.flatMap((value) => {
+                        const result = [];
+                        for (let i = 0; i < value; i++) {
+                            result.push(value.toString());
+                        }
+                        return result;
+                    });
+                    test.assertEqual(flatMapIterator.toArray().await(), ["1", "2", "2", "3", "3", "3"]);
+                });
+                runner.test("with non-empty started iterator", (test) => {
+                    const iterator = Iterator.create([1, 2, 3]).start().await();
+                    const flatMapIterator = iterator.flatMap((value) => {
+                        const result = [];
+                        for (let i = 0; i < value; i++) {
+                            result.push(value.toString());
+                        }
+                        return result;
+                    });
+                    test.assertEqual(flatMapIterator.toArray().await(), ["1", "2", "2", "3", "3", "3"]);
+                });
+                runner.test("with mapping that sometimes returns an empty iterable", (test) => {
+                    const iterator = Iterator.create([1, 2, 3, 4]).start().await();
+                    const flatMapIterator = iterator.flatMap((value) => {
+                        const result = [];
+                        if (value % 2 === 1) {
+                            for (let i = 0; i < value; i++) {
+                                result.push(value.toString());
+                            }
+                        }
+                        return result;
+                    });
+                    test.assertEqual(flatMapIterator.toArray().await(), ["1", "3", "3", "3"]);
+                });
+            });
+            runner.testFunction("first()", () => {
+                runner.testGroup("with no condition", () => {
+                    function firstErrorTest(iterable, expected) {
+                        runner.test(`with ${runner.toString(iterable)}`, (test) => {
+                            const iterator = Iterator.create(iterable);
+                            for (let i = 0; i < 3; i++) {
+                                test.assertThrows(() => { iterator.first().await(); }, expected);
+                            }
+                        });
+                    }
+                    firstErrorTest([], new EmptyError());
+                    function firstTest(iterable, expected) {
+                        runner.test(`with ${runner.toString(iterable)}`, (test) => {
+                            const iterator = Iterator.create(iterable);
+                            for (let i = 0; i < 3; i++) {
+                                test.assertEqual(iterator.first().await(), expected);
+                            }
+                        });
+                    }
+                    firstTest([1], 1);
+                    firstTest([2, 3], 2);
+                    firstTest([4, 5, 6, 7, 8], 4);
+                });
+                runner.testGroup("with condition argument", () => {
+                    function firstErrorTest(iterable, condition, expected) {
+                        runner.test(`with ${runner.toString(iterable)} and ${condition?.name} condition`, (test) => {
+                            const iterator = Iterator.create(iterable);
+                            for (let i = 0; i < 3; i++) {
+                                test.assertThrows(() => {
+                                    iterator.first(condition).await();
+                                }, expected);
+                            }
+                        });
+                    }
+                    function isOdd(value) {
+                        return value % 2 === 1;
+                    }
+                    function isEven(value) {
+                        return value % 2 === 0;
+                    }
+                    firstErrorTest([], undefined, new EmptyError());
+                    firstErrorTest([], null, new EmptyError());
+                    firstErrorTest([1], isEven, new NotFoundError("No value was found in the Iterator that matched the provided condition."));
+                    firstErrorTest([2, 4], isOdd, new NotFoundError("No value was found in the Iterator that matched the provided condition."));
+                    function firstTest(iterable, condition, expected) {
+                        runner.test(`with ${runner.toString(iterable)} and ${condition?.name} condition`, (test) => {
+                            const iterator = Iterator.create(iterable);
+                            for (let i = 0; i < 3; i++) {
+                                test.assertEqual(iterator.first(condition).await(), expected);
+                            }
+                        });
+                    }
+                    firstTest([1], isOdd, 1);
+                    firstTest([2, 3], isEven, 2);
+                    firstTest([2, 3], isOdd, 3);
+                    firstTest([4, 6, 7, 8], isEven, 4);
+                    firstTest([4, 6, 7, 8], isOdd, 7);
+                });
+            });
+            runner.testFunction("skip(number)", () => {
+                function skipErrorTest(iterable, maximumToSkip, expected) {
+                    runner.test(`with ${runner.andList([iterable, maximumToSkip])}`, (test) => {
+                        const iterator = Iterator.create(iterable);
+                        test.assertThrows(() => iterator.skip(maximumToSkip), expected);
+                    });
+                }
+                skipErrorTest([], undefined, new PreConditionError("Expression: maximumToSkip", "Expected: not undefined and not null", "Actual: undefined"));
+                skipErrorTest([], null, new PreConditionError("Expression: maximumToSkip", "Expected: not undefined and not null", "Actual: null"));
+                skipErrorTest([], 0.5, new PreConditionError("Expression: maximumToSkip", "Expected: integer", "Actual: 0.5"));
+                skipErrorTest([], -1, new PreConditionError("Expression: maximumToSkip", "Expected: greater than or equal to 0", "Actual: -1"));
+                function skipTest(iterable, maximumToSkip, expected) {
+                    runner.test(`with ${runner.andList([iterable, maximumToSkip])}`, (test) => {
+                        const iterator = Iterator.create(iterable);
+                        const skipIterator = iterator.skip(maximumToSkip);
+                        test.assertEqual(expected, skipIterator.toArray().await());
+                    });
+                }
+                skipTest([], 0, []);
+                skipTest([], 1, []);
+                skipTest([], 2, []);
+                skipTest(["a", "b", "c"], 0, ["a", "b", "c"]);
+                skipTest(["a", "b", "c"], 1, ["b", "c"]);
+                skipTest(["a", "b", "c"], 2, ["c"]);
+                skipTest(["a", "b", "c"], 3, []);
+                skipTest(["a", "b", "c"], 4, []);
+            });
+        });
+    });
+}
+export function iteratorTests(runner, creator) {
+    runner.testType("Iterator<T>", () => {
+        runner.testFunction("creator()", (test) => {
+            const iterator = creator();
+            test.assertNotUndefinedAndNotNull(iterator);
+            test.assertFalse(iterator.hasStarted());
+            test.assertFalse(iterator.hasCurrent());
+            test.assertThrows(() => iterator.getCurrent(), new PreConditionError("Expression: this.hasCurrent()", "Expected: true", "Actual: false"));
+        });
+        runner.testFunction("start()", (test) => {
+            const iterator = creator();
+            for (let i = 0; i < 2; i++) {
+                const startResult = iterator.start().await();
+                test.assertSame(startResult, iterator);
+                test.assertTrue(iterator.hasStarted());
+                test.assertFalse(iterator.hasCurrent());
+            }
+        });
+        runner.testFunction("takeCurrent()", () => {
+            runner.testGroup("with empty", () => {
+                runner.test("not started", (test) => {
+                    const iterator = creator();
+                    for (let i = 0; i < 2; i++) {
+                        test.assertThrows(() => iterator.takeCurrent(), new PreConditionError("Expression: iterator.hasCurrent()", "Expected: true", "Actual: false"));
+                        test.assertFalse(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                    }
+                });
+                runner.test("started", (test) => {
+                    const iterator = creator().start().await();
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                    for (let i = 0; i < 2; i++) {
+                        test.assertThrows(() => iterator.takeCurrent(), new PreConditionError("Expression: iterator.hasCurrent()", "Expected: true", "Actual: false"));
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                    }
+                });
+            });
+        });
+        runner.testFunction("next()", () => {
+            runner.testGroup("with empty", () => {
+                runner.test("not started", (test) => {
+                    const iterator = creator();
+                    test.assertFalse(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                    for (let i = 0; i < 2; i++) {
+                        test.assertFalse(iterator.next().await());
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                    }
+                });
+                runner.test("started", (test) => {
+                    const iterator = creator().start().await();
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                    for (let i = 0; i < 2; i++) {
+                        test.assertFalse(iterator.next().await());
+                        test.assertTrue(iterator.hasStarted());
+                        test.assertFalse(iterator.hasCurrent());
+                    }
+                });
+            });
+        });
+        runner.testFunction("[Symbol.iterator]()", (test) => {
+            const iterator = creator();
+            test.assertFalse(iterator.hasStarted());
+            test.assertFalse(iterator.hasCurrent());
+            const jsIterator = iterator[Symbol.iterator]();
+            test.assertFalse(iterator.hasStarted());
+            test.assertFalse(iterator.hasCurrent());
+            for (let i = 0; i < 2; i++) {
+                const result = jsIterator.next();
+                test.assertEqual(result.done, true);
+                test.assertUndefined(result.value);
+                test.assertTrue(iterator.hasStarted());
+                test.assertFalse(iterator.hasCurrent());
+            }
+        });
+        runner.testFunction("any()", (test) => {
+            const iterator = creator();
+            test.assertFalse(iterator.hasStarted());
+            test.assertFalse(iterator.hasCurrent());
+            test.assertFalse(iterator.any().await());
+            test.assertTrue(iterator.hasStarted());
+            test.assertFalse(iterator.hasCurrent());
+        });
+        runner.testFunction("getCount()", (test) => {
+            const iterator = creator();
+            test.assertFalse(iterator.hasStarted());
+            test.assertFalse(iterator.hasCurrent());
+            for (let i = 0; i < 2; i++) {
+                test.assertEqual(iterator.getCount().await(), 0);
+                test.assertTrue(iterator.hasStarted());
+                test.assertFalse(iterator.hasCurrent());
+            }
+        });
+        runner.testFunction("toArray()", (test) => {
+            const iterator = creator();
+            test.assertFalse(iterator.hasStarted());
+            test.assertFalse(iterator.hasCurrent());
+            for (let i = 0; i < 2; i++) {
+                const array = iterator.toArray().await();
+                test.assertEqual(array, []);
+                test.assertTrue(iterator.hasStarted());
+                test.assertFalse(iterator.hasCurrent());
+            }
+        });
+        runner.testFunction("where()", () => {
+            runner.test("with undefined condition", (test) => {
+                const iterator = creator();
+                test.assertThrows(() => iterator.where(undefined), new PreConditionError("Expression: condition", "Expected: not undefined and not null", "Actual: undefined"));
+                test.assertFalse(iterator.hasStarted());
+                test.assertFalse(iterator.hasCurrent());
+            });
+            runner.test("with null condition", (test) => {
+                const iterator = creator();
+                test.assertThrows(() => iterator.where(null), new PreConditionError("Expression: condition", "Expected: not undefined and not null", "Actual: null"));
+                test.assertFalse(iterator.hasStarted());
+                test.assertFalse(iterator.hasCurrent());
+            });
+            runner.testGroup("with empty", () => {
+                runner.test("not started", (test) => {
+                    const iterator = creator();
+                    const result = iterator.where((value) => value !== undefined);
+                    test.assertNotUndefinedAndNotNull(result);
+                    test.assertNotSame(result, iterator);
+                    test.assertFalse(result.hasStarted());
+                    test.assertFalse(result.hasCurrent());
+                    test.assertFalse(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                    test.assertFalse(result.next().await());
+                    test.assertTrue(result.hasStarted());
+                    test.assertFalse(result.hasCurrent());
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                });
+                runner.test("started", (test) => {
+                    const iterator = creator().start().await();
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                    const result = iterator.where((value) => value !== undefined);
+                    test.assertNotUndefinedAndNotNull(result);
+                    test.assertNotSame(result, iterator);
+                    test.assertFalse(result.hasStarted());
+                    test.assertFalse(result.hasCurrent());
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                    test.assertFalse(result.next().await());
+                    test.assertTrue(result.hasStarted());
+                    test.assertFalse(result.hasCurrent());
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                });
+            });
+        });
+        runner.testFunction("map()", () => {
+            runner.test("with undefined", (test) => {
+                const iterator = creator();
+                test.assertThrows(() => iterator.map(undefined), new PreConditionError("Expression: mapping", "Expected: not undefined and not null", "Actual: undefined"));
+                test.assertFalse(iterator.hasStarted());
+                test.assertFalse(iterator.hasCurrent());
+            });
+            runner.test("with null", (test) => {
+                const iterator = creator();
+                test.assertThrows(() => iterator.map(null), new PreConditionError("Expression: mapping", "Expected: not undefined and not null", "Actual: null"));
+                test.assertFalse(iterator.hasStarted());
+                test.assertFalse(iterator.hasCurrent());
+            });
+            runner.testGroup("with empty", () => {
+                runner.test("not started", (test) => {
+                    const iterator = creator();
+                    test.assertFalse(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                    const mapIterator = iterator.map(_ => 5);
+                    test.assertFalse(mapIterator.hasStarted());
+                    test.assertFalse(mapIterator.hasCurrent());
+                    test.assertFalse(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                });
+                runner.test("started", (test) => {
+                    const iterator = creator().start().await();
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                    const mapIterator = iterator.map(_ => 5);
+                    test.assertFalse(mapIterator.hasStarted());
+                    test.assertFalse(mapIterator.hasCurrent());
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                    test.assertFalse(mapIterator.next().await());
+                    test.assertTrue(mapIterator.hasStarted());
+                    test.assertFalse(mapIterator.hasCurrent());
+                    test.assertTrue(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                });
+            });
+        });
+    });
+}
+//# sourceMappingURL=iteratorTests.js.map