Diferença entre assertEquals e assertSame no phpunit?

PHPUnit contém um método assertEquals: https://phpunit.de/manual/current/en/appendixes.assertions.html#appendixes.assertions.assertEquals

Ele também possui um método assertSame: https://phpunit.de/manual/current/en/appendixes.assertions.html#appendixes.assertions.assertSame

À primeira vista, parece que eles fazem a mesma coisa. Qual é a diferença entre os dois? Por que eles são especificados?

Eu uso os dois esporadicamente, mas de acordo com os documentos:

assertSame

Relata um erro identificado por $messagese as duas variáveis $expectede $actualnão tiverem o mesmo tipo e valor ".

E como você pode ver no exemplo abaixo do trecho acima, eles estão passando '2204'e 2204, que falharão em usar assertSameporque one é a stringe one é int,basicamente:

'2204' !== 2204
assertSame('2204', 2204) // this test fails

assertEquals

"Relata um erro identificado por $ message se as duas variáveis ​​$ esperado e $ real não forem iguais."

assertEqualsparece não levar em consideração o tipo de dados, portanto, use o exemplo acima de 2204:

'2204' == 2204
assertEquals('2204', 2204) // this test passes

Acabei de executar alguns testes de unidade nos exemplos acima e, de fato, eles resultaram em comportamento documentado.

Quando se trata de comparação de objetos:

assertSame: só pode afirmar se 2 objetos estão fazendo referência à mesma instância de objeto. Portanto, mesmo se dois objetos separados tiverem para todos os seus atributos exatamente os mesmos valores, assertSame falhará se eles não fizerem referência à mesma instância.

    $expected = new \stdClass();
    $expected->foo = 'foo';
    $expected->bar = 'bar';

    $actual = new \stdClass();
    $actual->foo = 'foo';
    $actual->bar = 'bar';

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

assertEquals: pode afirmar se 2 objetos separados correspondem aos seus valores de atributo em qualquer caso. Portanto, é o método adequado para afirmar a correspondência de objetos.

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

https://phpunit.de/manual/current/en/appendixes.assertions.html

$this->assertEquals(3, true);
$this->assertSame(3, true);

O primeiro vai passar!

O segundo falhará.

Essa é a diferença.

Eu acho que você sempre deve usar assertSame.

Como já foi dito antes, AssertSamerelata um erro se os dois elementos não compartilham tipo e valor, mas também é importante observar isso na documentação :

Relata um erro identificado por $ message se as duas variáveis ​​$ esperado e $ real não fazem referência ao mesmo objeto.

Portanto, esse teste também falharia, apesar de compartilharem tipo e valor:

class SameTest extends TestCase
{
    public function testFailure()
    {
        $this->assertSame(new stdClass, new stdClass);
    }
}

Além disso,

// Passes
$this->assertSame("123.", "123.");
$this->assertEquals("123.", "123");
// Fails
$this->assertSame("123.", "123");

assertSame () == Testa se a saída real e o parâmetro esperado são iguais.

isso é :

$this->assertSame('$expected','$expected');

ou

$this->assertSame('100','100');

assertEquals == Se virmos em relação a uma página de site, eu tenho uma página com 2 'tabela'; portanto, quando executo assertEquals, verificarei sua contagem de que a 'tabela' é 2 usando uma função de contagem. Por exemplo:

$this->assertEquals(2, $var->filter('table')->count()); 

Aqui podemos ver que assertEquals verifica se há 2 tabelas encontradas na página da web. também podemos usar as divisões encontradas na página usando '#division name' dentro do colchete.

Por exemplo 2:

public function testAdd()
{
    $calc = new Calculator();

    $result = $calc->add(30, 12);

    // assert that our calculator added the numbers correctly!
    $this->assertEquals(42, $result);
}

Como mencionado anteriormente, assertEquals()trata-se principalmente de um valor interpretado, seja por tipo de malabarismo ou por um objeto com um método de apresentação __magic ( __toString()por exemplo).

Um bom caso de uso assertSame()é para testar uma fábrica de singleton.

class CacheFactoryTest extends TestCase
{
    public function testThatCacheFactoryReturnsSingletons()
    {
        $this->assertSame(CacheFactory::create(), CacheFactory::create());
    }
}