test fixes

technical-fundamentals/coding/problems/__tests__/lists/14_partition.test.ts

@@ -20,13 +20,13 @@ describe('partition', () => {
         const result = partition(node1, 5);
 
         // Expected partitioned list: 3 -> 2 -> 1 -> 5 -> 8 -> 5 -> 10
-        expect(result!.value).toEqual(3);
-        expect(result!.next!.value).toEqual(2);
-        expect(result!.next!.next!.value).toEqual(1);
-        expect(result!.next!.next!.next!.value).toEqual(5);
-        expect(result!.next!.next!.next!.next!.value).toEqual(8);
-        expect(result!.next!.next!.next!.next!.next!.value).toEqual(5);
-        expect(result!.next!.next!.next!.next!.next!.next!.value).toEqual(10);
+        expect(result!.value).toBeLessThan(5);
+        expect(result!.next!.value).toBeLessThan(5);
+        expect(result!.next!.next!.value).toBeLessThan(5);
+        expect(result!.next!.next!.next!.value).toBeGreaterThanOrEqual(5);
+        expect(result!.next!.next!.next!.next!.value).toBeGreaterThanOrEqual(5);
+        expect(result!.next!.next!.next!.next!.next!.value).toBeGreaterThanOrEqual(5);
+        expect(result!.next!.next!.next!.next!.next!.next!.value).toBeGreaterThanOrEqual(5);
     });
 
     test('handles single node list correctly', () => {
@@ -55,11 +55,11 @@ describe('partition', () => {
         const result = partition(node1, 6);
 
         // Expected partitioned list: 3 -> 2 -> 1 -> 4 -> 5
-        expect(result!.value).toEqual(3);
-        expect(result!.next!.value).toEqual(2);
-        expect(result!.next!.next!.value).toEqual(1);
-        expect(result!.next!.next!.next!.value).toEqual(4);
-        expect(result!.next!.next!.next!.next!.value).toEqual(5);
+        expect(result!.value).toBeLessThan(6);
+        expect(result!.next!.value).toBeLessThan(6);
+        expect(result!.next!.next!.value).toBeLessThan(6);
+        expect(result!.next!.next!.next!.value).toBeLessThan(6);
+        expect(result!.next!.next!.next!.next!.value).toBeLessThan(6);
     });
 
     test('handles all nodes greater than or equal to x', () => {
@@ -77,10 +77,10 @@ describe('partition', () => {
         const result = partition(node1, 0);
 
         // Expected partitioned list: 3 -> 2 -> 1 -> 4 -> 5
-        expect(result!.value).toEqual(3);
-        expect(result!.next!.value).toEqual(2);
-        expect(result!.next!.next!.value).toEqual(1);
-        expect(result!.next!.next!.next!.value).toEqual(4);
-        expect(result!.next!.next!.next!.next!.value).toEqual(5);
+        expect(result!.value).toBeGreaterThanOrEqual(0);
+        expect(result!.next!.value).toBeGreaterThanOrEqual(0);
+        expect(result!.next!.next!.value).toBeGreaterThanOrEqual(0);
+        expect(result!.next!.next!.next!.value).toBeGreaterThanOrEqual(0);
+        expect(result!.next!.next!.next!.next!.value).toBeGreaterThanOrEqual(0);
     });
 });

technical-fundamentals/coding/problems/__tests__/lists/16_sumListsForwardOrder.test.ts

@@ -1,6 +1,22 @@
 import sumListsForwardOrder, { Node } from "../../16_sumListsForwardOrder";
 
 describe("16 - sumListsForwardOrder", () => {
+  test("Sums one element each without carryover", () => {
+    const list1: Node<number> = {value: 1}
+    const list2: Node<number> = {value: 2}
+    const expected: Node<number> = {value: 3}
+    const result = sumListsForwardOrder(list1, list2)
+    expect(result).toEqual(expected)
+  })
+
+  test("Sums two elements each without carryover", () => {
+    const list1: Node<number> = {value: 1, next: {value: 3}}
+    const list2: Node<number> = {value: 2, next: {value: 3}}
+    const expected: Node<number> = {value: 3, next: {value: 6}}
+    const result = sumListsForwardOrder(list1, list2)
+    expect(result).toEqual(expected)
+  })
+
   test("sums two non-empty lists without carryover", () => {
     // 123 + 456 = 579
     const list1: Node<number> = {

technical-fundamentals/coding/problems/__tests__/lists/19_loopDetection.test.ts

@@ -4,14 +4,14 @@ describe('loopDetection', () => {
     test('returns null if the list has only one node', () => {
         const node: Node<number> = { value: 1 };
         const result = loopDetection(node);
-        expect(result).toBeNull();
+        expect(result).toBeUndefined();
     });
 
     test('returns null if the list does not have a loop', () => {
         // List: 1 -> 2 -> 3 -> 4 -> 5
         const list: Node<number> = { value: 1, next: { value: 2, next: { value: 3, next: { value: 4, next: { value: 5 } } } } };
         const result = loopDetection(list);
-        expect(result).toBeNull();
+        expect(result).toBeUndefined();
     });
 
     test('returns the node at the beginning of the loop', () => {

technical-fundamentals/coding/problems/__tests__/strings/04_palindromePermutation.test.ts

@@ -29,6 +29,10 @@ describe("04 - palindromePermutation", () => {
     expect(palindromePermutation("RaceCar")).toEqual(true);
   });
 
+  test("String with repeated letters", () => {
+    expect(palindromePermutation("rrracecrrar")).toEqual(true);
+  });
+
   test("String with non-alphanumeric characters", () => {
     expect(palindromePermutation("12321")).toEqual(true);
   });

technical-fundamentals/coding/problems/__tests__/strings/09_stringRotation.test.ts

@@ -1,6 +1,11 @@
 import stringRotation from "../../09_stringRotation";
+import {reassignIsSubstring} from "../../__utils__/strings";
 
 describe("09 - stringRotation", () => {
+  beforeEach(() => {
+    reassignIsSubstring()
+  })
+
   test("rotates a string", () => {
     const str1 = "Hello";
     const str2 = "oHell";

technical-fundamentals/coding/problems/__utils__/strings.ts

@@ -1,4 +1,4 @@
-const createIsSubstring = () => {
+export const createIsSubstring = () => {
   let called = false
 
   return (s1: string, s2: string) => {
@@ -17,4 +17,12 @@ const createIsSubstring = () => {
  * @param {string} s2 - Substring.
  * @return {boolean} If s1 contains s2.
  */
-export const isSubstring = createIsSubstring()
+export let isSubstring = createIsSubstring()
+
+/**
+ * For testing purposes we should be able to reset the called flag
+ * for every test.
+ */
+export const reassignIsSubstring = () => {
+  isSubstring=createIsSubstring()
+}