@everyonesoftware/common 3.0.0 → 5.0.0

package/tests/conditionTests.ts

@@ -1,877 +0,0 @@
-import { Condition } from "../sources/condition";
-import { JavascriptIterable } from "../sources/javascript";
-import { MutableCondition } from "../sources/mutableCondition";
-import { PreConditionError } from "../sources/preConditionError";
-import { join } from "../sources/strings";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("condition.ts", () =>
-    {
-        runner.testType("Condition", () =>
-        {
-            runner.testFunction("create()", (test: Test) =>
-            {
-                const condition: MutableCondition = Condition.create();
-                test.assertNotUndefinedAndNotNull(condition);
-                test.assertThrows(() => condition.assertFalse(true),
-                    new Error([
-                        "Expected: false",
-                        "Actual: true",
-                    ].join("\n")));
-            });
-
-            runner.testFunction("assertUndefined(unknown,string?,string?)", () =>
-            {
-                runner.test("with undefined", () =>
-                {
-                    const condition: MutableCondition = Condition.create();
-                    condition.assertUndefined(undefined, "fake-expression", "fake-message");
-                });
-
-                function assertUndefinedErrorTest(value: unknown, expected: Error): void
-                {
-                    runner.test(`with ${runner.toString(value)}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertUndefined(value), expected);
-                    });
-                }
-
-                assertUndefinedErrorTest(
-                    null,
-                    new Error(join("\n", [
-                        "Expected: undefined",
-                        "Actual: null",
-                    ])));
-                assertUndefinedErrorTest(
-                    "",
-                    new Error(join("\n", [
-                        "Expected: undefined",
-                        "Actual: \"\"",
-                    ])));
-                assertUndefinedErrorTest(
-                    50,
-                    new Error(join("\n", [
-                        "Expected: undefined",
-                        "Actual: 50",
-                    ])));
-            });
-
-            runner.testFunction("assertNotUndefinedAndNotNull<T>(undefined|null|T,string?,string?)", () =>
-            {
-                runner.test("with undefined", (test: Test) =>
-                {
-                    const condition: MutableCondition = Condition.create();
-                    test.assertThrows(() => condition.assertNotUndefinedAndNotNull(undefined),
-                        new Error([
-                            "Expected: not undefined and not null",
-                            "Actual: undefined",
-                        ].join("\n")));
-                });
-
-                runner.test("with null", (test: Test) =>
-                {
-                    const condition: MutableCondition = Condition.create();
-                    test.assertThrows(() => condition.assertNotUndefinedAndNotNull(null),
-                        new Error([
-                            "Expected: not undefined and not null",
-                            "Actual: null",
-                        ].join("\n")));
-                });
-
-                runner.test("with not undefined and not null", (test: Test) =>
-                {
-                    function valueCreator(): string | undefined
-                    {
-                        return "hello";
-                    }
-
-                    const condition: MutableCondition = Condition.create();
-                    const value: string | undefined = valueCreator();
-                    condition.assertNotUndefinedAndNotNull(value);
-                    test.assertEqual(value.substring(1, 3), "el");
-                });
-
-                runner.test("with undefined and expression", (test: Test) =>
-                {
-                    const condition: MutableCondition = Condition.create();
-                    test.assertThrows(() => condition.assertNotUndefinedAndNotNull(undefined, "fake-expression"),
-                        new Error([
-                            "Expression: fake-expression",
-                            "Expected: not undefined and not null",
-                            "Actual: undefined"
-                        ].join("\n")));
-                });
-
-                runner.test("with null, expression, and message", (test: Test) =>
-                {
-                    const condition: MutableCondition = Condition.create();
-                    test.assertThrows(() => condition.assertNotUndefinedAndNotNull(null, "fake-expression", "fake-message"),
-                        new Error([
-                            "Message: fake-message",
-                            "Expression: fake-expression",
-                            "Expected: not undefined and not null",
-                            "Actual: null"
-                        ].join("\n")));
-                });
-            });
-
-            runner.testFunction("assertTrue(boolean)", () =>
-            {
-                runner.test("with false", (test: Test) =>
-                {
-                    const condition: MutableCondition = Condition.create();
-                    test.assertThrows(() => condition.assertTrue(false),
-                        new Error([
-                            "Expected: true",
-                            "Actual: false",
-                        ].join("\n")));
-                });
-
-                runner.test("with true", (test: Test) =>
-                {
-                    function valueCreator(): boolean { return true; }
-                    const condition: MutableCondition = Condition.create();
-                    const value: boolean = valueCreator();
-                    condition.assertTrue(value);
-                    test.assertTrue(value);
-                });
-            });
-
-            runner.testFunction("assertFalse(boolean)", () =>
-            {
-                runner.test("with true", (test: Test) =>
-                {
-                    const condition: MutableCondition = Condition.create();
-                    test.assertThrows(() => condition.assertFalse(true),
-                        new Error([
-                            "Expected: false",
-                            "Actual: true",
-                        ].join("\n")));
-                });
-
-                runner.test("with false", (test: Test) =>
-                {
-                    function valueCreator(): boolean { return false; }
-                    const condition: MutableCondition = Condition.create();
-                    const value: boolean = valueCreator();
-                    condition.assertFalse(value);
-                    test.assertFalse(value);
-                });
-            });
-
-            runner.testFunction("assertSame<T>(T,T,string?,string?)", () =>
-            {
-                function assertSameErrorTest<T>(expected: T, actual: T, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([expected, actual, expression, message])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertSame(expected, actual, expression, message), expectedError);
-                    });
-                }
-                
-                assertSameErrorTest(
-                    undefined,
-                    null,
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: undefined",
-                        "Actual: null",
-                    ])));
-                assertSameErrorTest(
-                    3,
-                    4,
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: 3",
-                        "Actual: 4",
-                    ])));
-                assertSameErrorTest(
-                    {},
-                    {},
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: {}",
-                        "Actual: {}",
-                    ])));
-                assertSameErrorTest(
-                    { "a": "b" },
-                    { "a": "b" },
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: {\"a\":\"b\"}",
-                        "Actual: {\"a\":\"b\"}",
-                    ])));
-                assertSameErrorTest(
-                    [],
-                    [],
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: []",
-                        "Actual: []",
-                    ])));
-
-                function assertSameTest<T>(expected: T, actual: T, expression: string | undefined, message: string | undefined): void
-                {
-                    runner.test(`with ${runner.andList([expected, actual, expression, message])}`, (_test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertSame(expected, actual, expression, message);
-                    });
-                }
-
-                assertSameTest(undefined, undefined, "fake-expression", "fake-message");
-                assertSameTest(null, null, "fake-expression", "fake-message");
-                assertSameTest(0, 0, "fake-expression", "fake-message");
-                assertSameTest(10, 10, "fake-expression", "fake-message");
-                assertSameTest(true, true, "fake-expression", "fake-message");
-                assertSameTest("abc", "abc", "fake-expression", "fake-message");
-                
-                const o = {};
-                assertSameTest(o, o, "fake-expression", "fake-message");
-            });
-
-            runner.testFunction("assertNotSame<T>(T,T,string?,string?)", () =>
-            {
-                function assertNotSameErrorTest<T>(expected: T, actual: T, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([expected, actual, expression, message])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertNotSame(expected, actual, expression, message), expectedError);
-                    });
-                }
-
-                assertNotSameErrorTest(
-                    undefined,
-                    undefined,
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: not undefined",
-                        "Actual: undefined",
-                    ])));
-                assertNotSameErrorTest(
-                    null,
-                    null,
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: not null",
-                        "Actual: null",
-                    ])));
-                assertNotSameErrorTest(
-                    0,
-                    0,
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: not 0",
-                        "Actual: 0",
-                    ])));
-                assertNotSameErrorTest(
-                    10,
-                    10,
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: not 10",
-                        "Actual: 10",
-                    ])));
-                assertNotSameErrorTest(
-                    true,
-                    true,
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: not true",
-                        "Actual: true",
-                    ])));
-                assertNotSameErrorTest(
-                    "abc",
-                    "abc",
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: not \"abc\"",
-                        "Actual: \"abc\"",
-                    ])));
-                
-                const o = {};
-                assertNotSameErrorTest(
-                    o,
-                    o,
-                    "fake-expression",
-                    "fake-message",
-                    new Error(join("\n", [
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: not {}",
-                        "Actual: {}",
-                    ])));
-
-                function assertNotSameTest<T>(expected: T, actual: T, expression: string | undefined, message: string | undefined): void
-                {
-                    runner.test(`with ${runner.andList([expected, actual, expression, message])}`, (_test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertNotSame(expected, actual, expression, message);
-                    });
-                }
-
-                assertNotSameTest(undefined, null, "fake-expression", "fake-message");
-                assertNotSameTest(false, true, "fake-expression", "fake-message");
-                assertNotSameTest(1, 2, "fake-expression", "fake-message");
-                assertNotSameTest({}, {}, "fake-expression", "fake-message");
-                assertNotSameTest({ "a": "b" }, { "a": "b" }, "fake-expression", "fake-message");
-                assertNotSameTest([], [], "fake-expression", "fake-message");
-            });
-
-            runner.testFunction("assertNotEmpty(string,string?,string?)", () =>
-            {
-                function assertNotEmptyErrorTest(value: string, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([value, expression, message])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertNotEmpty(value, expression, message), expectedError);
-                    });
-                }
-
-                assertNotEmptyErrorTest(undefined!, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: not undefined and not null",
-                    "Actual: undefined",
-                ])));
-                assertNotEmptyErrorTest(null!, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: not undefined and not null",
-                    "Actual: null",
-                ])));
-                assertNotEmptyErrorTest("", "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: not empty",
-                    "Actual: \"\"",
-                ])));
-
-                function assertNotEmptyTest(value: string, expression: string | undefined, message: string | undefined): void
-                {
-                    runner.test(`with ${runner.andList([value, expression, message])}`, (_test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertNotEmpty(value, expression, message);
-                    });
-                }
-
-                assertNotEmptyTest(" ", "fake-expression", "fake-message");
-                assertNotEmptyTest("a", "fake-expression", "fake-message");
-            });
-
-            runner.testFunction("assertLessThan(number,number,string?,string?)", () =>
-            {
-                function assertLessThanErrorTest(value: number, upperBound: number, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([value, upperBound])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertLessThan(value, upperBound, expression, message), expectedError);
-                    });
-                }
-
-                assertLessThanErrorTest(-1, -1, undefined, undefined, new Error(join("\n", [
-                    "Expected: less than -1",
-                    "Actual: -1",
-                ])));
-                assertLessThanErrorTest(0, 0, undefined, undefined, new Error(join("\n", [
-                    "Expected: less than 0",
-                    "Actual: 0",
-                ])));
-                assertLessThanErrorTest(2, 1, undefined, undefined, new Error(join("\n", [
-                    "Expected: less than 1",
-                    "Actual: 2",
-                ])));
-                assertLessThanErrorTest(2, 1, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: less than 1",
-                    "Actual: 2",
-                ])));
-
-                function assertLessThanTest(value: number, upperBound: number, expression?: string, message?: string): void
-                {
-                    runner.test(`with ${runner.andList([value, upperBound])}`, () =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertLessThan(value, upperBound, expression, message);
-                    });
-                }
-
-                assertLessThanTest(-10, -9);
-                assertLessThanTest(-1, 0);
-                assertLessThanTest(0, 1);
-                assertLessThanTest(4, 5);
-            });
-
-            runner.testFunction("assertLessThanOrEqualTo(number,number,string?,string?)", () =>
-            {
-                function assertLessThanOrEqualToErrorTest(value: number, upperBound: number, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([value, upperBound])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertLessThanOrEqualTo(value, upperBound, expression, message), expectedError);
-                    });
-                }
-
-                assertLessThanOrEqualToErrorTest(2, 1, undefined, undefined, new Error(join("\n", [
-                    "Expected: less than or equal to 1",
-                    "Actual: 2",
-                ])));
-                assertLessThanOrEqualToErrorTest(2, 1, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: less than or equal to 1",
-                    "Actual: 2",
-                ])));
-
-                function assertLessThanOrEqualToTest(value: number, upperBound: number, expression: string | undefined, message: string | undefined): void
-                {
-                    runner.test(`with ${runner.andList([value, upperBound])}`, () =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertLessThanOrEqualTo(value, upperBound, expression, message);
-                    });
-                }
-
-                assertLessThanOrEqualToTest(-10, -9, undefined, undefined);
-                assertLessThanOrEqualToTest(-1, 0, undefined, undefined);
-                assertLessThanOrEqualToTest(0, 1, undefined, undefined);
-                assertLessThanOrEqualToTest(4, 5, undefined, undefined);
-                assertLessThanOrEqualToTest(-1, -1, undefined, undefined);
-                assertLessThanOrEqualToTest(0, 0, undefined, undefined);
-                assertLessThanOrEqualToTest(1, 1, undefined, undefined);
-            });
-
-            runner.testFunction("assertGreaterThanOrEqualTo(number,number,string?,string?)", () =>
-            {
-                function assertGreaterThanOrEqualToErrorTest(value: number, lowerBound: number, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([value, lowerBound])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertGreaterThanOrEqualTo(value, lowerBound, expression, message), expectedError);
-                    });
-                }
-
-                assertGreaterThanOrEqualToErrorTest(1, 2, undefined, undefined, new Error(join("\n", [
-                    "Expected: greater than or equal to 2",
-                    "Actual: 1",
-                ])));
-                assertGreaterThanOrEqualToErrorTest(1, 2, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: greater than or equal to 2",
-                    "Actual: 1",
-                ])));
-
-                function assertGreaterThanOrEqualToTest(value: number, lowerBound: number, expression?: string, message?: string): void
-                {
-                    runner.test(`with ${runner.andList([value, lowerBound])}`, (_test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertGreaterThanOrEqualTo(value, lowerBound, expression, message);
-                    });
-                }
-
-                assertGreaterThanOrEqualToTest(-9, -10);
-                assertGreaterThanOrEqualToTest(0, -1);
-                assertGreaterThanOrEqualToTest(1, 0);
-                assertGreaterThanOrEqualToTest(5, 4);
-                assertGreaterThanOrEqualToTest(-1, -1);
-                assertGreaterThanOrEqualToTest(0, 0);
-                assertGreaterThanOrEqualToTest(1, 1);
-            });
-
-            runner.testFunction("assertGreaterThan(number,number,string?,string?)", () =>
-            {
-                function assertGreaterThanErrorTest(value: number, lowerBound: number, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([value, lowerBound])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertGreaterThan(value, lowerBound, expression, message), expectedError);
-                    });
-                }
-
-                assertGreaterThanErrorTest(-1, -1, undefined, undefined, new Error(join("\n", [
-                    "Expected: greater than -1",
-                    "Actual: -1",
-                ])));
-                assertGreaterThanErrorTest(0, 0, undefined, undefined, new Error(join("\n", [
-                    "Expected: greater than 0",
-                    "Actual: 0",
-                ])));
-                assertGreaterThanErrorTest(1, 2, undefined, undefined, new Error(join("\n", [
-                    "Expected: greater than 2",
-                    "Actual: 1",
-                ])));
-                assertGreaterThanErrorTest(1, 2, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: greater than 2",
-                    "Actual: 1",
-                ])));
-
-                function assertGreaterThanTest(value: number, lowerBound: number, expression?: string, message?: string): void
-                {
-                    runner.test(`with ${runner.andList([value, lowerBound])}`, (_test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertGreaterThan(value, lowerBound, expression, message);
-                    });
-                }
-
-                assertGreaterThanTest(-9, -10);
-                assertGreaterThanTest(0, -1);
-                assertGreaterThanTest(1, 0);
-                assertGreaterThanTest(5, 4);
-            });
-
-            runner.testFunction("assertBetween(number,number,number,string?,string?)", () =>
-            {
-                function assertBetweenErrorTest(lowerBound: number, value: number, upperBound: number, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([lowerBound, value, upperBound])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertBetween(lowerBound, value, upperBound, expression, message), expectedError);
-                    });
-                }
-
-                assertBetweenErrorTest(0, 1, 0, undefined, undefined, new Error(join("\n", [
-                    "Expected: 0",
-                    "Actual: 1",
-                ])));
-                assertBetweenErrorTest(0, -1, 0, undefined, undefined, new Error(join("\n", [
-                    "Expected: 0",
-                    "Actual: -1",
-                ])));
-                assertBetweenErrorTest(0, -1, 2, undefined, undefined, new Error(join("\n", [
-                    "Expected: between 0 and 2",
-                    "Actual: -1",
-                ])));
-                assertBetweenErrorTest(0, 3, 2, undefined, undefined, new Error(join("\n", [
-                    "Expected: between 0 and 2",
-                    "Actual: 3",
-                ])));
-                assertBetweenErrorTest(5, 3, 2, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Expression: lowerBound",
-                    "Expected: less than or equal to 2",
-                    "Actual: 5",
-                ])));
-
-                function assertBetweenTest(lowerBound: number, value: number, upperBound: number, expression?: string, message?: string): void
-                {
-                    runner.test(`with ${runner.andList([lowerBound, value, upperBound])}`, () =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertBetween(lowerBound, value, upperBound, expression, message);
-                    });
-                }
-
-                assertBetweenTest(-12, -11, -10);
-                assertBetweenTest(-1, 0, 1);
-                assertBetweenTest(0, 1, 2);
-                assertBetweenTest(4, 5, 6);
-                assertBetweenTest(0, 0, 0);
-                assertBetweenTest(1, 1, 1);
-            });
-
-            runner.testFunction("assertAccessIndex(number,number,string?,string?)", () =>
-            {
-                function assertAccessIndexTest(index: number, count: number, expression?: string, message?: string): void
-                {
-                    runner.test(`with ${runner.andList([index, count])}`, (_test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertAccessIndex(index, count, expression, message);
-                    });
-                }
-
-                assertAccessIndexTest(0, 1);
-                assertAccessIndexTest(0, 2);
-                assertAccessIndexTest(1, 2);
-
-                function assertAccessIndexErrorTest(index: number, count: number, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([index, count])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertAccessIndex(index, count, expression, message), expectedError);
-                    });
-                }
-
-                assertAccessIndexErrorTest(-1, 0, undefined, undefined, new Error(join("\n", [
-                    "Expression: count",
-                    "Expected: greater than or equal to 1",
-                    "Actual: 0",
-                ])));
-                assertAccessIndexErrorTest(0, 0, undefined, undefined, new Error(join("\n", [
-                    "Expression: count",
-                    "Expected: greater than or equal to 1",
-                    "Actual: 0",
-                ])));
-                assertAccessIndexErrorTest(1, 0, undefined, undefined, new Error(join("\n", [
-                    "Expression: count",
-                    "Expected: greater than or equal to 1",
-                    "Actual: 0",
-                ])));
-                assertAccessIndexErrorTest(-1, 1, undefined, undefined, new Error(join("\n", [
-                    "Expected: 0",
-                    "Actual: -1",
-                ])));
-                assertAccessIndexErrorTest(1, 1, undefined, undefined, new Error(join("\n", [
-                    "Expected: 0",
-                    "Actual: 1",
-                ])));
-                assertAccessIndexErrorTest(-1, 2, undefined, undefined, new Error(join("\n", [
-                    "Expected: between 0 and 1",
-                    "Actual: -1",
-                ])));
-                assertAccessIndexErrorTest(1, 1, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: 0",
-                    "Actual: 1",
-                ])));
-                assertAccessIndexErrorTest(3, 2, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: between 0 and 1",
-                    "Actual: 3",
-                ])));
-            });
-
-            runner.testFunction("assertInsertIndex(number,number,string?,string?)", () =>
-            {
-                function assertInsertIndexErrorTest(index: number, count: number, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([index, count])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertInsertIndex(index, count, expression, message), expectedError);
-                    });
-                }
-
-                assertInsertIndexErrorTest(-1, 0, undefined, undefined, new Error(join("\n", [
-                    "Expected: 0",
-                    "Actual: -1",
-                ])));
-                assertInsertIndexErrorTest(1, 0, undefined, undefined, new Error(join("\n", [
-                    "Expected: 0",
-                    "Actual: 1",
-                ])));
-                assertInsertIndexErrorTest(-1, 1, undefined, undefined, new Error(join("\n", [
-                    "Expected: between 0 and 1",
-                    "Actual: -1",
-                ])));
-                assertInsertIndexErrorTest(2, 1, undefined, undefined, new Error(join("\n", [
-                    "Expected: between 0 and 1",
-                    "Actual: 2",
-                ])));
-                assertInsertIndexErrorTest(-1, 2, undefined, undefined, new Error(join("\n", [
-                    "Expected: between 0 and 2",
-                    "Actual: -1",
-                ])));
-                assertInsertIndexErrorTest(2, 1, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: between 0 and 1",
-                    "Actual: 2",
-                ])));
-                assertInsertIndexErrorTest(3, 2, "fake-expression", "fake-message", new Error(join("\n", [
-                    "Message: fake-message",
-                    "Expression: fake-expression",
-                    "Expected: between 0 and 2",
-                    "Actual: 3",
-                ])));
-
-                function assertInsertIndexTest(index: number, count: number, expression?: string, message?: string): void
-                {
-                    runner.test(`with ${runner.andList([index, count])}`, (_test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertInsertIndex(index, count, expression, message);
-                    });
-                }
-
-                assertInsertIndexTest(0, 0);
-                assertInsertIndexTest(0, 1);
-                assertInsertIndexTest(1, 1);
-                assertInsertIndexTest(0, 2);
-                assertInsertIndexTest(1, 2);
-                assertInsertIndexTest(2, 2);
-            });
-
-            runner.testFunction("assertOneOf<T>(JavascriptIterable<T>,T,string?,string?)", () =>
-            {
-                function assertOneOfErrorTest<T>(possibilities: JavascriptIterable<T>, value: T, expression: string | undefined, message: string | undefined, expectedError: Error): void
-                {
-                    runner.test(`with ${runner.andList([possibilities, value, expression, message])}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertOneOf(possibilities, value, expression, message), expectedError);
-                    });
-                }
-
-                assertOneOfErrorTest(
-                    undefined!,
-                    5,
-                    undefined,
-                    undefined,
-                    new PreConditionError(
-                        "Expression: possibilities",
-                        "Expected: not undefined and not null",
-                        "Actual: undefined",
-                    ));
-                assertOneOfErrorTest(
-                    null!,
-                    5,
-                    undefined,
-                    undefined,
-                    new PreConditionError(
-                        "Expression: possibilities",
-                        "Expected: not undefined and not null",
-                        "Actual: null",
-                    ));
-                assertOneOfErrorTest(
-                    [],
-                    5,
-                    undefined,
-                    undefined,
-                    new PreConditionError(
-                        "Expected: one of []",
-                        "Actual: 5",
-                    ));
-                assertOneOfErrorTest(
-                    [],
-                    5,
-                    "fake-expression",
-                    "fake-message",
-                    new PreConditionError(
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: one of []",
-                        "Actual: 5",
-                    ));
-                assertOneOfErrorTest(
-                    [1, 2, 3],
-                    5,
-                    "fake-expression",
-                    "fake-message",
-                    new PreConditionError(
-                        "Message: fake-message",
-                        "Expression: fake-expression",
-                        "Expected: one of [1,2,3]",
-                        "Actual: 5",
-                    ));
-
-                function assertOneOfTest<T>(possibilities: JavascriptIterable<T>, value: T, expression?: string, message?: string): void
-                {
-                    runner.test(`with ${runner.andList([possibilities, value, expression, message])}`, (_test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertOneOf(possibilities, value, expression, message);
-                    });
-                }
-
-                assertOneOfTest([5], 5);
-                assertOneOfTest([1, 3, 5, 7], 5);
-            });
-
-            runner.testFunction("assertInteger(number,string?,string?)", () =>
-            {
-                function assertIntegerErrorTest(value: number, expected: Error): void
-                {
-                    runner.test(`with ${runner.toString(value)}`, (test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        test.assertThrows(() => condition.assertInteger(value), expected);
-                    });
-                }
-
-                assertIntegerErrorTest(
-                    1.2,
-                    new Error(join("\n", [
-                        "Expected: integer",
-                        "Actual: 1.2",
-                    ])));
-                assertIntegerErrorTest(
-                    NaN,
-                    new Error(join("\n", [
-                        "Expected: integer",
-                        "Actual: NaN",
-                    ])));
-                assertIntegerErrorTest(
-                    Infinity,
-                    new Error(join("\n", [
-                        "Expected: integer",
-                        "Actual: Infinity",
-                    ])));
-                assertIntegerErrorTest(
-                    -Infinity,
-                    new Error(join("\n", [
-                        "Expected: integer",
-                        "Actual: -Infinity",
-                    ])));
-
-                function assertIntegerTest(value: number): void
-                {
-                    runner.test(`with ${value}`, (_test: Test) =>
-                    {
-                        const condition: MutableCondition = Condition.create();
-                        condition.assertInteger(value);
-                    });
-                }
-
-                assertIntegerTest(-1);
-                assertIntegerTest(0);
-                assertIntegerTest(1);
-            });
-        });
-    });
-}