split scale tests into separate files

jest.config.ts

@@ -169,10 +169,10 @@ export default {
 	// testLocationInResults: false,
 
 	// The glob patterns Jest uses to detect test files
-	// testMatch: [
-	//   "**/__tests__/**/*.[jt]s?(x)",
-	//   "**/?(*.)+(spec|test).[tj]s?(x)"
-	// ],
+	testMatch: [
+		"**/?(*.)function!(.scale).test.ts",
+		"**/scale.test.ts",
+	],
 
 	// An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
 	// testPathIgnorePatterns: [

test/comparisons/disjoint.function.scale.test.ts

@@ -0,0 +1,108 @@
+import { afterAll, describe, expect, it, jest } from '@jest/globals';
+import { disjoint }  from '../../src';
+import {
+	coupleDisjoint,
+	coupleEquivalent,
+	fewDisjoint,
+	fewEquivalent,
+	manyDisjoint,
+	manyEquivalent,
+	multiplesOf1,
+	multiplesOf2,
+	multiplesOf3,
+	padding,
+	someDisjoint,
+	someEquivalent,
+	times,
+} from '../constants/scale-testing.constants';
+import { Timer } from '../constants/timer.model';
+
+export function disjointScaleTest(): void {
+
+	describe('disjoint ⋅ large sets', () => {
+		it('disjoint(of1):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(multiplesOf1));
+			expect(result).toBe(true);
+		});
+
+		it('disjoint(of1, of1):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(multiplesOf1, multiplesOf1));
+			expect(result).toBe(false);
+		});
+
+		it('disjoint(of1, of2):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(multiplesOf1, multiplesOf2));
+			expect(result).toBe(false);
+		});
+
+		it('disjoint(of2, of1):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(multiplesOf2, multiplesOf1));
+			expect(result).toBe(false);
+		});
+
+		it('disjoint(of1, of1, of1):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(multiplesOf1, multiplesOf1, multiplesOf1));
+			expect(result).toBe(false);
+		});
+
+		it('disjoint(of1, of2, of3):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(multiplesOf1, multiplesOf2, multiplesOf3));
+			expect(result).toBe(false);
+		});
+
+		it('disjoint(of3, of2, of1):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(multiplesOf3, multiplesOf2, multiplesOf1));
+			expect(result).toBe(false);
+		});
+	});
+
+	describe('disjoint ⋅ many sets', () => {
+		it('disjoint(100 Equivalent):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(...someEquivalent));
+			expect(result).toBe(false);
+		});
+
+		it('disjoint(10k Equivalent):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(...manyEquivalent));
+			expect(result).toBe(false);
+		});
+
+		it('disjoint(100 Disjoint):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(...someDisjoint));
+			expect(result).toBe(true);
+		});
+
+		it('disjoint(10k Disjoint):'.padEnd(padding), () => {
+			const result = Timer.time('disjoint', () => disjoint(...manyDisjoint));
+			expect(result).toBe(true);
+		});
+	});
+
+	describe('disjoint ⋅ many times', () => {
+		it('100k ⋅ disjoint(2 Equivalent):'.padEnd(padding), () => {
+			const disjointMock = jest.fn(disjoint);
+			Timer.manyTimes('disjoint', () => disjointMock(...coupleEquivalent), times);
+			expect(disjointMock).toHaveBeenCalledTimes(times);
+		});
+
+		it('100k ⋅ disjoint(5 Equivalent):'.padEnd(padding), () => {
+			const disjointMock = jest.fn(disjoint);
+			Timer.manyTimes('disjoint', () => disjointMock(...fewEquivalent), times);
+			expect(disjointMock).toHaveBeenCalledTimes(times);
+		});
+
+		it('100k ⋅ disjoint(2 Disjoint):'.padEnd(padding), () => {
+			const disjointMock = jest.fn(disjoint);
+			Timer.manyTimes('disjoint', () => disjointMock(...coupleDisjoint), times);
+			expect(disjointMock).toHaveBeenCalledTimes(times);
+		});
+
+		it('100k ⋅ disjoint(5 Disjoint):'.padEnd(padding), () => {
+			const disjointMock = jest.fn(disjoint);
+			Timer.manyTimes('disjoint', () => disjointMock(...fewDisjoint), times);
+			expect(disjointMock).toHaveBeenCalledTimes(times);
+		});
+	});
+
+	afterAll(() => Timer.log('disjoint'));
+}

test/comparisons/disjoint.function.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from '@jest/globals';
 import { disjoint } from '../../src';
