fix: plug more ressource leaks

Signed-off-by: Jérôme Benoit <[email protected]>

Author: jerome-benoit

src/queues/abstract-fixed-queue.ts

@@ -99,16 +99,28 @@ export abstract class AbstractFixedQueue<T> implements IFixedQueue<T> {
       return undefined
     }
     const index = this.start
+    const data = this.nodeArray[index]!.data
+    this.nodeArray[index] = undefined
     ++this.start
     if (this.start === this.capacity) {
       this.start = 0
     }
     --this.size
-    return this.nodeArray[index]!.data
+    return data
   }
 
   /** @inheritdoc */
   public clear(): void {
+    if (this.size > 0) {
+      let index = this.start
+      for (let i = 0; i < this.size; i++) {
+        this.nodeArray[index] = undefined
+        ++index
+        if (index === this.capacity) {
+          index = 0
+        }
+      }
+    }
     this.start = 0
     this.size = 0
   }

src/queues/priority-queue.ts

@@ -112,15 +112,8 @@ export class PriorityQueue<T> {
     let prev: PriorityQueueNode<T> | undefined
     while (node != null) {
       if (node.delete(data)) {
-        if (node.empty() && this.head !== this.tail) {
-          if (node === this.tail) {
-            this.tail = node.next!
-          } else {
-            prev!.next = node.next
-            if (node === this.head) {
-              this.head = prev!
-            }
-          }
+        if (node.empty()) {
+          this.removePriorityQueueNode(node, prev)
         }
         --this.size
         return true
@@ -164,15 +157,8 @@ export class PriorityQueue<T> {
     }
     const data = targetNode!.dequeue()
     --this.size
-    if (targetNode!.empty() && this.head !== this.tail) {
-      if (targetNode === this.tail) {
-        this.tail = this.tail.next!
-      } else {
-        prev!.next = targetNode!.next
-        if (targetNode === this.head) {
-          this.head = prev!
-        }
-      }
+    if (targetNode!.empty()) {
+      this.removePriorityQueueNode(targetNode!, prev)
     }
     return data
   }
@@ -231,4 +217,24 @@ export class PriorityQueue<T> {
     }
     return fixedQueue
   }
+
+  private removePriorityQueueNode(
+    nodeToRemove: PriorityQueueNode<T>,
+    previousNode?: PriorityQueueNode<T>,
+  ): void {
+    if (this.head === this.tail) {
+      return
+    }
+
+    if (nodeToRemove === this.tail) {
+      this.tail = nodeToRemove.next!
+    } else if (nodeToRemove === this.head) {
+      this.head = previousNode!
+      this.head.next = undefined
+    } else {
+      previousNode!.next = nodeToRemove.next
+    }
+
+    nodeToRemove.next = undefined
+  }
 }

tests/queues/fixed-priority-queue.test.mjs

@@ -102,7 +102,7 @@ describe('Fixed priority queue test suite', () => {
     expect(fixedPriorityQueue.size).toBe(2)
     expect(rtItem).toBe(2)
     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-      { data: 2, priority: -1 },
+      undefined,
       { data: 1, priority: 0 },
       { data: 3, priority: 0 },
     ])
@@ -112,8 +112,8 @@ describe('Fixed priority queue test suite', () => {
     expect(fixedPriorityQueue.size).toBe(1)
     expect(rtItem).toBe(1)
     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-      { data: 2, priority: -1 },
-      { data: 1, priority: 0 },
+      undefined,
+      undefined,
       { data: 3, priority: 0 },
     ])
     expect(fixedPriorityQueue.capacity).toBe(queueSize)
@@ -122,19 +122,19 @@ describe('Fixed priority queue test suite', () => {
     expect(fixedPriorityQueue.size).toBe(0)
     expect(rtItem).toBe(3)
     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-      { data: 2, priority: -1 },
-      { data: 1, priority: 0 },
-      { data: 3, priority: 0 },
+      undefined,
+      undefined,
+      undefined,
     ])
     expect(fixedPriorityQueue.capacity).toBe(queueSize)
     rtItem = fixedPriorityQueue.dequeue()
     expect(fixedPriorityQueue.start).toBe(3)
     expect(fixedPriorityQueue.size).toBe(0)
     expect(rtItem).toBe(undefined)
     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-      { data: 2, priority: -1 },
-      { data: 1, priority: 0 },
-      { data: 3, priority: 0 },
+      undefined,
+      undefined,
+      undefined,
     ])
     expect(fixedPriorityQueue.capacity).toBe(queueSize)
   })
