Come per il test di un interprete o di un compilatore?

StackOverflow https://stackoverflow.com/questions/691844

Domanda

Ho fatto qualche esperimento con la creazione di un interprete per il Brainfuck, e sebbene sia abbastanza semplice da fare e di ottenere fino e in esecuzione, una parte di me vuole essere in grado di eseguire le prove contro di essa.Io non riesco a capire quanti test si potrebbe scrivere per provare tutte le possibili istruzioni combinazioni di garantire che l'applicazione è corretta.

Ovviamente, con Brainfuck, il set di istruzioni è piccolo, ma non posso fare a meno di pensare che ulteriori istruzioni sono aggiunti, il codice di test, sarebbe cresciuto in modo esponenziale.Di più, in modo che il vostro tipico test in qualsiasi rate.

Ora, io sono circa come newbie, come si può ottenere in termini di scrittura di compilatori e interpreti, quindi la mia ipotesi potrebbe essere il modo fuori base.

In sostanza, dove anche inizia con un test o qualcosa del genere?

È stato utile?

Soluzione

La prova di un compilatore è un po 'diverso da testare alcuni altri tipi di applicazioni, perché è OK per il compilatore di produrre diverse versioni di assemblaggio di codice di un programma a patto che tutti fanno la cosa giusta. Tuttavia, se si sta solo testando un interprete, è praticamente la stessa di qualsiasi altra applicazione basata su testo. Ecco una vista Unix-centric:

  1. Si vorrà costruire una suite di test di regressione . Ogni test dovrebbe avere
    • Il codice sorgente si interpretare, dire test001.bf
    • di ingresso standard per il programma che sarà interpretare, dire test001.0
    • Cosa si aspetta l'interprete di produrre sullo standard output, ad esempio test001.1
    • Cosa si aspetta l'interprete di produrre su standard error, dire test001.2 (si preoccupa di errore standard, perché si desidera verificare i messaggi di errore del vostro interprete)

  2. Sarà necessario uno script di "test run" che fa qualcosa di simile al seguente 

    function fail {
  echo "Unexpected differences on $1:"
  diff $2 $3
  exit 1
}

for testname
do
  tmp1=$(tempfile)
  tmp2=$(tempfile)
  brainfuck $testname.bf < $testname.0 > $tmp1 2> $tmp2
  [ cmp -s $testname.1 $tmp1 ] || fail "stdout" $testname.1 $tmp1
  [ cmp -s $testname.2 $tmp2 ] || fail "stderr" $testname.2 $tmp2
done

  3. Lo troverete utile avere uno script di "creare test" che fa qualcosa di simile 

    brainfuck $testname.bf < $testname.0 > $testname.1 2> $testname.2

    Si esegue questa operazione solo quando si è totalmente sicuri che l'interprete lavora per questo caso.

  4. È mantenere la suite di test sotto il controllo del codice sorgente.

  5. E 'conveniente per abbellire il vostro script di test in modo da poter lasciare fuori i file che dovrebbero essere vuota.

  6. Tutte le modifiche nulla di tempo, si ri-eseguire tutti i test. Probabilmente anche ri-eseguire tutti loro ogni notte tramite un job cron.

  7. Infine, si desidera aggiungere abbastanza prove per ottenere una buona copertura di test del codice sorgente del compilatore. La qualità degli strumenti di copertura varia ampiamente, ma GNU gcov è uno strumento di copertura adeguata.

Buona fortuna con il vostro interprete! Se volete vedere un'infrastruttura di test amore artigianale, ma non molto ben documentato, andare a vedere la directory test2 per il rapida C-- compilatore .

Altri suggerimenti

Non credo che ci sia qualcosa di 'speciale' sulla sperimentazione di un compilatore; in un certo senso è quasi più facile di testare alcuni programmi, dal momento che un compilatore ha una tale base di sintesi di alto livello - lei mano nella fonte, ti dà indietro (forse) il codice e (forse) una serie di messaggi di diagnostica compilato

Come qualsiasi entità software complesso, ci saranno molti percorsi di codice, ma dal momento che è tutto molto data-oriented (testo in, testo e byte fuori) E 'semplice da prove d'autore.

Ho scritto un articolo sul compilatore test, originale cui conclusione (leggermente attenuato per la pubblicazione) è stata: E ' moralmente sbagliato a reinventare la ruota. A meno che non conoscete già le soluzioni preesistenti, e hanno una buona ragione per ignorare loro, si dovrebbe iniziare a guardare gli strumenti che già esistono.Il modo più semplice per iniziare è Gnu C Tortura, ma tenete a mente che si basa su Deja Gnu, che è, diciamo così, i problemi.(Mi ci sono voluti sei tentativi anche per ottenere il manutentore per consentire un di bug critici per il report sull'esempio "Hello World" sulla mailing list.)

Io immodestamente consigliamo di guardare il seguente come un punto di partenza per gli strumenti per indagare:

  1. Software:La pratica e l'Esperienza Aprile 2007.(Payware, non disponibili per il pubblico in generale---libero preprint a http://pobox.com/~flash/Practical_Testing_of_C99.pdf.

  2. http://en.wikipedia.org/wiki/Compiler_correctness#Testing (In gran parte scritto da me.)

  3. Compilatore test di bibliografia (Per favore fatemi sapere di eventuali aggiornamenti ho perso.)

Nel caso di Brainfuck, credo che il test dovrebbe essere fatto con gli script Brainfuck. Ho iniziato ad esaminare quanto segue, anche se:

1: Sono tutte le celle inizializzate a 0

2: Cosa succede quando si decrementa il puntatore di dati quando è attualmente indicando la prima cellula? Ha avvolgere? Ha puntare a memoria non valida?

3: Che cosa accade quando si incrementa il puntatore di dati quando è indicando l'ultima cella? Ha avvolgere? Ha puntare a memoria non valida

4: Fa funzione di uscita correttamente

5: Fa funzione di ingresso correttamente

6: Fa il [] roba di lavoro correttamente

7: Cosa succede quando si incrementa un byte più di 255 volte, ci si avvolge a 0 correttamente, o è erroneamente trattato come un intero o di altro valore

.

Ulteriori test sono possibili anche, ma questo è probabilmente dove mi piacerebbe iniziare. Ho scritto un compilatore BF a pochi anni fa, e che ha avuto un paio di test in più. In particolare ho provato la roba [] pesantemente, avendo un sacco di codice all'interno del blocco, dal momento che una prima versione del mio generatore di codice avevano problemi lì (su x86 con un jxx Ho avuto problemi quando il blocco ha prodotto più di 128 byte o giù di lì di codice, con conseguente non valida asm x86).

È possibile verificare con alcune applicazioni già scritte.

Il segreto è quello di:

  • separare le preoccupazioni
  • Osservare la legge di Demetra
  • Iniettare le dipendenze

Bene, un software che è difficile da testare è un segno che lo sviluppatore ha scritto come se fosse 1985. Mi dispiace dirlo, ma utilizzando i tre principi che ho presentato qui, anche la linea numerata di base sarebbe unità testabili (è possibile iniettare le dipendenze in BASIC, perché si può fare "goto variabile".

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top