xdbc 1.0.217 → 1.0.219

package/__tests__/DBC/AE.test.ts

@@ -1,62 +1,62 @@
-import { AE } from "../../src/DBC/AE";
-import { EQ } from "../../src/DBC/EQ";
-import { REGEX } from "../../src/DBC/REGEX";
-
-describe("AE", () => {
-	const ae = new AE([new REGEX(/^a$/), new EQ("a")]);
-
-	test("Should report no infringement with 'a' to check", () => {
-		expect(ae.check("a" as unknown as object)).toBe(true);
-	});
-
-	test("Should report no infringement with ['a','a','a'] to check", () => {
-		expect(ae.check(["a", "a", "a"] as unknown as object)).toBe(true);
-	});
-
-	test("Should report infringement with ['a','b','a'] to check", () => {
-		expect(typeof ae.check(["a", "b", "a"] as unknown as object)).toBe(
-			"string",
-		);
-		1;
-	});
-
-	test("Should not report infringement with ['b','a','b'] to check when checking only index 1", () => {
-		expect(
-			new AE([new REGEX(/^a$/), new EQ("a")], 1).check([
-				"b",
-				"a",
-				"b",
-			] as unknown as object),
-		).toBe(true);
-	});
-
-	test("Should report infringement with ['b','a','b'] to check when checking from index 1 on", () => {
-		expect(
-			typeof new AE([new REGEX(/^a$/), new EQ("a")], 1, -1).check([
-				"b",
-				"a",
-				"b",
-			] as unknown as object),
-		).toBe("string");
-	});
-
-	test("Should not report infringement with ['a','a','b'] to check when checking from index 0 to 1", () => {
-		expect(
-			new AE([new REGEX(/^a$/), new EQ("a")], 0, 1).check([
-				"a",
-				"a",
-				"b",
-			] as unknown as object),
-		).toBe(true);
-	});
-
-	test("Should report infringement with ['a','a','b'] to check when checking from index 0 to 1 case of EQ-Condition", () => {
-		expect(
-			typeof new AE([new REGEX(/^a$/), new EQ("b")], 0, 1).check([
-				"a",
-				"a",
-				"b",
-			] as unknown as object),
-		).toBe("string");
-	});
-});
+import { AE } from "../../src/DBC/AE";
+import { EQ } from "../../src/DBC/EQ";
+import { REGEX } from "../../src/DBC/REGEX";
+
+describe("AE", () => {
+	const ae = new AE([new REGEX(/^a$/), new EQ("a")]);
+
+	test("Should report no infringement with 'a' to check", () => {
+		expect(ae.check("a" as unknown as object)).toBe(true);
+	});
+
+	test("Should report no infringement with ['a','a','a'] to check", () => {
+		expect(ae.check(["a", "a", "a"] as unknown as object)).toBe(true);
+	});
+
+	test("Should report infringement with ['a','b','a'] to check", () => {
+		expect(typeof ae.check(["a", "b", "a"] as unknown as object)).toBe(
+			"string",
+		);
+		1;
+	});
+
+	test("Should not report infringement with ['b','a','b'] to check when checking only index 1", () => {
+		expect(
+			new AE([new REGEX(/^a$/), new EQ("a")], 1).check([
+				"b",
+				"a",
+				"b",
+			] as unknown as object),
+		).toBe(true);
+	});
+
+	test("Should report infringement with ['b','a','b'] to check when checking from index 1 on", () => {
+		expect(
+			typeof new AE([new REGEX(/^a$/), new EQ("a")], 1, -1).check([
+				"b",
+				"a",
+				"b",
+			] as unknown as object),
+		).toBe("string");
+	});
+
+	test("Should not report infringement with ['a','a','b'] to check when checking from index 0 to 1", () => {
+		expect(
+			new AE([new REGEX(/^a$/), new EQ("a")], 0, 1).check([
+				"a",
+				"a",
+				"b",
+			] as unknown as object),
+		).toBe(true);
+	});
+
+	test("Should report infringement with ['a','a','b'] to check when checking from index 0 to 1 case of EQ-Condition", () => {
+		expect(
+			typeof new AE([new REGEX(/^a$/), new EQ("b")], 0, 1).check([
+				"a",
+				"a",
+				"b",
+			] as unknown as object),
+		).toBe("string");
+	});
+});

package/__tests__/DBC/ARRAY.test.ts

