Test delle unità: perché l'argomento previsto è sempre il primo nei test di uguaglianza?

Question

Perché è che ogni quadro unit testing (che conosco :) richiede che il valore atteso nei test di uguaglianza è sempre il primo argomento:

Assert.AreEqual(42, Util.GetAnswerToLifeTheUniverseAndEverything()); 

assertEquals(42, Util.GetAnswerToLifeTheUniverseAndEverything()); 

ecc

Sono abbastanza abituato ora, ma ogni programmatore che cerco di insegnare come unità di test fa l'errore di invertire gli argomenti, che io capisco perfettamente. Google non ha aiutato, forse uno dei collaudatori di unità hard-core qui conosce la risposta?

Answer 1

penso che è solo una convenzione ormai e, come lei ha detto che è adottato da "ogni quadro unit testing (che conosco)". Se si utilizza un framework sarebbe fastidioso passare a un altro framework che utilizza la convenzione opposta. Quindi (se stai scrivendo una nuova unità di test framework per esempio) sarebbe preferibile anche per te seguire la convenzione esistente. Credo che questo deriva dal modo in cui alcuni sviluppatori preferiscono scrivere i loro test di uguaglianza:

if (4 == myVar) 

Per evitare qualsiasi cessione indesiderata, per errore, scrivendo un "=" al posto di "==". In questo caso il compilatore catturerà questo errore e eviterete un sacco di problemi nel tentativo di correggere un bug di runtime strano.

Answer 2

Nessuno lo sa ed è la fonte di confusioni senza fine. Tuttavia non tutti i quadri seguono questo modello (ad una maggiore confusione):

1. FEST-Assert utilizza normale ordine:

   assertThat(Util.GetAnswerToLifeTheUniverseAndEverything()).isEqualTo(42); 
   

2. Hamcrest:

   assertThat(Util.GetAnswerToLifeTheUniverseAndEverything(), equalTo(42)) 
   

3. ScalaTest non lo fa davvero fare una distinzione:

   Util.GetAnswerToLifeTheUniverseAndEverything() should equal (42) 
   

Answer 3

Non so, ma ho partecipato a diverse discussioni animate sull'ordine degli argomenti ai test di uguaglianza in generale.

Ci sono un sacco di persone che pensano

if (42 == answer) { 
    doSomething(); 
} 

è preferibile

if (answer == 42) { 
    doSomething(); 
} 

nei linguaggi C-based. La ragione di questo è che se si mette accidentalmente un unico segno di uguale:

if (42 = answer) { 
    doSomething(); 
} 

vi darà un errore di compilazione, ma

if (answer = 42) { 
    doSomething(); 
} 

non potrebbe, e sarebbe sicuramente introdurre un bug che potrebbe essere difficile rintracciare. Quindi, chi lo sa, forse la persona/le persone che hanno creato il quadro di test unitario sono stati abituati a pensare ai test di uguaglianza in questo modo - o stavano copiando altri framework di test unitari che erano già stati impostati in questo modo.

Answer 4

Penso che sia perché JUnit è stato il precursore della maggior parte dei framework di testing unitario (non che fosse il primo framework di testing unitario, ma ha dato il via a un'esplosione nei test unitari). Da quando JUnit lo ha fatto in quel modo, tutti i quadri successivi hanno copiato questo modulo ed è diventato una convenzione.

perché JUnit è stato così? Non lo so, chiedi a Kent Beck!

Answer 5

Sembra che la maggior parte dei quadri primi usati prevede prima attuale (per qualche motivo sconosciuto, però, lancio dei dadi forse?). Tuttavia, con lo sviluppo dei linguaggi di programmazione e con l'aumento della fluidità , l'ordine è stato annullato. Le interfacce più fluenti di solito cercano di imitare il linguaggio naturale e le strutture di test delle unità non sono diverse.

Nell'asserzione, vogliamo assicurare che alcuni oggetti soddisfano alcune condizioni. Questa è la forma del linguaggio naturale, come se si dovesse spiegare il tuo codice di prova si sarebbe probabilmente dire

"In questo test, mi assicuro che il valore calcolato è pari a 5"

invece di

"In questo test, mi assicuro che 5 sia uguale al valore calcolato".

La differenza potrebbe non essere enorme, ma spingiamola ulteriormente. Considera questo:

Assert.That(Roses, Are(Red)); 

Suoni di destra. Now:

Assert.That(Red, Are(Roses)); 

Hm ..? Probabilmente non saresti troppo sorpreso se qualcuno ti dicesse che le rose sono rosse. Altrimenti, rosso sono rose, solleva domande sospette. Yoda, qualcuno?

Yoda di fare un punto importante - invertì l'ordine ti costringe a think.

diventa ancora più innaturale quando le tue affermazioni sono più complesse:

Assert.That(Forest, Has.MoreThan(15, Trees)); 

Come ti invertire quello? Più di 15 alberi sono stati trovati dalla foresta?

Questa affermazione (scioltezza come fattore trainante per la modifica) sia in qualche modo riflette nel cambiamento che NUnit ha attraversato - in origine (Assert.AreEqual) ha usato previsto prima attuale (vecchio stile). Estensioni fluide (o per utilizzare la terminologia NUnit, basata sul vincolo - Assert.That) hanno invertito questo ordine.

Answer 6

Beh, hanno dovuto scegliere una convenzione. Se vuoi invertire, prova i giocatori di Hamcrest. Servono per aumentare la leggibilità. Ecco un esempio di base:

import org.junit.Test; 
import static org.junit.Assert.assertThat; 
import static org.hamcrest.core.Is.is; 

public HamcrestTest{ 
    @Test 
    public void matcherShouldWork(){ 
     assertThat( Math.pow(2, 3), is(8) ); 
    } 
} 

Answer 7

Sicuramente ha senso logico per mettere il valore atteso prima, in quanto è il primo valore di nota.

Pensateci nel contesto dei test manuali. Un test manuale avrà il valore previsto scritto, con il valore effettivo registrato successivamente.

Answer 8

Perché, purtroppo, non molti programmatori hanno letto Self-Reliance by Ralph Waldo Emerson.