Simplify test code by replacing assertion helper with hash table destructuring

Author: thekid

src/test/php/util/data/unittest/CollectorsTest.class.php

@@ -8,9 +8,6 @@
 class CollectorsTest {
   private $people;
 
-  /**
-   * Sets up test, initializing people member
-   */
   #[Before]
   public function setUp() {
     $this->people= [
@@ -20,20 +17,9 @@ public function setUp() {
     ];
   }
 
-  /**
-   * Compares a hashtable against an expected map.
-   *
-   * @param  [:var] $expected
-   * @param  util.collections.HashTable $actual
-   * @throws unittest.AssertionFailedError
-   */
-  private function assertHashTable($expected, $actual) {
-    Assert::instance(HashTable::class, $actual);
-    $compare= [];
-    foreach ($actual as $pair) {
-      $compare[$pair->key]= $pair->value;
-    }
-    return Assert::equals($expected, $compare);
+  /** Destructure map pairs */
+  private function map($pair) {
+    yield $pair->key => $pair->value;
   }
 
   /** @return var[][] */
@@ -235,48 +221,62 @@ public function joining_names_with_prefix_and_suffix() {
 
   #[Test, Values(from: 'employeesDepartment')]
   public function groupingBy($departmentOf) {
-    $this->assertHashTable(
-      ['B' => new Vector([$this->people[1549]]), 'I' => new Vector([$this->people[1552], $this->people[6100]])],
-      Sequence::of($this->people)->collect(Collectors::groupingBy($departmentOf))
-    );
+    $collector= Collectors::groupingBy($departmentOf);
+    Assert::that(Sequence::of($this->people)->collect($collector))
+      ->mappedBy([$this, 'map'])
+      ->isEqualTo([
+        'B' => new Vector([$this->people[1549]]),
+        'I' => new Vector([$this->people[1552], $this->people[6100]])
+      ])
+    ;
   }
 
   #[Test]
   public function groupingBy_with_summing_of_years() {
-    $this->assertHashTable(['B' => 15, 'I' => 18], Sequence::of($this->people)
-      ->collect(Collectors::groupingBy(
-        function($e) { return $e->department(); },
-        Collectors::summing(function($e) { return $e->years(); })
-      ))
+    $collector= Collectors::groupingBy(
+      function($e) { return $e->department(); },
+      Collectors::summing(function($e) { return $e->years(); })
     );
+    Assert::that(Sequence::of($this->people)->collect($collector))
+      ->mappedBy([$this, 'map'])
+      ->isEqualTo(['B' => 15, 'I' => 18])
+    ;
   }
 
   #[Test]
   public function groupingBy_with_averaging_of_years() {
-    $this->assertHashTable(['B' => 15, 'I' => 9], Sequence::of($this->people)
-      ->collect(Collectors::groupingBy(
-        function($e) { return $e->department(); },
-        Collectors::averaging(function($e) { return $e->years(); })
-      ))
+    $collector= Collectors::groupingBy(
+      function($e) { return $e->department(); },
+      Collectors::averaging(function($e) { return $e->years(); })
     );
+    Assert::that(Sequence::of($this->people)->collect($collector))
+      ->mappedBy([$this, 'map'])
+      ->isEqualTo(['B' => 15, 'I' => 9])
+    ;
   }
 
   #[Test, Values(from: 'dinosaurEmployees')]
   public function partitioningBy($moreThanTen) {
-    $this->assertHashTable(
-      [true => new Vector([$this->people[1549], $this->people[1552]]), false => new Vector([$this->people[6100]])],
-      Sequence::of($this->people)->collect(Collectors::partitioningBy($moreThanTen))
-    );
+    $collector= Collectors::partitioningBy($moreThanTen);
+    Assert::that(Sequence::of($this->people)->collect($collector))
+      ->mappedBy([$this, 'map'])
+      ->isEqualTo([
+        true  => new Vector([$this->people[1549], $this->people[1552]]),
+        false => new Vector([$this->people[6100]])
+      ])
+    ;
   }
 
   #[Test]
   public function partitioningBy_handles_non_booleans() {
-    $this->assertHashTable(
-      [true => new Vector(['Test', 'Unittest']), false => new Vector(['Trial & Error'])],
-      Sequence::of(['Test', 'Unittest', 'Trial & Error'])->collect(Collectors::partitioningBy(function($e) {
-        return stristr($e, 'Test');
-      }))
-    );
+    $collector= Collectors::partitioningBy(function($e) { return stristr($e, 'Test'); });
+    Assert::that(Sequence::of(['Test', 'Unittest', 'Trial & Error'])->collect($collector))
+      ->mappedBy([$this, 'map'])
+      ->isEqualTo([
+        true  => new Vector(['Test', 'Unittest']),
+        false => new Vector(['Trial & Error'])
+      ])
+    ;
   }
 
   #[Test]