@@ -1,91 +1,91 @@
-import { ARRAY } from "../../src/DBC/ARRAY";
-import { DBC } from "../../src/DBC";
-
-describe("ARRAY", () => {
-	const array = new ARRAY();
-
-	test("Should not report infringement with an array", () => {
-		expect(array.check([1, 2, 3])).toBe(true);
-	});
-
-	test("Should not report infringement with an empty array", () => {
-		expect(array.check([])).toBe(true);
-	});
-
-	test("Should not report infringement with undefined (null-passthrough)", () => {
-		expect(array.check(undefined)).toBe(true);
-	});
-
-	test("Should not report infringement with null (null-passthrough)", () => {
-		expect(array.check(null)).toBe(true);
-	});
-
-	test("Should report infringement with a plain object", () => {
-		expect(typeof array.check({})).toBe("string");
-	});
-
-	test("Should report infringement with a string", () => {
-		expect(typeof array.check("hello")).toBe("string");
-	});
-
-	test("Should report infringement with a number", () => {
-		expect(typeof array.check(42)).toBe("string");
-	});
-
-	describe("checkAlgorithm", () => {
-		test("Should return true for an array", () => {
-			expect(ARRAY.checkAlgorithm([1, 2, 3])).toBe(true);
-		});
-
-		test("Should return true for an empty array", () => {
-			expect(ARRAY.checkAlgorithm([])).toBe(true);
-		});
-
-		test("Should return true for null (null-passthrough)", () => {
-			expect(ARRAY.checkAlgorithm(null)).toBe(true);
-		});
-
-		test("Should return true for undefined (null-passthrough)", () => {
-			expect(ARRAY.checkAlgorithm(undefined)).toBe(true);
-		});
-
-		test("Should return string for a plain object", () => {
-			const result = ARRAY.checkAlgorithm({});
-			expect(typeof result).toBe("string");
-			expect(result).toContain("ARRAY");
-		});
-
-		test("Should return string for a string value", () => {
-			const result = ARRAY.checkAlgorithm("hello");
-			expect(typeof result).toBe("string");
-		});
-
-		test("Should return string for a number", () => {
-			const result = ARRAY.checkAlgorithm(42);
-			expect(typeof result).toBe("string");
-		});
-	});
-
-	describe("tsCheck", () => {
-		test("Should return the value when it is an array", () => {
-			const value = [1, 2, 3];
-			expect(ARRAY.tsCheck(value)).toBe(value);
-		});
-
-		test("Should throw DBC.Infringement when value is not an array", () => {
-			expect(() => ARRAY.tsCheck({} as any)).toThrow(DBC.Infringement);
-		});
-
-		test("Should include hint in the infringement message", () => {
-			expect(() => ARRAY.tsCheck("oops" as any, "must be an array")).toThrow(
-				/must be an array/,
-			);
-		});
-
-		test("Should include id in the infringement message", () => {
-			expect(() => ARRAY.tsCheck(42 as any, undefined, "myParam")).toThrow(
-				/myParam/,
-			);
-		});
-	});
-});
+import { DBC } from "../../src/DBC";
+import { ARRAY } from "../../src/DBC/ARRAY";
+
+describe("ARRAY", () => {
+	const array = new ARRAY();
+
+	test("Should not report infringement with an array", () => {
+		expect(array.check([1, 2, 3])).toBe(true);
+	});
+
+	test("Should not report infringement with an empty array", () => {
+		expect(array.check([])).toBe(true);
+	});
+
+	test("Should not report infringement with undefined (null-passthrough)", () => {
+		expect(array.check(undefined)).toBe(true);
+	});
+
+	test("Should not report infringement with null (null-passthrough)", () => {
+		expect(array.check(null)).toBe(true);
+	});
+
+	test("Should report infringement with a plain object", () => {
+		expect(typeof array.check({})).toBe("string");
+	});
+
+	test("Should report infringement with a string", () => {
+		expect(typeof array.check("hello")).toBe("string");
+	});
+
+	test("Should report infringement with a number", () => {
+		expect(typeof array.check(42)).toBe("string");
+	});
+
+	describe("checkAlgorithm", () => {
+		test("Should return true for an array", () => {
+			expect(ARRAY.checkAlgorithm([1, 2, 3])).toBe(true);
+		});
+
+		test("Should return true for an empty array", () => {
+			expect(ARRAY.checkAlgorithm([])).toBe(true);
+		});
+
+		test("Should return true for null (null-passthrough)", () => {
+			expect(ARRAY.checkAlgorithm(null)).toBe(true);
+		});
+
+		test("Should return true for undefined (null-passthrough)", () => {
+			expect(ARRAY.checkAlgorithm(undefined)).toBe(true);
+		});
+
+		test("Should return string for a plain object", () => {
+			const result = ARRAY.checkAlgorithm({});
+			expect(typeof result).toBe("string");
+			expect(result).toContain("ARRAY");
+		});
+
+		test("Should return string for a string value", () => {
+			const result = ARRAY.checkAlgorithm("hello");
+			expect(typeof result).toBe("string");
+		});
+
+		test("Should return string for a number", () => {
+			const result = ARRAY.checkAlgorithm(42);
+			expect(typeof result).toBe("string");
+		});
+	});
+
+	describe("tsCheck", () => {
+		test("Should return the value when it is an array", () => {
+			const value = [1, 2, 3];
+			expect(ARRAY.tsCheck(value)).toBe(value);
+		});
+
+		test("Should throw DBC.Infringement when value is not an array", () => {
+			expect(() => ARRAY.tsCheck({} as any)).toThrow(DBC.Infringement);
+		});
+
+		test("Should include hint in the infringement message", () => {
+			expect(() => ARRAY.tsCheck("oops" as any, "must be an array")).toThrow(
+				/must be an array/,
+			);
+		});
+
+		test("Should include id in the infringement message", () => {
+			expect(() => ARRAY.tsCheck(42 as any, undefined, "myParam")).toThrow(
+				/myParam/,
+			);
+		});
+	});
+});

