@everyonesoftware/common 2.0.0 → 4.0.0

package/tests/propertyTests.ts

@@ -1,63 +0,0 @@
-import { Property } from "../sources/property";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("property.ts", () =>
-    {
-        runner.testType("Property<T>", () =>
-        {
-            runner.testFunction("create()", () =>
-            {
-                runner.test("with initialValue", (test: Test) =>
-                {
-                    const property: Property<number> = Property.create(5);
-                    test.assertEqual(5, property.getValue());
-                    
-                    const setResult: Property<number> = property.setValue(20);
-                    test.assertSame(property, setResult);
-                    test.assertEqual(20, property.getValue());
-                    
-                    test.assertEqual("20", property.toString());
-                });
-
-                runner.test("with getter and setter functions", (test: Test) =>
-                {
-                    let propertyValue: string = "hello";
-
-                    const property: Property<string> = Property.create(
-                        () => propertyValue,
-                        (value: string) => { propertyValue = value; },
-                    );
-                    test.assertEqual("hello", property.getValue());
-                    
-                    const setResult: Property<string> = property.setValue("there");
-                    test.assertSame(property, setResult);
-                    test.assertEqual("there", property.getValue());
-                    test.assertEqual("there", propertyValue);
-                    
-                    test.assertEqual("there", property.toString());
-                });
-
-                runner.test("with options", (test: Test) =>
-                {
-                    let propertyValue: string = "hello";
-
-                    const property: Property<string> = Property.create({
-                        getter: () => propertyValue,
-                        setter: (value: string) => { propertyValue = value; },
-                    });
-                    test.assertEqual("hello", property.getValue());
-                    
-                    const setResult: Property<string> = property.setValue("there");
-                    test.assertSame(property, setResult);
-                    test.assertEqual("there", property.getValue());
-                    test.assertEqual("there", propertyValue);
-                    
-                    test.assertEqual("there", property.toString());
-                });
-            });
-        });
-    });
-}

package/tests/queueTests.ts

@@ -1,29 +0,0 @@
-import { EmptyError } from "../sources/emptyError";
-import { ListQueue } from "../sources/listQueue";
-import { Queue } from "../sources/queue";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("queue.ts", () =>
-    {
-        runner.testType("Queue<T>", () =>
-        {
-            runner.testFunction("create()", (test: Test) =>
-            {
-                const queue: ListQueue<number> = Queue.create();
-                test.assertNotUndefinedAndNotNull(queue);
-                test.assertFalse(queue.any().await());
-                test.assertThrows(() => queue.remove().await(), new EmptyError());
-            });
-
-            runner.testFunction("add()", (test: Test) =>
-            {
-                const queue: ListQueue<number> = Queue.create();
-                queue.add(20).await();
-                test.assertEqual(20, queue.remove().await());
-            });
-        });
-    });
-}

package/tests/recreationDotGovClientTests.ts

