Ogni esercizio fornisce gli unit test e una ricetta di build per CMake. A fornire
l'implementazione ci pensi tu.
Ogni file di test va collegato all'implementazione per produrre un
eseguibile da console che esegue i test. Eseguire l'eseguibile dei test
stampa un messaggio per ogni test che fallisce e restituisce uno stato di uscita
diverso da zero quando i test falliscono.
Il file di test si chiamerà <exercise>_test.f90, quindi per l'esercizio
"Bob" il file che contiene i test è bob_test.f90. Ogni test avrà
un commento che lo descrive e poi il test vero e proprio, che inizia con
call assert_equal, ad esempio
! Test 16: non-letters with question
call assert_equal("Sure.", hey(":) ?"), "non-letters with question")
Per disabilitare un test, basta trasformarlo in commento con un '!', ad esempio
! Test 16: non-letters with question
! call assert_equal("Sure.", hey(":) ?"), "non-letters with question")
Svolgere ogni esercizio è un processo fatto di:
- Creare la build iniziale con CMake
- Per ogni unit test:
- Risolvere gli errori di compilazione in modo che il test fallisca.
- Implementare solo lo stretto necessario perché il test passi.
- Riorganizzare l'implementazione per migliorare la leggibilità, ridurre le duplicazioni, ecc.
- Togliere il commento dal test successivo
Creare la build iniziale con CMake
Ogni esercizio porta con sé un file CMakeLists.txt insieme agli unit
test. Contiene la ricetta CMake già pronta che gestisce la build al posto
tuo. Non dovresti aver bisogno di modificare questo file. La ricetta fornita
presuppone che l'implementazione si trovi in un file sorgente che prende il
nome dall'esercizio.
Ad esempio, l'esercizio "Bob" si aspetta un'implementazione nel file bob.f90.
Crea i file di implementazione iniziali prima di eseguire CMake.
Se non hai il file bob.f90 quando esegui CMake per l'esercizio "Bob", CMake genererà un errore perché non trova i file.
Questi file possono essere vuoti, ma devono esistere.
Con questa ricetta, CMake può generare un progetto adatto al tuo ambiente
eseguendo cmake -G con un generatore adatto e il percorso della
directory dell'esercizio. CMake genererà uno script di build appropriato
per il tuo sistema operativo. Per tenere i file generati separati dal
codice sorgente dell'esercizio, è prassi comune creare una directory chiamata build
che contenga sia questi file di build generati sia il codice compilato.
In questo modo la cartella dell'esercizio resta ordinata e senza confusione.
**Nota: la prima volta che viene invocato cmake, la testlib viene scaricata automaticamente. La testlib è necessaria perché gli unit test funzionino.
Dato che eseguirai CMake per creare le istruzioni di build di ogni
esercizio, potresti voler creare uno script bash (Linux/MacOS) o
un file batch (Windows) per questo comando.
Una volta che CMake ha creato l'ambiente di build, puoi compilare il
codice con il comando appropriato al tuo ambiente:
- Linux con make:
make
- Windows con Visual Studio: seleziona Build / Build Solution dal menu.
- Windows con MingW:
mingw32-make.exe
- Windows con nMake:
nmake.exe
- MacOS con Xcode: seleziona Build dalla barra degli strumenti
Qui sotto trovi alcuni esempi di esecuzione di CMake in ambienti diversi.
Linux\MacOS con Make
Il nome del generatore per CMake è Unix Makefiles.
Supponendo che l'esercizio corrente sia bob e che ci troviamo nella cartella dell'esercizio:
$ touch bob.f90
$ mkdir build
$ cd build
$ cmake -G "Unix Makefiles" ..
$ make
Questo esempio mostra come creare file vuoti per l'implementazione prima
di eseguire CMake.
Per compilare i test, basta digitare make nella directory di build. Dovrebbero
comparire errori di compilazione. Una volta corretti gli errori, esegui di nuovo make.
Quando tutti gli errori di build sono risolti, esegui i test:
$ ctest -V
Windows con Visual Studio 2017
Il nome del generatore per CMake è Visual Studio 15. Lo stesso generatore
supporta tutte le edizioni IDE di Visual Studio 2017: Community, Professional
ed Enterprise. Supponendo che l'esercizio corrente sia bob e che ci troviamo nella
cartella dell'esercizio:
> copy nul: bob.f90
> mkdir build
> cd build
> cmake -G "Visual Studio 15" ..
Questo esempio mostra come creare file vuoti per l'implementazione prima
di eseguire CMake.
Windows con MingW
Il nome del generatore per CMake è MinGW Makefiles. Supponendo che l'esercizio
corrente sia bob e che ci troviamo nella cartella dell'esercizio:
> copy nul: bob.f90
> mkdir build
> cd build
> cmake -G "MinGW Makefiles" ..
Questo esempio mostra come creare file vuoti per l'implementazione prima
di eseguire CMake.
Per compilare i test, basta digitare make nella directory di build. Dovrebbero
comparire errori di compilazione. Una volta corretti gli errori, esegui di nuovo make.
Quando tutti gli errori di build sono risolti, esegui i test:
MacOS con Xcode
Il nome del generatore per CMake è Xcode.
Supponendo che l'esercizio corrente sia bob e che ci troviamo nella cartella dell'esercizio:
$ touch bob.f90
$ mkdir build
$ cd build
$ cmake -G Xcode ..
Questo esempio mostra come creare file vuoti per l'implementazione prima
di eseguire CMake.
Per compilare i test, basta digitare make nella directory di build. Dovrebbero
comparire errori di compilazione. Una volta corretti gli errori, esegui di nuovo make.
Quando tutti gli errori di build sono risolti, esegui i test:
$ ctest -V
Testlib
I test dipendono da una piccola libreria chiamata testlib, che viene scaricata da GitHub la prima volta che la build viene configurata con cmake.
Se il download non riesce, è possibile scaricarla manualmente, ad esempio
mkdir testlib
cd testlib
wget https://raw.githubusercontent.com/exercism/fortran/master/testlib/CMakeLists.txt
wget https://raw.githubusercontent.com/exercism/fortran/master/testlib/TesterMain.f90
