authorgravatar for saurabh.m@proton.meSaurabh Mishra <saurabh.m@proton.me> 2026-02-18 11:20:32-08:00
committergravatar for saurabh.m@proton.meSaurabh Mishra <saurabh.m@proton.me> 2026-02-18 11:20:32-08:00
logd297f7b8f2f598967a8b91a45df1b1932dd3c81d
treef25a5a5c140588f96741c5aba641d3a4215991a6
parent0e3c6514a4d1f89498bf411b58131d129218807f

make priority dequeue an unmanaged container and ensure tests pass

1 files changed, 237 insertions(+), 175 deletions(-)

lib/std/priority_dequeue.zig+237-175
......@@ -21,33 +21,31 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
2121
2222 items: []T,
2323 len: usize,
24 allocator: Allocator,
2524 context: Context,
2625
2726 /// Initialize and return a new priority dequeue.
28 pub fn init(allocator: Allocator, context: Context) Self {
27 pub fn init(context: Context) Self {
2928 return Self{
3029 .items = &[_]T{},
3130 .len = 0,
32 .allocator = allocator,
3331 .context = context,
3432 };
3533 }
3634
3735 /// Free memory used by the dequeue.
38 pub fn deinit(self: Self) void {
39 self.allocator.free(self.items);
36 pub fn deinit(self: Self, allocator: Allocator) void {
37 allocator.free(self.items);
4038 }
4139
4240 /// Insert a new element, maintaining priority.
43 pub fn add(self: *Self, elem: T) !void {
44 try self.ensureUnusedCapacity(1);
41 pub fn add(self: *Self, allocator: Allocator, elem: T) !void {
42 try self.ensureUnusedCapacity(allocator, 1);
4543 addUnchecked(self, elem);
4644 }
4745
4846 /// Add each element in `items` to the dequeue.
49 pub fn addSlice(self: *Self, items: []const T) !void {
50 try self.ensureUnusedCapacity(items.len);
47 pub fn addSlice(self: *Self, allocator: Allocator, items: []const T) !void {
48 try self.ensureUnusedCapacity(allocator, items.len);
5149 for (items) |e| {
5250 self.addUnchecked(e);
5351 }
......@@ -333,14 +331,12 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
333331 return self.items.len;
334332 }
335333
336 /// Dequeue takes ownership of the passed in slice. The slice must have been
337 /// allocated with `allocator`.
338 /// De-initialize with `deinit`.
339 pub fn fromOwnedSlice(allocator: Allocator, items: []T, context: Context) Self {
334 /// Dequeue takes ownership of the passed in slice. The slice must be de-initialize
335 /// with `deinit`.
336 pub fn fromOwnedSlice(items: []T, context: Context) Self {
340337 var queue = Self{
341338 .items = items,
342339 .len = items.len,
343 .allocator = allocator,
344340 .context = context,
345341 };
346342
......@@ -356,29 +352,29 @@ pub fn PriorityDequeue(comptime T: type, comptime Context: type, comptime compar
356352 }
357353
358354 /// Ensure that the dequeue can fit at least `new_capacity` items.
359 pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
355 pub fn ensureTotalCapacity(self: *Self, allocator: Allocator, new_capacity: usize) !void {
360356 var better_capacity = self.capacity();
361357 if (better_capacity >= new_capacity) return;
362358 while (true) {
363359 better_capacity += better_capacity / 2 + 8;
364360 if (better_capacity >= new_capacity) break;
365361 }
366 self.items = try self.allocator.realloc(self.items, better_capacity);
362 self.items = try allocator.realloc(self.items, better_capacity);
367363 }
368364
369365 /// Ensure that the dequeue can fit at least `additional_count` **more** items.
370 pub fn ensureUnusedCapacity(self: *Self, additional_count: usize) !void {
371 return self.ensureTotalCapacity(self.len + additional_count);
366 pub fn ensureUnusedCapacity(self: *Self, allocator: Allocator, additional_count: usize) !void {
367 return self.ensureTotalCapacity(allocator, self.len + additional_count);
372368 }
373369
374370 /// Reduce allocated capacity to `new_len`.
375 pub fn shrinkAndFree(self: *Self, new_len: usize) void {
371 pub fn shrinkAndFree(self: *Self, allocator: Allocator, new_len: usize) void {
376372 assert(new_len <= self.items.len);
377373
378374 // Cannot shrink to smaller than the current queue size without invalidating the heap property
379375 assert(new_len >= self.len);
380376
381 self.items = self.allocator.realloc(self.items[0..], new_len) catch |e| switch (e) {
377 self.items = allocator.realloc(self.items[0..], new_len) catch |e| switch (e) {
382378 error.OutOfMemory => { // no problem, capacity is still correct then.
383379 self.items.len = new_len;
384380 return;
......@@ -468,15 +464,16 @@ fn lessThanComparison(context: void, a: u32, b: u32) Order {
468464const PDQ = PriorityDequeue(u32, void, lessThanComparison);
469465
470466test "add and remove min" {
471 var queue = PDQ.init(testing.allocator, {});
472 defer queue.deinit();
467 const gpa = std.testing.allocator;
468 var queue = PDQ.init({});
469 defer queue.deinit(gpa);
473470
474 try queue.add(54);
475 try queue.add(12);
476 try queue.add(7);
477 try queue.add(23);
478 try queue.add(25);
479 try queue.add(13);
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);
480477
481478 try expectEqual(@as(u32, 7), queue.removeMin());
482479 try expectEqual(@as(u32, 12), queue.removeMin());
......@@ -487,6 +484,8 @@ test "add and remove min" {
487484}
488485
489486test "add and remove min structs" {
487 const gpa = std.testing.allocator;
488
490489 const S = struct {
491490 size: u32,
492491 };
......@@ -495,15 +494,15 @@ test "add and remove min structs" {
495494 _ = context;
496495 return std.math.order(a.size, b.size);
497496 }
498 }.order).init(testing.allocator, {});
499 defer queue.deinit();
497 }.order).init({});
498 defer queue.deinit(gpa);
500499
501 try queue.add(.{ .size = 54 });
502 try queue.add(.{ .size = 12 });
503 try queue.add(.{ .size = 7 });
504 try queue.add(.{ .size = 23 });
505 try queue.add(.{ .size = 25 });
506 try queue.add(.{ .size = 13 });
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 });
507506
508507 try expectEqual(@as(u32, 7), queue.removeMin().size);
509508 try expectEqual(@as(u32, 12), queue.removeMin().size);
......@@ -514,15 +513,17 @@ test "add and remove min structs" {
514513}
515514
516515test "add and remove max" {
517 var queue = PDQ.init(testing.allocator, {});
518 defer queue.deinit();
516 const gpa = std.testing.allocator;
517
518 var queue = PDQ.init({});
519 defer queue.deinit(gpa);
519520
520 try queue.add(54);
521 try queue.add(12);
522 try queue.add(7);
523 try queue.add(23);
524 try queue.add(25);
525 try queue.add(13);
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);
526527
527528 try expectEqual(@as(u32, 54), queue.removeMax());
528529 try expectEqual(@as(u32, 25), queue.removeMax());
......@@ -533,15 +534,17 @@ test "add and remove max" {
533534}
534535
535536test "add and remove same min" {
536 var queue = PDQ.init(testing.allocator, {});
537 defer queue.deinit();
537 const gpa = std.testing.allocator;
538
539 var queue = PDQ.init({});
540 defer queue.deinit(gpa);
538541
539 try queue.add(1);
540 try queue.add(1);
541 try queue.add(2);
542 try queue.add(2);
543 try queue.add(1);
544 try queue.add(1);
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);
545548
546549 try expectEqual(@as(u32, 1), queue.removeMin());
547550 try expectEqual(@as(u32, 1), queue.removeMin());
......@@ -552,15 +555,17 @@ test "add and remove same min" {
552555}
553556
554557test "add and remove same max" {
555 var queue = PDQ.init(testing.allocator, {});
556 defer queue.deinit();
558 const gpa = std.testing.allocator;
557559
558 try queue.add(1);
559 try queue.add(1);
560 try queue.add(2);
561 try queue.add(2);
562 try queue.add(1);
563 try queue.add(1);
560 var queue = PDQ.init({});
561 defer queue.deinit(gpa);
562
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);
564569
565570 try expectEqual(@as(u32, 2), queue.removeMax());
566571 try expectEqual(@as(u32, 2), queue.removeMax());
......@@ -571,20 +576,24 @@ test "add and remove same max" {
571576}
572577
573578test "removeOrNull empty" {
574 var queue = PDQ.init(testing.allocator, {});
575 defer queue.deinit();
579 const gpa = std.testing.allocator;
580
581 var queue = PDQ.init({});
582 defer queue.deinit(gpa);
576583
577584 try expect(queue.removeMinOrNull() == null);
578585 try expect(queue.removeMaxOrNull() == null);
579586}
580587
581588test "edge case 3 elements" {
582 var queue = PDQ.init(testing.allocator, {});
583 defer queue.deinit();
589 const gpa = std.testing.allocator;
584590
585 try queue.add(9);
586 try queue.add(3);
587 try queue.add(2);
591 var queue = PDQ.init({});
592 defer queue.deinit(gpa);
593
594 try queue.add(gpa, 9);
595 try queue.add(gpa, 3);
596 try queue.add(gpa, 2);
588597
589598 try expectEqual(@as(u32, 2), queue.removeMin());
590599 try expectEqual(@as(u32, 3), queue.removeMin());
......@@ -592,12 +601,14 @@ test "edge case 3 elements" {
592601}
593602
594603test "edge case 3 elements max" {
595 var queue = PDQ.init(testing.allocator, {});
596 defer queue.deinit();
604 const gpa = std.testing.allocator;
605
606 var queue = PDQ.init({});
607 defer queue.deinit(gpa);
597608
598 try queue.add(9);
599 try queue.add(3);
600 try queue.add(2);
609 try queue.add(gpa, 9);
610 try queue.add(gpa, 3);
611 try queue.add(gpa, 2);
601612
602613 try expectEqual(@as(u32, 9), queue.removeMax());
603614 try expectEqual(@as(u32, 3), queue.removeMax());
......@@ -605,39 +616,46 @@ test "edge case 3 elements max" {
605616}
606617
607618test "peekMin" {
608 var queue = PDQ.init(testing.allocator, {});
609 defer queue.deinit();
619 const gpa = std.testing.allocator;
620
621 var queue = PDQ.init({});
622 defer queue.deinit(gpa);
610623
611624 try expect(queue.peekMin() == null);
612625
613 try queue.add(9);
614 try queue.add(3);
615 try queue.add(2);
626 try queue.add(gpa, 9);
627 try queue.add(gpa, 3);
628 try queue.add(gpa, 2);
616629
617630 try expect(queue.peekMin().? == 2);
618631 try expect(queue.peekMin().? == 2);
619632}
620633
621634test "peekMax" {
622 var queue = PDQ.init(testing.allocator, {});
623 defer queue.deinit();
635 const gpa = std.testing.allocator;
636
637 var queue = PDQ.init({});
638 defer queue.deinit(gpa);
624639
625640 try expect(queue.peekMin() == null);
626641
627 try queue.add(9);
628 try queue.add(3);
629 try queue.add(2);
642 try queue.add(gpa, 9);
643 try queue.add(gpa, 3);
644 try queue.add(gpa, 2);
630645
631646 try expect(queue.peekMax().? == 9);
632647 try expect(queue.peekMax().? == 9);
633648}
634649
635650test "sift up with odd indices, removeMin" {
636 var queue = PDQ.init(testing.allocator, {});
637 defer queue.deinit();
651 const gpa = std.testing.allocator;
652
653 var queue = PDQ.init({});
654 defer queue.deinit(gpa);
655
638656 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
639657 for (items) |e| {
640 try queue.add(e);
658 try queue.add(gpa, e);
641659 }
642660
643661 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
......@@ -647,11 +665,14 @@ test "sift up with odd indices, removeMin" {
647665}
648666
649667test "sift up with odd indices, removeMax" {
650 var queue = PDQ.init(testing.allocator, {});
651 defer queue.deinit();
668 const gpa = std.testing.allocator;
669
670 var queue = PDQ.init({});
671 defer queue.deinit(gpa);
672
652673 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
653674 for (items) |e| {
654 try queue.add(e);
675 try queue.add(gpa, e);
655676 }
656677
657678 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
......@@ -661,10 +682,13 @@ test "sift up with odd indices, removeMax" {
661682}
662683
663684test "addSlice min" {
664 var queue = PDQ.init(testing.allocator, {});
665 defer queue.deinit();
685 const gpa = std.testing.allocator;
686
687 var queue = PDQ.init({});
688 defer queue.deinit(gpa);
689
666690 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
667 try queue.addSlice(items[0..]);
691 try queue.addSlice(gpa, items[0..]);
668692
669693 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
670694 for (sorted_items) |e| {
......@@ -673,10 +697,13 @@ test "addSlice min" {
673697}
674698
675699test "addSlice max" {
676 var queue = PDQ.init(testing.allocator, {});
677 defer queue.deinit();
700 const gpa = std.testing.allocator;
701
702 var queue = PDQ.init({});
703 defer queue.deinit(gpa);
704
678705 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
679 try queue.addSlice(items[0..]);
706 try queue.addSlice(gpa, items[0..]);
680707
681708 const sorted_items = [_]u32{ 25, 24, 24, 22, 21, 16, 15, 15, 14, 13, 12, 11, 7, 7, 6, 5, 2, 1 };
682709 for (sorted_items) |e| {
......@@ -685,19 +712,26 @@ test "addSlice max" {
685712}
686713
687714test "fromOwnedSlice trivial case 0" {
715 const gpa = std.testing.allocator;
716
688717 const items = [0]u32{};
689 const queue_items = try testing.allocator.dupe(u32, &items);
690 var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});
691 defer queue.deinit();
718 const queue_items = try gpa.dupe(u32, &items);
719
720 var queue = PDQ.fromOwnedSlice(queue_items[0..], {});
721 defer queue.deinit(gpa);
722
692723 try expectEqual(@as(usize, 0), queue.len);
693724 try expect(queue.removeMinOrNull() == null);
694725}
695726
696727test "fromOwnedSlice trivial case 1" {
728 const gpa = std.testing.allocator;
729
697730 const items = [1]u32{1};
698 const queue_items = try testing.allocator.dupe(u32, &items);
699 var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});
700 defer queue.deinit();
731 const queue_items = try gpa.dupe(u32, &items);
732
733 var queue = PDQ.fromOwnedSlice(queue_items[0..], {});
734 defer queue.deinit(gpa);
701735
702736 try expectEqual(@as(usize, 1), queue.len);
703737 try expectEqual(items[0], queue.removeMin());
......@@ -705,10 +739,13 @@ test "fromOwnedSlice trivial case 1" {
705739}
706740
707741test "fromOwnedSlice" {
742 const gpa = std.testing.allocator;
743
708744 const items = [_]u32{ 15, 7, 21, 14, 13, 22, 12, 6, 7, 25, 5, 24, 11, 16, 15, 24, 2, 1 };
709 const queue_items = try testing.allocator.dupe(u32, items[0..]);
710 var queue = PDQ.fromOwnedSlice(testing.allocator, queue_items[0..], {});
711 defer queue.deinit();
745 const queue_items = try gpa.dupe(u32, items[0..]);
746
747 var queue = PDQ.fromOwnedSlice(queue_items[0..], {});
748 defer queue.deinit(gpa);
712749
713750 const sorted_items = [_]u32{ 1, 2, 5, 6, 7, 7, 11, 12, 13, 14, 15, 15, 16, 21, 22, 24, 24, 25 };
714751 for (sorted_items) |e| {
......@@ -717,12 +754,14 @@ test "fromOwnedSlice" {
717754}
718755
719756test "update min queue" {
720 var queue = PDQ.init(testing.allocator, {});
721 defer queue.deinit();
757 const gpa = std.testing.allocator;
722758
723 try queue.add(55);
724 try queue.add(44);
725 try queue.add(11);
759 var queue = PDQ.init({});
760 defer queue.deinit(gpa);
761
762 try queue.add(gpa, 55);
763 try queue.add(gpa, 44);
764 try queue.add(gpa, 11);
726765 try queue.update(55, 5);
727766 try queue.update(44, 4);
728767 try queue.update(11, 1);
......@@ -732,13 +771,15 @@ test "update min queue" {
732771}
733772
734773test "update same min queue" {
735 var queue = PDQ.init(testing.allocator, {});
736 defer queue.deinit();
774 const gpa = std.testing.allocator;
775
776 var queue = PDQ.init({});
777 defer queue.deinit(gpa);
737778
738 try queue.add(1);
739 try queue.add(1);
740 try queue.add(2);
741 try queue.add(2);
779 try queue.add(gpa, 1);
780 try queue.add(gpa, 1);
781 try queue.add(gpa, 2);
782 try queue.add(gpa, 2);
742783 try queue.update(1, 5);
743784 try queue.update(2, 4);
744785 try expectEqual(@as(u32, 1), queue.removeMin());
......@@ -748,12 +789,14 @@ test "update same min queue" {
748789}
749790
750791test "update max queue" {
751 var queue = PDQ.init(testing.allocator, {});
752 defer queue.deinit();
792 const gpa = std.testing.allocator;
793
794 var queue = PDQ.init({});
795 defer queue.deinit(gpa);
753796
754 try queue.add(55);
755 try queue.add(44);
756 try queue.add(11);
797 try queue.add(gpa, 55);
798 try queue.add(gpa, 44);
799 try queue.add(gpa, 11);
757800 try queue.update(55, 5);
758801 try queue.update(44, 1);
759802 try queue.update(11, 4);
......@@ -764,13 +807,15 @@ test "update max queue" {
764807}
765808
766809test "update same max queue" {
767 var queue = PDQ.init(testing.allocator, {});
768 defer queue.deinit();
810 const gpa = std.testing.allocator;
769811
770 try queue.add(1);
771 try queue.add(1);
772 try queue.add(2);
773 try queue.add(2);
812 var queue = PDQ.init({});
813 defer queue.deinit(gpa);
814
815 try queue.add(gpa, 1);
816 try queue.add(gpa, 1);
817 try queue.add(gpa, 2);
818 try queue.add(gpa, 2);
774819 try queue.update(1, 5);
775820 try queue.update(2, 4);
776821 try expectEqual(@as(u32, 5), queue.removeMax());
......@@ -780,25 +825,29 @@ test "update same max queue" {
780825}
781826
782827test "update after remove" {
783 var queue = PDQ.init(testing.allocator, {});
784 defer queue.deinit();
828 const gpa = std.testing.allocator;
829
830 var queue = PDQ.init({});
831 defer queue.deinit(gpa);
785832
786 try queue.add(1);
833 try queue.add(gpa, 1);
787834 try expectEqual(@as(u32, 1), queue.removeMin());
788835 try expectError(error.ElementNotFound, queue.update(1, 1));
789836}
790837
791838test "iterator" {
792 var queue = PDQ.init(testing.allocator, {});
839 const gpa = std.testing.allocator;
840
841 var queue = PDQ.init({});
793842 var map = std.AutoHashMap(u32, void).init(testing.allocator);
794843 defer {
795 queue.deinit();
844 queue.deinit(gpa);
796845 map.deinit();
797846 }
798847
799848 const items = [_]u32{ 54, 12, 7, 23, 25, 13 };
800849 for (items) |e| {
801 _ = try queue.add(e);
850 _ = try queue.add(gpa, e);
802851 _ = try map.put(e, {});
803852 }
804853
......@@ -811,12 +860,14 @@ test "iterator" {
811860}
812861
813862test "remove at index" {
814 var queue = PDQ.init(testing.allocator, {});
815 defer queue.deinit();
863 const gpa = std.testing.allocator;
864
865 var queue = PDQ.init({});
866 defer queue.deinit(gpa);
816867
817 try queue.add(3);
818 try queue.add(2);
819 try queue.add(1);
868 try queue.add(gpa, 3);
869 try queue.add(gpa, 2);
870 try queue.add(gpa, 1);
820871
821872 var it = queue.iterator();
822873 var elem = it.next();
......@@ -834,8 +885,10 @@ test "remove at index" {
834885}
835886
836887test "iterator while empty" {
837 var queue = PDQ.init(testing.allocator, {});
838 defer queue.deinit();
888 const gpa = std.testing.allocator;
889
890 var queue = PDQ.init({});
891 defer queue.deinit(gpa);
839892
840893 var it = queue.iterator();
841894
......@@ -843,19 +896,21 @@ test "iterator while empty" {
843896}
844897
845898test "shrinkAndFree" {
846 var queue = PDQ.init(testing.allocator, {});
847 defer queue.deinit();
899 const gpa = std.testing.allocator;
848900
849 try queue.ensureTotalCapacity(4);
901 var queue = PDQ.init({});
902 defer queue.deinit(gpa);
903
904 try queue.ensureTotalCapacity(gpa, 4);
850905 try expect(queue.capacity() >= 4);
851906
852 try queue.add(1);
853 try queue.add(2);
854 try queue.add(3);
907 try queue.add(gpa, 1);
908 try queue.add(gpa, 2);
909 try queue.add(gpa, 3);
855910 try expect(queue.capacity() >= 4);
856911 try expectEqual(@as(usize, 3), queue.len);
857912
858 queue.shrinkAndFree(3);
913 queue.shrinkAndFree(gpa, 3);
859914 try expectEqual(@as(usize, 3), queue.capacity());
860915 try expectEqual(@as(usize, 3), queue.len);
861916
......@@ -879,11 +934,12 @@ test "fuzz testing min" {
879934}
880935
881936fn fuzzTestMin(rng: std.Random, comptime queue_size: usize) !void {
882 const allocator = testing.allocator;
883 const items = try generateRandomSlice(allocator, rng, queue_size);
937 const gpa = std.testing.allocator;
938
939 const items = try generateRandomSlice(gpa, rng, queue_size);
884940
885 var queue = PDQ.fromOwnedSlice(allocator, items, {});
886 defer queue.deinit();
941 var queue = PDQ.fromOwnedSlice(items, {});
942 defer queue.deinit(gpa);
887943
888944 var last_removed: ?u32 = null;
889945 while (queue.removeMinOrNull()) |next| {
......@@ -908,11 +964,12 @@ test "fuzz testing max" {
908964}
909965
910966fn fuzzTestMax(rng: std.Random, queue_size: usize) !void {
911 const allocator = testing.allocator;
912 const items = try generateRandomSlice(allocator, rng, queue_size);
967 const gpa = std.testing.allocator;
913968
914 var queue = PDQ.fromOwnedSlice(testing.allocator, items, {});
915 defer queue.deinit();
969 const items = try generateRandomSlice(gpa, rng, queue_size);
970
971 var queue = PDQ.fromOwnedSlice(items, {});
972 defer queue.deinit(gpa);
916973
917974 var last_removed: ?u32 = null;
918975 while (queue.removeMaxOrNull()) |next| {
......@@ -937,11 +994,12 @@ test "fuzz testing min and max" {
937994}
938995
939996fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void {
940 const allocator = testing.allocator;
941 const items = try generateRandomSlice(allocator, rng, queue_size);
997 const gpa = std.testing.allocator;
998
999 const items = try generateRandomSlice(gpa, rng, queue_size);
9421000
943 var queue = PDQ.fromOwnedSlice(allocator, items, {});
944 defer queue.deinit();
1001 var queue = PDQ.fromOwnedSlice(items, {});
1002 defer queue.deinit(gpa);
9451003
9461004 var last_min: ?u32 = null;
9471005 var last_max: ?u32 = null;
......@@ -983,18 +1041,20 @@ fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order {
9831041const CPDQ = PriorityDequeue(usize, []const u32, contextLessThanComparison);
9841042
9851043test "add and remove" {
1044 const gpa = std.testing.allocator;
1045
9861046 const context = [_]u32{ 5, 3, 4, 2, 2, 8, 0 };
9871047
988 var queue = CPDQ.init(testing.allocator, context[0..]);
989 defer queue.deinit();
1048 var queue = CPDQ.init(context[0..]);
1049 defer queue.deinit(gpa);
9901050
991 try queue.add(0);
992 try queue.add(1);
993 try queue.add(2);
994 try queue.add(3);
995 try queue.add(4);
996 try queue.add(5);
997 try queue.add(6);
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);
9981058 try expectEqual(@as(usize, 6), queue.removeMin());
9991059 try expectEqual(@as(usize, 5), queue.removeMax());
10001060 try expectEqual(@as(usize, 3), queue.removeMin());
......@@ -1007,20 +1067,22 @@ test "add and remove" {
10071067var all_cmps_unique = true;
10081068
10091069test "don't compare a value to a copy of itself" {
1070 const gpa = std.testing.allocator;
1071
10101072 var depq = PriorityDequeue(u32, void, struct {
10111073 fn uniqueLessThan(_: void, a: u32, b: u32) Order {
10121074 all_cmps_unique = all_cmps_unique and (a != b);
10131075 return std.math.order(a, b);
10141076 }
1015 }.uniqueLessThan).init(testing.allocator, {});
1016 defer depq.deinit();
1017
1018 try depq.add(1);
1019 try depq.add(2);
1020 try depq.add(3);
1021 try depq.add(4);
1022 try depq.add(5);
1023 try depq.add(6);
1077 }.uniqueLessThan).init({});
1078 defer depq.deinit(gpa);
1079
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);
10241086
10251087 _ = depq.removeIndex(2);
10261088 try expectEqual(all_cmps_unique, true);