PHPUnit: menyatakan dua array sama, tetapi urutan elemen tidak penting

Apa cara yang baik untuk menyatakan bahwa dua array objek adalah sama, ketika urutan elemen-elemen dalam array tidak penting, atau bahkan dapat berubah?

Cara terbersih untuk melakukan ini adalah memperluas phpunit dengan metode penegasan baru. Tapi ini ide untuk cara yang lebih sederhana untuk saat ini. Kode belum diuji, harap verifikasi:

Di suatu tempat di aplikasi Anda:

 /**
 * Determine if two associative arrays are similar
 *
 * Both arrays must have the same indexes with identical values
 * without respect to key ordering 
 * 
 * @param array $a
 * @param array $b
 * @return bool
 */
function arrays_are_similar($a, $b) {
  // if the indexes don't match, return immediately
  if (count(array_diff_assoc($a, $b))) {
    return false;
  }
  // we know that the indexes, but maybe not values, match.
  // compare the values between the two arrays
  foreach($a as $k => $v) {
    if ($v !== $b[$k]) {
      return false;
    }
  }
  // we have identical indexes, and no unequal values
  return true;
}

Dalam tes Anda:

$this->assertTrue(arrays_are_similar($foo, $bar));

Anda dapat menggunakan metode assertEqualsCanonicalize yang ditambahkan di PHPUnit 7.5. Jika Anda membandingkan array menggunakan metode ini, array ini akan diurutkan oleh komparator array PHPUnit itu sendiri.

Contoh kode:

class ArraysTest extends \PHPUnit\Framework\TestCase
{
    public function testEquality()
    {
        $obj1 = $this->getObject(1);
        $obj2 = $this->getObject(2);
        $obj3 = $this->getObject(3);

        $array1 = [$obj1, $obj2, $obj3];
        $array2 = [$obj2, $obj1, $obj3];

        // Pass
        $this->assertEqualsCanonicalizing($array1, $array2);

        // Fail
        $this->assertEquals($array1, $array2);
    }

    private function getObject($value)
    {
        $result = new \stdClass();
        $result->property = $value;
        return $result;
    }
}

Dalam versi PHPUnit yang lebih lama, Anda dapat menggunakan param $ canonicalize dari metode assertEquals tanpa dokumen . Jika Anda melewatkan $ canonicalize = true , Anda akan mendapatkan efek yang sama:

class ArraysTest extends PHPUnit_Framework_TestCase
{
    public function testEquality()
    {
        $obj1 = $this->getObject(1);
        $obj2 = $this->getObject(2);
        $obj3 = $this->getObject(3);

        $array1 = [$obj1, $obj2, $obj3];
        $array2 = [$obj2, $obj1, $obj3];

        // Pass
        $this->assertEquals($array1, $array2, "\$canonicalize = true", 0.0, 10, true);

        // Fail
        $this->assertEquals($array1, $array2, "Default behaviour");
    }

    private function getObject($value)
    {
        $result = new stdclass();
        $result->property = $value;
        return $result;
    }
}

Array kode sumber komparator pada versi terbaru dari PHPUnit: https://github.com/sebastianbergmann/comparator/blob/master/src/ArrayComparator.php#L46

Masalah saya adalah saya memiliki 2 array (kunci array tidak relevan untuk saya, hanya nilainya).

Misalnya saya ingin menguji apakah

$expected = array("0" => "green", "2" => "red", "5" => "blue", "9" => "pink");

memiliki konten yang sama (pesanan tidak relevan untuk saya) seperti

$actual = array("0" => "pink", "1" => "green", "3" => "yellow", "red", "blue");

Jadi saya telah menggunakan array_diff .

Hasil akhir adalah (jika array sama, perbedaannya akan menghasilkan array kosong). Harap dicatat bahwa perbedaannya dihitung dua arah (Terima kasih @beret, @GordonM)

$this->assertEmpty(array_merge(array_diff($expected, $actual), array_diff($actual, $expected)));

Untuk pesan kesalahan yang lebih terperinci (saat debugging), Anda juga dapat menguji seperti ini (terima kasih @ DenilsonSá):

$this->assertSame(array_diff($expected, $actual), array_diff($actual, $expected));

Versi lama dengan bug di dalamnya:

$ this-> assertEmpty (array_diff ($ array2, $ array1));

Satu kemungkinan lain:

1. Sortir kedua array
2. Konversikan menjadi string
3. Tegaskan kedua string sama

$arr = array(23, 42, 108);
$exp = array(42, 23, 108);

sort($arr);
sort($exp);

$this->assertEquals(json_encode($exp), json_encode($arr));

Metode pembantu sederhana

protected function assertEqualsArrays($expected, $actual, $message) {
    $this->assertTrue(count($expected) == count(array_intersect($expected, $actual)), $message);
}

Atau jika Anda memerlukan lebih banyak info debug ketika array tidak sama

protected function assertEqualsArrays($expected, $actual, $message) {
    sort($expected);
    sort($actual);

    $this->assertEquals($expected, $actual, $message);
}

Jika arraynya bisa diurutkan, saya akan mengurutkan keduanya sebelum memeriksa persamaan. Jika tidak, saya akan mengonversinya menjadi beberapa set dan membandingkannya.

Menggunakan array_diff () :

