Sviluppo basato su test di applicazioni Go

Il LiteIDE è un ambiente di sviluppo gratuito, disponibile per tutti i sistemi operativi - concepito per il lavoro quotidiano con Go. Oltre ai test automatizzati e al debugging con delve o gdb, supporta anche la compilazione attraverso le varie piattaforme. Questo tutorial spiega lo sviluppo sulla base di test di applicazioni Go. Su questi viene realizzato un breve programma che somma fra loro due cifre.

Introduzione: Il ciclo di sviluppo basato sui test

• 1. Rosso Tutto comincia con un test non superato:

  indipendentemente che sia necessario implementare una nuova feature o riparare un bug: Il primo passo implica sempre la scrittura di un test. Dal momento che non esiste ancora nessun codice di produzione, naturalmente il test non viene superato.

• 2. Verde Il nuovo codice supera il test:

  ora viene scritto esattamente il codice di produzione necessario per svolgere il test con successo. Il codice non deve essere particolarmente bello, bensì deve essere una soluzione il più semplice possibile per il problema parziale.

• 3. Rielaborare: Garantire la leggibilità e possibilità di manutenzione

  Nell’ultimo passo il codice di produzione viene riordinato, rielaborato e commentato approfonditamente. Qui è importante mantenere leggibile e idoneo alla manutenzione il codice creato.

  Dopo varie iterazioni in questo ciclo si sono formate raccolte di test complete. Nello sviluppo di nuove feature vengono eseguiti tutti i test. In questo modo viene indicato un ambito ristretto per nuove parti di programma, il che determina in generale un’elevata qualità del codice.

Crea progetto

1. 1 Cliccare sull’interfaccia "Nuovo" o selezionare il punto "Nuovo" dal menu "File".

2. 2 Scegliere "Go1 Command Project"

3. 3 Assegnare un nome al progetto, per esempio "litetutorial"

Il progetto appena creato contiene già due file: il file go.doc 1 , che dovrebbe contenere la documentazione del progetto e il file aperto nella finestra dell’editor main.go 2 , in cui IDE ha scritto un programma Hello World.

1. Rosso Realizzare ed eseguire un test

Seguendo il principio "Nessun codice riga senza test non riuscito", viene realizzato nella prima fase un test per la funzione Add (a,b). Se il Go-Tool viene attivato con il comando go test esso cerca in file terminanti in _test.go funzioni che cominciano con un test scritto maiuscolo.

Create dunque il file litetutorial_test.go

					
						package main

						import "testing"

						func TestAdd(t *testing.T) {
								a,b := 2, 3
								want := 5
								result := Add(a, b)

								if result != want {
										t.Errorf("Error in Addition: %d + %d = %d ", a, b, result)
								}
						}
					
				

• Riga 1:
  Volete realizzare un file eseguibile. Pertanto il pacchetto in cui lavorate è il pacchetto main.

• Riga 3:
  Per scrivere un test, utilizzate il pacchetto testing dalla biblioteca standard.

• Riga 5:
  Una funzione che comincia con Test, viene eseguita come test. Come parametro la funzione riceve un pointer su uno testing.T-Objekt.

• Riga 11:
  Se viene richiamata la funzione t.Errorf() il test non va a buon fine. t.Errorf() funziona in modo simile alla funzione fmt.Printf() o funzione C printf() e riceve una stringa di formato e le vengono assegnati diversi valori per l’emissione.

Il test viene avviato attraverso l’interfaccia "T" sul bordo superiore dello schermo - o mediante la combinazione di tasti Strg+T. Dal momento che la funzione Add(a,b) non esiste, il test non va a buon fine.

					
						C:/Go/bin/go.exe test -v [C:/Users/Gopher/go/src/litetutorial]
						=== RUN TestAdd
						--- FAIL: TestAdd (0.00s)
								liteIDE_test.go:12: Error in Addition: 2 + 3 = -1
								FAIL
								exit status 1
								FAIL	litetutorial	0.019s
								Fehler: Prozess beendet mit Rückgabewert 1.
					
				

2. Verde Implementare il codice di produzione ed effettuare nuovamente il test

Dal momento che il test non è andato a buon fine, adesso si può Add(a,b) implementare la funzione. Per strutturare la base codice, la funzione viene trasferita nel calcfunctions.go file.

					
						package main
						func Add(a, b int) int {
								var result in
								result = a + b
								return result
						}
					
				

Dopo aver nuovamente richiamato il test con la combinazione di tasti Strg+T il test funziona correttamente.

3. Riordinare

L’ultima fase del ciclo di sviluppo guidata dai test viene spesso sottovalutata: Il riordino. In questa fase il codice viene rielaborato in modo tale da essere ben comprensibile e idoneo alla manutenzione. Il codice di programmazione viene dunque ridotto all’essenziale e commentato:

					
						//Add returns the sum of to integers a and b
						func Add(a, b int) int {
							return a+b
						}
					
				

Un test svolto un’altra volta si svolge senza errori. Adesso la funzione può essere utilizzata litetutorial.go nel programma principale.

					
						package main

						import "fmt"

						func main() {
							a := 2
							b := 3
							sum := Add(a, b)

							fmt.Println(a, "+", b, "=", sum, "\n")
						}
					
				

Con un test per la sottrazione adesso può cominciare un nuovo ciclo di sviluppo.

Compilare programma per il pure.box

• 1 Scegliete dalla selezione di sistema "cross-arm5"

• 2 Cliccando sul simbolo B compilate il programma

• 3 Infine il file eseguibile compare nella directory del progetto.

Come spiegato nel tutorial "Primi passi in Go", il binary pronto adesso può essere caricato ed eseguito tramite FTP, Samba o SCP sul pure.box.