@@ -1,191 +0,0 @@
-import { HttpClient } from "../sources/httpClient";
-import { PreConditionError } from "../sources/preConditionError";
-import { RecreationDotGovClient, RecreationDotGovDivisionAvailability, RecreationDotGovDivisionAvailabilityJson, RecreationDotGovError, RecreationDotGovPermitItineraryJson } from "../sources/recreationDotGovClient";
-import { WonderlandTrailClient, WonderlandTrailLocations } from "../sources/wonderlandTrailClient";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-import { hasNetworkAccess } from "./tests";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("recreationDotGovClient.ts", () =>
-    {
-        runner.testType("RecreationDotGovClient", () =>
-        {
-            runner.testFunction("create()", () =>
-            {
-                function createErrorTest(httpClient: HttpClient, expected: Error): void
-                {
-                    runner.test(`with ${runner.toString(httpClient)}`, (test: Test) =>
-                    {
-                        test.assertThrows(() => RecreationDotGovClient.create(httpClient), expected);
-                    });
-                }
-
-                createErrorTest(undefined!, new PreConditionError(
-                    "Expression: httpClient",
-                    "Expected: not undefined and not null",
-                    "Actual: undefined",
-                ));
-                createErrorTest(null!, new PreConditionError(
-                    "Expression: httpClient",
-                    "Expected: not undefined and not null",
-                    "Actual: null",
-                ));
-
-                runner.test("with default HttpClient", (test: Test) =>
-                {
-                    const httpClient: HttpClient = HttpClient.create();
-                    const recreationDotGovClient: RecreationDotGovClient = RecreationDotGovClient.create(httpClient);
-                    test.assertNotUndefinedAndNotNull(recreationDotGovClient);
-                });
-            });
-
-            runner.testFunction("getPermitItinerary()", () =>
-            {
-                function getPermitItineraryErrorTest(itineraryId: string, expected: Error): void
-                {
-                    runner.test(`with ${runner.toString(itineraryId)}`, async (test: Test) =>
-                    {
-                        const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
-                        await test.assertThrowsAsync(async () => await client.getPermitItinerary(itineraryId), expected);
-                    });
-                }
-
-                getPermitItineraryErrorTest(undefined!, new PreConditionError(
-                    "Expression: permitItineraryId",
-                    "Expected: not undefined and not null",
-                    "Actual: undefined",
-                ));
-                getPermitItineraryErrorTest(null!, new PreConditionError(
-                    "Expression: permitItineraryId",
-                    "Expected: not undefined and not null",
-                    "Actual: null",
-                ));
-                getPermitItineraryErrorTest("", new PreConditionError(
-                    "Expression: permitItineraryId",
-                    "Expected: not empty",
-                    "Actual: \"\"",
-                ));
-
-                runner.test("with invalid permit itinerary id", runner.skip(!hasNetworkAccess), async (test: Test) =>
-                {
-                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
-                    await test.assertThrowsAsync(
-                        async () => await client.getPermitItinerary("oopsie!"),
-                        new RecreationDotGovError(
-                            `No permit itinerary found for id: "oopsie!"`,
-                        ),
-                    );
-                });
-
-                runner.test("with valid permit itinerary id", runner.skip(!hasNetworkAccess), async (test: Test) =>
-                {
-                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
-                    const result: RecreationDotGovPermitItineraryJson = await client.getPermitItinerary(WonderlandTrailClient.permitItineraryId);
-                    test.assertNotUndefinedAndNotNull(result);
-                    test.assertEqual(result.id, WonderlandTrailClient.permitItineraryId);
-                    test.assertEqual(result.name, "Mount Rainier National Park Wilderness and Climbing Permits");
-                    test.assertNotUndefinedAndNotNull(result.divisions);
-                    test.assertTrue(Object.keys(result.divisions).length > 0);
-                    for (const division of Object.values(result.divisions))
-                    {
-                        test.assertNotUndefinedAndNotNull(division.id);
-                        test.assertNotUndefinedAndNotNull(division.district);
-                        test.assertNotUndefinedAndNotNull(division.name);
-                        test.assertNotUndefinedAndNotNull(division.type);
-                    }
-                });
-            });
-
-            runner.testFunction("getDivisionAvailability()", () =>
-            {
-                function getDivisionAvailabilityErrorTest(itineraryId: string, divisionId: string, month: number, year: number, expected: Error): void
-                {
-                    runner.test(`with ${runner.andList([itineraryId, divisionId, month, year])}`, async (test: Test) =>
-                    {
-
-                    });
-                }
-
-                getDivisionAvailabilityErrorTest(undefined!, "fake-division-id", 5, 2026, new PreConditionError(
-                    "Expression: permitItineraryId",
-                    "Expected: not undefined and not null",
-                    "Actual: undefined",
-                ));
-                getDivisionAvailabilityErrorTest(null!, "fake-division-id", 5, 2026, new PreConditionError(
-                    "Expression: permitItineraryId",
-                    "Expected: not undefined and not null",
-                    "Actual: null",
-                ));
-                getDivisionAvailabilityErrorTest("", "fake-division-id", 5, 2026, new PreConditionError(
-                    "Expression: permitItineraryId",
-                    "Expected: not empty",
-                    "Actual: \"\"",
-                ));
-                getDivisionAvailabilityErrorTest("oopsie!", "fake-division-id", 5, 2026, new RecreationDotGovError(
-                    `No permit itinerary found for id: "oopsie!"`,
-                ));
-
-                runner.test("with invalid division id", runner.skip(!hasNetworkAccess), async (test: Test) =>
-                {
-                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
-                    const itineraryId: string = WonderlandTrailClient.permitItineraryId;
-                    const divisionId: string = "fake-division-id";
-                    const month: number = 5;
-                    const year: number = 2026;
-                    const earlyAccessPermitLotteryId: string = "";
-                    
-                    const response: RecreationDotGovDivisionAvailability = await client.getDivisionAvailability(itineraryId, divisionId, month, year, earlyAccessPermitLotteryId);
-
-                    test.assertNotUndefinedAndNotNull(response);
-                    test.assertNotUndefinedAndNotNull(response.json);
-                    test.assertNotUndefinedAndNotNull(response.dayAvailabilities);
-                    test.assertEqual(0, response.dayAvailabilities.getCount().await());
-                    test.assertUndefined(response.maximumGroupSize);
-                    test.assertUndefined(response.minimumGroupSize);
-                });
-
-                runner.test("with Sunrise Camp division id", runner.skip(!hasNetworkAccess), async (test: Test) =>
-                {
-                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
-
-                    const itineraryId: string = WonderlandTrailClient.permitItineraryId;
-                    const divisionId: string = WonderlandTrailLocations.sunriseCamp.divisionId;
-                    const month: number = 8;
-                    const year: number = 2026;
-                    const earlyAccessPermitLotteryId: string = "";
-                    
-                    const response: RecreationDotGovDivisionAvailability = await client.getDivisionAvailability(itineraryId, divisionId, month, year, earlyAccessPermitLotteryId);
-
-                    test.assertNotUndefinedAndNotNull(response);
-                    test.assertNotUndefinedAndNotNull(response.json);
-                    test.assertNotUndefinedAndNotNull(response.dayAvailabilities);
-                    test.assertEqual(31, response.dayAvailabilities.getCount().await());
-                    test.assertNotUndefinedAndNotNull(response.maximumGroupSize);
-                    test.assertNotUndefinedAndNotNull(response.minimumGroupSize);
-                });
-
-                runner.test("with Indian Bar division id", runner.skip(!hasNetworkAccess), async (test: Test) =>
-                {
-                    const client: RecreationDotGovClient = RecreationDotGovClient.create(HttpClient.create());
-
-                    const itineraryId: string = WonderlandTrailClient.permitItineraryId;
-                    const divisionId: string = WonderlandTrailLocations.indianBar.divisionId;
-                    const month: number = 7;
-                    const year: number = 2026;
-                    const earlyAccessPermitLotteryId: string = "";
-                    
-                    const response: RecreationDotGovDivisionAvailability = await client.getDivisionAvailability(itineraryId, divisionId, month, year, earlyAccessPermitLotteryId);
-
-                    test.assertNotUndefinedAndNotNull(response);
-                    test.assertNotUndefinedAndNotNull(response.json);
-                    test.assertNotUndefinedAndNotNull(response.dayAvailabilities);
-                    test.assertEqual(31, response.dayAvailabilities.getCount().await());
-                    test.assertNotUndefinedAndNotNull(response.maximumGroupSize);
-                    test.assertNotUndefinedAndNotNull(response.minimumGroupSize);
-                });
-            });
-        });
-    });
-}

