data-structure-typed 1.54.3 → 2.0.0

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -37,6 +37,16 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(2);
       expect(list.toArray()).toEqual([1, 2]);
     });
+
+    it('push with maxLen', () => {
+      const list = new SinglyLinkedList<number>([], { maxLen: 10 });
+      for (let i = 0; i < 1000; i++) {
+        list.push(i);
+      }
+      expect(list.maxLen).toBe(10);
+      expect(list.length).toBe(10);
+      expect(list.first).toBe(990);
+    });
   });
 
   describe('pop', () => {
@@ -187,7 +197,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       list.clear();
       expect(list.toArray()).toEqual([]);
-      expect(list.size).toBe(0);
+      expect(list.length).toBe(0);
       expect(list.isEmpty()).toBe(true);
     });
   });
@@ -277,10 +287,10 @@ describe('SinglyLinkedList Operation Test', () => {
 
   describe('getLength', () => {
     it('should return the correct length of the list', () => {
-      expect(list.size).toBe(0);
+      expect(list.length).toBe(0);
       list.push(1);
       list.push(2);
-      expect(list.size).toBe(2);
+      expect(list.length).toBe(2);
     });
   });
 
@@ -290,14 +300,14 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(2);
       list.push(3);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(true);
+      expect(removed).toBe(2);
       expect(list.toArray()).toEqual([1, 3]);
     });
 
     it('should return undefined for an out-of-bounds index', () => {
       list.push(1);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(false);
+      expect(removed).toBe(undefined);
     });
 
     it('should delete and return the first element', () => {
@@ -308,7 +318,7 @@ describe('SinglyLinkedList Operation Test', () => {
       const removed = list.deleteAt(0);
       expect(list.first).toBe(2);
       expect(list.last).toBe(2);
-      expect(removed).toBe(true);
+      expect(removed).toBe(1);
       expect(list.toArray()).toEqual([2]);
     });
 
@@ -316,7 +326,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(2);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(true);
+      expect(removed).toBe(2);
       expect(list.toArray()).toEqual([1]);
     });
   });
@@ -448,6 +458,95 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 });
 
+describe('SinglyLinkedList Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    const slicedList = list.slice(1, 4);
+
+    expect(slicedList.toArray()).toEqual([2, 3, 4]);
+    expect(list.length).toBe(5); // Original list unchanged
+  });
+
+  // Splice method implementation
+  test('splice should modify list and return removed elements', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    const removedList = list.splice(2, 2, 6, 7);
+
+    expect(list.toArray()).toEqual([1, 2, 6, 7, 5]);
+    expect(removedList.toArray()).toEqual([3, 4]);
+  });
+
+  // Concat method test
+  test('concat should combine multiple lists', () => {
+    const list1 = new SinglyLinkedList([1, 2]);
+    const list2 = new SinglyLinkedList([3, 4]);
+    const list3 = new SinglyLinkedList([5, 6]);
+
+    const concatenatedList = list1.concat(list2, list3);
+    expect(concatenatedList.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  // Sort method test
+  test('sort should order elements in ascending order', () => {
+    const list = new SinglyLinkedList([5, 2, 8, 1, 9]);
+    list.sort((a, b) => a - b);
+
+    expect(list.toArray()).toEqual([1, 2, 5, 8, 9]);
+  });
+
+  // Reverse method test
+  test('reverse should invert the list order', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    list.reverse();
+
+    expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  // Join method test
+  test('join should convert list to string with separator', () => {
+    const list = new SinglyLinkedList(['a', 'b', 'c']);
+
+    expect(list.join('-')).toBe('a-b-c');
+    expect(list.join()).toBe('a,b,c');
+  });
+
+  // IndexOf method test
+  test('indexOf should return first occurrence index', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2)).toBe(1);
+    expect(list.indexOf(4)).toBe(-1);
+  });
+
+  // LastIndexOf method test
+  test('lastIndexOf should return last occurrence index', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.lastIndexOf(2)).toBe(3);
+    expect(list.lastIndexOf(4)).toBe(-1);
+  });
+
+  // findIndex method test
+  test('findIndex should return first occurrence index', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect(list.findIndex(item => item === 2)).toBe(1);
+    expect(list.findIndex(item => item === 4)).toBe(-1);
+  });
+
+  // fill method test
+  test('fill should return fill all the list', () => {
+    let list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('SinglyLinkedList', () => {
   let list: SinglyLinkedList<number>;
 
@@ -458,7 +557,7 @@ describe('SinglyLinkedList', () => {
   it('should initialize an empty list', () => {
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
   });
 
   it('should push elements to the end of the list', () => {
@@ -466,7 +565,7 @@ describe('SinglyLinkedList', () => {
     list.push(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(2);
-    expect(list.size).toBe(2);
+    expect(list.length).toBe(2);
   });
 
   it('should pop elements from the end of the list', () => {
@@ -476,7 +575,7 @@ describe('SinglyLinkedList', () => {
     expect(popped).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
   });
 
   it('should reverse the list', () => {
@@ -545,7 +644,8 @@ describe('iterable methods', () => {
     expect(sl.some(element => element > 2)).toBe(true);
 
     expect([...sl.filter(element => element > 2)]).toEqual([3]);
-    expect([...sl.map(element => element * 2)]).toEqual([2, 4, 6]);
+    const mappedSl = sl.map(element => element * 2);
+    expect([...mappedSl]).toEqual([2, 4, 6]);
     expect(sl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
   });
 });