@@ -213,7 +213,7 @@ describe('Fixed priority queue test suite', () => {
   })
 
   it('Verify clear() behavior', () => {
-    const fixedPriorityQueue = new FixedPriorityQueue()
+    const fixedPriorityQueue = new FixedPriorityQueue(2)
     fixedPriorityQueue.start = 1
     fixedPriorityQueue.size = 2
     fixedPriorityQueue.nodeArray = [
@@ -223,9 +223,6 @@ describe('Fixed priority queue test suite', () => {
     fixedPriorityQueue.clear()
     expect(fixedPriorityQueue.start).toBe(0)
     expect(fixedPriorityQueue.size).toBe(0)
-    expect(fixedPriorityQueue.nodeArray).toMatchObject([
-      { data: 2, priority: 0 },
-      { data: 3, priority: 0 },
-    ])
+    expect(fixedPriorityQueue.nodeArray).toStrictEqual([undefined, undefined])
   })
 })

tests/queues/fixed-queue.test.mjs

@@ -100,7 +100,7 @@ describe('Fixed queue test suite', () => {
     expect(fixedQueue.size).toBe(2)
     expect(rtItem).toBe(1)
     expect(fixedQueue.nodeArray).toMatchObject([
-      { data: 1, priority: 0 },
+      undefined,
       { data: 2, priority: -1 },
       { data: 3, priority: 0 },
     ])
@@ -110,8 +110,8 @@ describe('Fixed queue test suite', () => {
     expect(fixedQueue.size).toBe(1)
     expect(rtItem).toBe(2)
     expect(fixedQueue.nodeArray).toMatchObject([
-      { data: 1, priority: 0 },
-      { data: 2, priority: -1 },
+      undefined,
+      undefined,
       { data: 3, priority: 0 },
     ])
     expect(fixedQueue.capacity).toBe(queueSize)
@@ -120,19 +120,19 @@ describe('Fixed queue test suite', () => {
     expect(fixedQueue.size).toBe(0)
     expect(rtItem).toBe(3)
     expect(fixedQueue.nodeArray).toMatchObject([
-      { data: 1, priority: 0 },
-      { data: 2, priority: -1 },
-      { data: 3, priority: 0 },
+      undefined,
+      undefined,
+      undefined,
     ])
     expect(fixedQueue.capacity).toBe(queueSize)
     rtItem = fixedQueue.dequeue()
     expect(fixedQueue.start).toBe(3)
     expect(fixedQueue.size).toBe(0)
     expect(rtItem).toBe(undefined)
     expect(fixedQueue.nodeArray).toMatchObject([
-      { data: 1, priority: 0 },
-      { data: 2, priority: -1 },
-      { data: 3, priority: 0 },
+      undefined,
+      undefined,
+      undefined,
     ])
     expect(fixedQueue.capacity).toBe(queueSize)
   })
@@ -209,7 +209,7 @@ describe('Fixed queue test suite', () => {
   })
 
   it('Verify clear() behavior', () => {
-    const fixedQueue = new FixedQueue()
+    const fixedQueue = new FixedQueue(2)
     fixedQueue.start = 1
     fixedQueue.size = 2
     fixedQueue.nodeArray = [
@@ -219,9 +219,6 @@ describe('Fixed queue test suite', () => {
     fixedQueue.clear()
     expect(fixedQueue.start).toBe(0)
     expect(fixedQueue.size).toBe(0)
-    expect(fixedQueue.nodeArray).toMatchObject([
-      { data: 2, priority: 0 },
-      { data: 3, priority: 0 },
-    ])
+    expect(fixedQueue.nodeArray).toStrictEqual([undefined, undefined])
   })
 })