-import { empty, setA, setB, setC, setD, setE, setF, universal } from '../constants/testing-constants';
+import { empty, setA, setB, setC, setD, setE, setF, universal } from '../constants/testing.constants';
 
 describe('disjoint', () => {
 	it('no sets are disjoint', () => {

test/comparisons/equivalence.function.scale.test.ts

@@ -0,0 +1,108 @@
+import { afterAll, describe, expect, it, jest } from '@jest/globals';
+import { equivalence } from '../../src';
+import {
+	coupleDisjoint,
+	coupleEquivalent,
+	fewDisjoint,
+	fewEquivalent,
+	manyDisjoint,
+	manyEquivalent,
+	multiplesOf1,
+	multiplesOf2,
+	multiplesOf3,
+	padding,
+	someDisjoint,
+	someEquivalent,
+	times,
+} from '../constants/scale-testing.constants';
+import { Timer } from '../constants/timer.model';
+
+export function equivalenceScaleTest(): void {
+
+	describe('equivalence ⋅ large sets', () => {
+		it('equivalence(of1):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(multiplesOf1));
+			expect(result).toBe(true);
+		});
+
+		it('equivalence(of1, of1):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(multiplesOf1, multiplesOf1));
+			expect(result).toBe(true);
+		});
+
+		it('equivalence(of1, of2):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(multiplesOf1, multiplesOf2));
+			expect(result).toBe(false);
+		});
+
+		it('equivalence(of2, of1):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(multiplesOf2, multiplesOf1));
+			expect(result).toBe(false);
+		});
+
+		it('equivalence(of1, of1, of1):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(multiplesOf1, multiplesOf1, multiplesOf1));
+			expect(result).toBe(true);
+		});
+
+		it('equivalence(of1, of2, of3):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(multiplesOf1, multiplesOf2, multiplesOf3));
+			expect(result).toBe(false);
+		});
+
+		it('equivalence(of3, of2, of1):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(multiplesOf3, multiplesOf2, multiplesOf1));
+			expect(result).toBe(false);
+		});
+	});
+
+	describe('equivalence ⋅ many sets', () => {
+		it('equivalence(100 Equivalent):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(...someEquivalent));
+			expect(result).toBe(true);
+		});
+
+		it('equivalence(10k Equivalent):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(...manyEquivalent));
+			expect(result).toBe(true);
+		});
+
+		it('equivalence(100 Disjoint):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(...someDisjoint));
+			expect(result).toBe(false);
+		});
+
+		it('equivalence(10k Disjoint):'.padEnd(padding), () => {
+			const result = Timer.time('equivalence', () => equivalence(...manyDisjoint));
+			expect(result).toBe(false);
+		});
+	});
+
+	describe('equivalence ⋅ many times', () => {
+		it('100k ⋅ equivalence(2 Equivalent):'.padEnd(padding), () => {
+			const equivalenceMock = jest.fn(equivalence);
+			Timer.manyTimes('equivalence', () => equivalenceMock(...coupleEquivalent), times);
+			expect(equivalenceMock).toHaveBeenCalledTimes(times);
+		});
+
+		it('100k ⋅ equivalence(5 Equivalent):'.padEnd(padding), () => {
+			const equivalenceMock = jest.fn(equivalence);
+			Timer.manyTimes('equivalence', () => equivalenceMock(...fewEquivalent), times);
+			expect(equivalenceMock).toHaveBeenCalledTimes(times);
+		});
+
+		it('100k ⋅ equivalence(2 Disjoint):'.padEnd(padding), () => {
+			const equivalenceMock = jest.fn(equivalence);
+			Timer.manyTimes('equivalence', () => equivalenceMock(...coupleDisjoint), times);
+			expect(equivalenceMock).toHaveBeenCalledTimes(times);
+		});
+
+		it('100k ⋅ equivalence(5 Disjoint):'.padEnd(padding), () => {
+			const equivalenceMock = jest.fn(equivalence);
+			Timer.manyTimes('equivalence', () => equivalenceMock(...fewDisjoint), times);
+			expect(equivalenceMock).toHaveBeenCalledTimes(times);
+		});
+	});
+
+	afterAll(() => Timer.log('equivalence'));
+}

test/comparisons/equivalence.function.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from '@jest/globals';
 import { equivalence } from '../../src';