$a1 = array(1, 2, 3);
$a2 = array(3, 2, 1);

// error when arrays don't have the same elements (order doesn't matter):
$this->assertEquals(0, count(array_diff($a1, $a2)) + count(array_diff($a2, $a1)));

Atau dengan 2 menegaskan (lebih mudah dibaca):

// error when arrays don't have the same elements (order doesn't matter):
$this->assertEquals(0, count(array_diff($a1, $a2)));
$this->assertEquals(0, count(array_diff($a2, $a1)));

Meskipun Anda tidak peduli dengan pesanan, mungkin lebih mudah untuk memperhitungkannya:

Mencoba:

asort($foo);
asort($bar);
$this->assertEquals($foo, $bar);

Kami menggunakan metode pembungkus berikut dalam Tes kami:

/**
 * Assert that two arrays are equal. This helper method will sort the two arrays before comparing them if
 * necessary. This only works for one-dimensional arrays, if you need multi-dimension support, you will
 * have to iterate through the dimensions yourself.
 * @param array $expected the expected array
 * @param array $actual the actual array
 * @param bool $regard_order whether or not array elements may appear in any order, default is false
 * @param bool $check_keys whether or not to check the keys in an associative array
 */
protected function assertArraysEqual(array $expected, array $actual, $regard_order = false, $check_keys = true) {
    // check length first
    $this->assertEquals(count($expected), count($actual), 'Failed to assert that two arrays have the same length.');

    // sort arrays if order is irrelevant
    if (!$regard_order) {
        if ($check_keys) {
            $this->assertTrue(ksort($expected), 'Failed to sort array.');
            $this->assertTrue(ksort($actual), 'Failed to sort array.');
        } else {
            $this->assertTrue(sort($expected), 'Failed to sort array.');
            $this->assertTrue(sort($actual), 'Failed to sort array.');
        }
    }

    $this->assertEquals($expected, $actual);
}

Jika kuncinya sama tetapi rusak, ini harus menyelesaikannya.

Anda hanya perlu mendapatkan kunci dalam urutan yang sama dan membandingkan hasilnya.

 /**
 * Assert Array structures are the same
 *
 * @param array       $expected Expected Array
 * @param array       $actual   Actual Array
 * @param string|null $msg      Message to output on failure
 *
 * @return bool
 */
public function assertArrayStructure($expected, $actual, $msg = '') {
    ksort($expected);
    ksort($actual);
    $this->assertSame($expected, $actual, $msg);
}

Solusi yang diberikan tidak melakukan pekerjaan untuk saya karena saya ingin dapat menangani array multi-dimensi dan memiliki pesan yang jelas tentang apa yang berbeda antara dua array.

Inilah fungsi saya

public function assertArrayEquals($array1, $array2, $rootPath = array())
{
    foreach ($array1 as $key => $value)
    {
        $this->assertArrayHasKey($key, $array2);

        if (isset($array2[$key]))
        {
            $keyPath = $rootPath;
            $keyPath[] = $key;

            if (is_array($value))
            {
                $this->assertArrayEquals($value, $array2[$key], $keyPath);
            }
            else
            {
                $this->assertEquals($value, $array2[$key], "Failed asserting that `".$array2[$key]."` matches expected `$value` for path `".implode(" > ", $keyPath)."`.");
            }
        }
    }
}

Lalu untuk menggunakannya

$this->assertArrayEquals($array1, $array2, array("/"));

Saya menulis beberapa kode sederhana untuk pertama mendapatkan semua kunci dari array multi-dimensi:

 /**
 * Returns all keys from arrays with any number of levels
 * @param  array
 * @return array
 */
protected function getAllArrayKeys($array)
{
    $keys = array();
    foreach ($array as $key => $element) {
        $keys[] = $key;
        if (is_array($array[$key])) {
            $keys = array_merge($keys, $this->getAllArrayKeys($array[$key]));
        }
    }
    return $keys;
}

Kemudian untuk menguji bahwa mereka terstruktur sama terlepas dari urutan kunci:

    $expectedKeys = $this->getAllArrayKeys($expectedData);
    $actualKeys = $this->getAllArrayKeys($actualData);
    $this->assertEmpty(array_diff($expectedKeys, $actualKeys));

HTH

Jika nilai hanya int atau string, dan tidak ada array level ganda ....

Mengapa tidak hanya menyortir array, mengubahnya menjadi string ...

    $mapping = implode(',', array_sort($myArray));

    $list = implode(',', array_sort($myExpectedArray));

... lalu bandingkan string:

    $this->assertEquals($myExpectedArray, $myArray);

Jika Anda ingin menguji hanya nilai-nilai array yang dapat Anda lakukan:

$this->assertEquals(array_values($arrayOne), array_values($arrayTwo));

Pilihan lain, seolah-olah Anda belum memiliki cukup, adalah untuk menggabungkan assertArraySubsetdikombinasikan dengan assertCountuntuk membuat pernyataan Anda. Jadi, kode Anda akan terlihat seperti itu.

self::assertCount(EXPECTED_NUM_ELEMENT, $array); self::assertArraySubset(SUBSET, $array);

Dengan cara ini Anda dapat memesan secara independen tetapi tetap menegaskan bahwa semua elemen Anda ada.