flo-mat 3.0.14 → 4.0.1

package/__tests__/cp-node/check-clone-eql-calc.spec.ts

@@ -0,0 +1,58 @@
+import { test } from '@jest/globals';
+
+test.todo('Ignore this test for now');
+
+
+// import type { CpNode } from '../../src/cp-node/cp-node.js';
+// import { expect, test } from '@jest/globals';
+// import { getAllOnLoop } from '../../src/cp-node/fs/get-all-on-loop.js';
+// import { randomWalk } from './random-walk.js';
+// import { getMats1 } from '../get-mats1.js';
+
+
+// test('Check MAT objects equal (after clone)', function() {
+//     const mats1 = getMats1();  // Calculates MAT from shape
+
+//     // too hard for Jest due to circular references
+//     // expect(mats_obj1).toEqual(mats_calc1);
+    
+//     // Fast path: check root array structure and length
+//     expect(Array.isArray(mats1_)).toBe(true);
+//     expect(Array.isArray(mats1)).toBe(true);
+//     expect(mats1_.length).toBe(mats1.length);
+    
+//     // Verify key properties of the MAT objects instead of deep comparison
+//     const mats1_0_ = mats1_[0];
+//     const mats1_0 = mats1[0];
+    
+//     // Check critical structure exists
+//     expect(mats1_0_).toHaveProperty('cpNode');
+//     expect(mats1_0).toHaveProperty('cpNode');
+    
+//     // Verify circular reference integrity
+//     if (mats1_0_.cpNode && mats1_0_.cpNode.nextOnCircle) {
+//         expect(mats1_0_.cpNode.nextOnCircle).toBeDefined();
+//     }
+
+//     getAllOnLoop(mats1_0_.cpNode).length; //?
+
+//     // Perform a random walk on the calculated MAT to ensure it behaves as expected
+//     let testCpNode = mats1_0.cpNode;
+//     let testCpNode_ = mats1_0_.cpNode;
+
+//     const N = 10;
+//     let reachCpNodes = new Set<CpNode>();
+//     for (let i=0; i<N; i++) {
+//         testCpNode = randomWalk(testCpNode, i*N, N);
+//         testCpNode_ = randomWalk(testCpNode_, i*N, N);
+
+//         // testCpNode.cp.pointOnShape.p; //?
+//         // testCpNode_.cp.pointOnShape.p;//?
+
+//         reachCpNodes.add(testCpNode);
+
+//         expect(testCpNode.cp.pointOnShape).toEqual(testCpNode_.cp.pointOnShape);
+//     }
+
+//     reachCpNodes.size; //?
+// });

package/__tests__/cp-node/compare-cp-nodes-by-value.ts

@@ -0,0 +1,37 @@
+import { CpNode } from "../../src/cp-node/cp-node.js";
+import { comparePossByValue } from "./compare-poss-by-value.js";
+import { randomWalk } from "./random-walk.js";
+
+
+function compareCpNodesByValue(
+        cpNode1: CpNode,
+        cpNode2: CpNode): boolean {
+
+    // Perform a random walk on the calculated MAT to ensure it behaves as expected
+
+    const N = 10;
+    let reachCpNodes1 = new Set<CpNode>();
+    let reachCpNodes2 = new Set<CpNode>();
+    for (let i=0; i<N; i++) {
+        cpNode1 = randomWalk(cpNode1, i*N, N);
+        cpNode2 = randomWalk(cpNode2, i*N, N);
+
+        reachCpNodes1.add(cpNode1);
+        reachCpNodes2.add(cpNode2);
+
+        if (!comparePossByValue(cpNode1.pointOnShape, cpNode2.pointOnShape)) {
+            return false;
+        }
+        
+        cpNode2.pointOnShape;
+    }
+
+    if (reachCpNodes1.size !== reachCpNodes2.size) {
+        return false;
+    }
+
+    return true;
+}
+
+
+export { compareCpNodesByValue }

package/__tests__/cp-node/compare-loops-by-value.ts

