Fix bug. Refactor test code.

src/collections_methods.c

@@ -361,7 +361,7 @@ static zend_always_inline void zend_hash_distinct(zend_array* ht, Bucket* ref, c
     {
         ref[num_elements].h = UINT32_MAX;
         ZVAL_UNDEF(&ref[num_elements].val);
-        uint32_t min_offset = UINT32_MAX;
+        uint32_t min_offset = ref[0].h;
         for (idx = 1; idx <= num_elements; ++idx)
         {
             Bucket* bucket = &ref[idx];

tests/000-loaded.phpt

@@ -2,7 +2,8 @@
 Check whether the extension is loaded.
 --FILE--
 <?php
-if (!extension_loaded('collections'))
+if (!extension_loaded('collections')) {
     echo "Extension not loaded.", PHP_EOL;
+}
 ?>
 --EXPECT--

tests/001-pair.phpt

@@ -3,7 +3,8 @@ Test Pair.
 --FILE--
 <?php
 $pair = new Pair('foo', 'bar');
-if ($pair->first != 'foo' || $pair->second != 'bar')
+if ($pair->first != 'foo' || $pair->second != 'bar') {
     echo 'Test for Pair failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/002-init.phpt

@@ -6,7 +6,8 @@ $array = ['a' => 'b'];
 $collection = Collection::init($array);
 $collection1 = Collection::init($collection);
 $collection2 = Collection::init();
-if ($array != $collection1->toArray() || $collection2->toArray() != [])
+if ($array != $collection1->toArray() || $collection2->toArray() != []) {
     echo 'Collection::init() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/003-add-all.phpt

@@ -6,7 +6,8 @@ $array = [3, 7, 5, 6, 1, 2];
 $collection = Collection::init([6, 1, 2]);
 $collection2 = Collection::init([3, 7, 5]);
 $collection2->addAll($collection);
-if ($array != $collection2->toArray())
+if ($array != $collection2->toArray()) {
     echo 'Collection::addAll() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/004-all-any-none.phpt

@@ -9,23 +9,26 @@ $result = $collection->all(function ($value) {
 $result1 = $collection->all(function ($value, $key) {
     return strlen($key) < 4;
 });
-if ($result || !$result1)
+if ($result || !$result1) {
     echo 'Collection::all() failed.', PHP_EOL;
+}
 $result = $collection->any(function ($value) {
     return $value % 3 == 0;
 });
 $result1 = $collection->any(function ($value, $key) {
     return strpos($key, 'g') !== false;
 });
-if (!$result || $result1)
+if (!$result || $result1) {
     echo 'Collection::any() failed.', PHP_EOL;
+}
 $result = $collection->none(function ($value) {
     return $value < 0;
 });
 $result1 = $collection->none(function ($value, $key) {
     return ctype_alnum($value . $key);
 });
-if (!$result || $result1)
+if (!$result || $result1) {
     echo 'Collection::none() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/005-associate.phpt

@@ -7,15 +7,17 @@ $collection = Collection::init($array)
     ->associate(function ($value, $key) {
         return new Pair($value, $key);
     });
-if ($collection->toArray() != array_flip($array))
+if ($collection->toArray() != array_flip($array)) {
     echo 'Collection::associate() failed.', PHP_EOL;
+}
 $array1 = ['baz' => 1];
 $collection1 = Collection::init($array1);
 $array2 = $collection->associateTo($collection1,
     function ($value, $key) {
         return new Pair($key, $value);
     })->toArray();
-if ($array2 != $array1 + array_flip($array) || $collection1->toArray() != $array2)
+if ($array2 != $array1 + array_flip($array) || $collection1->toArray() != $array2) {
     echo 'Collection::associateTo() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/006-associate-by.phpt

@@ -7,14 +7,16 @@ $collection = Collection::init($array)
     ->associateBy(function ($value, $key) {
         return strlen($key) - 1;
     });
-if ($collection->toArray() != array_values($array))
+if ($collection->toArray() != array_values($array)) {
     echo 'Collection::associateBy() failed.', PHP_EOL;
-$array1 = ['foo' => 'bar'];
-$collection1 = Collection::init($array1);
-$array2 = $collection->associateByTo($collection1, function ($value, $key) {
+}
+$array = ['foo' => 'bar'];
+$collection = Collection::init($array);
+$array1 = $collection->associateByTo($collection, function ($value, $key) {
     return $key;
 })->toArray();
-if ($array2 != $array1 + $collection->toArray() || $collection1->toArray() != $array2)
+if ($array1 != $array + $collection->toArray() || $collection->toArray() != $array1) {
     echo 'Collection::associateTo() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/007-average.phpt

@@ -4,7 +4,8 @@ Test Collection::average().
 <?php
 $array = [2.632, 7.871, 9.094, 5.457, 3, 9, 6];
 $average = Collection::init($array)->average();
-if ($average != array_sum($array) / count($array))
+if ($average != array_sum($array) / count($array)) {
     echo 'Collection::average() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/008-contains-all.phpt

@@ -5,7 +5,8 @@ Test Collection::containsAll().
 $array = [[], 1, 't'];
 $array1 = [2, ['t'], 5];
 $collection = Collection::init([1, 2, 't', [], 5]);
-if (!$collection->containsAll($array) || $collection->containsAll($array1))
+if (!$collection->containsAll($array) || $collection->containsAll($array1)) {
     echo 'Collection::containsAll() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/009-contains-key-value.phpt

@@ -3,9 +3,11 @@ Test Collection::containsKey() and Collection::containsValue().
 --FILE--
 <?php
 $collection = Collection::init(['foo' => 'bar', 12 => 6, 'baz' => 27]);
-if (!$collection->containsKey('foo') || $collection->containsKey('Baz'))
+if (!$collection->containsKey('foo') || $collection->containsKey('Baz')) {
     echo 'Collection::containsKey() failed.', PHP_EOL;
-if (!$collection->containsValue(27) || $collection->containsValue(3))
+}
+if (!$collection->containsValue(27) || $collection->containsValue(3)) {
     echo 'Collection::containsValue() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/010-copy-of.phpt

@@ -5,8 +5,12 @@ Test Collection::copyOf();
 $array = ['a' => 2, 3 => 'd', 'e' => 'f'];
 $collection = Collection::init($array);
 $collection1 = $collection->copyOf(2);
-$collection2 = $collection->copyOf();
-if ($collection1->toArray() != array_slice($array, 0, 2, true) || $collection2->toArray() != $array)
+if ($collection1->toArray() != array_slice($array, 0, 2, true)) {
     echo 'Collection::copyOf() failed.', PHP_EOL;
+}
+$collection1 = $collection->copyOf();
+if ($collection1->toArray() != $array) {
+    echo 'Collection::copyOf() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/011-copy-of-range.phpt

@@ -9,7 +9,8 @@ $array = [3, 7, 6, 9, 2];
 $array1 = ['a' => 'b', 'c', 'd' => 'e'];
 $array2 = Collection::init($array)->copyOfRange(2, 4)->toArray();
 $array3 = Collection::init($array1)->copyOfRange(1, 2)->toArray();
-if ($array2 != array_slice($array, 2, 4) || $array3 != array_slice($array1, 1, 2))
+if ($array2 != array_slice($array, 2, 4) || $array3 != array_slice($array1, 1, 2)) {
     echo 'Collection::copyOfRange() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/012-countable.phpt

@@ -4,9 +4,11 @@ Test Collection::count() and implementation of interface Countable.
 <?php
 $array = [1, 2, 3, 4, 5, 6];
 $collection = Collection::init($array);
-if ($collection->count() != count($array))
+if ($collection->count() != count($array)) {
     echo 'Collection::count() failed.', PHP_EOL;
-if (count($collection) != count($array))
+}
+if (count($collection) != count($array)) {
     echo 'Test for handlers.count_elements failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/013-array-access.phpt

@@ -7,13 +7,17 @@ $collection = Collection::init($array);
 $collection['a'] = 'foo'.strval(123);
 $collection['h'] = 'bar';
 unset($collection['c']);
-if (empty($collection) || isset($collection['t']) || !isset($collection['e']))
+if (empty($collection) || isset($collection['t']) || !isset($collection['e'])) {
     echo 'Test for handlers.has_dimension failed.', PHP_EOL;
-if ($collection['e']['f'] != 'g')
+}
+if ($collection['e']['f'] != 'g') {
     echo 'Test for handlers.read_dimension failed.', PHP_EOL;
-if ($collection['a'] != 'foo'.strval(123) || $collection['h'] != 'bar')
+}
+if ($collection['a'] != 'foo'.strval(123) || $collection['h'] != 'bar') {
     echo 'Test for handlers.write_dimension failed.', PHP_EOL;
-if (isset($collection['c']))
+}
+if (isset($collection['c'])) {
     echo 'Test for handlers.unset_dimension failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/014-drop.phpt

@@ -4,10 +4,12 @@ Test Collection::drop() and Collection::dropLast().
 <?php
 $collection = Collection::init(['ab' => 'c', 'd', 'e' => 'f', 12, 34]);
 $collection1 = $collection->drop(2);
-$collection2 = $collection->dropLast(3);
-if ($collection1->toArray() != ['e' => 'f', 1 => 12, 2 => 34])
+if ($collection1->toArray() != ['e' => 'f', 1 => 12, 2 => 34]) {
     echo 'Collection::drop() failed.', PHP_EOL;
-if ($collection2->toArray() != ['ab' => 'c', 'd'])
+}
+$collection1 = $collection->dropLast(3);
+if ($collection1->toArray() != ['ab' => 'c', 'd']) {
     echo 'Collection::dropLast() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/015-drop-while.phpt

@@ -6,12 +6,14 @@ $collection = Collection::init([5, 7, 1, 4, 3]);
 $collection1 = $collection->dropWhile(function ($value) {
     return $value % 2;
 });
-if ($collection1->toArray() != [3 => 4, 4 => 3])
+if ($collection1->toArray() != [3 => 4, 4 => 3]) {
     echo 'Collection::dropWhile() failed.', PHP_EOL;
-$collection2 = $collection->dropLastWhile(function ($value) {
+}
+$collection1 = $collection->dropLastWhile(function ($value) {
     return $value < 6;
 });
-if ($collection2->toArray() != [5, 7])
+if ($collection1->toArray() != [5, 7]) {
     echo 'Collection::dropLastWhile() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/016-fill.phpt

@@ -9,7 +9,8 @@ $array1 = ['foo', 'bar' => 't', 't', 't', 3];
 $collection1 = Collection::init($array);
 $collection1->fill(0);
 $array2 = [0, 'bar' => 0, 0, 0, 0];
-if ($collection->toArray() != $array1 || $collection1->toArray() != $array2)
+if ($collection->toArray() != $array1 || $collection1->toArray() != $array2) {
     echo 'Collection::fill() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/017-filter.phpt

@@ -11,10 +11,12 @@ $pred_is_even = function ($value) {
 };
 $collection = Collection::init($array)->filter($pred_is_odd);
 $collection1 = Collection::init($array)->filterNot($pred_is_odd);
-if ($collection->toArray() != array_values(array_filter($array, $pred_is_odd)))
+if ($collection->toArray() != array_values(array_filter($array, $pred_is_odd))) {
     echo 'Collection::filter() failed.', PHP_EOL;
-if ($collection1->toArray() != array_values(array_filter($array, $pred_is_even)))
+}
+if ($collection1->toArray() != array_values(array_filter($array, $pred_is_even))) {
     echo 'Collection::filterNot() failed.', PHP_EOL;
+}
 $dest = Collection::init($array);
 $collection2 = Collection::init($array)->filterTo($dest, $pred_is_odd);
 if ($collection2->toArray() != array_merge($array, $collection->toArray()))

tests/018-first-last.phpt

@@ -8,12 +8,14 @@ $collection1 = Collection::init();
 $value = $collection->first(function ($value) {
     return $value > 0;
 });
-if ($value != 1 || $collection->first() != -5 || $collection1->first() != null)
+if ($value != 1 || $collection->first() != -5 || $collection1->first() != null) {
     echo 'Collection::first() failed.', PHP_EOL;
+}
 $value1 = $collection->last(function ($value) {
     return $value % 2 == 0;
 });
-if ($value1 != 8 || $collection->last() != 9 || $collection1->last() != null)
-    echo 'Collection::last() failed.', PHP_EOL;
+if ($value1 != 8 || $collection->last() != 9 || $collection1->last() != null) {
+    echo 'Collection::last() failed.', PHP_EOL;    
+}
 ?>
 --EXPECT--

tests/019-flat-map.phpt

@@ -6,13 +6,15 @@ $array = [['a' => ['b', 'c'], 'd' => ['e', 'f']], ['a' => ['g', 'h'], 'd' => ['i
 $collection = Collection::init($array)->flatMap(function ($value) {
     return $value['a'];
 });
-if ($collection->toArray() != ['b', 'c', 'g', 'h'])
+if ($collection->toArray() != ['b', 'c', 'g', 'h']) {
     echo 'Collection::flatMap() failed.', PHP_EOL;
+}
 $collection1 = Collection::init(['k', 'l']);
 $collection2 = Collection::init($array)->flatMapTo($collection1, function ($value) {
     return Collection::init($value['d']);
 });
-if ($collection2->toArray() != ['k', 'l', 'e', 'f', 'i', 'j'])
+if ($collection2->toArray() != ['k', 'l', 'e', 'f', 'i', 'j']) {
     echo 'Collection::flatMap() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/020-to-collection.phpt

@@ -4,7 +4,8 @@ Test Collection::toCollection().
 <?php
 $collection = Collection::init(['a', 'b']);
 Collection::init(['foo', 'bar'])->toCollection($collection);
-if ($collection->toArray() != ['a', 'b', 'foo', 'bar'])
+if ($collection->toArray() != ['a', 'b', 'foo', 'bar']) {
     echo 'Collection::toCollection() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/021-to-pairs.phpt

@@ -4,9 +4,11 @@ Test Collection::toPairs().
 <?php
 $pairs = Collection::init(['a' => 'b', 'c' => 'd'])->toPairs();
 $test = '';
-foreach ($pairs as $pair)
+foreach ($pairs as $pair) {
     $test .= $pair->first . ',' . $pair->second . ';';
-if ($test != 'a,b;c,d;')
+}
+if ($test != 'a,b;c,d;') {
     echo 'Collection::toPairs() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/022-flatten.phpt

@@ -4,7 +4,8 @@ Test Collection::flatten().
 <?php
 $array = [['a', 'foo' => 'b'], ['c', 'd', ['e']], 'bar' => 'f'];
 $collection = Collection::init($array)->flatten();
-if ($collection->toArray() != ['a', 'foo' => 'b', 'c', 'd', ['e'], 'bar' => 'f'])
+if ($collection->toArray() != ['a', 'foo' => 'b', 'c', 'd', ['e'], 'bar' => 'f']) {
     echo 'Collection::flatten() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/023-min-max.phpt

@@ -4,15 +4,20 @@ Test Collection::min() and Collection::max().
 <?php
 $array = [3.42, 7.15, 0.0, -4.2, 1.64];
 $collection = Collection::init($array);
-if ($collection->max() != max($array) || Collection::init()->max() != null)
+if ($collection->max() != max($array) || Collection::init()->max() != null) {
     echo 'Collection::max() failed.', PHP_EOL;
-if ($collection->min() != min($array) || Collection::init()->min() != null)
+}
+if ($collection->min() != min($array) || Collection::init()->min() != null) {
     echo 'Collection::min() failed.', PHP_EOL;
-$array1 = ['p3.4', 'p3.32', 'p10.2'];
-$collection1 = Collection::init($array1);
-if ($collection1->max() != $array1[0] || $collection1->max(Collection::COMPARE_NATRUAL) != $array1[2])
+}
+
+$array = ['p3.4', 'p3.32', 'p10.2'];
+$collection = Collection::init($array);
+if ($collection->max() != $array[0] || $collection->max(Collection::COMPARE_NATRUAL) != $array[2]) {
     echo 'Collection::max() failed.', PHP_EOL;
-if ($collection1->min() != $array1[2] || $collection1->min(Collection::COMPARE_NATRUAL) != $array1[0])
+}
+if ($collection->min() != $array[2] || $collection->min(Collection::COMPARE_NATRUAL) != $array[0]) {
     echo 'Collection::min() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/024-keys-values.phpt

@@ -4,9 +4,11 @@ Test Collection::keys() and Collection::values().
 <?php
 $array = ['a' => 'b', 'c' => ['d'], 10 => 'f'];
 $collection = Collection::init($array);
-if ($collection->keys()->toArray() != array_keys($array))
+if ($collection->keys()->toArray() != array_keys($array)) {
     echo 'Collection::keys() failed.', PHP_EOL;
-if ($collection->values()->toArray() != array_values($array))
+}
+if ($collection->values()->toArray() != array_values($array)) {
     echo 'Collection::values() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/025-single.phpt

@@ -13,7 +13,8 @@ $value1 = $collection->single(function ($value) {
 $value2 = $collection->single(function ($value, $key) {
     return $key > 5;
 });
-if (isset($value) || $value1 != 'cd' || isset($value2))
+if (isset($value) || $value1 != 'cd' || isset($value2)) {
     echo 'Collection::single() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/026-is-empty.phpt

@@ -2,9 +2,11 @@
 Test Collection::isEmpty() and Collection::isNotEmpty().
 --FILE--
 <?php
-if (!Collection::init()->isEmpty())
+if (!Collection::init()->isEmpty()) {
     echo 'Collection::isEmpty() failed.', PHP_EOL;
-if (!Collection::init(['foo', 'bar'])->isNotEmpty())
+}
+if (!Collection::init(['foo', 'bar'])->isNotEmpty()) {
     echo 'Collection::isNotEmpty() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/027-get-set-remove.phpt

@@ -8,14 +8,19 @@ $collection->set('a', 'foo');
 $collection->set('e', 'bar');
 $array['a'] = 'foo';
 $array['e'] = 'bar';
-if ($collection->toArray() != $array)
+if ($collection->toArray() != $array) {
     echo 'Collection::set() failed.', PHP_EOL;
+}
 if ($collection->get('a') != $array['a'] ||
-    $collection->get('f', function ($key) { return $key; }) != 'f')
+    $collection->get('f', function ($key) { return $key; }) != 'f'
+) {
     echo 'Collection::get() failed.', PHP_EOL;
-if (!$collection->remove('a') || !is_null($collection->get('a')))
+}
+if (!$collection->remove('a') || !is_null($collection->get('a'))) {
     echo 'Collection::remove() failed.', PHP_EOL;
-if ($collection->remove('c', 'e') || $collection->get('c') != 'd')
+}
+if ($collection->remove('c', 'e') || $collection->get('c') != 'd') {
     echo 'Collection::remove() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/028-min-max-by.phpt

@@ -11,13 +11,15 @@ $collection = Collection::init($array);
 $result = $collection->maxBy(function ($value) {
     return $value[0];
 });
-if ($result != $array[1])
+if ($result != $array[1]) {
     echo 'Collection::maxBy() failed.', PHP_EOL;
+}
 $result = $collection->minBy(function ($value) {
     return $value[2];
 });
-if ($result != $array[0])
+if ($result != $array[0]) {
     echo 'Collection::minBy() failed.', PHP_EOL;
+}
 $array1 = [
     ['abc', 'ABD'],
     ['ACE', 'ABC'],
@@ -27,12 +29,14 @@ $collection1 = Collection::init($array1);
 $result = $collection1->maxBy(function ($value) {
     return $value[0];
 });
-if ($result != $array1[2])
+if ($result != $array1[2]) {
     echo 'Collection::maxBy() failed.', PHP_EOL;
+}
 $result = $collection1->minBy(function ($value) {
     return $value[1];
 }, Collection::FOLD_CASE);
-if ($result != $array1[2])
+if ($result != $array1[2]) {
     echo 'Collection::minBy() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/029-remove-retain-all.phpt

@@ -8,14 +8,17 @@ $pred_is_odd = function ($value) {
 };
 $collection = Collection::init($array);
 $collection->removeAll($pred_is_odd);
-if ($collection->toArray() != ['a' => 4, 'd' => -2, 'e' => 0])
+if ($collection->toArray() != ['a' => 4, 'd' => -2, 'e' => 0]) {
     echo 'Collection::removeAll() failed.', PHP_EOL;
+}
 $collection->removeAll();
-if ($collection->toArray() != [])
+if ($collection->toArray() != []) {
     echo 'Collection::removeAll() failed.', PHP_EOL;
+}
 $collection = Collection::init($array);
 $collection->retainAll($pred_is_odd);
-if ($collection->toArray() != ['b' => 1, 'c' => 9])
+if ($collection->toArray() != ['b' => 1, 'c' => 9]) {
     echo 'Collection::retainAll() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/030-foreach-oneach.phpt

@@ -4,8 +4,9 @@ Test Collection::forEach() and Collection::onEach().
 <?php
 $array = ['a', 'b', 'c', 'd', 'e'];
 $result2 = $result1 = $result = '';
-foreach ($array as $value)
+foreach ($array as $value) {
     $result .= $value;
+}
 $collection = Collection::init($array);
 $collection->forEach(function ($value) use (&$result1) {
     $result1 .= $value;
@@ -13,9 +14,11 @@ $collection->forEach(function ($value) use (&$result1) {
 $collection1 = $collection->onEach(function ($value) use (&$result2) {
     $result2 .= $value;
 });
-if ($result1 != $result)
+if ($result1 != $result) {
     echo 'Collection::forEach() failed.', PHP_EOL;
-if ($result2 != $result || $collection1->toArray() != $collection->toArray())
+}
+if ($result2 != $result || $collection1->toArray() != $collection->toArray()) {
     echo 'Collection::onEach() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/031-partition.phpt

@@ -6,7 +6,8 @@ $array = ['abc', 'd', 'ef', 'ghij'];
 $pair = Collection::init($array)->partition(function ($value) {
     return strlen($value) % 2;
 });
-if ($pair->first != ['abc', 'd'] || $pair->second != ['ef', 'ghij'])
+if ($pair->first != ['abc', 'd'] || $pair->second != ['ef', 'ghij']) {
     echo 'Collection::partition() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/032-reverse-reversed.phpt

@@ -5,9 +5,11 @@ Test Collection::reverse() and Collection::reversed().
 $array = ['a', 'b', 'c', 'd', 'e'];
 $collection = Collection::init($array);
 $collection->reverse();
-if ($collection->toArray() != array_reverse($array))
+if ($collection->toArray() != array_reverse($array)) {
     echo 'Collection::reverse() failed.', PHP_EOL;
-if ($collection->reversed()->toArray() != $array)
+}
+if ($collection->reversed()->toArray() != $array) {
     echo 'Collection::reversed() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/033-take.phpt

@@ -4,11 +4,17 @@ Test Collection::take() and Collection::takeLast().
 <?php
 $array = ['a', 'b', 'c', 'd', 'e'];
 $collection = Collection::init($array);
-if ($collection->take(0)->toArray() != [] || $collection->take(6)->toArray() != $array ||
-    $collection->take(3)->toArray() != array_slice($array, 0, 3))
+if ($collection->take(0)->toArray() != [] ||
+    $collection->take(6)->toArray() != $array ||
+    $collection->take(3)->toArray() != array_slice($array, 0, 3)
+) {   
     echo 'Collection::take() failed.', PHP_EOL;
-if ($collection->takeLast(0)->toArray() != [] || $collection->takeLast(10)->toArray() != $array ||
-    $collection->takeLast(4)->toArray() != array_slice($array, -4, 4))
+}
+if ($collection->takeLast(0)->toArray() != [] ||
+    $collection->takeLast(10)->toArray() != $array ||
+    $collection->takeLast(4)->toArray() != array_slice($array, -4, 4)
+) {
     echo 'Collection::takeLast() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/034-take-while.phpt

@@ -7,12 +7,14 @@ $collection = Collection::init($array);
 $collection1 = $collection->takeWhile(function ($value) {
     return ord($value) > ord('Z');
 });
-if ($collection1->toArray() != ['a', 'b'])
+if ($collection1->toArray() != ['a', 'b']) {
     echo 'Collection::takeWhile() failed.', PHP_EOL;
+}
 $collection2 = $collection->takeLastWhile(function ($value) {
     return $value != 'b';
 });
-if ($collection2->toArray() != ['C', 'D', 'e'])
+if ($collection2->toArray() != ['C', 'D', 'e']) {
     echo 'Collection::takeLastWhile() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/035-index-of.phpt

@@ -4,20 +4,24 @@ Test Collection::indexOf(), Collection::lastIndexOf(), Collection::indexOfFirst(
 <?php
 $collection = Collection::init(['t', 'B', 13, 'f', 'G', 19, 'N', 'f']);
 $first_f_at = $collection->indexOf('f');
-if ($first_f_at != 3)
+if ($first_f_at != 3) {
     echo 'Collection::indexOf() failed.', PHP_EOL;
+}
 $last_f_at = $collection->lastIndexOf('f');
-if ($last_f_at != 7)
+if ($last_f_at != 7) {
     echo 'Collection::lastIndexOf() failed.', PHP_EOL;
+}
 $first_numeric_at = $collection->indexOfFirst(function ($value) {
     return is_numeric($value);
 });
-if ($first_numeric_at != 2)
+if ($first_numeric_at != 2) {
     echo 'Collection::indexOfFirst() failed.', PHP_EOL;
+}
 $last_upper_case_at = $collection->indexOfLast(function ($value) {
     return ctype_upper($value);
 });
-if ($last_upper_case_at != 6)
+if ($last_upper_case_at != 6) {
     echo 'Collection::indexOfLast() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/036-slice.phpt

@@ -6,7 +6,8 @@ $array = [1, 2, 3, 4, 5, 6];
 $collection = Collection::init($array)->slice([2, -1, 3, 6]);
 $array1 = ['a' => 'b', 'c' => 'd', 'e' => 'f'];
 $collection1 = Collection::init($array1)->slice(['c', 'a', 'g']);
-if ($collection->toArray() != [3, 4] || $collection1->toArray() != ['c' => 'd', 'a' => 'b'])
+if ($collection->toArray() != [3, 4] || $collection1->toArray() != ['c' => 'd', 'a' => 'b']) {
     echo 'Collection::slice() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/037-map.phpt

@@ -6,13 +6,17 @@ $array = ['foo' => 'bar', 'bar' => 'baz'];
 $collection = Collection::init($array)->map(function ($value, $key) {
     return $key.$value;
 });
-if ($collection->toArray() != ['foobar', 'barbaz'])
+if ($collection->toArray() != ['foobar', 'barbaz']) {
     echo 'Collection::map() failed.', PHP_EOL;
+}
 $collection1 = Collection::init(['dummy']);
 $collection2 = Collection::init($array)->mapTo($collection1, function ($value, $key) {
     return $value.$key;
 });
-if ($collection1->toArray() != $collection2->toArray() || $collection1->toArray() != ['dummy', 'barfoo','bazbar'])
+if ($collection1->toArray() != $collection2->toArray() ||
+    $collection1->toArray() != ['dummy', 'barfoo','bazbar']
+) {
     echo 'Collection::mapTo() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/038-put-all.phpt

@@ -6,7 +6,8 @@ $array = ['a' => 'foo', 'b' => 'bar'];
 $array1 = ['a' => 'b', 'c' => 'd', 'e' => 'f'];
 $collection = Collection::init($array);
 $collection->putAll($array1);
-if ($collection->toArray() != array_merge($array, $array1))
+if ($collection->toArray() != array_merge($array, $array1)) {
     echo 'Collection::putAll() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/039-reduce.phpt

@@ -6,9 +6,11 @@ $collection = Collection::init(['a', 'b', 'c', 'd', 'e']);
 $reduce_cb = function ($acc, $value, $key) {
     return $acc.$value.strval($key);
 };
-if ($collection->reduce($reduce_cb) != 'ab1c2d3e4')
+if ($collection->reduce($reduce_cb) != 'ab1c2d3e4') {
     echo 'Collection::reduce() failed.', PHP_EOL;
-if ($collection->reduceRight($reduce_cb) != 'ed3c2b1a0')
+}
+if ($collection->reduceRight($reduce_cb) != 'ed3c2b1a0') {
     echo 'Collection::reduceRight() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/040-packed.phpt

@@ -5,7 +5,8 @@ Test Collection::packed().
 $case = Collection::init(['a', 'b', 'c'])->packed();
 $case1 = Collection::init(['foo' => 'bar', 'baz'])->packed();
 $case2 = Collection::init()->packed();
-if (!$case || $case1 || $case2)
+if (!$case || $case1 || $case2) {
     echo 'Collection::packed() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/041-fold.phpt

@@ -6,9 +6,11 @@ $collection = Collection::init(['a', 'b', 'c', 'd', 'e']);
 $reduce_cb = function ($acc, $value, $key) {
     return $acc.$value.strval($key);
 };
-if ($collection->fold('foo', $reduce_cb) != 'fooa0b1c2d3e4')
+if ($collection->fold('foo', $reduce_cb) != 'fooa0b1c2d3e4') {
     echo 'Collection::fold() failed.', PHP_EOL;
-if ($collection->foldRight('bar', $reduce_cb) != 'bare4d3c2b1a0')
+}
+if ($collection->foldRight('bar', $reduce_cb) != 'bare4d3c2b1a0') {
     echo 'Collection::foldRight() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/042-shuffle-shuffled.phpt

@@ -7,26 +7,30 @@ $array = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5];
 for ($i = 0; ; ++$i) {
     $collection = Collection::init($array);
     $collection->shuffle();
-    if ($collection->toArray() != array_values($array))
+    if ($collection->toArray() != array_values($array)) {
         break;
+    }
     if ($i > 10) {
         echo 'Collection::shuffle() failed.', PHP_EOL;
         exit;
     }
 }
-if (array_sum($array) != array_sum($collection->toArray()))
+if (array_sum($array) != array_sum($collection->toArray())) {
     echo 'Collection::shuffle() failed.', PHP_EOL;
+}
 
 for ($i = 0; ; ++$i) {
     $shuffled = Collection::init($array)->shuffled();
-    if ($shuffled->toArray() != array_values($array))
+    if ($shuffled->toArray() != array_values($array)) {
         break;
+    }
     if ($i > 10) {
         echo 'Collection::shuffled() failed.', PHP_EOL;
         exit;
     }
 }
-if (array_sum($array) != array_sum($shuffled->toArray()))
+if (array_sum($array) != array_sum($shuffled->toArray())) {
     echo 'Collection::shuffled() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/043-min-max-with.phpt

@@ -14,9 +14,11 @@ $by_b = function ($p1, $p2) {
 $by_c = function ($p1, $p2) {
     return strval($p1->second['c'] - $p2->second['c']);
 };
-if ($collection->minWith($by_b) != $array['a'] || $collection->minWith($by_c) != $array['d'])
+if ($collection->minWith($by_b) != $array['a'] || $collection->minWith($by_c) != $array['d']) {
     echo 'Collection::minWith() failed.', PHP_EOL;
-if ($collection->maxWith($by_b) != $array['e'] || $collection->maxWith($by_c) != $array['a'])
+}
+if ($collection->maxWith($by_b) != $array['e'] || $collection->maxWith($by_c) != $array['a']) {
     echo 'Collection::maxWith() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/044-sort-with-sorted-with.phpt

@@ -18,8 +18,9 @@ $usort_by_b = function ($v1, $v2) {
 $sorted_by_b = $collection->sortedWith($by_b);
 $array1 = $array;
 usort($array1, $usort_by_b);
-if ($sorted_by_b->toArray() != $array1)
+if ($sorted_by_b->toArray() != $array1) {
     echo 'Collection::sortedWith() failed.', PHP_EOL;
+}
 $by_c = function ($p1, $p2) {
     return $p1->second['c'] - $p2->second['c'];
 };
@@ -29,7 +30,8 @@ $usort_by_c = function ($v1, $v2) {
 $collection->sortWith($by_c);
 $array2 = $array;
 usort($array2, $usort_by_c);
-if ($collection->toArray() != $array2)
+if ($collection->toArray() != $array2) {
     echo 'Collection::sortedWith() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/045-sort-sorted.phpt

@@ -3,33 +3,38 @@ Test Collection::sort(), Collection::sortDescending(), Collection::sorted(), Col
 --FILE--
 <?php
 $array = [];
-for ($i = 0; $i < 100; ++$i)
+for ($i = 0; $i < 100; ++$i) {
     $array[] = random_int(-200, 200);
+}
 
 $collection = Collection::init($array);
 $collection->sort();
 $array1 = $array;
 sort($array1, SORT_NUMERIC);
-if ($array1 != $collection->toArray())
+if ($array1 != $collection->toArray()) {
     echo 'Collection::sort() failed.', PHP_EOL;
+}
 
 $collection = Collection::init($array);
 $collection->sortDescending();
 $array1 = $array;
 rsort($array1, SORT_NUMERIC);
-if ($array1 != $collection->toArray())
+if ($array1 != $collection->toArray()) {
     echo 'Collection::sortDescending() failed.', PHP_EOL;
+}
 
 $collection = Collection::init($array);
 $array1 = $array;
 sort($array1, SORT_NUMERIC);
-if ($array1 != $collection->sorted()->toArray())
+if ($array1 != $collection->sorted()->toArray()) {
     echo 'Collection::sorted() failed.', PHP_EOL;
+}
 
 $collection = Collection::init($array);
 $array1 = $array;
 rsort($array1, SORT_NUMERIC);
-if ($array1 != $collection->sortedDescending()->toArray())
+if ($array1 != $collection->sortedDescending()->toArray()) {
     echo 'Collection::sortedDescending() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/046-sort-by-sorted-by.phpt

@@ -3,8 +3,9 @@ Test Collection::sortBy(), Collection::sortByDescending(), Collection::sortedBy(
 --FILE--
 <?php
 $array = [];
-for ($i = 0; $i < 4; ++$i)
+for ($i = 0; $i < 4; ++$i) {
     $array[random_bytes(2)] = [random_int(10, 99)];
+}
 
 $sort_by = function ($value) {
     return strval($value[0]);
@@ -20,26 +21,30 @@ $collection = Collection::init($array);
 $collection->sortBy($sort_by);
 $array1 = $array;
 usort($array1, $sort_with);
-if ($array1 != $collection->toArray())
+if ($array1 != $collection->toArray()) {
     echo 'Collection::sortBy() failed.', PHP_EOL;
+}
 
 $collection = Collection::init($array);
 $collection->sortByDescending($sort_by);
 $array1 = $array;
 usort($array1, $sort_with_descending);
-if ($array1 != $collection->toArray())
+if ($array1 != $collection->toArray()) {
     echo 'Collection::sortByDescending() failed.', PHP_EOL;
+}
 
 $collection = Collection::init($array);
 $array1 = $array;
 usort($array1, $sort_with);
-if ($array1 != $collection->sortedBy($sort_by)->toArray())
+if ($array1 != $collection->sortedBy($sort_by)->toArray()) {
     echo 'Collection::sortedBy() failed.', PHP_EOL;
+}
 
 $collection = Collection::init($array);
 $array1 = $array;
 usort($array1, $sort_with_descending);
-if ($array1 != $collection->sortedByDescending($sort_by)->toArray())
+if ($array1 != $collection->sortedByDescending($sort_by)->toArray()) {
     echo 'Collection::sortedByDescending() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--

tests/047-distinct.phpt

@@ -3,17 +3,21 @@ Test Collection::distinct().
 --FILE--
 <?php
 $array = [];
-for ($i = 0; $i < 100; ++$i)
-    $array[] = random_int(1, 10);
+for ($i = 0; $i < 400; ++$i) {
+    $array[] = random_int(1, 400);
+}
 $collection = Collection::init($array)->distinct();
-if ($collection->toArray() != array_values(array_unique($array)))
+if ($collection->toArray() != array_values(array_unique($array))) {
     echo 'Collection::distinct() failed.', PHP_EOL;
+}
 
 $array = [];
-for ($i = 0; $i < 100; ++$i)
+for ($i = 0; $i < 100; ++$i) {
     $array[random_bytes(4)] = random_int(1, 10);
+}
 $collection = Collection::init($array)->distinct();
-if (array_diff($collection->toArray(), array_unique($array)))
+if (array_diff($collection->toArray(), array_unique($array))) {
     echo 'Collection::distinct() failed.', PHP_EOL;
+}
 ?>
 --EXPECT--