@everyonesoftware/common 13.0.0 → 14.0.0

package/outputs/tests/conditionTests.js

@@ -0,0 +1,602 @@
+import { Condition } from "../sources/condition.js";
+import { PreConditionError } from "../sources/preConditionError.js";
+import { join } from "../sources/strings.js";
+export function test(runner) {
+    runner.testFile("condition.ts", () => {
+        runner.testType("Condition", () => {
+            runner.testFunction("create()", (test) => {
+                const condition = 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 = Condition.create();
+                    condition.assertUndefined(undefined, "fake-expression", "fake-message");
+                });
+                function assertUndefinedErrorTest(value, expected) {
+                    runner.test(`with ${runner.toString(value)}`, (test) => {
+                        const condition = 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) => {
+                    const condition = Condition.create();
+                    test.assertThrows(() => condition.assertNotUndefinedAndNotNull(undefined), new Error([
+                        "Expected: not undefined and not null",
+                        "Actual: undefined",
+                    ].join("\n")));
+                });
+                runner.test("with null", (test) => {
+                    const condition = 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) => {
+                    function valueCreator() {
+                        return "hello";
+                    }
+                    const condition = Condition.create();
+                    const value = valueCreator();
+                    condition.assertNotUndefinedAndNotNull(value);
+                    test.assertEqual(value.substring(1, 3), "el");
+                });
+                runner.test("with undefined and expression", (test) => {
+                    const condition = 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) => {
+                    const condition = 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) => {
+                    const condition = Condition.create();
+                    test.assertThrows(() => condition.assertTrue(false), new Error([
+                        "Expected: true",
+                        "Actual: false",
+                    ].join("\n")));
+                });
+                runner.test("with true", (test) => {
+                    function valueCreator() { return true; }
+                    const condition = Condition.create();
+                    const value = valueCreator();
+                    condition.assertTrue(value);
+                    test.assertTrue(value);
+                });
+            });
+            runner.testFunction("assertFalse(boolean)", () => {
+                runner.test("with true", (test) => {
+                    const condition = Condition.create();
+                    test.assertThrows(() => condition.assertFalse(true), new Error([
+                        "Expected: false",
+                        "Actual: true",
+                    ].join("\n")));
+                });
+                runner.test("with false", (test) => {
+                    function valueCreator() { return false; }
+                    const condition = Condition.create();
+                    const value = valueCreator();
+                    condition.assertFalse(value);
+                    test.assertFalse(value);
+                });
+            });
+            runner.testFunction("assertSame<T>(T,T,string?,string?)", () => {
+                function assertSameErrorTest(expected, actual, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([expected, actual, expression, message])}`, (test) => {
+                        const condition = 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(expected, actual, expression, message) {
+                    runner.test(`with ${runner.andList([expected, actual, expression, message])}`, (_test) => {
+                        const condition = 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(expected, actual, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([expected, actual, expression, message])}`, (test) => {
+                        const condition = 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(expected, actual, expression, message) {
+                    runner.test(`with ${runner.andList([expected, actual, expression, message])}`, (_test) => {
+                        const condition = 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, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([value, expression, message])}`, (test) => {
+                        const condition = 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, expression, message) {
+                    runner.test(`with ${runner.andList([value, expression, message])}`, (_test) => {
+                        const condition = 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, upperBound, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([value, upperBound])}`, (test) => {
+                        const condition = 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, upperBound, expression, message) {
+                    runner.test(`with ${runner.andList([value, upperBound])}`, () => {
+                        const condition = 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, upperBound, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([value, upperBound])}`, (test) => {
+                        const condition = 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, upperBound, expression, message) {
+                    runner.test(`with ${runner.andList([value, upperBound])}`, () => {
+                        const condition = 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, lowerBound, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([value, lowerBound])}`, (test) => {
+                        const condition = 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, lowerBound, expression, message) {
+                    runner.test(`with ${runner.andList([value, lowerBound])}`, (_test) => {
+                        const condition = 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, lowerBound, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([value, lowerBound])}`, (test) => {
+                        const condition = 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, lowerBound, expression, message) {
+                    runner.test(`with ${runner.andList([value, lowerBound])}`, (_test) => {
+                        const condition = 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, value, upperBound, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([lowerBound, value, upperBound])}`, (test) => {
+                        const condition = 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, value, upperBound, expression, message) {
+                    runner.test(`with ${runner.andList([lowerBound, value, upperBound])}`, () => {
+                        const condition = 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, count, expression, message) {
+                    runner.test(`with ${runner.andList([index, count])}`, (_test) => {
+                        const condition = Condition.create();
+                        condition.assertAccessIndex(index, count, expression, message);
+                    });
+                }
+                assertAccessIndexTest(0, 1);
+                assertAccessIndexTest(0, 2);
+                assertAccessIndexTest(1, 2);
+                function assertAccessIndexErrorTest(index, count, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([index, count])}`, (test) => {
+                        const condition = 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, count, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([index, count])}`, (test) => {
+                        const condition = 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, count, expression, message) {
+                    runner.test(`with ${runner.andList([index, count])}`, (_test) => {
+                        const condition = 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(possibilities, value, expression, message, expectedError) {
+                    runner.test(`with ${runner.andList([possibilities, value, expression, message])}`, (test) => {
+                        const condition = 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(possibilities, value, expression, message) {
+                    runner.test(`with ${runner.andList([possibilities, value, expression, message])}`, (_test) => {
+                        const condition = 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, expected) {
+                    runner.test(`with ${runner.toString(value)}`, (test) => {
+                        const condition = 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) {
+                    runner.test(`with ${value}`, (_test) => {
+                        const condition = Condition.create();
+                        condition.assertInteger(value);
+                    });
+                }
+                assertIntegerTest(-1);
+                assertIntegerTest(0);
+                assertIntegerTest(1);
+            });
+        });
+    });
+}
+//# sourceMappingURL=conditionTests.js.map