@@ -0,0 +1,40 @@
+import { Loop } from "flo-boolean";
+
+
+function compareLoopsByValue(
+        loop1: Loop,
+        loop2: Loop): boolean {
+
+    const { idx: idx1, beziers: beziers1, curves: curves1 } = loop1;
+    const { idx: idx2, beziers: beziers2, curves: curves2 } = loop2;
+
+    if (idx1 !== idx2) { return false; }
+    if (beziers1.length !== beziers2.length) { return false; }
+    for (let i=0; i<beziers1.length; i++) {
+        const b1 = beziers1[i];
+        const b2 = beziers2[i];
+        if (b1.length !== b2.length) { return false; }
+        for (let j=0; j<b1.length; j++) {
+            const p1 = b1[j];
+            const p2 = b2[j];
+            if (p1[0] !== p2[0] || p1[1] !== p2[1]) { return false; }
+        }
+    }
+
+    for (let i=0; i<curves1.length; i++) {
+        const c1 = curves1[i];
+        const c2 = curves2[i];
+        
+        if (c1.idx !== c2.idx) { return false; }
+        if (!c1.next || !c2.next || !c1.prev || !c2.prev ||
+            !c1.ps || !c2.ps) {
+                
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+export { compareLoopsByValue }

package/__tests__/cp-node/compare-poss-by-value.ts

@@ -0,0 +1,25 @@
+import type { PointOnShape } from "../../src/point-on-shape/point-on-shape.js";
+
+
+function comparePossByValue(
+        pos1: PointOnShape, pos2: PointOnShape): boolean {
+
+    if (pos1.t !== pos2.t) { return false; }
+
+    if (pos1.p[0] !== pos2.p[0]) { return false; }
+    if (pos1.p[1] !== pos2.p[1]) { return false; }
+    if (pos1.curve.idx !== pos2.curve.idx) { return false; }
+    if (pos1.curve.loop.idx !== pos2.curve.loop.idx) { return false; }
+    if (pos1.isSource !== pos2.isSource) { return false; }
+    if (pos1.circle.center[0] !== pos2.circle.center[0]) { return false; }
+    if (pos1.circle.center[1] !== pos2.circle.center[1]) { return false; }
+    if (pos1.circle.radius !== pos2.circle.radius) { return false; }
+    if (pos1.order !== pos2.order) { return false; }
+    if (pos1.order2 !== pos2.order2) { return false; }
+    if (pos1.t !== pos2.t) { return false; }
+
+    return true;
+}
+
+
+export { comparePossByValue }

package/__tests__/cp-node/fs/clone.spec.ts

@@ -1,7 +1,23 @@
 import { expect, test } from '@jest/globals';
 import { clone } from '../../../src/cp-node/fs/clone.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('clone [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('clone', function() {
+    const { cpNode } = getMats1()[0];
+    const cloned = clone(cpNode);
+
+    expect(cloned === cpNode).toBe(false);
+
+    const origLoop = getAllOnLoop(cpNode);
+    const cloneLoop = getAllOnLoop(cloned);
+    expect(cloneLoop.length).toBe(origLoop.length);
+
+    expect(cloned.next.prev === cloned).toBe(true);
+    expect(cloned.prev.next === cloned).toBe(true);
+    expect(cloned.nextOnCircle.prevOnCircle === cloned).toBe(true);
+    expect(cloned.prevOnCircle.nextOnCircle === cloned).toBe(true);
+
+    expect(cloned.next !== cpNode.next).toBe(true);
 });

package/__tests__/cp-node/fs/find-first.spec.ts

@@ -1,7 +1,17 @@
 import { expect, test } from '@jest/globals';
 import { findFirst } from '../../../src/cp-node/fs/find-first.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('findFirst [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('findFirst', function() {
+    const { cpNode } = getMats1()[0];
+
+    // Always-true predicate: returns the start node
+    expect(findFirst(() => true, cpNode) === cpNode).toBe(true);
+
+    // Always-false predicate: returns undefined
+    expect(findFirst(() => false, cpNode)).toBeUndefined();
+
+    // Predicate matching cpNode.next: returns cpNode.next
+    expect(findFirst(n => n === cpNode.next, cpNode) === cpNode.next).toBe(true);
 });

package/__tests__/cp-node/fs/get-all-between.spec.ts

@@ -1,7 +1,24 @@
 import { expect, test } from '@jest/globals';
 import { getAllBetween } from '../../../src/cp-node/fs/get-all-between.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('getAllBetween [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getAllBetween', function() {
+    const { cpNode } = getMats1()[0];
+
+    // Same start and end (inclAllIfEqual=true): returns all nodes on the loop
+    const all = getAllBetween(cpNode, cpNode);
+    expect(all.cpNodes.length).toBe(getAllOnLoop(cpNode).length);
+    expect(all.cpNodes[0] === cpNode).toBe(true);
+
+    // Same start and end with inclAllIfEqual=false: returns empty
+    const none = getAllBetween(cpNode, cpNode, false);
+    expect(none.cpNodes.length).toBe(0);
+
+    // From cpNode to cpNode.next.next: returns [cpNode, cpNode.next]
+    const two = getAllBetween(cpNode, cpNode.next.next);
+    expect(two.cpNodes.length).toBe(2);
+    expect(two.cpNodes[0] === cpNode).toBe(true);
+    expect(two.cpNodes[1] === cpNode.next).toBe(true);
 });

package/__tests__/cp-node/fs/get-all-on-circle.spec.ts

@@ -1,5 +1,5 @@
 import { expect, test } from '@jest/globals';
-import { mats_obj1, getMats_calc1 } from './mat-dummys.js';
+import { getMats1 } from '../../get-mats1.js';
 import { getAllOnCircle } from '../../../src/cp-node/fs/get-all-on-circle.js';
 import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
 import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
@@ -12,16 +12,16 @@ test('CpNodeFs -> getAllOnCircle', function() {
     // expect(mats_obj1).toEqual(mats_calc1);
     
     // const { cpNode } = mats_calc1[0];
-    const { cpNode } = mats_obj1[0];
+    const { cpNode } = getMats1()[0];
 
     const cpNode_ = cpNode.nextOnCircle;
 
     expect(cpNode === cpNode_.nextOnCircle).toBe(true);
 
-    expect(cpNode_.cp.pointOnShape.p).toEqual([24,8]);
-    expect(cpNode_.cp.pointOnShape.t).toEqual(1);
-    expect(cpNode_.cp.pointOnShape.isSource).toEqual(true);
-    expect(cpNode_.cp.circle).toEqual({ center: [ 24, 8 ], radius: 0 });
+    expect(cpNode_.pointOnShape.p).toEqual([24,8]);
+    expect(cpNode_.pointOnShape.t).toEqual(1);
+    expect(cpNode_.pointOnShape.isSource).toEqual(true);
+    expect(cpNode_.pointOnShape.circle).toEqual({ center: [ 24, 8 ], radius: 0 });
 
     // Real test starts here...
 
@@ -79,14 +79,14 @@ test('CpNodeFs -> getAllOnCircle', function() {
 
         const cpNodes = getAllOnCircle(cpNode1);
         expect(cpNodes.length).toBe(2);
-        expect(cpNodes[0].cp.pointOnShape.p).toEqual([24,8]);
-        expect(cpNodes[1].cp.pointOnShape.p).toEqual([24,8]);
+        expect(cpNodes[0].pointOnShape.p).toEqual([24,8]);
+        expect(cpNodes[1].pointOnShape.p).toEqual([24,8]);
 
         const cpNodesExcl = getAllOnCircle(cpNode1, true);
         expect(cpNodesExcl.length).toBe(1);
         expect(cpNodesExcl[0] === cpNode1).toBe(false);
-        expect(cpNodesExcl[0].cp.pointOnShape.p).toEqual([24,8]);
+        expect(cpNodesExcl[0].pointOnShape.p).toEqual([24,8]);
 
-        expect(cpNodes[0].cp.circle.radius).toBe(0);
+        expect(cpNodes[0].pointOnShape.circle.radius).toBe(0);
     }
 });

package/__tests__/cp-node/fs/get-all-on-loop.spec.ts

@@ -1,7 +1,20 @@
 import { expect, test } from '@jest/globals';
 import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('getAllOnLoop [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getAllOnLoop', function() {
+    const { cpNode } = getMats1()[0];
+    const cpNodes = getAllOnLoop(cpNode);
+
+    expect(cpNodes.length).toBeGreaterThan(0);
+    expect(cpNodes[0] === cpNode).toBe(true);
+
+    // Each node's .next should point to the next node in the array (wrapping)
+    for (let i = 0; i < cpNodes.length; i++) {
+        expect(cpNodes[i].next === cpNodes[(i + 1) % cpNodes.length]).toBe(true);
+    }
+
+    // Starting from cpNode.next should give the same count
+    expect(getAllOnLoop(cpNode.next).length).toBe(cpNodes.length);
 });

package/__tests__/cp-node/fs/get-all-vertices.spec.ts

@@ -1,7 +1,18 @@
 import { expect, test } from '@jest/globals';
 import { getAllVertices } from '../../../src/cp-node/fs/get-all-vertices.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('getAllVertices [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getAllVertices', function() {
+    const { cpNode } = getMats1()[0];
+    const vertices = getAllVertices(cpNode);
+
+    expect(vertices.length).toBeGreaterThan(0);
+
+    // All returned vertices should be on the loop
+    const loopSet = new Set(getAllOnLoop(cpNode));
+    for (const v of vertices) {
+        expect(loopSet.has(v)).toBe(true);
+    }
 });

package/__tests__/cp-node/fs/get-children.spec.ts

@@ -1,7 +1,22 @@
 import { expect, test } from '@jest/globals';
 import { getChildren } from '../../../src/cp-node/fs/get-children.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('getChildren [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getChildren', function() {
+    const { cpNode } = getMats1()[0];
+    const allOnLoop = getAllOnLoop(cpNode);
+
+    const nonTerminating = allOnLoop.find(n => !isTerminating(n));
+    expect(nonTerminating).toBeDefined();
+
+    const children = getChildren(nonTerminating!);
+    expect(children.length).toBeGreaterThan(0);
+
+    for (const child of children) {
+        expect(child.next).toBeDefined();
+        expect(child.prev).toBeDefined();
+    }
 });

package/__tests__/cp-node/fs/get-non-terminating-on-circle.spec.ts

@@ -1,7 +1,18 @@
 import { expect, test } from '@jest/globals';
 import { getNonTerminatingOnCircle } from '../../../src/cp-node/fs/get-non-terminating-on-circle.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('getNonTerminatingOnCircle [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getNonTerminatingOnCircle', function() {
+    const { cpNode } = getMats1()[0];
+
+    const nonTerm = getNonTerminatingOnCircle(cpNode);
+    for (const n of nonTerm) {
+        expect(isTerminating(n)).toBe(false);
+    }
+
+    // exclThis=true should not include cpNode itself
+    const nonTermExcl = getNonTerminatingOnCircle(cpNode, true);
+    expect(nonTermExcl.includes(cpNode)).toBe(false);
 });

package/__tests__/cp-node/fs/get-prong-count.spec.ts

@@ -1,7 +1,20 @@
 import { expect, test } from '@jest/globals';
 import { getProngCount } from '../../../src/cp-node/fs/get-prong-count.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('getProngCount [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getProngCount', function() {
+    const { cpNode } = getMats1()[0];
+
+    const count = getProngCount(cpNode);
+    expect(count).toBeGreaterThanOrEqual(2);
+
+    // Manually counting nextOnCircle traversal should match
+    let circleCount = 0;
+    let curr = cpNode;
+    do {
+        circleCount++;
+        curr = curr.nextOnCircle;
+    } while (curr !== cpNode);
+    expect(circleCount).toBe(count);
 });

package/__tests__/cp-node/fs/get-real-prong-count.spec.ts

@@ -1,7 +1,15 @@
 import { expect, test } from '@jest/globals';
 import { getRealProngCount } from '../../../src/cp-node/fs/get-real-prong-count.js';
+import { getProngCount } from '../../../src/cp-node/fs/get-prong-count.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('getRealProngCount [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getRealProngCount', function() {
+    const { cpNode } = getMats1()[0];
+
+    const realCount = getRealProngCount(cpNode);
+    expect(realCount).toBeGreaterThanOrEqual(1);
+
+    // Real count excludes terminating nodes, so it's <= total prong count
+    expect(realCount).toBeLessThanOrEqual(getProngCount(cpNode));
 });

