[poolifier.git] / tests / priority-queue.test.mjs

import { expect } from 'expect'

import { FixedPriorityQueue } from '../lib/fixed-priority-queue.cjs'
import { defaultBucketSize, PriorityQueue } from '../lib/priority-queue.cjs'

describe('Priority queue test suite', () => {
  it('Verify constructor() behavior', () => {
    const priorityQueue = new PriorityQueue()
    expect(priorityQueue.size).toBe(0)
    expect(priorityQueue.maxSize).toBe(0)
    expect(priorityQueue.head).toBeInstanceOf(FixedPriorityQueue)
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.head.capacity).toBe(defaultBucketSize)
    expect(priorityQueue.tail).toBeInstanceOf(FixedPriorityQueue)
    expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
  })

  it('Verify default bucket size enqueue() behavior', () => {
    const priorityQueue = new PriorityQueue()
    let rtSize = priorityQueue.enqueue(1)
    expect(priorityQueue.size).toBe(1)
    expect(priorityQueue.maxSize).toBe(1)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 1, priority: 0 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
    rtSize = priorityQueue.enqueue(2)
    expect(priorityQueue.size).toBe(2)
    expect(priorityQueue.maxSize).toBe(2)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 1, priority: 0 },
      { data: 2, priority: 0 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
    rtSize = priorityQueue.enqueue(3)
    expect(priorityQueue.size).toBe(3)
    expect(priorityQueue.maxSize).toBe(3)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 1, priority: 0 },
      { data: 2, priority: 0 },
      { data: 3, priority: 0 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
    rtSize = priorityQueue.enqueue(3, -1)
    expect(priorityQueue.size).toBe(4)
    expect(priorityQueue.maxSize).toBe(4)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 3, priority: -1 },
      { data: 1, priority: 0 },
      { data: 2, priority: 0 },
      { data: 3, priority: 0 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
    rtSize = priorityQueue.enqueue(1, 1)
    expect(priorityQueue.size).toBe(5)
    expect(priorityQueue.maxSize).toBe(5)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 3, priority: -1 },
      { data: 1, priority: 0 },
      { data: 2, priority: 0 },
      { data: 3, priority: 0 },
      { data: 1, priority: 1 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
  })

  it('Verify bucketSize=2 enqueue() behavior', () => {
    const priorityQueue = new PriorityQueue(2)
    let rtSize = priorityQueue.enqueue(1)
    expect(priorityQueue.size).toBe(1)
    expect(priorityQueue.maxSize).toBe(1)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 1, priority: 0 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
    rtSize = priorityQueue.enqueue(2)
    expect(priorityQueue.size).toBe(2)
    expect(priorityQueue.maxSize).toBe(2)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 1, priority: 0 },
      { data: 2, priority: 0 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
    rtSize = priorityQueue.enqueue(3)
    expect(priorityQueue.size).toBe(3)
    expect(priorityQueue.maxSize).toBe(3)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 3, priority: 0 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail.nodeArray).toMatchObject([
      { data: 1, priority: 0 },
      { data: 2, priority: 0 }
    ])
    expect(priorityQueue.tail.next).toStrictEqual(priorityQueue.head)
    rtSize = priorityQueue.enqueue(3, -1)
    expect(priorityQueue.size).toBe(4)
    expect(priorityQueue.maxSize).toBe(4)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 3, priority: -1 },
      { data: 3, priority: 0 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail.nodeArray).toMatchObject([
      { data: 1, priority: 0 },
      { data: 2, priority: 0 }
    ])
    expect(priorityQueue.tail.next).toStrictEqual(priorityQueue.head)
    rtSize = priorityQueue.enqueue(1, 1)
    expect(priorityQueue.size).toBe(5)
    expect(priorityQueue.maxSize).toBe(5)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 1, priority: 1 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail.nodeArray).toMatchObject([
      { data: 1, priority: 0 },
      { data: 2, priority: 0 }
    ])
    expect(priorityQueue.tail.next).not.toStrictEqual(priorityQueue.head)
    expect(priorityQueue.tail.next.nodeArray).toMatchObject([
      { data: 3, priority: -1 },
      { data: 3, priority: 0 }
    ])
    rtSize = priorityQueue.enqueue(3, -2)
    expect(priorityQueue.size).toBe(6)
    expect(priorityQueue.maxSize).toBe(6)
    expect(rtSize).toBe(priorityQueue.size)
    expect(priorityQueue.head.nodeArray).toMatchObject([
      { data: 3, priority: -2 },
      { data: 1, priority: 1 }
    ])
    expect(priorityQueue.head.next).toBe(undefined)
    expect(priorityQueue.tail.nodeArray).toMatchObject([
      { data: 1, priority: 0 },
      { data: 2, priority: 0 }
    ])
    expect(priorityQueue.tail.next).not.toStrictEqual(priorityQueue.head)
    expect(priorityQueue.tail.next.nodeArray).toMatchObject([
      { data: 3, priority: -1 },
      { data: 3, priority: 0 }
    ])
  })

  it('Verify default bucket size dequeue() behavior', () => {
    const priorityQueue = new PriorityQueue()
    priorityQueue.enqueue(1)
    priorityQueue.enqueue(2, -1)
    priorityQueue.enqueue(3)
    expect(priorityQueue.size).toBe(3)
    expect(priorityQueue.maxSize).toBe(3)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail.next).toBe(undefined)
    let rtItem = priorityQueue.dequeue()
    expect(priorityQueue.size).toBe(2)
    expect(priorityQueue.maxSize).toBe(3)
    expect(rtItem).toBe(2)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail.next).toBe(undefined)
    rtItem = priorityQueue.dequeue()
    expect(priorityQueue.size).toBe(1)
    expect(priorityQueue.maxSize).toBe(3)
    expect(rtItem).toBe(1)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail.next).toBe(undefined)
    rtItem = priorityQueue.dequeue()
    expect(priorityQueue.size).toBe(0)
    expect(priorityQueue.maxSize).toBe(3)
    expect(rtItem).toBe(3)
    expect(priorityQueue.tail.empty()).toBe(true)
    expect(priorityQueue.tail.next).toBe(undefined)
  })

  it('Verify bucketSize=2 dequeue() behavior', () => {
    const priorityQueue = new PriorityQueue(2)
    priorityQueue.enqueue(1)
    priorityQueue.enqueue(2)
    priorityQueue.enqueue(3)
    priorityQueue.enqueue(3, -1)
    priorityQueue.enqueue(1, 1)
    priorityQueue.enqueue(3, -2)
    expect(priorityQueue.size).toBe(6)
    expect(priorityQueue.maxSize).toBe(6)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
    let rtItem = priorityQueue.dequeue(3)
    expect(priorityQueue.size).toBe(5)
    expect(priorityQueue.maxSize).toBe(6)
    expect(rtItem).toBe(3)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
    rtItem = priorityQueue.dequeue()
    expect(priorityQueue.size).toBe(4)
    expect(priorityQueue.maxSize).toBe(6)
    expect(rtItem).toBe(1)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
    rtItem = priorityQueue.dequeue(2)
    expect(priorityQueue.size).toBe(3)
    expect(priorityQueue.maxSize).toBe(6)
    expect(rtItem).toBe(3)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
    rtItem = priorityQueue.dequeue(2)
    expect(priorityQueue.size).toBe(2)
    expect(priorityQueue.maxSize).toBe(6)
    expect(rtItem).toBe(3)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
    rtItem = priorityQueue.dequeue(2)
    expect(priorityQueue.size).toBe(1)
    expect(priorityQueue.maxSize).toBe(6)
    expect(rtItem).toBe(1)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
    rtItem = priorityQueue.dequeue()
    expect(priorityQueue.size).toBe(0)
    expect(priorityQueue.maxSize).toBe(6)
    expect(rtItem).toBe(2)
    expect(priorityQueue.tail.empty()).toBe(true)
    expect(priorityQueue.tail.next).toBe(undefined)
  })

  it('Verify iterator behavior', () => {
    const priorityQueue = new PriorityQueue(2)
    priorityQueue.enqueue(1)
    priorityQueue.enqueue(2)
    priorityQueue.enqueue(3)
    let i = 1
    for (const value of priorityQueue) {
      expect(value).toBe(i)
      ++i
    }
  })

  it('Verify clear() behavior', () => {
    const priorityQueue = new PriorityQueue(2)
    priorityQueue.enqueue(1)
    priorityQueue.enqueue(2)
    priorityQueue.enqueue(3)
    expect(priorityQueue.size).toBe(3)
    expect(priorityQueue.maxSize).toBe(3)
    expect(priorityQueue.head.empty()).toBe(false)
    expect(priorityQueue.tail.empty()).toBe(false)
    expect(priorityQueue.tail).not.toStrictEqual(priorityQueue.head)
    priorityQueue.clear()
    expect(priorityQueue.size).toBe(0)
    expect(priorityQueue.maxSize).toBe(0)
    expect(priorityQueue.head.empty()).toBe(true)
    expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
  })
})
Commit	Line	Data
	1	import { expect } from 'expect'
	2
	3	import { FixedPriorityQueue } from '../lib/fixed-priority-queue.cjs'
	4	import { defaultBucketSize, PriorityQueue } from '../lib/priority-queue.cjs'
	5
	6	describe('Priority queue test suite', () => {
	7	it('Verify constructor() behavior', () => {
	8	const priorityQueue = new PriorityQueue()
	9	expect(priorityQueue.size).toBe(0)
	10	expect(priorityQueue.maxSize).toBe(0)
	11	expect(priorityQueue.head).toBeInstanceOf(FixedPriorityQueue)
	12	expect(priorityQueue.head.next).toBe(undefined)
	13	expect(priorityQueue.head.capacity).toBe(defaultBucketSize)
	14	expect(priorityQueue.tail).toBeInstanceOf(FixedPriorityQueue)
	15	expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
	16	})
	17
	18	it('Verify default bucket size enqueue() behavior', () => {
	19	const priorityQueue = new PriorityQueue()
	20	let rtSize = priorityQueue.enqueue(1)
	21	expect(priorityQueue.size).toBe(1)
	22	expect(priorityQueue.maxSize).toBe(1)
	23	expect(rtSize).toBe(priorityQueue.size)
	24	expect(priorityQueue.head.nodeArray).toMatchObject([
	25	{ data: 1, priority: 0 }
	26	])
	27	expect(priorityQueue.head.next).toBe(undefined)
	28	expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
	29	rtSize = priorityQueue.enqueue(2)
	30	expect(priorityQueue.size).toBe(2)
	31	expect(priorityQueue.maxSize).toBe(2)
	32	expect(rtSize).toBe(priorityQueue.size)
	33	expect(priorityQueue.head.nodeArray).toMatchObject([
	34	{ data: 1, priority: 0 },
	35	{ data: 2, priority: 0 }
	36	])
	37	expect(priorityQueue.head.next).toBe(undefined)
	38	expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
	39	rtSize = priorityQueue.enqueue(3)
	40	expect(priorityQueue.size).toBe(3)
	41	expect(priorityQueue.maxSize).toBe(3)
	42	expect(rtSize).toBe(priorityQueue.size)
	43	expect(priorityQueue.head.nodeArray).toMatchObject([
	44	{ data: 1, priority: 0 },
	45	{ data: 2, priority: 0 },
	46	{ data: 3, priority: 0 }
	47	])
	48	expect(priorityQueue.head.next).toBe(undefined)
	49	expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
	50	rtSize = priorityQueue.enqueue(3, -1)
	51	expect(priorityQueue.size).toBe(4)
	52	expect(priorityQueue.maxSize).toBe(4)
	53	expect(rtSize).toBe(priorityQueue.size)
	54	expect(priorityQueue.head.nodeArray).toMatchObject([
	55	{ data: 3, priority: -1 },
	56	{ data: 1, priority: 0 },
	57	{ data: 2, priority: 0 },
	58	{ data: 3, priority: 0 }
	59	])
	60	expect(priorityQueue.head.next).toBe(undefined)
	61	expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
	62	rtSize = priorityQueue.enqueue(1, 1)
	63	expect(priorityQueue.size).toBe(5)
	64	expect(priorityQueue.maxSize).toBe(5)
	65	expect(rtSize).toBe(priorityQueue.size)
	66	expect(priorityQueue.head.nodeArray).toMatchObject([
	67	{ data: 3, priority: -1 },
	68	{ data: 1, priority: 0 },
	69	{ data: 2, priority: 0 },
	70	{ data: 3, priority: 0 },
	71	{ data: 1, priority: 1 }
	72	])
	73	expect(priorityQueue.head.next).toBe(undefined)
	74	expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
	75	})
	76
	77	it('Verify bucketSize=2 enqueue() behavior', () => {
	78	const priorityQueue = new PriorityQueue(2)
	79	let rtSize = priorityQueue.enqueue(1)
	80	expect(priorityQueue.size).toBe(1)
	81	expect(priorityQueue.maxSize).toBe(1)
	82	expect(rtSize).toBe(priorityQueue.size)
	83	expect(priorityQueue.head.nodeArray).toMatchObject([
	84	{ data: 1, priority: 0 }
	85	])
	86	expect(priorityQueue.head.next).toBe(undefined)
	87	expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
	88	rtSize = priorityQueue.enqueue(2)
	89	expect(priorityQueue.size).toBe(2)
	90	expect(priorityQueue.maxSize).toBe(2)
	91	expect(rtSize).toBe(priorityQueue.size)
	92	expect(priorityQueue.head.nodeArray).toMatchObject([
	93	{ data: 1, priority: 0 },
	94	{ data: 2, priority: 0 }
	95	])
	96	expect(priorityQueue.head.next).toBe(undefined)
	97	expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
	98	rtSize = priorityQueue.enqueue(3)
	99	expect(priorityQueue.size).toBe(3)
	100	expect(priorityQueue.maxSize).toBe(3)
	101	expect(rtSize).toBe(priorityQueue.size)
	102	expect(priorityQueue.head.nodeArray).toMatchObject([
	103	{ data: 3, priority: 0 }
	104	])
	105	expect(priorityQueue.head.next).toBe(undefined)
	106	expect(priorityQueue.tail.nodeArray).toMatchObject([
	107	{ data: 1, priority: 0 },
	108	{ data: 2, priority: 0 }
	109	])
	110	expect(priorityQueue.tail.next).toStrictEqual(priorityQueue.head)
	111	rtSize = priorityQueue.enqueue(3, -1)
	112	expect(priorityQueue.size).toBe(4)
	113	expect(priorityQueue.maxSize).toBe(4)
	114	expect(rtSize).toBe(priorityQueue.size)
	115	expect(priorityQueue.head.nodeArray).toMatchObject([
	116	{ data: 3, priority: -1 },
	117	{ data: 3, priority: 0 }
	118	])
	119	expect(priorityQueue.head.next).toBe(undefined)
	120	expect(priorityQueue.tail.nodeArray).toMatchObject([
	121	{ data: 1, priority: 0 },
	122	{ data: 2, priority: 0 }
	123	])
	124	expect(priorityQueue.tail.next).toStrictEqual(priorityQueue.head)
	125	rtSize = priorityQueue.enqueue(1, 1)
	126	expect(priorityQueue.size).toBe(5)
	127	expect(priorityQueue.maxSize).toBe(5)
	128	expect(rtSize).toBe(priorityQueue.size)
	129	expect(priorityQueue.head.nodeArray).toMatchObject([
	130	{ data: 1, priority: 1 }
	131	])
	132	expect(priorityQueue.head.next).toBe(undefined)
	133	expect(priorityQueue.tail.nodeArray).toMatchObject([
	134	{ data: 1, priority: 0 },
	135	{ data: 2, priority: 0 }
	136	])
	137	expect(priorityQueue.tail.next).not.toStrictEqual(priorityQueue.head)
	138	expect(priorityQueue.tail.next.nodeArray).toMatchObject([
	139	{ data: 3, priority: -1 },
	140	{ data: 3, priority: 0 }
	141	])
	142	rtSize = priorityQueue.enqueue(3, -2)
	143	expect(priorityQueue.size).toBe(6)
	144	expect(priorityQueue.maxSize).toBe(6)
	145	expect(rtSize).toBe(priorityQueue.size)
	146	expect(priorityQueue.head.nodeArray).toMatchObject([
	147	{ data: 3, priority: -2 },
	148	{ data: 1, priority: 1 }
	149	])
	150	expect(priorityQueue.head.next).toBe(undefined)
	151	expect(priorityQueue.tail.nodeArray).toMatchObject([
	152	{ data: 1, priority: 0 },
	153	{ data: 2, priority: 0 }
	154	])
	155	expect(priorityQueue.tail.next).not.toStrictEqual(priorityQueue.head)
	156	expect(priorityQueue.tail.next.nodeArray).toMatchObject([
	157	{ data: 3, priority: -1 },
	158	{ data: 3, priority: 0 }
	159	])
	160	})
	161
	162	it('Verify default bucket size dequeue() behavior', () => {
	163	const priorityQueue = new PriorityQueue()
	164	priorityQueue.enqueue(1)
	165	priorityQueue.enqueue(2, -1)
	166	priorityQueue.enqueue(3)
	167	expect(priorityQueue.size).toBe(3)
	168	expect(priorityQueue.maxSize).toBe(3)
	169	expect(priorityQueue.tail.empty()).toBe(false)
	170	expect(priorityQueue.tail.next).toBe(undefined)
	171	let rtItem = priorityQueue.dequeue()
	172	expect(priorityQueue.size).toBe(2)
	173	expect(priorityQueue.maxSize).toBe(3)
	174	expect(rtItem).toBe(2)
	175	expect(priorityQueue.tail.empty()).toBe(false)
	176	expect(priorityQueue.tail.next).toBe(undefined)
	177	rtItem = priorityQueue.dequeue()
	178	expect(priorityQueue.size).toBe(1)
	179	expect(priorityQueue.maxSize).toBe(3)
	180	expect(rtItem).toBe(1)
	181	expect(priorityQueue.tail.empty()).toBe(false)
	182	expect(priorityQueue.tail.next).toBe(undefined)
	183	rtItem = priorityQueue.dequeue()
	184	expect(priorityQueue.size).toBe(0)
	185	expect(priorityQueue.maxSize).toBe(3)
	186	expect(rtItem).toBe(3)
	187	expect(priorityQueue.tail.empty()).toBe(true)
	188	expect(priorityQueue.tail.next).toBe(undefined)
	189	})
	190
	191	it('Verify bucketSize=2 dequeue() behavior', () => {
	192	const priorityQueue = new PriorityQueue(2)
	193	priorityQueue.enqueue(1)
	194	priorityQueue.enqueue(2)
	195	priorityQueue.enqueue(3)
	196	priorityQueue.enqueue(3, -1)
	197	priorityQueue.enqueue(1, 1)
	198	priorityQueue.enqueue(3, -2)
	199	expect(priorityQueue.size).toBe(6)
	200	expect(priorityQueue.maxSize).toBe(6)
	201	expect(priorityQueue.tail.empty()).toBe(false)
	202	expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
	203	let rtItem = priorityQueue.dequeue(3)
	204	expect(priorityQueue.size).toBe(5)
	205	expect(priorityQueue.maxSize).toBe(6)
	206	expect(rtItem).toBe(3)
	207	expect(priorityQueue.tail.empty()).toBe(false)
	208	expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
	209	rtItem = priorityQueue.dequeue()
	210	expect(priorityQueue.size).toBe(4)
	211	expect(priorityQueue.maxSize).toBe(6)
	212	expect(rtItem).toBe(1)
	213	expect(priorityQueue.tail.empty()).toBe(false)
	214	expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
	215	rtItem = priorityQueue.dequeue(2)
	216	expect(priorityQueue.size).toBe(3)
	217	expect(priorityQueue.maxSize).toBe(6)
	218	expect(rtItem).toBe(3)
	219	expect(priorityQueue.tail.empty()).toBe(false)
	220	expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
	221	rtItem = priorityQueue.dequeue(2)
	222	expect(priorityQueue.size).toBe(2)
	223	expect(priorityQueue.maxSize).toBe(6)
	224	expect(rtItem).toBe(3)
	225	expect(priorityQueue.tail.empty()).toBe(false)
	226	expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
	227	rtItem = priorityQueue.dequeue(2)
	228	expect(priorityQueue.size).toBe(1)
	229	expect(priorityQueue.maxSize).toBe(6)
	230	expect(rtItem).toBe(1)
	231	expect(priorityQueue.tail.empty()).toBe(false)
	232	expect(priorityQueue.tail.next).toBeInstanceOf(FixedPriorityQueue)
	233	rtItem = priorityQueue.dequeue()
	234	expect(priorityQueue.size).toBe(0)
	235	expect(priorityQueue.maxSize).toBe(6)
	236	expect(rtItem).toBe(2)
	237	expect(priorityQueue.tail.empty()).toBe(true)
	238	expect(priorityQueue.tail.next).toBe(undefined)
	239	})
	240
	241	it('Verify iterator behavior', () => {
	242	const priorityQueue = new PriorityQueue(2)
	243	priorityQueue.enqueue(1)
	244	priorityQueue.enqueue(2)
	245	priorityQueue.enqueue(3)
	246	let i = 1
	247	for (const value of priorityQueue) {
	248	expect(value).toBe(i)
	249	++i
	250	}
	251	})
	252
	253	it('Verify clear() behavior', () => {
	254	const priorityQueue = new PriorityQueue(2)
	255	priorityQueue.enqueue(1)
	256	priorityQueue.enqueue(2)
	257	priorityQueue.enqueue(3)
	258	expect(priorityQueue.size).toBe(3)
	259	expect(priorityQueue.maxSize).toBe(3)
	260	expect(priorityQueue.head.empty()).toBe(false)
	261	expect(priorityQueue.tail.empty()).toBe(false)
	262	expect(priorityQueue.tail).not.toStrictEqual(priorityQueue.head)
	263	priorityQueue.clear()
	264	expect(priorityQueue.size).toBe(0)
	265	expect(priorityQueue.maxSize).toBe(0)
	266	expect(priorityQueue.head.empty()).toBe(true)
	267	expect(priorityQueue.tail).toStrictEqual(priorityQueue.head)
	268	})
	269	})