authorgravatar for saurabh.m@proton.meSaurabh Mishra <saurabh.m@proton.me> 2026-02-18 11:43:57-08:00
committergravatar for saurabh.m@proton.meSaurabh Mishra <saurabh.m@proton.me> 2026-02-18 11:43:57-08:00
log535722b37419f821650a3765e20880a3186ceff3
tree48cff6ea4e9eb51730a2be73314ba4efde758db7
parentd297f7b8f2f598967a8b91a45df1b1932dd3c81d

rename `add` to `push` and `remove` to `pop` in methods and tests

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

lib/std/priority_dequeue.zig+196-196
......@@ -38,20 +38,20 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
3838 }
3939
4040 /// Insert a new element, maintaining priority.
41 pub fn add(self: *Self, allocator: Allocator, elem: T) !void {
41 pub fn push(self: *Self, allocator: Allocator, elem: T) !void {
4242 try self.ensureUnusedCapacity(allocator, 1);
43 addUnchecked(self, elem);
43 pushUnchecked(self, elem);
4444 }
4545
4646 /// Add each element in `items` to the dequeue.
47 pub fn addSlice(self: *Self, allocator: Allocator, items: []const T) !void {
47 pub fn pushSlice(self: *Self, allocator: Allocator, items: []const T) !void {
4848 try self.ensureUnusedCapacity(allocator, items.len);
4949 for (items) |e| {
50 self.addUnchecked(e);
50 self.pushUnchecked(e);
5151 }
5252 }
5353
54 fn addUnchecked(self: *Self, elem: T) void {
54 fn pushUnchecked(self: *Self, elem: T) void {
5555 self.items[self.len] = elem;
5656
5757 if (self.len > 0) {
......@@ -151,32 +151,32 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
151151
152152 /// Pop the smallest element from the dequeue. Returns
153153 /// `null` if empty.
154 pub fn removeMinOrNull(self: *Self) ?T {
155 return if (self.len > 0) self.removeMin() else null;
154 pub fn popMinOrNull(self: *Self) ?T {
155 return if (self.len > 0) self.popMin() else null;
156156 }
157157
158158 /// Remove and return the smallest element from the
159159 /// dequeue.
160 pub fn removeMin(self: *Self) T {
161 return self.removeIndex(0);
160 pub fn popMin(self: *Self) T {
161 return self.popIndex(0);
162162 }
163163
164164 /// Pop the largest element from the dequeue. Returns
165165 /// `null` if empty.
166 pub fn removeMaxOrNull(self: *Self) ?T {
167 return if (self.len > 0) self.removeMax() else null;
166 pub fn popMaxOrNull(self: *Self) ?T {
167 return if (self.len > 0) self.popMax() else null;
168168 }
169169
170170 /// Remove and return the largest element from the
171171 /// dequeue.
172 pub fn removeMax(self: *Self) T {
173 return self.removeIndex(self.maxIndex().?);
172 pub fn popMax(self: *Self) T {
173 return self.popIndex(self.maxIndex().?);
174174 }
175175
176176 /// Remove and return element at index. Indices are in the
177177 /// same order as iterator, which is not necessarily priority
178178 /// order.
179 pub fn removeIndex(self: *Self, index: usize) T {
179 pub fn popIndex(self: *Self, index: usize) T {
180180 assert(self.len > index);
181181 const item = self.items[index];
182182 const last = self.items[self.len - 1];
......@@ -391,8 +391,8 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
391391 }
392392 return error.ElementNotFound;
393393 };
394 _ = self.removeIndex(old_index);
395 self.addUnchecked(new_elem);
394 _ = self.popIndex(old_index);
395 self.pushUnchecked(new_elem);
396396 }
397397
398398 pub const Iterator = struct {
......@@ -463,27 +463,27 @@ fn lessThanComparison(context: void, a: u32, b: u32) Order {
463463
464464const PDQ = PriorityDequeue(u32, void, lessThanComparison);
465465
466test "add and remove min" {
466test "push and pop min" {
467467 const gpa = std.testing.allocator;
468468 var queue = PDQ.init({});
469469 defer queue.deinit(gpa);
470470
471 try queue.add(gpa, 54);
472 try queue.add(gpa, 12);
473 try queue.add(gpa, 7);
474 try queue.add(gpa, 23);
475 try queue.add(gpa, 25);
476 try queue.add(gpa, 13);
477
478 try expectEqual(@as(u32, 7), queue.removeMin());
479 try expectEqual(@as(u32, 12), queue.removeMin());
480 try expectEqual(@as(u32, 13), queue.removeMin());
481 try expectEqual(@as(u32, 23), queue.removeMin());
482 try expectEqual(@as(u32, 25), queue.removeMin());
483 try expectEqual(@as(u32, 54), queue.removeMin());
471 try queue.push(gpa, 54);
472 try queue.push(gpa, 12);
473 try queue.push(gpa, 7);
474 try queue.push(gpa, 23);
475 try queue.push(gpa, 25);
476 try queue.push(gpa, 13);
477
478 try expectEqual(@as(u32, 7), queue.popMin());
479 try expectEqual(@as(u32, 12), queue.popMin());
480 try expectEqual(@as(u32, 13), queue.popMin());
481 try expectEqual(@as(u32, 23), queue.popMin());
482 try expectEqual(@as(u32, 25), queue.popMin());
483 try expectEqual(@as(u32, 54), queue.popMin());
484484}
485485
486test "add and remove min structs" {
486test "push and pop min structs" {
487487 const gpa = std.testing.allocator;
488488
489489 const S = struct {
......@@ -497,92 +497,92 @@ test "add and remove min structs" {
497497 }.order).init({});
498498 defer queue.deinit(gpa);
499499
500 try queue.add(gpa, .{ .size = 54 });
501 try queue.add(gpa, .{ .size = 12 });
502 try queue.add(gpa, .{ .size = 7 });
503 try queue.add(gpa, .{ .size = 23 });
504 try queue.add(gpa, .{ .size = 25 });
505 try queue.add(gpa, .{ .size = 13 });
506
507 try expectEqual(@as(u32, 7), queue.removeMin().size);
508 try expectEqual(@as(u32, 12), queue.removeMin().size);
509 try expectEqual(@as(u32, 13), queue.removeMin().size);
510 try expectEqual(@as(u32, 23), queue.removeMin().size);
511 try expectEqual(@as(u32, 25), queue.removeMin().size);
512 try expectEqual(@as(u32, 54), queue.removeMin().size);
500 try queue.push(gpa, .{ .size = 54 });
501 try queue.push(gpa, .{ .size = 12 });
502 try queue.push(gpa, .{ .size = 7 });
503 try queue.push(gpa, .{ .size = 23 });
504 try queue.push(gpa, .{ .size = 25 });
505 try queue.push(gpa, .{ .size = 13 });
506
507 try expectEqual(@as(u32, 7), queue.popMin().size);
508 try expectEqual(@as(u32, 12), queue.popMin().size);
509 try expectEqual(@as(u32, 13), queue.popMin().size);
510 try expectEqual(@as(u32, 23), queue.popMin().size);
511 try expectEqual(@as(u32, 25), queue.popMin().size);
512 try expectEqual(@as(u32, 54), queue.popMin().size);
513513}
514514
515test "add and remove max" {
515test "push and pop max" {
516516 const gpa = std.testing.allocator;
517517
518518 var queue = PDQ.init({});
519519 defer queue.deinit(gpa);
520520
521 try queue.add(gpa, 54);
522 try queue.add(gpa, 12);
523 try queue.add(gpa, 7);
524 try queue.add(gpa, 23);
525 try queue.add(gpa, 25);
526 try queue.add(gpa, 13);
527
528 try expectEqual(@as(u32, 54), queue.removeMax());
529 try expectEqual(@as(u32, 25), queue.removeMax());
530 try expectEqual(@as(u32, 23), queue.removeMax());
531 try expectEqual(@as(u32, 13), queue.removeMax());
532 try expectEqual(@as(u32, 12), queue.removeMax());
533 try expectEqual(@as(u32, 7), queue.removeMax());
521 try queue.push(gpa, 54);
522 try queue.push(gpa, 12);
523 try queue.push(gpa, 7);
524 try queue.push(gpa, 23);
525 try queue.push(gpa, 25);
526 try queue.push(gpa, 13);
527
528 try expectEqual(@as(u32, 54), queue.popMax());
529 try expectEqual(@as(u32, 25), queue.popMax());
530 try expectEqual(@as(u32, 23), queue.popMax());
531 try expectEqual(@as(u32, 13), queue.popMax());
532 try expectEqual(@as(u32, 12), queue.popMax());
533 try expectEqual(@as(u32, 7), queue.popMax());
534534}
535535
536test "add and remove same min" {
536test "push and pop same min" {
537537 const gpa = std.testing.allocator;
538538
539539 var queue = PDQ.init({});
540540 defer queue.deinit(gpa);
541541
542 try queue.add(gpa, 1);
543 try queue.add(gpa, 1);
544 try queue.add(gpa, 2);
545 try queue.add(gpa, 2);
546 try queue.add(gpa, 1);
547 try queue.add(gpa, 1);
548
549 try expectEqual(@as(u32, 1), queue.removeMin());
550 try expectEqual(@as(u32, 1), queue.removeMin());
551 try expectEqual(@as(u32, 1), queue.removeMin());
552 try expectEqual(@as(u32, 1), queue.removeMin());
553 try expectEqual(@as(u32, 2), queue.removeMin());
554 try expectEqual(@as(u32, 2), queue.removeMin());
542 try queue.push(gpa, 1);
543 try queue.push(gpa, 1);
544 try queue.push(gpa, 2);
545 try queue.push(gpa, 2);
546 try queue.push(gpa, 1);
547 try queue.push(gpa, 1);
548
549 try expectEqual(@as(u32, 1), queue.popMin());
550 try expectEqual(@as(u32, 1), queue.popMin());
551 try expectEqual(@as(u32, 1), queue.popMin());
552 try expectEqual(@as(u32, 1), queue.popMin());
553 try expectEqual(@as(u32, 2), queue.popMin());
554 try expectEqual(@as(u32, 2), queue.popMin());
555555}
556556
557test "add and remove same max" {
557test "push and pop same max" {
558558 const gpa = std.testing.allocator;
559559
560560 var queue = PDQ.init({});
561561 defer queue.deinit(gpa);
562562
563 try queue.add(gpa, 1);
564 try queue.add(gpa, 1);
565 try queue.add(gpa, 2);
566 try queue.add(gpa, 2);
567 try queue.add(gpa, 1);
568 try queue.add(gpa, 1);
569
570 try expectEqual(@as(u32, 2), queue.removeMax());
571 try expectEqual(@as(u32, 2), queue.removeMax());
572 try expectEqual(@as(u32, 1), queue.removeMax());
573 try expectEqual(@as(u32, 1), queue.removeMax());
574 try expectEqual(@as(u32, 1), queue.removeMax());
575 try expectEqual(@as(u32, 1), queue.removeMax());
563 try queue.push(gpa, 1);
564 try queue.push(gpa, 1);
565 try queue.push(gpa, 2);
566 try queue.push(gpa, 2);
567 try queue.push(gpa, 1);
568 try queue.push(gpa, 1);
569
570 try expectEqual(@as(u32, 2), queue.popMax());
571 try expectEqual(@as(u32, 2), queue.popMax());
572 try expectEqual(@as(u32, 1), queue.popMax());
573 try expectEqual(@as(u32, 1), queue.popMax());
574 try expectEqual(@as(u32, 1), queue.popMax());
575 try expectEqual(@as(u32, 1), queue.popMax());
576576}
577577
578test "removeOrNull empty" {
578test "popOrNull empty" {
579579 const gpa = std.testing.allocator;
580580
581581 var queue = PDQ.init({});
582582 defer queue.deinit(gpa);
583583
584 try expect(queue.removeMinOrNull() == null);
585 try expect(queue.removeMaxOrNull() == null);
584 try expect(queue.popMinOrNull() == null);
585 try expect(queue.popMaxOrNull() == null);
586586}
587587
588588test "edge case 3 elements" {
......@@ -591,13 +591,13 @@ test "edge case 3 elements" {
591591 var queue = PDQ.init({});
592592 defer queue.deinit(gpa);
593593
594 try queue.add(gpa, 9);
595 try queue.add(gpa, 3);
596 try queue.add(gpa, 2);
594 try queue.push(gpa, 9);
595 try queue.push(gpa, 3);
596 try queue.push(gpa, 2);
597597
598 try expectEqual(@as(u32, 2), queue.removeMin());
599 try expectEqual(@as(u32, 3), queue.removeMin());
600 try expectEqual(@as(u32, 9), queue.removeMin());
598 try expectEqual(@as(u32, 2), queue.popMin());
599 try expectEqual(@as(u32, 3), queue.popMin());
600 try expectEqual(@as(u32, 9), queue.popMin());
601601}
602602
603603test "edge case 3 elements max" {
......@@ -606,13 +606,13 @@ test "edge case 3 elements max" {
606606 var queue = PDQ.init({});
607607 defer queue.deinit(gpa);
608608
609 try queue.add(gpa, 9);
610 try queue.add(gpa, 3);
611 try queue.add(gpa, 2);
609 try queue.push(gpa, 9);
610 try queue.push(gpa, 3);
611 try queue.push(gpa, 2);
612612
613 try expectEqual(@as(u32, 9), queue.removeMax());
614 try expectEqual(@as(u32, 3), queue.removeMax());
615 try expectEqual(@as(u32, 2), queue.removeMax());
613 try expectEqual(@as(u32, 9), queue.popMax());
614 try expectEqual(@as(u32, 3), queue.popMax());
615 try expectEqual(@as(u32, 2), queue.popMax());
616616}
617617
618618test "peekMin" {
......@@ -623,9 +623,9 @@ test "peekMin" {
623623
624624 try expect(queue.peekMin() == null);
625625
626 try queue.add(gpa, 9);
627 try queue.add(gpa, 3);
628 try queue.add(gpa, 2);
626 try queue.push(gpa, 9);
627 try queue.push(gpa, 3);
628 try queue.push(gpa, 2);
629629
630630 try expect(queue.peekMin().? == 2);
631631 try expect(queue.peekMin().? == 2);
......@@ -639,15 +639,15 @@ test "peekMax" {
639639
640640 try expect(queue.peekMin() == null);
641641
642 try queue.add(gpa, 9);
643 try queue.add(gpa, 3);
644 try queue.add(gpa, 2);
642 try queue.push(gpa, 9);
643 try queue.push(gpa, 3);
644 try queue.push(gpa, 2);
645645
646646 try expect(queue.peekMax().? == 9);
647647 try expect(queue.peekMax().? == 9);
648648}
649649
650test "sift up with odd indices, removeMin" {
650test "sift up with odd indices, popMin" {
651651 const gpa = std.testing.allocator;
652652
653653 var queue = PDQ.init({});
......@@ -655,16 +655,16 @@ test "sift up with odd indices, removeMin" {
655655
656656 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
657657 for (items) |e| {
658 try queue.add(gpa, e);
658 try queue.push(gpa, e);
659659 }
660660
661661 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
662662 for (sorted_items) |e| {
663 try expectEqual(e, queue.removeMin());
663 try expectEqual(e, queue.popMin());
664664 }
665665}
666666
667test "sift up with odd indices, removeMax" {
667test "sift up with odd indices, popMax" {
668668 const gpa = std.testing.allocator;
669669
670670 var queue = PDQ.init({});
......@@ -672,42 +672,42 @@ test "sift up with odd indices, removeMax" {
672672
673673 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
674674 for (items) |e| {
675 try queue.add(gpa, e);
675 try queue.push(gpa, e);
676676 }
677677
678678 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
679679 for (sorted_items) |e| {
680 try expectEqual(e, queue.removeMax());
680 try expectEqual(e, queue.popMax());
681681 }
682682}
683683
684test "addSlice min" {
684test "pushSlice min" {
685685 const gpa = std.testing.allocator;
686686
687687 var queue = PDQ.init({});
688688 defer queue.deinit(gpa);
689689
690690 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
691 try queue.addSlice(gpa, items[0..]);
691 try queue.pushSlice(gpa, items[0..]);
692692
693693 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
694694 for (sorted_items) |e| {
695 try expectEqual(e, queue.removeMin());
695 try expectEqual(e, queue.popMin());
696696 }
697697}
698698
699test "addSlice max" {
699test "pushSlice max" {
700700 const gpa = std.testing.allocator;
701701
702702 var queue = PDQ.init({});
703703 defer queue.deinit(gpa);
704704
705705 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
706 try queue.addSlice(gpa, items[0..]);
706 try queue.pushSlice(gpa, items[0..]);
707707
708708 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
709709 for (sorted_items) |e| {
710 try expectEqual(e, queue.removeMax());
710 try expectEqual(e, queue.popMax());
711711 }
712712}
713713
......@@ -721,7 +721,7 @@ test "fromOwnedSlice trivial case 0" {
721721 defer queue.deinit(gpa);
722722
723723 try expectEqual(@as(usize, 0), queue.len);
724 try expect(queue.removeMinOrNull() == null);
724 try expect(queue.popMinOrNull() == null);
725725}
726726
727727test "fromOwnedSlice trivial case 1" {
......@@ -734,8 +734,8 @@ test "fromOwnedSlice trivial case 1" {
734734 defer queue.deinit(gpa);
735735
736736 try expectEqual(@as(usize, 1), queue.len);
737 try expectEqual(items[0], queue.removeMin());
738 try expect(queue.removeMinOrNull() == null);
737 try expectEqual(items[0], queue.popMin());
738 try expect(queue.popMinOrNull() == null);
739739}
740740
741741test "fromOwnedSlice" {
......@@ -749,7 +749,7 @@ test "fromOwnedSlice" {
749749
750750 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
751751 for (sorted_items) |e| {
752 try expectEqual(e, queue.removeMin());
752 try expectEqual(e, queue.popMin());
753753 }
754754}
755755
......@@ -759,15 +759,15 @@ test "update min queue" {
759759 var queue = PDQ.init({});
760760 defer queue.deinit(gpa);
761761
762 try queue.add(gpa, 55);
763 try queue.add(gpa, 44);
764 try queue.add(gpa, 11);
762 try queue.push(gpa, 55);
763 try queue.push(gpa, 44);
764 try queue.push(gpa, 11);
765765 try queue.update(55, 5);
766766 try queue.update(44, 4);
767767 try queue.update(11, 1);
768 try expectEqual(@as(u32, 1), queue.removeMin());
769 try expectEqual(@as(u32, 4), queue.removeMin());
770 try expectEqual(@as(u32, 5), queue.removeMin());
768 try expectEqual(@as(u32, 1), queue.popMin());
769 try expectEqual(@as(u32, 4), queue.popMin());
770 try expectEqual(@as(u32, 5), queue.popMin());
771771}
772772
773773test "update same min queue" {
......@@ -776,16 +776,16 @@ test "update same min queue" {
776776 var queue = PDQ.init({});
777777 defer queue.deinit(gpa);
778778
779 try queue.add(gpa, 1);
780 try queue.add(gpa, 1);
781 try queue.add(gpa, 2);
782 try queue.add(gpa, 2);
779 try queue.push(gpa, 1);
780 try queue.push(gpa, 1);
781 try queue.push(gpa, 2);
782 try queue.push(gpa, 2);
783783 try queue.update(1, 5);
784784 try queue.update(2, 4);
785 try expectEqual(@as(u32, 1), queue.removeMin());
786 try expectEqual(@as(u32, 2), queue.removeMin());
787 try expectEqual(@as(u32, 4), queue.removeMin());
788 try expectEqual(@as(u32, 5), queue.removeMin());
785 try expectEqual(@as(u32, 1), queue.popMin());
786 try expectEqual(@as(u32, 2), queue.popMin());
787 try expectEqual(@as(u32, 4), queue.popMin());
788 try expectEqual(@as(u32, 5), queue.popMin());
789789}
790790
791791test "update max queue" {
......@@ -794,16 +794,16 @@ test "update max queue" {
794794 var queue = PDQ.init({});
795795 defer queue.deinit(gpa);
796796
797 try queue.add(gpa, 55);
798 try queue.add(gpa, 44);
799 try queue.add(gpa, 11);
797 try queue.push(gpa, 55);
798 try queue.push(gpa, 44);
799 try queue.push(gpa, 11);
800800 try queue.update(55, 5);
801801 try queue.update(44, 1);
802802 try queue.update(11, 4);
803803
804 try expectEqual(@as(u32, 5), queue.removeMax());
805 try expectEqual(@as(u32, 4), queue.removeMax());
806 try expectEqual(@as(u32, 1), queue.removeMax());
804 try expectEqual(@as(u32, 5), queue.popMax());
805 try expectEqual(@as(u32, 4), queue.popMax());
806 try expectEqual(@as(u32, 1), queue.popMax());
807807}
808808
809809test "update same max queue" {
......@@ -812,26 +812,26 @@ test "update same max queue" {
812812 var queue = PDQ.init({});
813813 defer queue.deinit(gpa);
814814
815 try queue.add(gpa, 1);
816 try queue.add(gpa, 1);
817 try queue.add(gpa, 2);
818 try queue.add(gpa, 2);
815 try queue.push(gpa, 1);
816 try queue.push(gpa, 1);
817 try queue.push(gpa, 2);
818 try queue.push(gpa, 2);
819819 try queue.update(1, 5);
820820 try queue.update(2, 4);
821 try expectEqual(@as(u32, 5), queue.removeMax());
822 try expectEqual(@as(u32, 4), queue.removeMax());
823 try expectEqual(@as(u32, 2), queue.removeMax());
824 try expectEqual(@as(u32, 1), queue.removeMax());
821 try expectEqual(@as(u32, 5), queue.popMax());
822 try expectEqual(@as(u32, 4), queue.popMax());
823 try expectEqual(@as(u32, 2), queue.popMax());
824 try expectEqual(@as(u32, 1), queue.popMax());
825825}
826826
827test "update after remove" {
827test "update after pop" {
828828 const gpa = std.testing.allocator;
829829
830830 var queue = PDQ.init({});
831831 defer queue.deinit(gpa);
832832
833 try queue.add(gpa, 1);
834 try expectEqual(@as(u32, 1), queue.removeMin());
833 try queue.push(gpa, 1);
834 try expectEqual(@as(u32, 1), queue.popMin());
835835 try expectError(error.ElementNotFound, queue.update(1, 1));
836836}
837837
......@@ -847,7 +847,7 @@ test "iterator" {
847847
848848 const items = [_]u32{ 54, 12, 7, 23, 25, 13 };
849849 for (items) |e| {
850 _ = try queue.add(gpa, e);
850 _ = try queue.push(gpa, e);
851851 _ = try map.put(e, {});
852852 }
853853
......@@ -859,15 +859,15 @@ test "iterator" {
859859 try expectEqual(@as(usize, 0), map.count());
860860}
861861
862test "remove at index" {
862test "pop at index" {
863863 const gpa = std.testing.allocator;
864864
865865 var queue = PDQ.init({});
866866 defer queue.deinit(gpa);
867867
868 try queue.add(gpa, 3);
869 try queue.add(gpa, 2);
870 try queue.add(gpa, 1);
868 try queue.push(gpa, 3);
869 try queue.push(gpa, 2);
870 try queue.push(gpa, 1);
871871
872872 var it = queue.iterator();
873873 var elem = it.next();
......@@ -878,10 +878,10 @@ test "remove at index" {
878878 idx += 1;
879879 } else unreachable;
880880
881 try expectEqual(queue.removeIndex(two_idx), 2);
882 try expectEqual(queue.removeMin(), 1);
883 try expectEqual(queue.removeMin(), 3);
884 try expectEqual(queue.removeMinOrNull(), null);
881 try expectEqual(queue.popIndex(two_idx), 2);
882 try expectEqual(queue.popMin(), 1);
883 try expectEqual(queue.popMin(), 3);
884 try expectEqual(queue.popMinOrNull(), null);
885885}
886886
887887test "iterator while empty" {
......@@ -904,9 +904,9 @@ test "shrinkAndFree" {
904904 try queue.ensureTotalCapacity(gpa, 4);
905905 try expect(queue.capacity() >= 4);
906906
907 try queue.add(gpa, 1);
908 try queue.add(gpa, 2);
909 try queue.add(gpa, 3);
907 try queue.push(gpa, 1);
908 try queue.push(gpa, 2);
909 try queue.push(gpa, 3);
910910 try expect(queue.capacity() >= 4);
911911 try expectEqual(@as(usize, 3), queue.len);
912912
......@@ -914,10 +914,10 @@ test "shrinkAndFree" {
914914 try expectEqual(@as(usize, 3), queue.capacity());
915915 try expectEqual(@as(usize, 3), queue.len);
916916
917 try expectEqual(@as(u32, 3), queue.removeMax());
918 try expectEqual(@as(u32, 2), queue.removeMax());
919 try expectEqual(@as(u32, 1), queue.removeMax());
920 try expect(queue.removeMaxOrNull() == null);
917 try expectEqual(@as(u32, 3), queue.popMax());
918 try expectEqual(@as(u32, 2), queue.popMax());
919 try expectEqual(@as(u32, 1), queue.popMax());
920 try expect(queue.popMaxOrNull() == null);
921921}
922922
923923test "fuzz testing min" {
......@@ -942,7 +942,7 @@ fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void {
942942 defer queue.deinit(gpa);
943943
944944 var last_removed: ?u32 = null;
945 while (queue.removeMinOrNull()) |next| {
945 while (queue.popMinOrNull()) |next| {
946946 if (last_removed) |last| {
947947 try expect(last <= next);
948948 }
......@@ -972,7 +972,7 @@ fn fuzzTestMax(rng: std.Random, queue_size: usize) !void {
972972 defer queue.deinit(gpa);
973973
974974 var last_removed: ?u32 = null;
975 while (queue.removeMaxOrNull()) |next| {
975 while (queue.popMaxOrNull()) |next| {
976976 if (last_removed) |last| {
977977 try expect(last >= next);
978978 }
......@@ -1006,13 +1006,13 @@ fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void {
10061006 var i: usize = 0;
10071007 while (i < queue_size) : (i += 1) {
10081008 if (i % 2 == 0) {
1009 const next = queue.removeMin();
1009 const next = queue.popMin();
10101010 if (last_min) |last| {
10111011 try expect(last <= next);
10121012 }
10131013 last_min = next;
10141014 } else {
1015 const next = queue.removeMax();
1015 const next = queue.popMax();
10161016 if (last_max) |last| {
10171017 try expect(last >= next);
10181018 }
......@@ -1040,7 +1040,7 @@ fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order {
10401040
10411041const CPDQ = PriorityDequeue(usize, []const u32, contextLessThanComparison);
10421042
1043test "add and remove" {
1043test "push and pop" {
10441044 const gpa = std.testing.allocator;
10451045
10461046 const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };
......@@ -1048,20 +1048,20 @@ test "add and remove" {
10481048 var queue = CPDQ.init(context[0..]);
10491049 defer queue.deinit(gpa);
10501050
1051 try queue.add(gpa, 0);
1052 try queue.add(gpa, 1);
1053 try queue.add(gpa, 2);
1054 try queue.add(gpa, 3);
1055 try queue.add(gpa, 4);
1056 try queue.add(gpa, 5);
1057 try queue.add(gpa, 6);
1058 try expectEqual(@as(usize, 6), queue.removeMin());
1059 try expectEqual(@as(usize, 5), queue.removeMax());
1060 try expectEqual(@as(usize, 3), queue.removeMin());
1061 try expectEqual(@as(usize, 0), queue.removeMax());
1062 try expectEqual(@as(usize, 4), queue.removeMin());
1063 try expectEqual(@as(usize, 2), queue.removeMax());
1064 try expectEqual(@as(usize, 1), queue.removeMin());
1051 try queue.push(gpa, 0);
1052 try queue.push(gpa, 1);
1053 try queue.push(gpa, 2);
1054 try queue.push(gpa, 3);
1055 try queue.push(gpa, 4);
1056 try queue.push(gpa, 5);
1057 try queue.push(gpa, 6);
1058 try expectEqual(@as(usize, 6), queue.popMin());
1059 try expectEqual(@as(usize, 5), queue.popMax());
1060 try expectEqual(@as(usize, 3), queue.popMin());
1061 try expectEqual(@as(usize, 0), queue.popMax());
1062 try expectEqual(@as(usize, 4), queue.popMin());
1063 try expectEqual(@as(usize, 2), queue.popMax());
1064 try expectEqual(@as(usize, 1), queue.popMin());
10651065}
10661066
10671067var all_cmps_unique = true;
......@@ -1077,13 +1077,13 @@ test "don't compare a value to a copy of itself" {
10771077 }.uniqueLessThan).init({});
10781078 defer depq.deinit(gpa);
10791079
1080 try depq.add(gpa, 1);
1081 try depq.add(gpa, 2);
1082 try depq.add(gpa, 3);
1083 try depq.add(gpa, 4);
1084 try depq.add(gpa, 5);
1085 try depq.add(gpa, 6);
1080 try depq.push(gpa, 1);
1081 try depq.push(gpa, 2);
1082 try depq.push(gpa, 3);
1083 try depq.push(gpa, 4);
1084 try depq.push(gpa, 5);
1085 try depq.push(gpa, 6);
10861086
1087 _ = depq.removeIndex(2);
1087 _ = depq.popIndex(2);
10881088 try expectEqual(all_cmps_unique, true);
10891089}