package/__tests__/cp-node/fs/get-terminating-on-circle.spec.ts

@@ -1,7 +1,24 @@
 import { expect, test } from '@jest/globals';
 import { getTerminatingOnCircle } from '../../../src/cp-node/fs/get-terminating-on-circle.js';
+import { getNonTerminatingOnCircle } from '../../../src/cp-node/fs/get-non-terminating-on-circle.js';
+import { getProngCount } from '../../../src/cp-node/fs/get-prong-count.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('getTerminatingOnCircle [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getTerminatingOnCircle', function() {
+    const { cpNode } = getMats1()[0];
+
+    const terminating = getTerminatingOnCircle(cpNode);
+    for (const n of terminating) {
+        expect(isTerminating(n)).toBe(true);
+    }
+
+    // terminating + non-terminating = total prong count
+    const nonTerminating = getNonTerminatingOnCircle(cpNode);
+    expect(terminating.length + nonTerminating.length).toBe(getProngCount(cpNode));
+
+    // exclThis: cpNode should not be included
+    const termExcl = getTerminatingOnCircle(cpNode, true);
+    expect(termExcl.includes(cpNode)).toBe(false);
 });

package/__tests__/cp-node/fs/is-fully-terminating.spec.ts

@@ -1,7 +1,20 @@
 import { expect, test } from '@jest/globals';
 import { isFullyTerminating } from '../../../src/cp-node/fs/is-fully-terminating.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getAllOnCircle } from '../../../src/cp-node/fs/get-all-on-circle.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('isFullyTerminating [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('isFullyTerminating', function() {
+    const { cpNode } = getMats1()[0];
+    const allOnLoop = getAllOnLoop(cpNode);
+
+    for (const n of allOnLoop) {
+        if (isFullyTerminating(n)) {
+            // All on the prevOnCircle's circle (excluding itself) should be terminating
+            const otherOnCircle = getAllOnCircle(n.prevOnCircle, true);
+            expect(otherOnCircle.every(isTerminating)).toBe(true);
+        }
+    }
 });

