Sviluppo guidato dai test
Introduzione al Testing in Java
Maria Milusheva
Senior Software Engineer
Test-Driven Development
Finora abbiamo scritto test solo dopo il codice di produzione.
- Il Test-Driven Development (TDD) è una tecnica in cui i test guidano il design
Nel TDD si scrivono test prima del codice di produzione
Perché fare TDD?
Vantaggi del TDD
- Con il TDD si rispettano meglio i requisiti
- Verifica immediata: ogni riga di codice ha già test
- Codificare partendo dai test porta a codice più pulito e strutturato
Le leggi del TDD
1. Scrivi un test che fallisce prima di qualsiasi codice di produzione
2. Scrivi il test più corto possibile
3. Non scrivere più codice di produzione del necessario per far passare il test
Applicarli in sequenza = un ciclo TDD
Lo sviluppo procede per cicli TDD ripetuti
Test sui palindromi
Supponiamo di voler scrivere un metodo che verifica se un intero è palindromo
Esempi di interi palindromi: 12321, 0, 3333
Scrivi un test che fallisce prima del codice
@Test
public void isPalindrome_nonPalindromicInt_returnsFalse() {
int number = 1234;
assertFalse(isPalindrome(number)); // isPalindrome() is not yet written
}
Un test è come un promemoria per il futuro che chiarisce i requisiti.
Scrivi il minimo per far passare il test
public boolean isPalindrome(int num) {
return false; // Scrivi il minimo necessario per far passare il test.
}
Ora il test passa. Possiamo passare al prossimo ciclo TDD.
Scrivi un altro test
Nuovo test = nuovo requisito della feature:
@Test
public void isPalindrome_PalindromicInt_ReturnsTrue() {
int number = 1234321; // Ora crea un caso più complesso.
assertTrue(isPalindrome(number)); // A questo punto isPalindrome() fallirà.
}
Implementa il metodo
public boolean isPalindrome(int num) {
int inverted = 0;
while (num != 0) {
// A ogni iterazione prendi l'ultima cifra con % 10
// e aggiungila a inverted * 10.
inverted = inverted * 10 + num % 10;
// Dopo aver elaborato l'ultima cifra, scartala con / 10.
num = num / 10;
}
return inverted;
}
Correzione bug con TDD
Il TDD è ottimo per correggere bug!
Il metodo scritto restituisce true per number = -121. Non è corretto!
Scriviamo un unit test per mostrare il bug:
@Test
public void isPalindrome_NegativeNumber_ReturnsFalse() {
int number = -121; // Non è palindromo: -121 ≠ 121-.
assertFalse(isPalindrome(number));
}
Correzione bug con TDD
public boolean isPalindrome(int num) {
if (num < 0) {
return false; // Aggiungiamo una clausola per i valori negativi.
}
int inverted = 0;
while (num != 0) {
inverted = inverted * 10 + num % 10;
num = num / 10;
}
return inverted;
}
Ayo berlatih!
Introduzione al Testing in Java
