fix for testing triplet packing

Author: MiriamNagar

prtpy/packing/triplet_packing.py

@@ -110,7 +110,7 @@ def triplet_packing(binner: Binner, binsize: float, items: List[Any], use_local_
     for bin_i, triplet in enumerate(result.solution.get_triplets()):
         for item in triplet.get():
             binner.add_item_to_bin(bins, item, bin_i)
-    logger.info(f"solution completed with {len(bins[1])} bins.")
+    logger.info(f"solution completed with {binner.numbins} bins.")
     return bins
 
 if __name__ == "__main__":

tests/test_packing_small_inputs.py

@@ -6,10 +6,37 @@
 """
 import prtpy, unittest, itertools
 from utils import functions_in_class
+from test_triplet_packing import create_random_allocatable_item_list
 
 class TestPackingAlgorithms(unittest.TestCase):
+    def _test_class_with_list_input_for_triplet_packing(self, items_num, binsize=1000):
+        algorithm = prtpy.packing.triplet_packing
+        items, _ = create_random_allocatable_item_list(binsize, items_num)
+        
+        result = prtpy.pack(algorithm=algorithm, binsize=binsize, items=items, outputtype=prtpy.out.Partition)
+        for tri in result:
+            assert len(tri) == 3, f"Expected 3 items per bin, got {len(tri)}"
+            assert sum(tri) == binsize, f"Bin sum mismatch: got {sum(tri)} instead of {binsize}"
+
+        result = prtpy.pack(algorithm=algorithm, binsize=binsize, items=items, outputtype=prtpy.out.Sums)
+        for triplet_sum in result:
+            assert triplet_sum == binsize
+
+        result = prtpy.pack(algorithm=algorithm, binsize=binsize, items=items, outputtype=prtpy.out.LargestSum)
+        assert (result==binsize)
+
+        result = prtpy.pack(algorithm=algorithm, binsize=binsize, items=items, outputtype=prtpy.out.SmallestSum)
+        assert (result==binsize)
+
+        result = prtpy.pack(algorithm=algorithm, binsize=binsize, items=items, outputtype=prtpy.out.BinCount)
+        assert (result==(items_num/3))
+
     def _test_class_with_list_input(self, theclass, items, binsize):
         for algorithm in functions_in_class(theclass):
+            if algorithm == prtpy.packing.triplet_packing:
+                self._test_class_with_list_input_for_triplet_packing(items_num=15, binsize=1000)
+                continue
+
             result = prtpy.pack(algorithm=algorithm, binsize=binsize, items=items, outputtype=prtpy.out.Partition)
             assert ((result[0]==[11] and result[1]==[22]) or (result[0]==[22] and result[1]==[11]))
 
@@ -31,6 +58,8 @@ def test_with_list_input(self):
 
     def _test_class_with_dict_input(self, theclass, items, binsize):
         for algorithm in functions_in_class(theclass):
+            if algorithm == prtpy.packing.triplet_packing:
+                continue  # triplet packing doesn't support str items input
             result = prtpy.pack(algorithm=algorithm, binsize=binsize, items=items, outputtype=prtpy.out.Partition)
             assert ((result[0]==["a"] and result[1]==["b"]) or (result[0]==["b"] and result[1]==["a"]))
 

tests/test_triplet_packing.py

@@ -238,6 +238,14 @@ def test_creation_random_allocatable_item_list():
     assert check_item_list_is_valid(bin_size, triplets)
 
 
+def assert_triplet_packing_valid_result(result, binsize):
+    _ , triplets_result = result
+
+    for tri in triplets_result:
+        assert len(tri) == 3, f"Expected 3 items per bin, got {len(tri)}"
+        assert sum(tri) == binsize, f"Bin sum mismatch: got {sum(tri)} instead of {binsize}"
+
+
 def test_randomized_items_packing_allocation():
     bin_sizes = [1000]
     item_nums = [60, 99]
@@ -249,19 +257,11 @@ def test_randomized_items_packing_allocation():
 
         # backtrack
         bin_result = triplet_packing(BinnerKeepingContents(), binsize=b_size, items=item_list)
-        _, triplets_result = bin_result
-
-        for tri in triplets_result:
-            assert len(tri) == 3, f"Expected 3 items per bin, got {len(tri)}"
-            assert sum(tri) == b_size, f"Bin sum mismatch: got {sum(tri)} instead of {b_size}"
+        assert_triplet_packing_valid_result(bin_result, b_size)
 
         # local search
         bin_result = triplet_packing(BinnerKeepingContents(), binsize=b_size, items=item_list, use_local_search=True)
-        _, triplets_result = bin_result
-
-        for tri in triplets_result:
-            assert len(tri) == 3, f"Expected 3 items per bin, got {len(tri)}"
-            assert sum(tri) == b_size, f"Bin sum mismatch: got {sum(tri)} instead of {b_size}"
+        assert_triplet_packing_valid_result(bin_result, b_size)
 
 
 def test_items_packing_allocation():
@@ -272,19 +272,11 @@ def test_items_packing_allocation():
 
         # backtrack
         bin_result = triplet_packing(BinnerKeepingContents(), binsize=b_size, items=item_list)
-        _, triplets_result = bin_result
-
-        for tri in triplets_result:
-            assert len(tri) == 3, f"Expected 3 items per bin, got {len(tri)}"
-            assert sum(tri) == b_size, f"Bin sum mismatch: got {sum(tri)} instead of {b_size}"
+        assert_triplet_packing_valid_result(bin_result, b_size)
 
         # local search
         bin_result = triplet_packing(BinnerKeepingContents(), binsize=b_size, items=item_list, use_local_search=True)
-        _, triplets_result = bin_result
-
-        for tri in triplets_result:
-            assert len(tri) == 3, f"Expected 3 items per bin, got {len(tri)}"
-            assert sum(tri) == b_size, f"Bin sum mismatch: got {sum(tri)} instead of {b_size}"
+        assert_triplet_packing_valid_result(bin_result, b_size)
 
 
 def test_invalid_input_throws_exception():