package/__tests__/DBC/DEFINED.test.ts

@@ -1,53 +1,53 @@
-import { DEFINED } from "../../src/DBC/DEFINED";
-
-describe("DEFINED", () => {
-	const defined = new DEFINED();
-
-	test("Should not report infringement with a string value", () => {
-		expect(defined.check("hello")).toBe(true);
-	});
-
-	test("Should not report infringement with a number value", () => {
-		expect(defined.check(42)).toBe(true);
-	});
-
-	test("Should not report infringement with an empty string", () => {
-		expect(defined.check("")).toBe(true);
-	});
-
-	test("Should not report infringement with zero", () => {
-		expect(defined.check(0)).toBe(true);
-	});
-
-	test("Should not report infringement with false", () => {
-		expect(defined.check(false)).toBe(true);
-	});
-
-	test("Should report infringement with null", () => {
-		expect(typeof defined.check(null)).toBe("string");
-	});
-
-	test("Should report infringement with undefined", () => {
-		expect(typeof defined.check(undefined)).toBe("string");
-	});
-
-	describe("checkAlgorithm", () => {
-		test("Should return true for defined values", () => {
-			expect(DEFINED.checkAlgorithm("test")).toBe(true);
-			expect(DEFINED.checkAlgorithm(0)).toBe(true);
-			expect(DEFINED.checkAlgorithm(false)).toBe(true);
-		});
-
-		test("Should return string for null", () => {
-			const result = DEFINED.checkAlgorithm(null);
-			expect(typeof result).toBe("string");
-			expect(result).toContain("NULL");
-		});
-
-		test("Should return string for undefined", () => {
-			const result = DEFINED.checkAlgorithm(undefined);
-			expect(typeof result).toBe("string");
-			expect(result).toContain("UNDEFINED");
-		});
-	});
-});
+import { DEFINED } from "../../src/DBC/DEFINED";
+
+describe("DEFINED", () => {
+	const defined = new DEFINED();
+
+	test("Should not report infringement with a string value", () => {
+		expect(defined.check("hello")).toBe(true);
+	});
+
+	test("Should not report infringement with a number value", () => {
+		expect(defined.check(42)).toBe(true);
+	});
+
+	test("Should not report infringement with an empty string", () => {
+		expect(defined.check("")).toBe(true);
+	});
+
+	test("Should not report infringement with zero", () => {
+		expect(defined.check(0)).toBe(true);
+	});
+
+	test("Should not report infringement with false", () => {
+		expect(defined.check(false)).toBe(true);
+	});
+
+	test("Should report infringement with null", () => {
+		expect(typeof defined.check(null)).toBe("string");
+	});
+
+	test("Should report infringement with undefined", () => {
+		expect(typeof defined.check(undefined)).toBe("string");
+	});
+
+	describe("checkAlgorithm", () => {
+		test("Should return true for defined values", () => {
+			expect(DEFINED.checkAlgorithm("test")).toBe(true);
+			expect(DEFINED.checkAlgorithm(0)).toBe(true);
+			expect(DEFINED.checkAlgorithm(false)).toBe(true);
+		});
+
+		test("Should return string for null", () => {
+			const result = DEFINED.checkAlgorithm(null);
+			expect(typeof result).toBe("string");
+			expect(result).toContain("NULL");
+		});
+
+		test("Should return string for undefined", () => {
+			const result = DEFINED.checkAlgorithm(undefined);
+			expect(typeof result).toBe("string");
+			expect(result).toContain("UNDEFINED");
+		});
+	});
+});