package/__tests__/cp-node/fs/is-on-same-circle.spec.ts

@@ -1,7 +1,24 @@
 import { expect, test } from '@jest/globals';
 import { isOnSameCircle } from '../../../src/cp-node/fs/is-on-same-circle.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('isOnSameCircle [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('isOnSameCircle', function() {
+    const { cpNode } = getMats1()[0];
+
+    // A node is on the same circle as itself
+    expect(isOnSameCircle(cpNode, cpNode)).toBe(true);
+
+    // A node is on the same circle as nextOnCircle
+    expect(isOnSameCircle(cpNode, cpNode.nextOnCircle)).toBe(true);
+
+    // Symmetric
+    expect(isOnSameCircle(cpNode.nextOnCircle, cpNode)).toBe(true);
+
+    // All nodes reachable via nextOnCircle are on the same circle
+    let curr = cpNode.nextOnCircle;
+    while (curr !== cpNode) {
+        expect(isOnSameCircle(cpNode, curr)).toBe(true);
+        curr = curr.nextOnCircle;
+    }
 });

package/__tests__/cp-node/fs/is-one-prong.spec.ts

@@ -1,7 +1,20 @@
 import { expect, test } from '@jest/globals';
 import { isOneProng } from '../../../src/cp-node/fs/is-one-prong.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('isOneProng [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('`isOneProng`', function() {
+    const { cpNode } = getMats1()[0];
+    const allOnLoop = getAllOnLoop(cpNode);
+
+    for (const n of allOnLoop) {
+        if (isOneProng(n)) {
+            // One-prong: nextOnCircle is at the same position
+            const p1 = n.pointOnShape.p;
+            const p2 = n.nextOnCircle.pointOnShape.p;
+            expect(p1[0]).toBe(p2[0]);
+            expect(p1[1]).toBe(p2[1]);
+        }
+    }
 });

package/__tests__/cp-node/fs/is-sharp.spec.ts

@@ -1,7 +1,14 @@
 import { expect, test } from '@jest/globals';
 import { isSharp } from '../../../src/cp-node/fs/is-sharp.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('isSharp [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('isSharp', function() {
+    const { cpNode } = getMats1()[0];
+    const allOnLoop = getAllOnLoop(cpNode);
+
+    for (const n of allOnLoop) {
+        expect(isSharp(n)).toBe(n.pointOnShape.circle.radius === 0);
+    }
 });

package/__tests__/cp-node/fs/is-single-3-prong.spec.ts

@@ -1,7 +1,17 @@
 import { expect, test } from '@jest/globals';
 import { isSingle3Prong } from '../../../src/cp-node/fs/is-single-3-prong.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('isSingle3Prong [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('isSingle3Prong', function() {
+    const { cpNode } = getMats1()[0];
+    const allOnLoop = getAllOnLoop(cpNode);
+
+    for (const n of allOnLoop) {
+        if (isSingle3Prong(n)) {
+            expect(n.next === n.nextOnCircle).toBe(true);
+            expect(n.next.next === n.next.nextOnCircle).toBe(true);
+        }
+    }
 });

package/__tests__/cp-node/fs/is-special.spec.ts

@@ -1,7 +1,16 @@
 import { expect, test } from '@jest/globals';
 import { isSpecial } from '../../../src/cp-node/fs/is-special.js';
+import { getRealProngCount } from '../../../src/cp-node/fs/get-real-prong-count.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('isSpecial [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('isSpecial', function() {
+    const { cpNode } = getMats1()[0];
+    const allOnLoop = getAllOnLoop(cpNode);
+
+    for (const n of allOnLoop) {
+        const expected = getRealProngCount(n) !== 2 && !n.isHoleClosing;
+        expect(isSpecial(n)).toBe(expected);
+    }
 });

package/__tests__/cp-node/fs/is-terminating.spec.ts

@@ -1,7 +1,19 @@
 import { expect, test } from '@jest/globals';
 import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('isTerminating [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('isTerminating', function() {
+    const { cpNode } = getMats1()[0];
+    const allOnLoop = getAllOnLoop(cpNode);
+
+    // A non-trivial MAT should have at least one terminating node
+    const termCount = allOnLoop.filter(isTerminating).length;
+    expect(termCount).toBeGreaterThan(0);
+
+    // Verify the definition: cpNode === cpNode.next.prevOnCircle
+    for (const n of allOnLoop) {
+        expect(isTerminating(n)).toBe(n === n.next.prevOnCircle);
+    }
 });

package/__tests__/cp-node/fs/is-trivial.spec.ts

@@ -1,7 +1,17 @@
 import { expect, test } from '@jest/globals';
 import { isTrivial } from '../../../src/cp-node/fs/is-trivial.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getAllOnCircle } from '../../../src/cp-node/fs/get-all-on-circle.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('isTrivial [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('isTrivial', function() {
+    const { cpNode } = getMats1()[0];
+    const allOnLoop = getAllOnLoop(cpNode);
+
+    for (const n of allOnLoop) {
+        const expected = getAllOnCircle(n).every(isTerminating);
+        expect(isTrivial(n)).toBe(expected);
+    }
 });