authorgravatar for git@zander.xyzZander Khan <git@zander.xyz> 2021-01-16 18:09:44+00:00
committergravatar for git@zander.xyzZander Khan <git@zander.xyz> 2021-01-16 18:09:44+00:00
log4600b489a6daf3990afc8464dd7f2b9a1a4efa72
tree71f39f7480ed09db71ed50d2fa6a25248b45f0a1
parent4d098034141d1f6ea5874d147227979af8aaae3c

Rename heap to queue in tests for consistency

1 files changed, 233 insertions(+), 233 deletions(-)

lib/std/priority_dequeue.zig+233-233
...@@ -334,7 +334,7 @@ pub fn PriorityDequeue(comptime T: type) type {...@@ -334,7 +334,7 @@ pub fn PriorityDequeue(comptime T: type) type {
334 }334 }
335 }335 }
336336
337 /// Return the number of elements remaining in the heap337 /// Return the number of elements remaining in the dequeue
338 pub fn count(self: Self) usize {338 pub fn count(self: Self) usize {
339 return self.len;339 return self.len;
340 }340 }
...@@ -345,7 +345,7 @@ pub fn PriorityDequeue(comptime T: type) type {...@@ -345,7 +345,7 @@ pub fn PriorityDequeue(comptime T: type) type {
345 return self.items.len;345 return self.items.len;
346 }346 }
347347
348 /// Heap takes ownership of the passed in slice. The slice must have been348 /// Dequeue takes ownership of the passed in slice. The slice must have been
349 /// allocated with `allocator`.349 /// allocated with `allocator`.
350 /// De-initialize with `deinit`.350 /// De-initialize with `deinit`.
351 pub fn fromOwnedSlice(allocator: *Allocator, lessThanFn: fn (T, T) bool, items: []T) Self {351 pub fn fromOwnedSlice(allocator: *Allocator, lessThanFn: fn (T, T) bool, items: []T) Self {
...@@ -395,14 +395,14 @@ pub fn PriorityDequeue(comptime T: type) type {...@@ -395,14 +395,14 @@ pub fn PriorityDequeue(comptime T: type) type {
395 }395 }
396396
397 pub const Iterator = struct {397 pub const Iterator = struct {
398 heap: *PriorityDequeue(T),398 queue: *PriorityDequeue(T),
399 count: usize,399 count: usize,
400400
401 pub fn next(it: *Iterator) ?T {401 pub fn next(it: *Iterator) ?T {
402 if (it.count >= it.heap.len) return null;402 if (it.count >= it.queue.len) return null;
403 const out = it.count;403 const out = it.count;
404 it.count += 1;404 it.count += 1;
405 return it.heap.items[out];405 return it.queue.items[out];
406 }406 }
407407
408 pub fn reset(it: *Iterator) void {408 pub fn reset(it: *Iterator) void {
...@@ -410,11 +410,11 @@ pub fn PriorityDequeue(comptime T: type) type {...@@ -410,11 +410,11 @@ pub fn PriorityDequeue(comptime T: type) type {
410 }410 }
411 };411 };
412412
413 /// Return an iterator that walks the heap without consuming413 /// Return an iterator that walks the queue without consuming
414 /// it. Invalidated if the heap is modified.414 /// it. Invalidated if the queue is modified.
415 pub fn iterator(self: *Self) Iterator {415 pub fn iterator(self: *Self) Iterator {
416 return Iterator{416 return Iterator{
417 .heap = self,417 .queue = self,
418 .count = 0,418 .count = 0,
419 };419 };
420 }420 }
...@@ -457,308 +457,308 @@ fn lessThanComparison(a: u32, b: u32) bool {...@@ -457,308 +457,308 @@ fn lessThanComparison(a: u32, b: u32) bool {
457 return a < b;457 return a < b;
458}458}
459459
460const Heap = PriorityDequeue(u32);460const PDQ = PriorityDequeue(u32);
461461
462test "std.PriorityDequeue: add and remove min" {462test "std.PriorityDequeue: add and remove min" {
463 var heap = Heap.init(testing.allocator, lessThanComparison);463 var queue = PDQ.init(testing.allocator, lessThanComparison);
464 defer heap.deinit();464 defer queue.deinit();
465465
466 try heap.add(54);466 try queue.add(54);
467 try heap.add(12);467 try queue.add(12);
468 try heap.add(7);468 try queue.add(7);
469 try heap.add(23);469 try queue.add(23);
470 try heap.add(25);470 try queue.add(25);
471 try heap.add(13);471 try queue.add(13);
472472
473 expectEqual(@as(u32, 7), heap.removeMin());473 expectEqual(@as(u32, 7), queue.removeMin());
474 expectEqual(@as(u32, 12), heap.removeMin());474 expectEqual(@as(u32, 12), queue.removeMin());
475 expectEqual(@as(u32, 13), heap.removeMin());475 expectEqual(@as(u32, 13), queue.removeMin());
476 expectEqual(@as(u32, 23), heap.removeMin());476 expectEqual(@as(u32, 23), queue.removeMin());
477 expectEqual(@as(u32, 25), heap.removeMin());477 expectEqual(@as(u32, 25), queue.removeMin());
478 expectEqual(@as(u32, 54), heap.removeMin());478 expectEqual(@as(u32, 54), queue.removeMin());
479}479}
480480
481test "std.PriorityDequeue: add and remove max" {481test "std.PriorityDequeue: add and remove max" {
482 var heap = Heap.init(testing.allocator, lessThanComparison);482 var queue = PDQ.init(testing.allocator, lessThanComparison);
483 defer heap.deinit();483 defer queue.deinit();
484484
485 try heap.add(54);485 try queue.add(54);
486 try heap.add(12);486 try queue.add(12);
487 try heap.add(7);487 try queue.add(7);
488 try heap.add(23);488 try queue.add(23);
489 try heap.add(25);489 try queue.add(25);
490 try heap.add(13);490 try queue.add(13);
491491
492 expectEqual(@as(u32, 54), heap.removeMax());492 expectEqual(@as(u32, 54), queue.removeMax());
493 expectEqual(@as(u32, 25), heap.removeMax());493 expectEqual(@as(u32, 25), queue.removeMax());
494 expectEqual(@as(u32, 23), heap.removeMax());494 expectEqual(@as(u32, 23), queue.removeMax());
495 expectEqual(@as(u32, 13), heap.removeMax());495 expectEqual(@as(u32, 13), queue.removeMax());
496 expectEqual(@as(u32, 12), heap.removeMax());496 expectEqual(@as(u32, 12), queue.removeMax());
497 expectEqual(@as(u32, 7), heap.removeMax());497 expectEqual(@as(u32, 7), queue.removeMax());
498}498}
499499
500test "std.PriorityDequeue: add and remove same min" {500test "std.PriorityDequeue: add and remove same min" {
501 var heap = Heap.init(testing.allocator, lessThanComparison);501 var queue = PDQ.init(testing.allocator, lessThanComparison);
502 defer heap.deinit();502 defer queue.deinit();
503503
504 try heap.add(1);504 try queue.add(1);
505 try heap.add(1);505 try queue.add(1);
506 try heap.add(2);506 try queue.add(2);
507 try heap.add(2);507 try queue.add(2);
508 try heap.add(1);508 try queue.add(1);
509 try heap.add(1);509 try queue.add(1);
510510
511 expectEqual(@as(u32, 1), heap.removeMin());511 expectEqual(@as(u32, 1), queue.removeMin());
512 expectEqual(@as(u32, 1), heap.removeMin());512 expectEqual(@as(u32, 1), queue.removeMin());
513 expectEqual(@as(u32, 1), heap.removeMin());513 expectEqual(@as(u32, 1), queue.removeMin());
514 expectEqual(@as(u32, 1), heap.removeMin());514 expectEqual(@as(u32, 1), queue.removeMin());
515 expectEqual(@as(u32, 2), heap.removeMin());515 expectEqual(@as(u32, 2), queue.removeMin());
516 expectEqual(@as(u32, 2), heap.removeMin());516 expectEqual(@as(u32, 2), queue.removeMin());
517}517}
518518
519test "std.PriorityDequeue: add and remove same max" {519test "std.PriorityDequeue: add and remove same max" {
520 var heap = Heap.init(testing.allocator, lessThanComparison);520 var queue = PDQ.init(testing.allocator, lessThanComparison);
521 defer heap.deinit();521 defer queue.deinit();
522522
523 try heap.add(1);523 try queue.add(1);
524 try heap.add(1);524 try queue.add(1);
525 try heap.add(2);525 try queue.add(2);
526 try heap.add(2);526 try queue.add(2);
527 try heap.add(1);527 try queue.add(1);
528 try heap.add(1);528 try queue.add(1);
529529
530 expectEqual(@as(u32, 2), heap.removeMax());530 expectEqual(@as(u32, 2), queue.removeMax());
531 expectEqual(@as(u32, 2), heap.removeMax());531 expectEqual(@as(u32, 2), queue.removeMax());
532 expectEqual(@as(u32, 1), heap.removeMax());532 expectEqual(@as(u32, 1), queue.removeMax());
533 expectEqual(@as(u32, 1), heap.removeMax());533 expectEqual(@as(u32, 1), queue.removeMax());
534 expectEqual(@as(u32, 1), heap.removeMax());534 expectEqual(@as(u32, 1), queue.removeMax());
535 expectEqual(@as(u32, 1), heap.removeMax());535 expectEqual(@as(u32, 1), queue.removeMax());
536}536}
537537
538test "std.PriorityDequeue: removeOrNull empty" {538test "std.PriorityDequeue: removeOrNull empty" {
539 var heap = Heap.init(testing.allocator, lessThanComparison);539 var queue = PDQ.init(testing.allocator, lessThanComparison);
540 defer heap.deinit();540 defer queue.deinit();
541541
542 expect(heap.removeMinOrNull() == null);542 expect(queue.removeMinOrNull() == null);
543 expect(heap.removeMaxOrNull() == null);543 expect(queue.removeMaxOrNull() == null);
544}544}
545545
546test "std.PriorityDequeue: edge case 3 elements" {546test "std.PriorityDequeue: edge case 3 elements" {
547 var heap = Heap.init(testing.allocator, lessThanComparison);547 var queue = PDQ.init(testing.allocator, lessThanComparison);
548 defer heap.deinit();548 defer queue.deinit();
549549
550 try heap.add(9);550 try queue.add(9);
551 try heap.add(3);551 try queue.add(3);
552 try heap.add(2);552 try queue.add(2);
553553
554 expectEqual(@as(u32, 2), heap.removeMin());554 expectEqual(@as(u32, 2), queue.removeMin());
555 expectEqual(@as(u32, 3), heap.removeMin());555 expectEqual(@as(u32, 3), queue.removeMin());
556 expectEqual(@as(u32, 9), heap.removeMin());556 expectEqual(@as(u32, 9), queue.removeMin());
557}557}
558558
559test "std.PriorityDequeue: edge case 3 elements max" {559test "std.PriorityDequeue: edge case 3 elements max" {
560 var heap = Heap.init(testing.allocator, lessThanComparison);560 var queue = PDQ.init(testing.allocator, lessThanComparison);
561 defer heap.deinit();561 defer queue.deinit();
562562
563 try heap.add(9);563 try queue.add(9);
564 try heap.add(3);564 try queue.add(3);
565 try heap.add(2);565 try queue.add(2);
566566
567 expectEqual(@as(u32, 9), heap.removeMax());567 expectEqual(@as(u32, 9), queue.removeMax());
568 expectEqual(@as(u32, 3), heap.removeMax());568 expectEqual(@as(u32, 3), queue.removeMax());
569 expectEqual(@as(u32, 2), heap.removeMax());569 expectEqual(@as(u32, 2), queue.removeMax());
570}570}
571571
572test "std.PriorityDequeue: peekMin" {572test "std.PriorityDequeue: peekMin" {
573 var heap = Heap.init(testing.allocator, lessThanComparison);573 var queue = PDQ.init(testing.allocator, lessThanComparison);
574 defer heap.deinit();574 defer queue.deinit();
575575
576 expect(heap.peekMin() == null);576 expect(queue.peekMin() == null);
577577
578 try heap.add(9);578 try queue.add(9);
579 try heap.add(3);579 try queue.add(3);
580 try heap.add(2);580 try queue.add(2);
581581
582 expect(heap.peekMin().? == 2);582 expect(queue.peekMin().? == 2);
583 expect(heap.peekMin().? == 2);583 expect(queue.peekMin().? == 2);
584}584}
585585
586test "std.PriorityDequeue: peekMax" {586test "std.PriorityDequeue: peekMax" {
587 var heap = Heap.init(testing.allocator, lessThanComparison);587 var queue = PDQ.init(testing.allocator, lessThanComparison);
588 defer heap.deinit();588 defer queue.deinit();
589589
590 expect(heap.peekMin() == null);590 expect(queue.peekMin() == null);
591591
592 try heap.add(9);592 try queue.add(9);
593 try heap.add(3);593 try queue.add(3);
594 try heap.add(2);594 try queue.add(2);
595595
596 expect(heap.peekMax().? == 9);596 expect(queue.peekMax().? == 9);
597 expect(heap.peekMax().? == 9);597 expect(queue.peekMax().? == 9);
598}598}
599599
600test "std.PriorityDequeue: sift up with odd indices" {600test "std.PriorityDequeue: sift up with odd indices" {
601 var heap = Heap.init(testing.allocator, lessThanComparison);601 var queue = PDQ.init(testing.allocator, lessThanComparison);
602 defer heap.deinit();602 defer queue.deinit();
603 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };603 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
604 for (items) |e| {604 for (items) |e| {
605 try heap.add(e);605 try queue.add(e);
606 }606 }
607607
608 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };608 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
609 for (sorted_items) |e| {609 for (sorted_items) |e| {
610 expectEqual(e, heap.removeMin());610 expectEqual(e, queue.removeMin());
611 }611 }
612}612}
613613
614test "std.PriorityDequeue: sift up with odd indices" {614test "std.PriorityDequeue: sift up with odd indices" {
615 var heap = Heap.init(testing.allocator, lessThanComparison);615 var queue = PDQ.init(testing.allocator, lessThanComparison);
616 defer heap.deinit();616 defer queue.deinit();
617 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };617 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
618 for (items) |e| {618 for (items) |e| {
619 try heap.add(e);619 try queue.add(e);
620 }620 }
621621
622 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };622 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
623 for (sorted_items) |e| {623 for (sorted_items) |e| {
624 expectEqual(e, heap.removeMax());624 expectEqual(e, queue.removeMax());
625 }625 }
626}626}
627627
628test "std.PriorityDequeue: addSlice min" {628test "std.PriorityDequeue: addSlice min" {
629 var heap = Heap.init(testing.allocator, lessThanComparison);629 var queue = PDQ.init(testing.allocator, lessThanComparison);
630 defer heap.deinit();630 defer queue.deinit();
631 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };631 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
632 try heap.addSlice(items[0..]);632 try queue.addSlice(items[0..]);
633633
634 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };634 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
635 for (sorted_items) |e| {635 for (sorted_items) |e| {
636 expectEqual(e, heap.removeMin());636 expectEqual(e, queue.removeMin());
637 }637 }
638}638}
639639
640test "std.PriorityDequeue: addSlice max" {640test "std.PriorityDequeue: addSlice max" {
641 var heap = Heap.init(testing.allocator, lessThanComparison);641 var queue = PDQ.init(testing.allocator, lessThanComparison);
642 defer heap.deinit();642 defer queue.deinit();
643 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };643 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
644 try heap.addSlice(items[0..]);644 try queue.addSlice(items[0..]);
645645
646 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };646 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
647 for (sorted_items) |e| {647 for (sorted_items) |e| {
648 expectEqual(e, heap.removeMax());648 expectEqual(e, queue.removeMax());
649 }649 }
650}650}
651651
652test "std.PriorityDequeue: fromOwnedSlice trivial case 0" {652test "std.PriorityDequeue: fromOwnedSlice trivial case 0" {
653 const items = [0]u32{};653 const items = [0]u32{};
654 const heap_items = try testing.allocator.dupe(u32, &items);654 const queue_items = try testing.allocator.dupe(u32, &items);
655 var heap = Heap.fromOwnedSlice(testing.allocator, lessThanComparison, heap_items[0..]);655 var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, queue_items[0..]);
656 defer heap.deinit();656 defer queue.deinit();
657 expectEqual(@as(usize, 0), heap.len);657 expectEqual(@as(usize, 0), queue.len);
658 expect(heap.removeMinOrNull() == null);658 expect(queue.removeMinOrNull() == null);
659}659}
660660
661test "std.PriorityDequeue: fromOwnedSlice trivial case 1" {661test "std.PriorityDequeue: fromOwnedSlice trivial case 1" {
662 const items = [1]u32{1};662 const items = [1]u32{1};
663 const heap_items = try testing.allocator.dupe(u32, &items);663 const queue_items = try testing.allocator.dupe(u32, &items);
664 var heap = Heap.fromOwnedSlice(testing.allocator, lessThanComparison, heap_items[0..]);664 var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, queue_items[0..]);
665 defer heap.deinit();665 defer queue.deinit();
666666
667 expectEqual(@as(usize, 1), heap.len);667 expectEqual(@as(usize, 1), queue.len);
668 expectEqual(items[0], heap.removeMin());668 expectEqual(items[0], queue.removeMin());
669 expect(heap.removeMinOrNull() == null);669 expect(queue.removeMinOrNull() == null);
670}670}
671671
672test "std.PriorityDequeue: fromOwnedSlice" {672test "std.PriorityDequeue: fromOwnedSlice" {
673 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };673 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
674 const heap_items = try testing.allocator.dupe(u32, items[0..]);674 const queue_items = try testing.allocator.dupe(u32, items[0..]);
675 var heap = Heap.fromOwnedSlice(testing.allocator, lessThanComparison, heap_items[0..]);675 var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, queue_items[0..]);
676 defer heap.deinit();676 defer queue.deinit();
677677
678 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };678 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
679 for (sorted_items) |e| {679 for (sorted_items) |e| {
680 expectEqual(e, heap.removeMin());680 expectEqual(e, queue.removeMin());
681 }681 }
682}682}
683683
684test "std.PriorityDequeue: update min heap" {684test "std.PriorityDequeue: update min queue" {
685 var heap = Heap.init(testing.allocator, lessThanComparison);685 var queue = PDQ.init(testing.allocator, lessThanComparison);
686 defer heap.deinit();686 defer queue.deinit();
687687
688 try heap.add(55);688 try queue.add(55);
689 try heap.add(44);689 try queue.add(44);
690 try heap.add(11);690 try queue.add(11);
691 try heap.update(55, 5);691 try queue.update(55, 5);
692 try heap.update(44, 4);692 try queue.update(44, 4);
693 try heap.update(11, 1);693 try queue.update(11, 1);
694 expectEqual(@as(u32, 1), heap.removeMin());694 expectEqual(@as(u32, 1), queue.removeMin());
695 expectEqual(@as(u32, 4), heap.removeMin());695 expectEqual(@as(u32, 4), queue.removeMin());
696 expectEqual(@as(u32, 5), heap.removeMin());696 expectEqual(@as(u32, 5), queue.removeMin());
697}697}
698698
699test "std.PriorityDequeue: update same min heap" {699test "std.PriorityDequeue: update same min queue" {
700 var heap = Heap.init(testing.allocator, lessThanComparison);700 var queue = PDQ.init(testing.allocator, lessThanComparison);
701 defer heap.deinit();701 defer queue.deinit();
702702
703 try heap.add(1);703 try queue.add(1);
704 try heap.add(1);704 try queue.add(1);
705 try heap.add(2);705 try queue.add(2);
706 try heap.add(2);706 try queue.add(2);
707 try heap.update(1, 5);707 try queue.update(1, 5);
708 try heap.update(2, 4);708 try queue.update(2, 4);
709 expectEqual(@as(u32, 1), heap.removeMin());709 expectEqual(@as(u32, 1), queue.removeMin());
710 expectEqual(@as(u32, 2), heap.removeMin());710 expectEqual(@as(u32, 2), queue.removeMin());
711 expectEqual(@as(u32, 4), heap.removeMin());711 expectEqual(@as(u32, 4), queue.removeMin());
712 expectEqual(@as(u32, 5), heap.removeMin());712 expectEqual(@as(u32, 5), queue.removeMin());
713}713}
714714
715test "std.PriorityDequeue: update max heap" {715test "std.PriorityDequeue: update max queue" {
716 var heap = Heap.init(testing.allocator, lessThanComparison);716 var queue = PDQ.init(testing.allocator, lessThanComparison);
717 defer heap.deinit();717 defer queue.deinit();
718718
719 try heap.add(55);719 try queue.add(55);
720 try heap.add(44);720 try queue.add(44);
721 try heap.add(11);721 try queue.add(11);
722 try heap.update(55, 5);722 try queue.update(55, 5);
723 try heap.update(44, 1);723 try queue.update(44, 1);
724 try heap.update(11, 4);724 try queue.update(11, 4);
725725
726 expectEqual(@as(u32, 5), heap.removeMax());726 expectEqual(@as(u32, 5), queue.removeMax());
727 expectEqual(@as(u32, 4), heap.removeMax());727 expectEqual(@as(u32, 4), queue.removeMax());
728 expectEqual(@as(u32, 1), heap.removeMax());728 expectEqual(@as(u32, 1), queue.removeMax());
729}729}
730730
731test "std.PriorityDequeue: update same max heap" {731test "std.PriorityDequeue: update same max queue" {
732 var heap = Heap.init(testing.allocator, lessThanComparison);732 var queue = PDQ.init(testing.allocator, lessThanComparison);
733 defer heap.deinit();733 defer queue.deinit();
734734
735 try heap.add(1);735 try queue.add(1);
736 try heap.add(1);736 try queue.add(1);
737 try heap.add(2);737 try queue.add(2);
738 try heap.add(2);738 try queue.add(2);
739 try heap.update(1, 5);739 try queue.update(1, 5);
740 try heap.update(2, 4);740 try queue.update(2, 4);
741 expectEqual(@as(u32, 5), heap.removeMax());741 expectEqual(@as(u32, 5), queue.removeMax());
742 expectEqual(@as(u32, 4), heap.removeMax());742 expectEqual(@as(u32, 4), queue.removeMax());
743 expectEqual(@as(u32, 2), heap.removeMax());743 expectEqual(@as(u32, 2), queue.removeMax());
744 expectEqual(@as(u32, 1), heap.removeMax());744 expectEqual(@as(u32, 1), queue.removeMax());
745}745}
746746
747test "std.PriorityDequeue: iterator" {747test "std.PriorityDequeue: iterator" {
748 var heap = Heap.init(testing.allocator, lessThanComparison);748 var queue = PDQ.init(testing.allocator, lessThanComparison);
749 var map = std.AutoHashMap(u32, void).init(testing.allocator);749 var map = std.AutoHashMap(u32, void).init(testing.allocator);
750 defer {750 defer {
751 heap.deinit();751 queue.deinit();
752 map.deinit();752 map.deinit();
753 }753 }
754754
755 const items = [_]u32{ 54, 12, 7, 23, 25, 13 };755 const items = [_]u32{ 54, 12, 7, 23, 25, 13 };
756 for (items) |e| {756 for (items) |e| {
757 _ = try heap.add(e);757 _ = try queue.add(e);
758 _ = try map.put(e, {});758 _ = try map.put(e, {});
759 }759 }
760760
761 var it = heap.iterator();761 var it = queue.iterator();
762 while (it.next()) |e| {762 while (it.next()) |e| {
763 _ = map.remove(e);763 _ = map.remove(e);
764 }764 }
...@@ -767,14 +767,14 @@ test "std.PriorityDequeue: iterator" {...@@ -767,14 +767,14 @@ test "std.PriorityDequeue: iterator" {
767}767}
768768
769test "std.PriorityDequeue: remove at index" {769test "std.PriorityDequeue: remove at index" {
770 var heap = Heap.init(testing.allocator, lessThanComparison);770 var queue = PDQ.init(testing.allocator, lessThanComparison);
771 defer heap.deinit();771 defer queue.deinit();
772772
773 try heap.add(3);773 try queue.add(3);
774 try heap.add(2);774 try queue.add(2);
775 try heap.add(1);775 try queue.add(1);
776776
777 var it = heap.iterator();777 var it = queue.iterator();
778 var elem = it.next();778 var elem = it.next();
779 var idx: usize = 0;779 var idx: usize = 0;
780 const two_idx = while (elem != null) : (elem = it.next()) {780 const two_idx = while (elem != null) : (elem = it.next()) {
...@@ -783,17 +783,17 @@ test "std.PriorityDequeue: remove at index" {...@@ -783,17 +783,17 @@ test "std.PriorityDequeue: remove at index" {
783 idx += 1;783 idx += 1;
784 } else unreachable;784 } else unreachable;
785785
786 expectEqual(heap.removeIndex(two_idx), 2);786 expectEqual(queue.removeIndex(two_idx), 2);
787 expectEqual(heap.removeMin(), 1);787 expectEqual(queue.removeMin(), 1);
788 expectEqual(heap.removeMin(), 3);788 expectEqual(queue.removeMin(), 3);
789 expectEqual(heap.removeMinOrNull(), null);789 expectEqual(queue.removeMinOrNull(), null);
790}790}
791791
792test "std.PriorityDequeue: iterator while empty" {792test "std.PriorityDequeue: iterator while empty" {
793 var heap = Heap.init(testing.allocator, lessThanComparison);793 var queue = PDQ.init(testing.allocator, lessThanComparison);
794 defer heap.deinit();794 defer queue.deinit();
795795
796 var it = heap.iterator();796 var it = queue.iterator();
797797
798 expectEqual(it.next(), null);798 expectEqual(it.next(), null);
799}799}
...@@ -802,23 +802,23 @@ test "std.PriorityDequeue: fuzz testing min" {...@@ -802,23 +802,23 @@ test "std.PriorityDequeue: fuzz testing min" {
802 var prng = std.rand.DefaultPrng.init(0x12345678);802 var prng = std.rand.DefaultPrng.init(0x12345678);
803803
804 const test_case_count = 100;804 const test_case_count = 100;
805 const heap_size = 1_000;805 const queue_size = 1_000;
806806
807 var i: usize = 0;807 var i: usize = 0;
808 while (i < test_case_count) : (i += 1) {808 while (i < test_case_count) : (i += 1) {
809 try fuzzTestMin(&prng.random, heap_size);809 try fuzzTestMin(&prng.random, queue_size);
810 }810 }
811}811}
812812
813fn fuzzTestMin(rng: *std.rand.Random, comptime heap_size: usize) !void {813fn fuzzTestMin(rng: *std.rand.Random, comptime queue_size: usize) !void {
814 const allocator = testing.allocator;814 const allocator = testing.allocator;
815 const items = try generateRandomSlice(allocator, rng, heap_size);815 const items = try generateRandomSlice(allocator, rng, queue_size);
816816
817 var heap = Heap.fromOwnedSlice(allocator, lessThanComparison, items);817 var queue = PDQ.fromOwnedSlice(allocator, lessThanComparison, items);
818 defer heap.deinit();818 defer queue.deinit();
819819
820 var last_removed: ?u32 = null;820 var last_removed: ?u32 = null;
821 while (heap.removeMinOrNull()) |next| {821 while (queue.removeMinOrNull()) |next| {
822 if (last_removed) |last| {822 if (last_removed) |last| {
823 expect(last <= next);823 expect(last <= next);
824 }824 }
...@@ -830,23 +830,23 @@ test "std.PriorityDequeue: fuzz testing max" {...@@ -830,23 +830,23 @@ test "std.PriorityDequeue: fuzz testing max" {
830 var prng = std.rand.DefaultPrng.init(0x87654321);830 var prng = std.rand.DefaultPrng.init(0x87654321);
831831
832 const test_case_count = 100;832 const test_case_count = 100;
833 const heap_size = 1_000;833 const queue_size = 1_000;
834834
835 var i: usize = 0;835 var i: usize = 0;
836 while (i < test_case_count) : (i += 1) {836 while (i < test_case_count) : (i += 1) {
837 try fuzzTestMax(&prng.random, heap_size);837 try fuzzTestMax(&prng.random, queue_size);
838 }838 }
839}839}
840840
841fn fuzzTestMax(rng: *std.rand.Random, heap_size: usize) !void {841fn fuzzTestMax(rng: *std.rand.Random, queue_size: usize) !void {
842 const allocator = testing.allocator;842 const allocator = testing.allocator;
843 const items = try generateRandomSlice(allocator, rng, heap_size);843 const items = try generateRandomSlice(allocator, rng, queue_size);
844844
845 var heap = Heap.fromOwnedSlice(testing.allocator, lessThanComparison, items);845 var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, items);
846 defer heap.deinit();846 defer queue.deinit();
847847
848 var last_removed: ?u32 = null;848 var last_removed: ?u32 = null;
849 while (heap.removeMaxOrNull()) |next| {849 while (queue.removeMaxOrNull()) |next| {
850 if (last_removed) |last| {850 if (last_removed) |last| {
851 expect(last >= next);851 expect(last >= next);
852 }852 }
...@@ -858,33 +858,33 @@ test "std.PriorityDequeue: fuzz testing min and max" {...@@ -858,33 +858,33 @@ test "std.PriorityDequeue: fuzz testing min and max" {
858 var prng = std.rand.DefaultPrng.init(0x87654321);858 var prng = std.rand.DefaultPrng.init(0x87654321);
859859
860 const test_case_count = 100;860 const test_case_count = 100;
861 const heap_size = 1_000;861 const queue_size = 1_000;
862862
863 var i: usize = 0;863 var i: usize = 0;
864 while (i < test_case_count) : (i += 1) {864 while (i < test_case_count) : (i += 1) {
865 try fuzzTestMinMax(&prng.random, heap_size);865 try fuzzTestMinMax(&prng.random, queue_size);
866 }866 }
867}867}
868868
869fn fuzzTestMinMax(rng: *std.rand.Random, heap_size: usize) !void {869fn fuzzTestMinMax(rng: *std.rand.Random, queue_size: usize) !void {
870 const allocator = testing.allocator;870 const allocator = testing.allocator;
871 const items = try generateRandomSlice(allocator, rng, heap_size);871 const items = try generateRandomSlice(allocator, rng, queue_size);
872872
873 var heap = Heap.fromOwnedSlice(allocator, lessThanComparison, items);873 var queue = PDQ.fromOwnedSlice(allocator, lessThanComparison, items);
874 defer heap.deinit();874 defer queue.deinit();
875875
876 var last_min: ?u32 = null;876 var last_min: ?u32 = null;
877 var last_max: ?u32 = null;877 var last_max: ?u32 = null;
878 var i: usize = 0;878 var i: usize = 0;
879 while (i < heap_size) : (i += 1) {879 while (i < queue_size) : (i += 1) {
880 if (i % 2 == 0) {880 if (i % 2 == 0) {
881 const next = heap.removeMin();881 const next = queue.removeMin();
882 if (last_min) |last| {882 if (last_min) |last| {
883 expect(last <= next);883 expect(last <= next);
884 }884 }
885 last_min = next;885 last_min = next;
886 } else {886 } else {
887 const next = heap.removeMax();887 const next = queue.removeMax();
888 if (last_max) |last| {888 if (last_max) |last| {
889 expect(last >= next);889 expect(last >= next);
890 }890 }