PHPUnit bevat een assertEquals()methode, maar het heeft ook een assertSame()een. Op het eerste gezicht lijkt het alsof ze hetzelfde doen.
Wat is het verschil tussen beide? Waarom zijn ze allebei gespecificeerd?
Antwoord 1, autoriteit 100%
Ik gebruik beide sporadisch, maar volgens de documenten:
AssertSame
Meldt een fout die wordt geïdentificeerd door
$messageals de twee variabelen$expecteden$actualniet hetzelfde typeen waarde.”
En zoals je kunt zien in het voorbeeld onder het bovenstaande fragment, geven ze '2204'en 2204door, wat niet lukt met AssertSameomdat de ene een stringis en de andere een int,eigenlijk:
'2204' !== 2204
assertSame('2204', 2204) // this test fails
assertEquals
“Meldt een fout geïdentificeerd door $message als de twee variabelen $expected en $actual niet gelijk zijn.”
assertEqualslijkt geen rekening te houden met het datatype, dus gebruik het bovenstaande voorbeeld van 2204:
'2204' == 2204
assertEquals('2204', 2204) // this test passes
Ik heb zojuist een aantal eenheidstests uitgevoerd met de bovenstaande voorbeelden, en ze hebben inderdaad geleid tot gedocumenteerd gedrag.
Antwoord 2, autoriteit 17%
Als het gaat om het vergelijken van objecten:
beweer hetzelfde
Kan alleen bevestigen als twee objecten verwijzen naar dezelfde objectinstantie. Dus zelfs als twee afzonderlijke objecten voor al hun attributen exact dezelfde waarden hebben, zal assertSame()falen als ze niet naar dezelfde instantie verwijzen.
$expected = new \stdClass();
$expected->foo = 'foo';
$expected->bar = 'bar';
$actual = new \stdClass();
$actual->foo = 'foo';
$actual->bar = 'bar';
$this->assertSame($expected, $actual); // FAILS
asserEquals
Kan in ieder geval bevestigen of twee afzonderlijke objecten overeenkomen met hun attribuutwaarden. Het is dus de methode die geschikt is om objectovereenkomst te bevestigen.
$this->assertEquals($expected, $actual); // PASSES
Antwoord 3, autoriteit 9%
$this->assertEquals(3, true);
$this->assertSame(3, true);
De eerste zal slagen!
De tweede zal mislukken.
Dat is het verschil.
Ik denk dat je altijd assertSame moet gebruiken.
Antwoord 4
Zoals al eerder is gezegd, rapporteertAssertSameeen fout als de twee elementen typeen waardeniet delen, maar het is ook belangrijk om op te merken dit uit de documentatie:
Meldt een fout die wordt geïdentificeerd door $message als de twee variabelen $expected
en $actual verwijzen niet naar hetzelfde object.
Dus deze test zou ook mislukken, ook al delen ze het type en de waarde:
class SameTest extends TestCase
{
public function testFailure()
{
$this->assertSame(new stdClass, new stdClass);
}
}
Antwoord 5
Bovendien,
// Passes
$this->assertSame("123.", "123.");
$this->assertEquals("123.", "123");
// Fails
$this->assertSame("123.", "123");
Antwoord 6
assetSame() == Test of de werkelijke uitvoer en de verwachte parameter hetzelfde zijn.
dat is:
$this->assertSame('$expected','$expected');
of
$this->assertSame('100','100');
asserEquals == Als we zien met betrekking tot een websitepagina, ik heb een pagina die 2 ‘table’ heeft, dus als ik assertEquals uitvoer, zal ik de telling controleren dat de ‘tabel’ 2 is met behulp van een telfunctie.
Bijv.:
$this->assertEquals(2, $var->filter('table')->count());
Hier kunnen we zien dat assertEquals controleert of er 2 tabellen op de webpagina staan. we kunnen ook divisies gebruiken die op de pagina staan met ‘#division name’ tussen haakjes.
Bijvoorbeeld 2:
public function testAdd()
{
$calc = new Calculator();
$result = $calc->add(30, 12);
// assert that our calculator added the numbers correctly!
$this->assertEquals(42, $result);
}
Antwoord 7
Zoals eerder vermeld, gaat assertEquals()in de eerste plaats over een geïnterpreteerde waarde, of het nu gaat om type jongleren of een object met een __magische presentatiemethode (bijvoorbeeld __toString()).
Een goede use case voor assertSame()is het testen van een singleton-fabriek.
class CacheFactoryTest extends TestCase
{
public function testThatCacheFactoryReturnsSingletons()
{
$this->assertSame(CacheFactory::create(), CacheFactory::create());
}
}