package/tests/setTests.ts

@@ -1,140 +0,0 @@
-import { TestRunner } from "./testRunner";
-import { Set } from "../sources/set";
-import { Test } from "./test";
-import { JavascriptSetSet } from "../sources/javascriptSetSet";
-import { NotFoundError } from "../sources/notFoundError";
-import { SyncResult } from "../sources/syncResult";
-import { JavascriptIterable } from "../sources/javascript";
-import { PreCondition } from "../sources/preCondition";
-import { PreConditionError } from "../sources/preConditionError";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("set.ts", () =>
-    {
-        runner.testType("Set<T>", () =>
-        {
-            runner.testFunction("create()", (test: Test) =>
-            {
-                const set: JavascriptSetSet<number> = Set.create();
-                test.assertNotUndefinedAndNotNull(set);
-                test.assertEqual(0, set.getCount().await());
-                test.assertEqual([], set.toArray().await());
-            });
-
-            runner.testFunction("add()", (test: Test) =>
-            {
-                const set: Set<number> = Set.create();
-                for (let i = 0; i < 3; i++)
-                {
-                    const addResult: Set<number> = set.add(20);
-                    test.assertSame(set, addResult);
-                    test.assertTrue(set.contains(20).await());
-                    test.assertEqual(set.getCount().await(), 1);
-                    test.assertEqual([20], set.toArray().await());
-                }
-            });
-
-            runner.testFunction("addAll()", (test: Test) =>
-            {
-                const set: Set<number> = Set.create();
-                for (let i = 0; i < 3; i++)
-                {
-                    const addResult: Set<number> = set.addAll([20, 20, 25, 26]);
-                    test.assertSame(set, addResult);
-                    test.assertTrue(set.contains(20).await());
-                    test.assertTrue(set.contains(25).await());
-                    test.assertTrue(set.contains(26).await());
-                    test.assertEqual(set.getCount().await(), 3);
-                    test.assertEqual([20, 25, 26], set.toArray().await());
-                }
-            });
-
-            runner.testFunction("remove()", (test: Test) =>
-            {
-                const set: Set<number> = Set.create();
-
-                test.assertThrows(set.remove(15), new NotFoundError("Could not find 15."));
-
-                set.add(16);
-                const removeResult: SyncResult<void> = set.remove(16);
-                test.assertNotUndefinedAndNotNull(removeResult);
-                test.assertFalse(set.contains(16).await());
-                test.assertUndefined(removeResult.await());
-
-                test.assertThrows(set.remove(16), new NotFoundError("Could not find 16."));
-            });
-
-            runner.testFunction("toString()", () =>
-            {
-                function toStringTest<T>(set: Set<T>, expected: string): void
-                {
-                    runner.test(`with ${runner.toString(set)}`, (test: Test) =>
-                    {
-                        test.assertEqual(set.toString(), expected);
-                    });
-                }
-
-                toStringTest(Set.create(), "{}");
-                toStringTest(Set.create().addAll([1]), "{1}");
-                toStringTest(Set.create().addAll([1, 2]), "{1,2}");
-                toStringTest(Set.create().addAll([3, 1, 2]), "{3,1,2}");
-            });
-
-            runner.testFunction("equals()", () =>
-            {
-                function equalsTest<T>(set: Set<T>, right: JavascriptIterable<T>, expected: boolean): void
-                {
-                    runner.test(`with ${runner.andList([set, right])}`, (test: Test) =>
-                    {
-                        test.assertEqual(set.equals(right).await(), expected);
-                    });
-                }
-
-                equalsTest(Set.create(), [], true);
-                equalsTest(Set.create(), [1], false);
-                equalsTest(Set.create<number>().addAll([1]), [], false);
-                equalsTest(Set.create<number>().addAll([1]), [1], true);
-                equalsTest(Set.create<number>().addAll([1]), [1, 1], false);
-                equalsTest(Set.create<number>().addAll([1, 2]), [1, 2], true);
-                equalsTest(Set.create<number>().addAll([1, 2]), [2, 1], false);
-                equalsTest(Set.create<number>().addAll([1, 2]), Set.create<number>().addAll([2, 1]), true);
-            });
-
-            runner.testFunction("union()", () =>
-            {
-                function unionErrorTest<T>(set: Set<T>, values: JavascriptIterable<T>, expected: Error): void
-                {
-                    runner.test(`with ${runner.andList([set, values])}`, (test: Test) =>
-                    {
-                        test.assertThrows(() => set.union(values), expected);
-                    });
-                }
-
-                unionErrorTest(Set.create<number>(), undefined!, new PreConditionError(
-                    "Expression: values",
-                    "Expected: not undefined and not null",
-                    "Actual: undefined",
-                ));
-                unionErrorTest(Set.create<number>(), null!, new PreConditionError(
-                    "Expression: values",
-                    "Expected: not undefined and not null",
-                    "Actual: null",
-                ));
-
-                function unionTest<T>(set: Set<T>, values: JavascriptIterable<T>, expected: JavascriptIterable<T>): void
-                {
-                    runner.test(`with ${runner.andList([set, values])}`, (test: Test) =>
-                    {
-                        test.assertEqual(set.union(values).toArray().await(), expected);
-                    });
-                }
-
-                unionTest(Set.create(), [], []);
-                unionTest(Set.create(), [1, 2], [1, 2]);
-                unionTest(Set.create([1]), [2], [1, 2]);
-                unionTest(Set.create([1, 2]), [1], [1, 2]);
-            });
-        });
-    });
-}

