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.skip('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.maxSize).toBe(0)
  20     expect(fixedPriorityQueue.nodeArray).toBeInstanceOf(Array)
  21     expect(fixedPriorityQueue.nodeArray.length).toBe(defaultQueueSize)
  22     fixedPriorityQueue = new FixedPriorityQueue(2)
  23     expect(fixedPriorityQueue.start).toBe(0)
  24     expect(fixedPriorityQueue.size).toBe(0)
  25     expect(fixedPriorityQueue.maxSize).toBe(0)
  26     expect(fixedPriorityQueue.nodeArray).toBeInstanceOf(Array)
  27     expect(fixedPriorityQueue.nodeArray.length).toBe(2)
  28   })
  29
  30   it('Verify enqueue() behavior', () => {
  31     const fixedPriorityQueue = new FixedPriorityQueue()
  32     let rtSize = fixedPriorityQueue.enqueue(1)
  33     expect(fixedPriorityQueue.start).toBe(0)
  34     expect(fixedPriorityQueue.size).toBe(1)
  35     expect(fixedPriorityQueue.maxSize).toBe(1)
  36     expect(rtSize).toBe(fixedPriorityQueue.size)
  37     expect(fixedPriorityQueue.nodeArray).toMatchObject([
  38       { data: 1, priority: 0 }
  39     ])
  40     rtSize = fixedPriorityQueue.enqueue(2)
  41     expect(fixedPriorityQueue.start).toBe(0)
  42     expect(fixedPriorityQueue.size).toBe(2)
  43     expect(fixedPriorityQueue.maxSize).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     rtSize = fixedPriorityQueue.enqueue(3)
  50     expect(fixedPriorityQueue.start).toBe(0)
  51     expect(fixedPriorityQueue.size).toBe(3)
  52     expect(fixedPriorityQueue.maxSize).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     rtSize = fixedPriorityQueue.enqueue(3, -1)
  60     expect(fixedPriorityQueue.start).toBe(0)
  61     expect(fixedPriorityQueue.size).toBe(4)
  62     expect(fixedPriorityQueue.maxSize).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     rtSize = fixedPriorityQueue.enqueue(1, 1)
  71     expect(fixedPriorityQueue.start).toBe(0)
  72     expect(fixedPriorityQueue.size).toBe(5)
  73     expect(fixedPriorityQueue.maxSize).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   })
  83
  84   it('Verify dequeue() behavior', () => {
  85     const fixedPriorityQueue = new FixedPriorityQueue()
  86     fixedPriorityQueue.enqueue(1)
  87     fixedPriorityQueue.enqueue(2, -1)
  88     fixedPriorityQueue.enqueue(3)
  89     expect(fixedPriorityQueue.start).toBe(0)
  90     expect(fixedPriorityQueue.size).toBe(3)
  91     expect(fixedPriorityQueue.maxSize).toBe(3)
  92     let rtItem = fixedPriorityQueue.dequeue()
  93     expect(fixedPriorityQueue.start).toBe(1)
  94     expect(fixedPriorityQueue.size).toBe(2)
  95     expect(fixedPriorityQueue.maxSize).toBe(3)
  96     expect(rtItem).toBe(2)
  97     expect(fixedPriorityQueue.nodeArray).toMatchObject([
  98       { data: 2, priority: -1 },
  99       { data: 1, priority: 0 },
 100       { data: 3, priority: 0 }
 101     ])
 102     rtItem = fixedPriorityQueue.dequeue()
 103     expect(fixedPriorityQueue.start).toBe(2)
 104     expect(fixedPriorityQueue.size).toBe(1)
 105     expect(fixedPriorityQueue.maxSize).toBe(3)
 106     expect(rtItem).toBe(1)
 107     expect(fixedPriorityQueue.nodeArray).toMatchObject([
 108       { data: 2, priority: -1 },
 109       { data: 1, priority: 0 },
 110       { data: 3, priority: 0 }
 111     ])
 112     rtItem = fixedPriorityQueue.dequeue()
 113     expect(fixedPriorityQueue.start).toBe(3)
 114     expect(fixedPriorityQueue.size).toBe(0)
 115     expect(fixedPriorityQueue.maxSize).toBe(3)
 116     expect(rtItem).toBe(3)
 117     expect(fixedPriorityQueue.nodeArray).toMatchObject([
 118       { data: 2, priority: -1 },
 119       { data: 1, priority: 0 },
 120       { data: 3, priority: 0 }
 121     ])
 122     expect(fixedPriorityQueue.dequeue()).toBe(undefined)
 123   })
 124
 125   it('Verify iterator behavior', () => {
 126     const fixedPriorityQueue = new FixedPriorityQueue()
 127     fixedPriorityQueue.enqueue(1)
 128     fixedPriorityQueue.enqueue(2)
 129     fixedPriorityQueue.enqueue(3)
 130     let i = fixedPriorityQueue.start + 1
 131     for (const value of fixedPriorityQueue) {
 132       expect(value).toBe(i)
 133       ++i
 134     }
 135     fixedPriorityQueue.dequeue()
 136     i = fixedPriorityQueue.start + 1
 137     for (const value of fixedPriorityQueue) {
 138       expect(value).toBe(i)
 139       ++i
 140     }
 141   })
 142
 143   it('Verify clear() behavior', () => {
 144     const fixedPriorityQueue = new FixedPriorityQueue()
 145     fixedPriorityQueue.start = 1
 146     fixedPriorityQueue.size = 2
 147     fixedPriorityQueue.maxSize = 2
 148     fixedPriorityQueue.nodeArray = [
 149       { data: 2, priority: 0 },
 150       { data: 3, priority: 0 }
 151     ]
 152     fixedPriorityQueue.clear()
 153     expect(fixedPriorityQueue.start).toBe(0)
 154     expect(fixedPriorityQueue.size).toBe(0)
 155     expect(fixedPriorityQueue.maxSize).toBe(0)
 156     expect(fixedPriorityQueue.nodeArray).toMatchObject([
 157       { data: 2, priority: 0 },
 158       { data: 3, priority: 0 }
 159     ])
 160   })
 161 })