Cada exercício traz os testes de unidade e uma receita de build do CMake. A
implementação é você que faz.
Cada arquivo de teste deve ser linkado à sua implementação para gerar um
executável de console que roda os testes. Ao rodar o executável de testes, são
impressas mensagens para cada teste que falha, e é reportado um status de saída
diferente de zero quando os testes falham.
O arquivo de teste tem o nome <exercise>_test.f90; assim, para o exercício
"Bob", o arquivo que contém os testes é bob_test.f90. Cada teste tem um
comentário descrevendo o teste e, em seguida, o teste em si, começando com
call assert_equal, por exemplo
! Test 16: non-letters with question
call assert_equal("Sure.", hey(":) ?"), "non-letters with question")
Para desabilitar um teste, basta comentá-lo com um '!', por exemplo
! Test 16: non-letters with question
! call assert_equal("Sure.", hey(":) ?"), "non-letters with question")
Trabalhar em cada exercício é um processo de:
- Criar o build inicial com o CMake
- Para cada teste de unidade:
- Resolver os erros de compilação para fazer o teste falhar.
- Implementar só o suficiente para fazer o teste passar.
- Refatorar a sua implementação para melhorar a legibilidade, reduzir duplicação etc.
- Descomentar o próximo teste
Cada exercício traz um arquivo CMakeLists.txt junto com os testes de unidade.
Ele contém a receita pronta do CMake que cuida do build para você.
Você não deve precisar editar esse arquivo. A receita fornecida parte do
princípio de que a sua implementação está em um arquivo-fonte com o nome do
exercício.
Por exemplo, o exercício "Bob" espera uma implementação no arquivo bob.f90.
Crie os arquivos da sua implementação inicial antes de rodar o CMake.
Se você não tiver o arquivo bob.f90 ao rodar o CMake para o exercício "Bob", o CMake vai gerar um erro dizendo que os arquivos não foram encontrados.
Esses arquivos podem estar vazios, mas precisam existir.
Usando essa receita, o CMake consegue gerar um projeto adequado ao seu ambiente
ao rodar cmake -G com um gerador adequado e o caminho do diretório do
exercício. O CMake vai gerar um script de build apropriado para o seu sistema
operacional. Para manter esses arquivos gerados separados do código-fonte do
exercício, é comum criar um diretório chamado build para guardar tanto os
arquivos de build gerados quanto o código compilado.
Assim a pasta do seu exercício fica organizada e sem bagunça.
**Observação: na primeira vez que o cmake for chamado, a testlib será baixada automaticamente. A testlib é necessária para que os testes de unidade funcionem.
Como você vai rodar o CMake para criar as instruções de build de cada tarefa,
pode valer a pena criar um script bash (Linux/MacOS) ou um arquivo em lote
(Windows) para esse comando.
Depois que o CMake criar o ambiente de build, você pode compilar o seu código
com o comando adequado ao seu ambiente:
- Linux com make:
make
- Windows com Visual Studio: selecione Build / Build Solution no menu.
- Windows com MingW:
mingw32-make.exe
- Windows com nMake:
nmake.exe
- MacOS com Xcode: selecione Build na barra de ferramentas
Veja abaixo exemplos de como rodar o CMake em ambientes diferentes.
O nome do gerador para o CMake é Unix Makefiles.
Supondo que o exercício atual seja bob e que estejamos na pasta do exercício:
$ touch bob.f90
$ mkdir build
$ cd build
$ cmake -G "Unix Makefiles" ..
$ make
Este exemplo mostra como criar arquivos vazios para a implementação antes de
rodar o CMake.
Basta digitar make no diretório de build para compilar os testes. Isso deve
gerar erros de compilação. Depois de corrigir os erros, rode make de novo.
Quando todos os erros de build estiverem corrigidos, rode os testes:
$ ctest -V
O nome do gerador para o CMake é Visual Studio 15. Esse mesmo gerador
funciona com todas as edições IDE do Visual Studio 2017: Community, Professional
e Enterprise. Supondo que o exercício atual seja bob e que estejamos na pasta
do exercício:
> copy nul: bob.f90
> mkdir build
> cd build
> cmake -G "Visual Studio 15" ..
Este exemplo mostra como criar arquivos vazios para a implementação antes de
rodar o CMake.
O nome do gerador para o CMake é MinGW Makefiles. Supondo que o exercício
atual seja bob e que estejamos na pasta do exercício:
> copy nul: bob.f90
> mkdir build
> cd build
> cmake -G "MinGW Makefiles" ..
Este exemplo mostra como criar arquivos vazios para a implementação antes de
rodar o CMake.
Basta digitar make no diretório de build para compilar os testes. Isso deve
gerar erros de compilação. Depois de corrigir os erros, rode make de novo.
Quando todos os erros de build estiverem corrigidos, rode os testes:
O nome do gerador para o CMake é Xcode.
Supondo que o exercício atual seja bob e que estejamos na pasta do exercício:
$ touch bob.f90
$ mkdir build
$ cd build
$ cmake -G Xcode ..
Este exemplo mostra como criar arquivos vazios para a implementação antes de
rodar o CMake.
Basta digitar make no diretório de build para compilar os testes. Isso deve
gerar erros de compilação. Depois de corrigir os erros, rode make de novo.
Quando todos os erros de build estiverem corrigidos, rode os testes:
$ ctest -V
Testlib
Os testes dependem de uma pequena biblioteca chamada testlib, que é baixada do GitHub na primeira vez que o build é configurado com o cmake.
Se o download falhar, dá para fazê-lo manualmente, por exemplo
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