package/tests/skippedTest.ts

@@ -1,39 +0,0 @@
-import { JavascriptIterable } from "../sources/javascript";
-import { PreCondition } from "../sources/preCondition";
-import { join } from "../sources/strings";
-import { TestSkip } from "./testSkip";
-
-export class SkippedTest
-{
-    private readonly skip: TestSkip;
-    private readonly fullTestNameParts: JavascriptIterable<string>;
-
-    private constructor(skip: TestSkip, fullTestNameParts: JavascriptIterable<string>)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
-        PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
-
-        this.skip = skip;
-        this.fullTestNameParts = fullTestNameParts;
-    }
-
-    public static create(skip: TestSkip, fullTestNameParts: JavascriptIterable<string>): SkippedTest
-    {
-        return new SkippedTest(skip, fullTestNameParts);
-    }
-
-    public getSkipMessage(): string
-    {
-        return this.skip.getMessage();
-    }
-
-    public getFullTestNameParts(): JavascriptIterable<string>
-    {
-        return this.fullTestNameParts;
-    }
-
-    public getFullTestName(): string
-    {
-        return join(" ", this.fullTestNameParts);
-    }
-}

package/tests/stackTests.ts

@@ -1,66 +0,0 @@
-import { EmptyError } from "../sources/emptyError";
-import { ListStack } from "../sources/listStack";
-import { Stack } from "../sources/stack";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("stack.ts", () =>
-    {
-        runner.testType("Stack<T>", () =>
-        {
-            runner.testFunction("create()", (test: Test) =>
-            {
-                const stack: ListStack<number> = Stack.create();
-                test.assertNotUndefinedAndNotNull(stack);
-                test.assertFalse(stack.any().await());
-            });
-
-            runner.testFunction("add()", (test: Test) =>
-            {
-                const stack: ListStack<number> = Stack.create();
-
-                stack.add(10).await();
-                test.assertTrue(stack.any().await());
-
-                stack.add(20).await();
-                test.assertTrue(stack.any().await());
-
-                test.assertEqual(20, stack.remove().await());
-                test.assertEqual(10, stack.remove().await());
-                test.assertFalse(stack.any().await());
-            });
-
-            runner.testFunction("addAll()", () =>
-            {
-                function addAllTest(values: number[]): void
-                {
-                    runner.test(`with ${runner.toString(values)}`, (test: Test) =>
-                    {
-                        const stack: ListStack<number> = Stack.create();
-                        stack.addAll(values).await();
-
-                        for (const value of values.reverse())
-                        {
-                            test.assertTrue(stack.any().await());
-                            test.assertEqual(value, stack.remove().await());
-                        }
-                        test.assertFalse(stack.any().await());
-                    });
-                }
-
-                addAllTest([]);
-                addAllTest([1]);
-                addAllTest([1, 2]);
-                addAllTest([1, 2, 3]);
-            });
-
-            runner.testFunction("remove()", (test: Test) =>
-            {
-                const stack: ListStack<number> = Stack.create();
-                test.assertThrows(() => stack.remove().await(), new EmptyError());
-            });
-        });
-    });
-}

