tests/fixed-priority-queue.test.mjs

   1 import { expect } from 'expect'
   2
   3 import {
   4   defaultQueueSize,
   5   FixedPriorityQueue,
   6 } from '../lib/fixed-priority-queue.cjs'
   7
   8 describe('Fixed priority queue test suite', () => {
   9   it('Verify constructor() behavior', () => {
  10     expect(() => new FixedPriorityQueue('')).toThrow(
  11       new TypeError("Invalid fixed priority queue size: '' is not an integer")
  12     )
  13     expect(() => new FixedPriorityQueue(-1)).toThrow(
  14       new RangeError('Invalid fixed priority queue size: -1 < 0')
  15     )
  16     let fixedPriorityQueue = new FixedPriorityQueue()
  17     expect(fixedPriorityQueue.start).toBe(0)
  18     expect(fixedPriorityQueue.size).toBe(0)
  19     expect(fixedPriorityQueue.nodeArray).toBeInstanceOf(Array)
  20     expect(fixedPriorityQueue.capacity).toBe(defaultQueueSize)
  21     expect(fixedPriorityQueue.enablePriority).toBe(false)
  22     fixedPriorityQueue = new FixedPriorityQueue(2, true)
  23     expect(fixedPriorityQueue.start).toBe(0)
  24     expect(fixedPriorityQueue.size).toBe(0)
  25     expect(fixedPriorityQueue.nodeArray).toBeInstanceOf(Array)
  26     expect(fixedPriorityQueue.capacity).toBe(2)
  27     expect(fixedPriorityQueue.enablePriority).toBe(true)
  28   })
  29
  30   it('Verify enqueue() behavior', () => {
  31     const queueSize = 5
  32     const fixedPriorityQueue = new FixedPriorityQueue(queueSize, true)
  33     let rtSize = fixedPriorityQueue.enqueue(1)
  34     expect(fixedPriorityQueue.start).toBe(0)
  35     expect(fixedPriorityQueue.size).toBe(1)
  36     expect(rtSize).toBe(fixedPriorityQueue.size)
  37     expect(fixedPriorityQueue.nodeArray).toMatchObject([
  38       { data: 1, priority: 0 },
  39     ])
  40     expect(fixedPriorityQueue.capacity).toBe(queueSize)
  41     rtSize = fixedPriorityQueue.enqueue(2)
  42     expect(fixedPriorityQueue.start).toBe(0)
  43     expect(fixedPriorityQueue.size).toBe(2)
  44     expect(rtSize).toBe(fixedPriorityQueue.size)
  45     expect(fixedPriorityQueue.nodeArray).toMatchObject([
  46       { data: 1, priority: 0 },
  47       { data: 2, priority: 0 },
  48     ])
  49     expect(fixedPriorityQueue.capacity).toBe(queueSize)
  50     rtSize = fixedPriorityQueue.enqueue(3)
  51     expect(fixedPriorityQueue.start).toBe(0)
  52     expect(fixedPriorityQueue.size).toBe(3)
  53     expect(rtSize).toBe(fixedPriorityQueue.size)
  54     expect(fixedPriorityQueue.nodeArray).toMatchObject([
  55       { data: 1, priority: 0 },
  56       { data: 2, priority: 0 },
  57       { data: 3, priority: 0 },
  58     ])
  59     expect(fixedPriorityQueue.capacity).toBe(queueSize)
  60     rtSize = fixedPriorityQueue.enqueue(3, -1)
  61     expect(fixedPriorityQueue.start).toBe(0)
  62     expect(fixedPriorityQueue.size).toBe(4)
  63     expect(rtSize).toBe(fixedPriorityQueue.size)
  64     expect(fixedPriorityQueue.nodeArray).toMatchObject([
  65       { data: 3, priority: -1 },
  66       { data: 1, priority: 0 },
  67       { data: 2, priority: 0 },
  68       { data: 3, priority: 0 },
  69     ])
  70     expect(fixedPriorityQueue.capacity).toBe(queueSize)
  71     rtSize = fixedPriorityQueue.enqueue(1, 1)
  72     expect(fixedPriorityQueue.start).toBe(0)
  73     expect(fixedPriorityQueue.size).toBe(5)
  74     expect(rtSize).toBe(fixedPriorityQueue.size)
  75     expect(fixedPriorityQueue.nodeArray).toMatchObject([
  76       { data: 3, priority: -1 },
  77       { data: 1, priority: 0 },
  78       { data: 2, priority: 0 },
  79       { data: 3, priority: 0 },
  80       { data: 1, priority: 1 },
  81     ])
  82     expect(fixedPriorityQueue.capacity).toBe(queueSize)
  83     expect(() => fixedPriorityQueue.enqueue(4)).toThrow(
  84       new Error('Priority queue is full')
  85     )
  86   })
  87
  88   it('Verify get() behavior', () => {
  89     const fixedPriorityQueue = new FixedPriorityQueue(defaultQueueSize, true)
  90     fixedPriorityQueue.enqueue(1)
  91     fixedPriorityQueue.enqueue(2, -1)
  92     fixedPriorityQueue.enqueue(3)
  93     expect(fixedPriorityQueue.get(0)).toBe(2)
  94     expect(fixedPriorityQueue.get(1)).toBe(1)
  95     expect(fixedPriorityQueue.get(2)).toBe(3)
  96     expect(fixedPriorityQueue.get(3)).toBe(undefined)
  97   })
  98
  99   it('Verify dequeue() behavior', () => {
 100     const queueSize = 5
 101     const fixedPriorityQueue = new FixedPriorityQueue(queueSize, true)
 102     fixedPriorityQueue.enqueue(1)
 103     fixedPriorityQueue.enqueue(2, -1)
 104     fixedPriorityQueue.enqueue(3)
 105     expect(fixedPriorityQueue.start).toBe(0)
 106     expect(fixedPriorityQueue.size).toBe(3)
 107     expect(fixedPriorityQueue.capacity).toBe(queueSize)
 108     let rtItem = fixedPriorityQueue.dequeue()
 109     expect(fixedPriorityQueue.start).toBe(1)
 110     expect(fixedPriorityQueue.size).toBe(2)
 111     expect(rtItem).toBe(2)
 112     expect(fixedPriorityQueue.nodeArray).toMatchObject([
 113       { data: 2, priority: -1 },
 114       { data: 1, priority: 0 },
 115       { data: 3, priority: 0 },
 116     ])
 117     expect(fixedPriorityQueue.capacity).toBe(queueSize)
 118     rtItem = fixedPriorityQueue.dequeue()
 119     expect(fixedPriorityQueue.start).toBe(2)
 120     expect(fixedPriorityQueue.size).toBe(1)
 121     expect(rtItem).toBe(1)
 122     expect(fixedPriorityQueue.nodeArray).toMatchObject([
 123       { data: 2, priority: -1 },
 124       { data: 1, priority: 0 },
 125       { data: 3, priority: 0 },
 126     ])
 127     expect(fixedPriorityQueue.capacity).toBe(queueSize)
 128     rtItem = fixedPriorityQueue.dequeue()
 129     expect(fixedPriorityQueue.start).toBe(3)
 130     expect(fixedPriorityQueue.size).toBe(0)
 131     expect(rtItem).toBe(3)
 132     expect(fixedPriorityQueue.nodeArray).toMatchObject([
 133       { data: 2, priority: -1 },
 134       { data: 1, priority: 0 },
 135       { data: 3, priority: 0 },
 136     ])
 137     expect(fixedPriorityQueue.capacity).toBe(queueSize)
 138     rtItem = fixedPriorityQueue.dequeue()
 139     expect(fixedPriorityQueue.start).toBe(3)
 140     expect(fixedPriorityQueue.size).toBe(0)
 141     expect(rtItem).toBe(undefined)
 142     expect(fixedPriorityQueue.nodeArray).toMatchObject([
 143       { data: 2, priority: -1 },
 144       { data: 1, priority: 0 },
 145       { data: 3, priority: 0 },
 146     ])
 147     expect(fixedPriorityQueue.capacity).toBe(queueSize)
 148   })
 149
 150   it('Verify iterator behavior', () => {
 151     const fixedPriorityQueue = new FixedPriorityQueue()
 152     fixedPriorityQueue.enqueue(1)
 153     fixedPriorityQueue.enqueue(2)
 154     fixedPriorityQueue.enqueue(3)
 155     let i = fixedPriorityQueue.start + 1
 156     for (const value of fixedPriorityQueue) {
 157       expect(value).toBe(i)
 158       ++i
 159     }
 160     fixedPriorityQueue.dequeue()
 161     i = fixedPriorityQueue.start + 1
 162     for (const value of fixedPriorityQueue) {
 163       expect(value).toBe(i)
 164       ++i
 165     }
 166   })
 167
 168   it('Verify empty() behavior', () => {
 169     const fixedPriorityQueue = new FixedPriorityQueue()
 170     expect(fixedPriorityQueue.empty()).toBe(true)
 171     fixedPriorityQueue.enqueue(1)
 172     expect(fixedPriorityQueue.empty()).toBe(false)
 173     fixedPriorityQueue.dequeue()
 174     expect(fixedPriorityQueue.empty()).toBe(true)
 175   })
 176
 177   it('Verify full() behavior', () => {
 178     const fixedPriorityQueue = new FixedPriorityQueue(2)
 179     expect(fixedPriorityQueue.full()).toBe(false)
 180     fixedPriorityQueue.enqueue(1)
 181     expect(fixedPriorityQueue.full()).toBe(false)
 182     fixedPriorityQueue.enqueue(2)
 183     expect(fixedPriorityQueue.full()).toBe(true)
 184     fixedPriorityQueue.dequeue()
 185     expect(fixedPriorityQueue.full()).toBe(false)
 186   })
 187
 188   it('Verify clear() behavior', () => {
 189     const fixedPriorityQueue = new FixedPriorityQueue()
 190     fixedPriorityQueue.start = 1
 191     fixedPriorityQueue.size = 2
 192     fixedPriorityQueue.nodeArray = [
 193       { data: 2, priority: 0 },
 194       { data: 3, priority: 0 },
 195     ]
 196     fixedPriorityQueue.clear()
 197     expect(fixedPriorityQueue.start).toBe(0)
 198     expect(fixedPriorityQueue.size).toBe(0)
 199     expect(fixedPriorityQueue.nodeArray).toMatchObject([
 200       { data: 2, priority: 0 },
 201       { data: 3, priority: 0 },
 202     ])
 203   })
 204 })