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 {
334334 }
335335 }
336336
337 /// Return the number of elements remaining in the heap
337 /// Return the number of elements remaining in the dequeue
338338 pub fn count(self: Self) usize {
339339 return self.len;
340340 }
......@@ -345,7 +345,7 @@ pub fn PriorityDequeue(comptime T: type) type {
345345 return self.items.len;
346346 }
347347
348 /// Heap takes ownership of the passed in slice. The slice must have been
348 /// Dequeue takes ownership of the passed in slice. The slice must have been
349349 /// allocated with `allocator`.
350350 /// De-initialize with `deinit`.
351351 pub fn fromOwnedSlice(allocator: *Allocator, lessThanFn: fn (T, T) bool, items: []T) Self {
......@@ -395,14 +395,14 @@ pub fn PriorityDequeue(comptime T: type) type {
395395 }
396396
397397 pub const Iterator = struct {
398 heap: *PriorityDequeue(T),
398 queue: *PriorityDequeue(T),
399399 count: usize,
400400
401401 pub fn next(it: *Iterator) ?T {
402 if (it.count >= it.heap.len) return null;
402 if (it.count >= it.queue.len) return null;
403403 const out = it.count;
404404 it.count += 1;
405 return it.heap.items[out];
405 return it.queue.items[out];
406406 }
407407
408408 pub fn reset(it: *Iterator) void {
......@@ -410,11 +410,11 @@ pub fn PriorityDequeue(comptime T: type) type {
410410 }
411411 };
412412
413 /// Return an iterator that walks the heap without consuming
414 /// it. Invalidated if the heap is modified.
413 /// Return an iterator that walks the queue without consuming
414 /// it. Invalidated if the queue is modified.
415415 pub fn iterator(self: *Self) Iterator {
416416 return Iterator{
417 .heap = self,
417 .queue = self,
418418 .count = 0,
419419 };
420420 }
......@@ -457,308 +457,308 @@ fn lessThanComparison(a: u32, b: u32) bool {
457457 return a < b;
458458}
459459
460const Heap = PriorityDequeue(u32);
460const PDQ = PriorityDequeue(u32);
461461
462462test "std.PriorityDequeue: add and remove min" {
463 var heap = Heap.init(testing.allocator, lessThanComparison);
464 defer heap.deinit();
463 var queue = PDQ.init(testing.allocator, lessThanComparison);
464 defer queue.deinit();
465465
466 try heap.add(54);
467 try heap.add(12);
468 try heap.add(7);
469 try heap.add(23);
470 try heap.add(25);
471 try heap.add(13);
466 try queue.add(54);
467 try queue.add(12);
468 try queue.add(7);
469 try queue.add(23);
470 try queue.add(25);
471 try queue.add(13);
472472
473 expectEqual(@as(u32, 7), heap.removeMin());
474 expectEqual(@as(u32, 12), heap.removeMin());
475 expectEqual(@as(u32, 13), heap.removeMin());
476 expectEqual(@as(u32, 23), heap.removeMin());
477 expectEqual(@as(u32, 25), heap.removeMin());
478 expectEqual(@as(u32, 54), heap.removeMin());
473 expectEqual(@as(u32, 7), queue.removeMin());
474 expectEqual(@as(u32, 12), queue.removeMin());
475 expectEqual(@as(u32, 13), queue.removeMin());
476 expectEqual(@as(u32, 23), queue.removeMin());
477 expectEqual(@as(u32, 25), queue.removeMin());
478 expectEqual(@as(u32, 54), queue.removeMin());
479479}
480480
481481test "std.PriorityDequeue: add and remove max" {
482 var heap = Heap.init(testing.allocator, lessThanComparison);
483 defer heap.deinit();
482 var queue = PDQ.init(testing.allocator, lessThanComparison);
483 defer queue.deinit();
484484
485 try heap.add(54);
486 try heap.add(12);
487 try heap.add(7);
488 try heap.add(23);
489 try heap.add(25);
490 try heap.add(13);
485 try queue.add(54);
486 try queue.add(12);
487 try queue.add(7);
488 try queue.add(23);
489 try queue.add(25);
490 try queue.add(13);
491491
492 expectEqual(@as(u32, 54), heap.removeMax());
493 expectEqual(@as(u32, 25), heap.removeMax());
494 expectEqual(@as(u32, 23), heap.removeMax());
495 expectEqual(@as(u32, 13), heap.removeMax());
496 expectEqual(@as(u32, 12), heap.removeMax());
497 expectEqual(@as(u32, 7), heap.removeMax());
492 expectEqual(@as(u32, 54), queue.removeMax());
493 expectEqual(@as(u32, 25), queue.removeMax());
494 expectEqual(@as(u32, 23), queue.removeMax());
495 expectEqual(@as(u32, 13), queue.removeMax());
496 expectEqual(@as(u32, 12), queue.removeMax());
497 expectEqual(@as(u32, 7), queue.removeMax());
498498}
499499
500500test "std.PriorityDequeue: add and remove same min" {
501 var heap = Heap.init(testing.allocator, lessThanComparison);
502 defer heap.deinit();
501 var queue = PDQ.init(testing.allocator, lessThanComparison);
502 defer queue.deinit();
503503
504 try heap.add(1);
505 try heap.add(1);
506 try heap.add(2);
507 try heap.add(2);
508 try heap.add(1);
509 try heap.add(1);
504 try queue.add(1);
505 try queue.add(1);
506 try queue.add(2);
507 try queue.add(2);
508 try queue.add(1);
509 try queue.add(1);
510510
511 expectEqual(@as(u32, 1), heap.removeMin());
512 expectEqual(@as(u32, 1), heap.removeMin());
513 expectEqual(@as(u32, 1), heap.removeMin());
514 expectEqual(@as(u32, 1), heap.removeMin());
515 expectEqual(@as(u32, 2), heap.removeMin());
516 expectEqual(@as(u32, 2), heap.removeMin());
511 expectEqual(@as(u32, 1), queue.removeMin());
512 expectEqual(@as(u32, 1), queue.removeMin());
513 expectEqual(@as(u32, 1), queue.removeMin());
514 expectEqual(@as(u32, 1), queue.removeMin());
515 expectEqual(@as(u32, 2), queue.removeMin());
516 expectEqual(@as(u32, 2), queue.removeMin());
517517}
518518
519519test "std.PriorityDequeue: add and remove same max" {
520 var heap = Heap.init(testing.allocator, lessThanComparison);
521 defer heap.deinit();
520 var queue = PDQ.init(testing.allocator, lessThanComparison);
521 defer queue.deinit();
522522
523 try heap.add(1);
524 try heap.add(1);
525 try heap.add(2);
526 try heap.add(2);
527 try heap.add(1);
528 try heap.add(1);
523 try queue.add(1);
524 try queue.add(1);
525 try queue.add(2);
526 try queue.add(2);
527 try queue.add(1);
528 try queue.add(1);
529529
530 expectEqual(@as(u32, 2), heap.removeMax());
531 expectEqual(@as(u32, 2), heap.removeMax());
532 expectEqual(@as(u32, 1), heap.removeMax());
533 expectEqual(@as(u32, 1), heap.removeMax());
534 expectEqual(@as(u32, 1), heap.removeMax());
535 expectEqual(@as(u32, 1), heap.removeMax());
530 expectEqual(@as(u32, 2), queue.removeMax());
531 expectEqual(@as(u32, 2), queue.removeMax());
532 expectEqual(@as(u32, 1), queue.removeMax());
533 expectEqual(@as(u32, 1), queue.removeMax());
534 expectEqual(@as(u32, 1), queue.removeMax());
535 expectEqual(@as(u32, 1), queue.removeMax());
536536}
537537
538538test "std.PriorityDequeue: removeOrNull empty" {
539 var heap = Heap.init(testing.allocator, lessThanComparison);
540 defer heap.deinit();
539 var queue = PDQ.init(testing.allocator, lessThanComparison);
540 defer queue.deinit();
541541
542 expect(heap.removeMinOrNull() == null);
543 expect(heap.removeMaxOrNull() == null);
542 expect(queue.removeMinOrNull() == null);
543 expect(queue.removeMaxOrNull() == null);
544544}
545545
546546test "std.PriorityDequeue: edge case 3 elements" {
547 var heap = Heap.init(testing.allocator, lessThanComparison);
548 defer heap.deinit();
547 var queue = PDQ.init(testing.allocator, lessThanComparison);
548 defer queue.deinit();
549549
550 try heap.add(9);
551 try heap.add(3);
552 try heap.add(2);
550 try queue.add(9);
551 try queue.add(3);
552 try queue.add(2);
553553
554 expectEqual(@as(u32, 2), heap.removeMin());
555 expectEqual(@as(u32, 3), heap.removeMin());
556 expectEqual(@as(u32, 9), heap.removeMin());
554 expectEqual(@as(u32, 2), queue.removeMin());
555 expectEqual(@as(u32, 3), queue.removeMin());
556 expectEqual(@as(u32, 9), queue.removeMin());
557557}
558558
559559test "std.PriorityDequeue: edge case 3 elements max" {
560 var heap = Heap.init(testing.allocator, lessThanComparison);
561 defer heap.deinit();
560 var queue = PDQ.init(testing.allocator, lessThanComparison);
561 defer queue.deinit();
562562
563 try heap.add(9);
564 try heap.add(3);
565 try heap.add(2);
563 try queue.add(9);
564 try queue.add(3);
565 try queue.add(2);
566566
567 expectEqual(@as(u32, 9), heap.removeMax());
568 expectEqual(@as(u32, 3), heap.removeMax());
569 expectEqual(@as(u32, 2), heap.removeMax());
567 expectEqual(@as(u32, 9), queue.removeMax());
568 expectEqual(@as(u32, 3), queue.removeMax());
569 expectEqual(@as(u32, 2), queue.removeMax());
570570}
571571
572572test "std.PriorityDequeue: peekMin" {
573 var heap = Heap.init(testing.allocator, lessThanComparison);
574 defer heap.deinit();
573 var queue = PDQ.init(testing.allocator, lessThanComparison);
574 defer queue.deinit();
575575
576 expect(heap.peekMin() == null);
576 expect(queue.peekMin() == null);
577577
578 try heap.add(9);
579 try heap.add(3);
580 try heap.add(2);
578 try queue.add(9);
579 try queue.add(3);
580 try queue.add(2);
581581
582 expect(heap.peekMin().? == 2);
583 expect(heap.peekMin().? == 2);
582 expect(queue.peekMin().? == 2);
583 expect(queue.peekMin().? == 2);
584584}
585585
586586test "std.PriorityDequeue: peekMax" {
587 var heap = Heap.init(testing.allocator, lessThanComparison);
588 defer heap.deinit();
587 var queue = PDQ.init(testing.allocator, lessThanComparison);
588 defer queue.deinit();
589589
590 expect(heap.peekMin() == null);
590 expect(queue.peekMin() == null);
591591
592 try heap.add(9);
593 try heap.add(3);
594 try heap.add(2);
592 try queue.add(9);
593 try queue.add(3);
594 try queue.add(2);
595595
596 expect(heap.peekMax().? == 9);
597 expect(heap.peekMax().? == 9);
596 expect(queue.peekMax().? == 9);
597 expect(queue.peekMax().? == 9);
598598}
599599
600600test "std.PriorityDequeue: sift up with odd indices" {
601 var heap = Heap.init(testing.allocator, lessThanComparison);
602 defer heap.deinit();
601 var queue = PDQ.init(testing.allocator, lessThanComparison);
602 defer queue.deinit();
603603 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
604604 for (items) |e| {
605 try heap.add(e);
605 try queue.add(e);
606606 }
607607
608608 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
609609 for (sorted_items) |e| {
610 expectEqual(e, heap.removeMin());
610 expectEqual(e, queue.removeMin());
611611 }
612612}
613613
614614test "std.PriorityDequeue: sift up with odd indices" {
615 var heap = Heap.init(testing.allocator, lessThanComparison);
616 defer heap.deinit();
615 var queue = PDQ.init(testing.allocator, lessThanComparison);
616 defer queue.deinit();
617617 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
618618 for (items) |e| {
619 try heap.add(e);
619 try queue.add(e);
620620 }
621621
622622 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
623623 for (sorted_items) |e| {
624 expectEqual(e, heap.removeMax());
624 expectEqual(e, queue.removeMax());
625625 }
626626}
627627
628628test "std.PriorityDequeue: addSlice min" {
629 var heap = Heap.init(testing.allocator, lessThanComparison);
630 defer heap.deinit();
629 var queue = PDQ.init(testing.allocator, lessThanComparison);
630 defer queue.deinit();
631631 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
634634 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
635635 for (sorted_items) |e| {
636 expectEqual(e, heap.removeMin());
636 expectEqual(e, queue.removeMin());
637637 }
638638}
639639
640640test "std.PriorityDequeue: addSlice max" {
641 var heap = Heap.init(testing.allocator, lessThanComparison);
642 defer heap.deinit();
641 var queue = PDQ.init(testing.allocator, lessThanComparison);
642 defer queue.deinit();
643643 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
646646 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
647647 for (sorted_items) |e| {
648 expectEqual(e, heap.removeMax());
648 expectEqual(e, queue.removeMax());
649649 }
650650}
651651
652652test "std.PriorityDequeue: fromOwnedSlice trivial case 0" {
653653 const items = [0]u32{};
654 const heap_items = try testing.allocator.dupe(u32, &items);
655 var heap = Heap.fromOwnedSlice(testing.allocator, lessThanComparison, heap_items[0..]);
656 defer heap.deinit();
657 expectEqual(@as(usize, 0), heap.len);
658 expect(heap.removeMinOrNull() == null);
654 const queue_items = try testing.allocator.dupe(u32, &items);
655 var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, queue_items[0..]);
656 defer queue.deinit();
657 expectEqual(@as(usize, 0), queue.len);
658 expect(queue.removeMinOrNull() == null);
659659}
660660
661661test "std.PriorityDequeue: fromOwnedSlice trivial case 1" {
662662 const items = [1]u32{1};
663 const heap_items = try testing.allocator.dupe(u32, &items);
664 var heap = Heap.fromOwnedSlice(testing.allocator, lessThanComparison, heap_items[0..]);
665 defer heap.deinit();
663 const queue_items = try testing.allocator.dupe(u32, &items);
664 var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, queue_items[0..]);
665 defer queue.deinit();
666666
667 expectEqual(@as(usize, 1), heap.len);
668 expectEqual(items[0], heap.removeMin());
669 expect(heap.removeMinOrNull() == null);
667 expectEqual(@as(usize, 1), queue.len);
668 expectEqual(items[0], queue.removeMin());
669 expect(queue.removeMinOrNull() == null);
670670}
671671
672672test "std.PriorityDequeue: fromOwnedSlice" {
673673 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..]);
675 var heap = Heap.fromOwnedSlice(testing.allocator, lessThanComparison, heap_items[0..]);
676 defer heap.deinit();
674 const queue_items = try testing.allocator.dupe(u32, items[0..]);
675 var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, queue_items[0..]);
676 defer queue.deinit();
677677
678678 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
679679 for (sorted_items) |e| {
680 expectEqual(e, heap.removeMin());
680 expectEqual(e, queue.removeMin());
681681 }
682682}
683683
684test "std.PriorityDequeue: update min heap" {
685 var heap = Heap.init(testing.allocator, lessThanComparison);
686 defer heap.deinit();
687
688 try heap.add(55);
689 try heap.add(44);
690 try heap.add(11);
691 try heap.update(55, 5);
692 try heap.update(44, 4);
693 try heap.update(11, 1);
694 expectEqual(@as(u32, 1), heap.removeMin());
695 expectEqual(@as(u32, 4), heap.removeMin());
696 expectEqual(@as(u32, 5), heap.removeMin());
697}
698
699test "std.PriorityDequeue: update same min heap" {
700 var heap = Heap.init(testing.allocator, lessThanComparison);
701 defer heap.deinit();
702
703 try heap.add(1);
704 try heap.add(1);
705 try heap.add(2);
706 try heap.add(2);
707 try heap.update(1, 5);
708 try heap.update(2, 4);
709 expectEqual(@as(u32, 1), heap.removeMin());
710 expectEqual(@as(u32, 2), heap.removeMin());
711 expectEqual(@as(u32, 4), heap.removeMin());
712 expectEqual(@as(u32, 5), heap.removeMin());
713}
714
715test "std.PriorityDequeue: update max heap" {
716 var heap = Heap.init(testing.allocator, lessThanComparison);
717 defer heap.deinit();
718
719 try heap.add(55);
720 try heap.add(44);
721 try heap.add(11);
722 try heap.update(55, 5);
723 try heap.update(44, 1);
724 try heap.update(11, 4);
725
726 expectEqual(@as(u32, 5), heap.removeMax());
727 expectEqual(@as(u32, 4), heap.removeMax());
728 expectEqual(@as(u32, 1), heap.removeMax());
729}
730
731test "std.PriorityDequeue: update same max heap" {
732 var heap = Heap.init(testing.allocator, lessThanComparison);
733 defer heap.deinit();
734
735 try heap.add(1);
736 try heap.add(1);
737 try heap.add(2);
738 try heap.add(2);
739 try heap.update(1, 5);
740 try heap.update(2, 4);
741 expectEqual(@as(u32, 5), heap.removeMax());
742 expectEqual(@as(u32, 4), heap.removeMax());
743 expectEqual(@as(u32, 2), heap.removeMax());
744 expectEqual(@as(u32, 1), heap.removeMax());
684test "std.PriorityDequeue: update min queue" {
685 var queue = PDQ.init(testing.allocator, lessThanComparison);
686 defer queue.deinit();
687
688 try queue.add(55);
689 try queue.add(44);
690 try queue.add(11);
691 try queue.update(55, 5);
692 try queue.update(44, 4);
693 try queue.update(11, 1);
694 expectEqual(@as(u32, 1), queue.removeMin());
695 expectEqual(@as(u32, 4), queue.removeMin());
696 expectEqual(@as(u32, 5), queue.removeMin());
697}
698
699test "std.PriorityDequeue: update same min queue" {
700 var queue = PDQ.init(testing.allocator, lessThanComparison);
701 defer queue.deinit();
702
703 try queue.add(1);
704 try queue.add(1);
705 try queue.add(2);
706 try queue.add(2);
707 try queue.update(1, 5);
708 try queue.update(2, 4);
709 expectEqual(@as(u32, 1), queue.removeMin());
710 expectEqual(@as(u32, 2), queue.removeMin());
711 expectEqual(@as(u32, 4), queue.removeMin());
712 expectEqual(@as(u32, 5), queue.removeMin());
713}
714
715test "std.PriorityDequeue: update max queue" {
716 var queue = PDQ.init(testing.allocator, lessThanComparison);
717 defer queue.deinit();
718
719 try queue.add(55);
720 try queue.add(44);
721 try queue.add(11);
722 try queue.update(55, 5);
723 try queue.update(44, 1);
724 try queue.update(11, 4);
725
726 expectEqual(@as(u32, 5), queue.removeMax());
727 expectEqual(@as(u32, 4), queue.removeMax());
728 expectEqual(@as(u32, 1), queue.removeMax());
729}
730
731test "std.PriorityDequeue: update same max queue" {
732 var queue = PDQ.init(testing.allocator, lessThanComparison);
733 defer queue.deinit();
734
735 try queue.add(1);
736 try queue.add(1);
737 try queue.add(2);
738 try queue.add(2);
739 try queue.update(1, 5);
740 try queue.update(2, 4);
741 expectEqual(@as(u32, 5), queue.removeMax());
742 expectEqual(@as(u32, 4), queue.removeMax());
743 expectEqual(@as(u32, 2), queue.removeMax());
744 expectEqual(@as(u32, 1), queue.removeMax());
745745}
746746
747747test "std.PriorityDequeue: iterator" {
748 var heap = Heap.init(testing.allocator, lessThanComparison);
748 var queue = PDQ.init(testing.allocator, lessThanComparison);
749749 var map = std.AutoHashMap(u32, void).init(testing.allocator);
750750 defer {
751 heap.deinit();
751 queue.deinit();
752752 map.deinit();
753753 }
754754
755755 const items = [_]u32{ 54, 12, 7, 23, 25, 13 };
756756 for (items) |e| {
757 _ = try heap.add(e);
757 _ = try queue.add(e);
758758 _ = try map.put(e, {});
759759 }
760760
761 var it = heap.iterator();
761 var it = queue.iterator();
762762 while (it.next()) |e| {
763763 _ = map.remove(e);
764764 }
......@@ -767,14 +767,14 @@ test "std.PriorityDequeue: iterator" {
767767}
768768
769769test "std.PriorityDequeue: remove at index" {
770 var heap = Heap.init(testing.allocator, lessThanComparison);
771 defer heap.deinit();
770 var queue = PDQ.init(testing.allocator, lessThanComparison);
771 defer queue.deinit();
772772
773 try heap.add(3);
774 try heap.add(2);
775 try heap.add(1);
773 try queue.add(3);
774 try queue.add(2);
775 try queue.add(1);
776776
777 var it = heap.iterator();
777 var it = queue.iterator();
778778 var elem = it.next();
779779 var idx: usize = 0;
780780 const two_idx = while (elem != null) : (elem = it.next()) {
......@@ -783,17 +783,17 @@ test "std.PriorityDequeue: remove at index" {
783783 idx += 1;
784784 } else unreachable;
785785
786 expectEqual(heap.removeIndex(two_idx), 2);
787 expectEqual(heap.removeMin(), 1);
788 expectEqual(heap.removeMin(), 3);
789 expectEqual(heap.removeMinOrNull(), null);
786 expectEqual(queue.removeIndex(two_idx), 2);
787 expectEqual(queue.removeMin(), 1);
788 expectEqual(queue.removeMin(), 3);
789 expectEqual(queue.removeMinOrNull(), null);
790790}
791791
792792test "std.PriorityDequeue: iterator while empty" {
793 var heap = Heap.init(testing.allocator, lessThanComparison);
794 defer heap.deinit();
793 var queue = PDQ.init(testing.allocator, lessThanComparison);
794 defer queue.deinit();
795795
796 var it = heap.iterator();
796 var it = queue.iterator();
797797
798798 expectEqual(it.next(), null);
799799}
......@@ -802,23 +802,23 @@ test "std.PriorityDequeue: fuzz testing min" {
802802 var prng = std.rand.DefaultPrng.init(0x12345678);
803803
804804 const test_case_count = 100;
805 const heap_size = 1_000;
805 const queue_size = 1_000;
806806
807807 var i: usize = 0;
808808 while (i < test_case_count) : (i += 1) {
809 try fuzzTestMin(&prng.random, heap_size);
809 try fuzzTestMin(&prng.random, queue_size);
810810 }
811811}
812812
813fn fuzzTestMin(rng: *std.rand.Random, comptime heap_size: usize) !void {
813fn fuzzTestMin(rng: *std.rand.Random, comptime queue_size: usize) !void {
814814 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);
818 defer heap.deinit();
817 var queue = PDQ.fromOwnedSlice(allocator, lessThanComparison, items);
818 defer queue.deinit();
819819
820820 var last_removed: ?u32 = null;
821 while (heap.removeMinOrNull()) |next| {
821 while (queue.removeMinOrNull()) |next| {
822822 if (last_removed) |last| {
823823 expect(last <= next);
824824 }
......@@ -830,23 +830,23 @@ test "std.PriorityDequeue: fuzz testing max" {
830830 var prng = std.rand.DefaultPrng.init(0x87654321);
831831
832832 const test_case_count = 100;
833 const heap_size = 1_000;
833 const queue_size = 1_000;
834834
835835 var i: usize = 0;
836836 while (i < test_case_count) : (i += 1) {
837 try fuzzTestMax(&prng.random, heap_size);
837 try fuzzTestMax(&prng.random, queue_size);
838838 }
839839}
840840
841fn fuzzTestMax(rng: *std.rand.Random, heap_size: usize) !void {
841fn fuzzTestMax(rng: *std.rand.Random, queue_size: usize) !void {
842842 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);
846 defer heap.deinit();
845 var queue = PDQ.fromOwnedSlice(testing.allocator, lessThanComparison, items);
846 defer queue.deinit();
847847
848848 var last_removed: ?u32 = null;
849 while (heap.removeMaxOrNull()) |next| {
849 while (queue.removeMaxOrNull()) |next| {
850850 if (last_removed) |last| {
851851 expect(last >= next);
852852 }
......@@ -858,33 +858,33 @@ test "std.PriorityDequeue: fuzz testing min and max" {
858858 var prng = std.rand.DefaultPrng.init(0x87654321);
859859
860860 const test_case_count = 100;
861 const heap_size = 1_000;
861 const queue_size = 1_000;
862862
863863 var i: usize = 0;
864864 while (i < test_case_count) : (i += 1) {
865 try fuzzTestMinMax(&prng.random, heap_size);
865 try fuzzTestMinMax(&prng.random, queue_size);
866866 }
867867}
868868
869fn fuzzTestMinMax(rng: *std.rand.Random, heap_size: usize) !void {
869fn fuzzTestMinMax(rng: *std.rand.Random, queue_size: usize) !void {
870870 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);
874 defer heap.deinit();
873 var queue = PDQ.fromOwnedSlice(allocator, lessThanComparison, items);
874 defer queue.deinit();
875875
876876 var last_min: ?u32 = null;
877877 var last_max: ?u32 = null;
878878 var i: usize = 0;
879 while (i < heap_size) : (i += 1) {
879 while (i < queue_size) : (i += 1) {
880880 if (i % 2 == 0) {
881 const next = heap.removeMin();
881 const next = queue.removeMin();
882882 if (last_min) |last| {
883883 expect(last <= next);
884884 }
885885 last_min = next;
886886 } else {
887 const next = heap.removeMax();
887 const next = queue.removeMax();
888888 if (last_max) |last| {
889889 expect(last >= next);
890890 }