-import { empty, minimal, setA, setB, setC, setD, setE, setF, universal } from '../constants/testing-constants';
+import { empty, minimal, setA, setB, setC, setD, setE, setF, universal } from '../constants/testing.constants';
 
 describe('equivalence', () => {
 	it('no sets are equivalent', () => {

test/comparisons/pairwise-disjoint.function.scale.test.ts

@@ -0,0 +1,108 @@
+import { afterAll, describe, expect, it, jest } from '@jest/globals';
+import { pairwiseDisjoint } from '../../src';
+import {
+	coupleDisjoint,
+	coupleEquivalent,
+	fewDisjoint,
+	fewEquivalent,
+	manyDisjoint,
+	manyEquivalent,
+	multiplesOf1,
+	multiplesOf2,
+	multiplesOf3,
+	padding,
+	someDisjoint,
+	someEquivalent,
+	times,
+} from '../constants/scale-testing.constants';
+import { Timer } from '../constants/timer.model';
+
+export function pairwiseDisjointScaleTest(): void {
+
+	describe('pairwise disjoint ⋅ large sets', () => {
+		it('pairwiseDisjoint(of1):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(multiplesOf1));
+			expect(result).toBe(true);
+		});
+
+		it('pairwiseDisjoint(of1, of1):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(multiplesOf1, multiplesOf1));
+			expect(result).toBe(false);
+		});
+
+		it('pairwiseDisjoint(of1, of2):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(multiplesOf1, multiplesOf2));
+			expect(result).toBe(false);
+		});
+
+		it('pairwiseDisjoint(of2, of1):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(multiplesOf2, multiplesOf1));
+			expect(result).toBe(false);
+		});
+
+		it('pairwiseDisjoint(of1, of1, of1):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(multiplesOf1, multiplesOf1, multiplesOf1));
+			expect(result).toBe(false);
+		});
+
+		it('pairwiseDisjoint(of1, of2, of3):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(multiplesOf1, multiplesOf2, multiplesOf3));
+			expect(result).toBe(false);
+		});
+
+		it('pairwiseDisjoint(of3, of2, of1):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(multiplesOf3, multiplesOf2, multiplesOf1));
+			expect(result).toBe(false);
+		});
+	});
+
+	describe('pairwise disjoint ⋅ many sets', () => {
+		it('pairwiseDisjoint(100 Equivalent):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(...someEquivalent));
+			expect(result).toBe(false);
+		});
+
+		it('pairwiseDisjoint(10k Equivalent):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(...manyEquivalent));
+			expect(result).toBe(false);
+		});
+
+		it('pairwiseDisjoint(100 Disjoint):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(...someDisjoint));
+			expect(result).toBe(true);
+		});
+
+		it('pairwiseDisjoint(10k Disjoint):'.padEnd(padding), () => {
+			const result = Timer.time('pairwiseDisjoint', () => pairwiseDisjoint(...manyDisjoint));
+			expect(result).toBe(true);
+		});
+	});
+
+	describe('pairwise disjoint ⋅ many times', () => {
+		it('100k ⋅ pairwiseDisjoint(2 Equivalent):'.padEnd(padding), () => {
+			const pairwiseDisjointMock = jest.fn(pairwiseDisjoint);
+			Timer.manyTimes('pairwiseDisjoint', () => pairwiseDisjointMock(...coupleEquivalent), times);
+			expect(pairwiseDisjointMock).toHaveBeenCalledTimes(times);
+		});
+
+		it('100k ⋅ pairwiseDisjoint(5 Equivalent):'.padEnd(padding), () => {
+			const pairwiseDisjointMock = jest.fn(pairwiseDisjoint);
+			Timer.manyTimes('pairwiseDisjoint', () => pairwiseDisjointMock(...fewEquivalent), times);
+			expect(pairwiseDisjointMock).toHaveBeenCalledTimes(times);
+		});
+
+		it('100k ⋅ pairwiseDisjoint(2 Disjoint):'.padEnd(padding), () => {
+			const pairwiseDisjointMock = jest.fn(pairwiseDisjoint);
+			Timer.manyTimes('pairwiseDisjoint', () => pairwiseDisjointMock(...coupleDisjoint), times);
+			expect(pairwiseDisjointMock).toHaveBeenCalledTimes(times);
+		});
+
+		it('100k ⋅ pairwiseDisjoint(5 Disjoint):'.padEnd(padding), () => {
+			const pairwiseDisjointMock = jest.fn(pairwiseDisjoint);
+			Timer.manyTimes('pairwiseDisjoint', () => pairwiseDisjointMock(...fewDisjoint), times);
+			expect(pairwiseDisjointMock).toHaveBeenCalledTimes(times);
+		});
+	});
+
+	afterAll(() => Timer.log('pairwiseDisjoint'));
+}

test/comparisons/pairwise-disjoint.function.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from '@jest/globals';
 import { pairwiseDisjoint } from '../../src';
-import { empty, setA, setB, setC, setD, setE, setF, universal } from '../constants/testing-constants';
+import { empty, setA, setB, setC, setD, setE, setF, universal } from '../constants/testing.constants';
 
 describe('pairwise disjoint', () => {
 	it('no sets are pairwise disjoint', () => {