package/tests/stringComparerTests.ts

@@ -1,60 +0,0 @@
-import { Comparison } from "../sources/comparison";
-import { StringComparer } from "../sources/stringComparer";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("stringComparer.ts", () =>
-    {
-        runner.testType("StringComparer", () =>
-        {
-            runner.testFunction("compare(string, string)", () =>
-            {
-                function compareTest(left: string, right: string, expected: Comparison): void
-                {
-                    runner.test(`with ${runner.andList([left, right])}`, (test: Test) =>
-                    {
-                        const comparer: StringComparer = StringComparer.create();
-                        test.assertEqual(comparer.compare(left, right), expected);
-                        test.assertEqual(comparer.lessThan(left, right), expected === Comparison.LessThan);
-                        test.assertEqual(comparer.lessThanOrEqual(left, right), expected !== Comparison.GreaterThan);
-                        test.assertEqual(comparer.equal(left, right), expected === Comparison.Equal);
-                        test.assertEqual(comparer.greaterThanOrEqualTo(left, right), expected !== Comparison.LessThan);
-                        test.assertEqual(comparer.greaterThan(left, right), expected === Comparison.GreaterThan);
-                    });
-                }
-
-                compareTest(undefined!, undefined!, Comparison.Equal);
-                compareTest(undefined!, null!, Comparison.LessThan);
-                compareTest(undefined!, "", Comparison.LessThan);
-                compareTest(undefined!, "a", Comparison.LessThan);
-                compareTest(undefined!, "def", Comparison.LessThan);
-
-                compareTest(null!, undefined!, Comparison.GreaterThan);
-                compareTest(null!, null!, Comparison.Equal);
-                compareTest(null!, "", Comparison.LessThan);
-                compareTest(null!, "a", Comparison.LessThan);
-                compareTest(null!, "def", Comparison.LessThan);
-
-                compareTest("", undefined!, Comparison.GreaterThan);
-                compareTest("", null!, Comparison.GreaterThan);
-                compareTest("", "", Comparison.Equal);
-                compareTest("", "a", Comparison.LessThan);
-                compareTest("", "def", Comparison.LessThan);
-
-                compareTest("a", undefined!, Comparison.GreaterThan);
-                compareTest("a", null!, Comparison.GreaterThan);
-                compareTest("a", "", Comparison.GreaterThan);
-                compareTest("a", "a", Comparison.Equal);
-                compareTest("a", "def", Comparison.LessThan);
-
-                compareTest("def", undefined!, Comparison.GreaterThan);
-                compareTest("def", null!, Comparison.GreaterThan);
-                compareTest("def", "", Comparison.GreaterThan);
-                compareTest("def", "a", Comparison.GreaterThan);
-                compareTest("def", "def", Comparison.Equal);
-            });
-        });
-    });
-}