repositories / poolifier.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
chore: migrate to eslint 9
[poolifier.git] / tests / fixed-priority-queue.test.mjs
diff --git a/tests/fixed-priority-queue.test.mjs b/tests/fixed-priority-queue.test.mjs
index b70bc17f7e760072bafa4fc9c381b4703c2337ad..40b5564313b6dadedbe0d7cc1520ae0b6454ad02 100644 (file)
--- a/tests/fixed-priority-queue.test.mjs
+++ b/tests/fixed-priority-queue.test.mjs
@@ -1,161 +1,204 @@
-// import { expect } from 'expect'
+import { expect } from 'expect'
 
-// import {
-//   defaultQueueSize,
-//   FixedPriorityQueue
-// } from '../lib/fixed-priority-queue.cjs'
+import {
+  defaultQueueSize,
+  FixedPriorityQueue,
+} from '../lib/fixed-priority-queue.cjs'
 
-// describe('Fixed Priority queue test suite', () => {
-//   it('Verify constructor() behavior', () => {
-//     expect(() => new FixedPriorityQueue('')).toThrow(
-//       new TypeError('Invalid fixed priority queue size:  is not an integer')
-//     )
-//     expect(() => new FixedPriorityQueue(-1)).toThrow(
-//       new RangeError('Invalid fixed priority queue size: -1 < 0')
-//     )
-//     let fixedPriorityQueue = new FixedPriorityQueue()
-//     expect(fixedPriorityQueue.start).toBe(0)
-//     expect(fixedPriorityQueue.size).toBe(0)
-//     expect(fixedPriorityQueue.maxSize).toBe(0)
-//     expect(fixedPriorityQueue.nodeArray).toBeInstanceOf(Array)
-//     expect(fixedPriorityQueue.nodeArray.length).toBe(defaultQueueSize)
-//     fixedPriorityQueue = new FixedPriorityQueue(2)
-//     expect(fixedPriorityQueue.start).toBe(0)
-//     expect(fixedPriorityQueue.size).toBe(0)
-//     expect(fixedPriorityQueue.maxSize).toBe(0)
-//     expect(fixedPriorityQueue.nodeArray).toBeInstanceOf(Array)
-//     expect(fixedPriorityQueue.nodeArray.length).toBe(2)
-//   })
+describe('Fixed priority queue test suite', () => {
+  it('Verify constructor() behavior', () => {
+    expect(() => new FixedPriorityQueue('')).toThrow(
+      new TypeError("Invalid fixed priority queue size: '' is not an integer")
+    )
+    expect(() => new FixedPriorityQueue(-1)).toThrow(
+      new RangeError('Invalid fixed priority queue size: -1 < 0')
+    )
+    let fixedPriorityQueue = new FixedPriorityQueue()
+    expect(fixedPriorityQueue.start).toBe(0)
+    expect(fixedPriorityQueue.size).toBe(0)
+    expect(fixedPriorityQueue.nodeArray).toBeInstanceOf(Array)
+    expect(fixedPriorityQueue.capacity).toBe(defaultQueueSize)
+    expect(fixedPriorityQueue.enablePriority).toBe(false)
+    fixedPriorityQueue = new FixedPriorityQueue(2, true)
+    expect(fixedPriorityQueue.start).toBe(0)
+    expect(fixedPriorityQueue.size).toBe(0)
+    expect(fixedPriorityQueue.nodeArray).toBeInstanceOf(Array)
+    expect(fixedPriorityQueue.capacity).toBe(2)
+    expect(fixedPriorityQueue.enablePriority).toBe(true)
+  })
 
-//   it('Verify enqueue() behavior', () => {
-//     const fixedPriorityQueue = new FixedPriorityQueue()
-//     let rtSize = fixedPriorityQueue.enqueue(1)
-//     expect(fixedPriorityQueue.start).toBe(0)
-//     expect(fixedPriorityQueue.size).toBe(1)
-//     expect(fixedPriorityQueue.maxSize).toBe(1)
-//     expect(rtSize).toBe(fixedPriorityQueue.size)
-//     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-//       { data: 1, priority: 0 }
-//     ])
-//     rtSize = fixedPriorityQueue.enqueue(2)
-//     expect(fixedPriorityQueue.start).toBe(0)
-//     expect(fixedPriorityQueue.size).toBe(2)
-//     expect(fixedPriorityQueue.maxSize).toBe(2)
-//     expect(rtSize).toBe(fixedPriorityQueue.size)
-//     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-//       { data: 1, priority: 0 },
-//       { data: 2, priority: 0 }
-//     ])
-//     rtSize = fixedPriorityQueue.enqueue(3)
-//     expect(fixedPriorityQueue.start).toBe(0)
-//     expect(fixedPriorityQueue.size).toBe(3)
-//     expect(fixedPriorityQueue.maxSize).toBe(3)
-//     expect(rtSize).toBe(fixedPriorityQueue.size)
-//     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-//       { data: 1, priority: 0 },
-//       { data: 2, priority: 0 },
-//       { data: 3, priority: 0 }
-//     ])
-//     rtSize = fixedPriorityQueue.enqueue(3, -1)
-//     expect(fixedPriorityQueue.start).toBe(0)
-//     expect(fixedPriorityQueue.size).toBe(4)
-//     expect(fixedPriorityQueue.maxSize).toBe(4)
-//     expect(rtSize).toBe(fixedPriorityQueue.size)
-//     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-//       { data: 3, priority: -1 },
-//       { data: 1, priority: 0 },
-//       { data: 2, priority: 0 },
-//       { data: 3, priority: 0 }
-//     ])
-//     rtSize = fixedPriorityQueue.enqueue(1, 1)
-//     expect(fixedPriorityQueue.start).toBe(0)
-//     expect(fixedPriorityQueue.size).toBe(5)
-//     expect(fixedPriorityQueue.maxSize).toBe(5)
-//     expect(rtSize).toBe(fixedPriorityQueue.size)
-//     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-//       { data: 3, priority: -1 },
-//       { data: 1, priority: 0 },
-//       { data: 2, priority: 0 },
-//       { data: 3, priority: 0 },
-//       { data: 1, priority: 1 }
-//     ])
-//   })
+  it('Verify enqueue() behavior', () => {
+    const queueSize = 5
+    const fixedPriorityQueue = new FixedPriorityQueue(queueSize, true)
+    let rtSize = fixedPriorityQueue.enqueue(1)
+    expect(fixedPriorityQueue.start).toBe(0)
+    expect(fixedPriorityQueue.size).toBe(1)
+    expect(rtSize).toBe(fixedPriorityQueue.size)
+    expect(fixedPriorityQueue.nodeArray).toMatchObject([
+      { data: 1, priority: 0 },
+    ])
+    expect(fixedPriorityQueue.capacity).toBe(queueSize)
+    rtSize = fixedPriorityQueue.enqueue(2)
+    expect(fixedPriorityQueue.start).toBe(0)
+    expect(fixedPriorityQueue.size).toBe(2)
+    expect(rtSize).toBe(fixedPriorityQueue.size)
+    expect(fixedPriorityQueue.nodeArray).toMatchObject([
+      { data: 1, priority: 0 },
+      { data: 2, priority: 0 },
+    ])
+    expect(fixedPriorityQueue.capacity).toBe(queueSize)
+    rtSize = fixedPriorityQueue.enqueue(3)
+    expect(fixedPriorityQueue.start).toBe(0)
+    expect(fixedPriorityQueue.size).toBe(3)
+    expect(rtSize).toBe(fixedPriorityQueue.size)
+    expect(fixedPriorityQueue.nodeArray).toMatchObject([
+      { data: 1, priority: 0 },
+      { data: 2, priority: 0 },
+      { data: 3, priority: 0 },
+    ])
+    expect(fixedPriorityQueue.capacity).toBe(queueSize)
+    rtSize = fixedPriorityQueue.enqueue(3, -1)
+    expect(fixedPriorityQueue.start).toBe(0)
+    expect(fixedPriorityQueue.size).toBe(4)
+    expect(rtSize).toBe(fixedPriorityQueue.size)
+    expect(fixedPriorityQueue.nodeArray).toMatchObject([
+      { data: 3, priority: -1 },
+      { data: 1, priority: 0 },
+      { data: 2, priority: 0 },
+      { data: 3, priority: 0 },
+    ])
+    expect(fixedPriorityQueue.capacity).toBe(queueSize)
+    rtSize = fixedPriorityQueue.enqueue(1, 1)
+    expect(fixedPriorityQueue.start).toBe(0)
+    expect(fixedPriorityQueue.size).toBe(5)
+    expect(rtSize).toBe(fixedPriorityQueue.size)
+    expect(fixedPriorityQueue.nodeArray).toMatchObject([
+      { data: 3, priority: -1 },
+      { data: 1, priority: 0 },
+      { data: 2, priority: 0 },
+      { data: 3, priority: 0 },
+      { data: 1, priority: 1 },
+    ])
+    expect(fixedPriorityQueue.capacity).toBe(queueSize)
+    expect(() => fixedPriorityQueue.enqueue(4)).toThrow(
+      new Error('Priority queue is full')
+    )
+  })
 
-//   it('Verify dequeue() behavior', () => {
-//     const fixedPriorityQueue = new FixedPriorityQueue()
-//     fixedPriorityQueue.enqueue(1)
-//     fixedPriorityQueue.enqueue(2, -1)
-//     fixedPriorityQueue.enqueue(3)
-//     expect(fixedPriorityQueue.start).toBe(0)
-//     expect(fixedPriorityQueue.size).toBe(3)
-//     expect(fixedPriorityQueue.maxSize).toBe(3)
-//     let rtItem = fixedPriorityQueue.dequeue()
-//     expect(fixedPriorityQueue.start).toBe(1)
-//     expect(fixedPriorityQueue.size).toBe(2)
-//     expect(fixedPriorityQueue.maxSize).toBe(3)
-//     expect(rtItem).toBe(2)
-//     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-//       { data: 2, priority: -1 },
-//       { data: 1, priority: 0 },
-//       { data: 3, priority: 0 }
-//     ])
-//     rtItem = fixedPriorityQueue.dequeue()
-//     expect(fixedPriorityQueue.start).toBe(2)
-//     expect(fixedPriorityQueue.size).toBe(1)
-//     expect(fixedPriorityQueue.maxSize).toBe(3)
-//     expect(rtItem).toBe(1)
-//     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-//       { data: 2, priority: -1 },
-//       { data: 1, priority: 0 },
-//       { data: 3, priority: 0 }
-//     ])
-//     rtItem = fixedPriorityQueue.dequeue()
-//     expect(fixedPriorityQueue.start).toBe(3)
-//     expect(fixedPriorityQueue.size).toBe(0)
-//     expect(fixedPriorityQueue.maxSize).toBe(3)
-//     expect(rtItem).toBe(3)
-//     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-//       { data: 2, priority: -1 },
-//       { data: 1, priority: 0 },
-//       { data: 3, priority: 0 }
-//     ])
-//     expect(fixedPriorityQueue.dequeue()).toBe(undefined)
-//   })
+  it('Verify get() behavior', () => {
+    const fixedPriorityQueue = new FixedPriorityQueue(defaultQueueSize, true)
+    fixedPriorityQueue.enqueue(1)
+    fixedPriorityQueue.enqueue(2, -1)
+    fixedPriorityQueue.enqueue(3)
+    expect(fixedPriorityQueue.get(0)).toBe(2)
+    expect(fixedPriorityQueue.get(1)).toBe(1)
+    expect(fixedPriorityQueue.get(2)).toBe(3)
+    expect(fixedPriorityQueue.get(3)).toBe(undefined)
+  })
 
-//   it('Verify iterator behavior', () => {
-//     const fixedPriorityQueue = new FixedPriorityQueue()
-//     fixedPriorityQueue.enqueue(1)
-//     fixedPriorityQueue.enqueue(2)
-//     fixedPriorityQueue.enqueue(3)
-//     let i = fixedPriorityQueue.start + 1
-//     for (const value of fixedPriorityQueue) {
-//       expect(value).toBe(i)
-//       ++i
-//     }
-//     fixedPriorityQueue.dequeue()
-//     i = fixedPriorityQueue.start + 1
-//     for (const value of fixedPriorityQueue) {
-//       expect(value).toBe(i)
-//       ++i
-//     }
-//   })
+  it('Verify dequeue() behavior', () => {
+    const queueSize = 5
+    const fixedPriorityQueue = new FixedPriorityQueue(queueSize, true)
+    fixedPriorityQueue.enqueue(1)
+    fixedPriorityQueue.enqueue(2, -1)
+    fixedPriorityQueue.enqueue(3)
+    expect(fixedPriorityQueue.start).toBe(0)
+    expect(fixedPriorityQueue.size).toBe(3)
+    expect(fixedPriorityQueue.capacity).toBe(queueSize)
+    let rtItem = fixedPriorityQueue.dequeue()
+    expect(fixedPriorityQueue.start).toBe(1)
+    expect(fixedPriorityQueue.size).toBe(2)
+    expect(rtItem).toBe(2)
+    expect(fixedPriorityQueue.nodeArray).toMatchObject([
+      { data: 2, priority: -1 },
+      { data: 1, priority: 0 },
+      { data: 3, priority: 0 },
+    ])
+    expect(fixedPriorityQueue.capacity).toBe(queueSize)
+    rtItem = fixedPriorityQueue.dequeue()
+    expect(fixedPriorityQueue.start).toBe(2)
+    expect(fixedPriorityQueue.size).toBe(1)
+    expect(rtItem).toBe(1)
+    expect(fixedPriorityQueue.nodeArray).toMatchObject([
+      { data: 2, priority: -1 },
+      { data: 1, priority: 0 },
+      { data: 3, priority: 0 },
+    ])
+    expect(fixedPriorityQueue.capacity).toBe(queueSize)
+    rtItem = fixedPriorityQueue.dequeue()
+    expect(fixedPriorityQueue.start).toBe(3)
+    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 },
+    ])
+    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 },
+    ])
+    expect(fixedPriorityQueue.capacity).toBe(queueSize)
+  })
 
-//   it('Verify clear() behavior', () => {
-//     const fixedPriorityQueue = new FixedPriorityQueue()
-//     fixedPriorityQueue.start = 1
-//     fixedPriorityQueue.size = 2
-//     fixedPriorityQueue.maxSize = 2
-//     fixedPriorityQueue.nodeArray = [
-//       { data: 2, priority: 0 },
-//       { data: 3, priority: 0 }
-//     ]
-//     fixedPriorityQueue.clear()
-//     expect(fixedPriorityQueue.start).toBe(0)
-//     expect(fixedPriorityQueue.size).toBe(0)
-//     expect(fixedPriorityQueue.maxSize).toBe(0)
-//     expect(fixedPriorityQueue.nodeArray).toMatchObject([
-//       { data: 2, priority: 0 },
-//       { data: 3, priority: 0 }
-//     ])
-//   })
-// })
+  it('Verify iterator behavior', () => {
+    const fixedPriorityQueue = new FixedPriorityQueue()
+    fixedPriorityQueue.enqueue(1)
+    fixedPriorityQueue.enqueue(2)
+    fixedPriorityQueue.enqueue(3)
+    let i = fixedPriorityQueue.start + 1
+    for (const value of fixedPriorityQueue) {
+      expect(value).toBe(i)
+      ++i
+    }
+    fixedPriorityQueue.dequeue()
+    i = fixedPriorityQueue.start + 1
+    for (const value of fixedPriorityQueue) {
+      expect(value).toBe(i)
+      ++i
+    }
+  })
+
+  it('Verify empty() behavior', () => {
+    const fixedPriorityQueue = new FixedPriorityQueue()
+    expect(fixedPriorityQueue.empty()).toBe(true)
+    fixedPriorityQueue.enqueue(1)
+    expect(fixedPriorityQueue.empty()).toBe(false)
+    fixedPriorityQueue.dequeue()
+    expect(fixedPriorityQueue.empty()).toBe(true)
+  })
+
+  it('Verify full() behavior', () => {
+    const fixedPriorityQueue = new FixedPriorityQueue(2)
+    expect(fixedPriorityQueue.full()).toBe(false)
+    fixedPriorityQueue.enqueue(1)
+    expect(fixedPriorityQueue.full()).toBe(false)
+    fixedPriorityQueue.enqueue(2)
+    expect(fixedPriorityQueue.full()).toBe(true)
+    fixedPriorityQueue.dequeue()
+    expect(fixedPriorityQueue.full()).toBe(false)
+  })
+
+  it('Verify clear() behavior', () => {
+    const fixedPriorityQueue = new FixedPriorityQueue()
+    fixedPriorityQueue.start = 1
+    fixedPriorityQueue.size = 2
+    fixedPriorityQueue.nodeArray = [
+      { data: 2, priority: 0 },
+      { data: 3, priority: 0 },
+    ]
+    fixedPriorityQueue.clear()
+    expect(fixedPriorityQueue.start).toBe(0)
+    expect(fixedPriorityQueue.size).toBe(0)
+    expect(fixedPriorityQueue.nodeArray).toMatchObject([
+      { data: 2, priority: 0 },
+      { data: 3, priority: 0 },
+    ])
+  })
+})
Fast and small Node.js thread pool implementation mirror - https://github.com/poolifier/poolifier