Qual è un normale rapporto tra "linee funzionali di codice" e "linee di test del codice"?

27

Sono abbastanza nuovo nell'approccio TDD e i miei primi esperimenti dicono che scrivere 1 riga di codice funzionale significa scrivere circa 2-3 righe di codice di test. Quindi, nel caso in cui scriverò 1000 LOC, l'intera base di codice compresi i test sarà qualcosa come ~ 3500 LOC.

È considerato normale? Qual è il rapporto nel codice che scrivi?

— Andrey Agibalov
fonte

8

Sì, TDD viene fornito con un tag costoso!

— EL Yusubov,

6

il tuo numero 2-3X è al massimo conservativo , in realtà è più vicino a 4-5X per cose come C # / Java, Python / Ruby potrebbe essere più vicino a 2-3X, con qualcosa di conciso come Erlang che è più vicino a 1: 1. Dipende da quanto dogmatico sei in TDD, più dogmatico, più aumentano quei rapporti!

6

@tomwrong: Nel libro di Kent cita Ward che dovresti scrivere dei test fino a quando la tua paura non si trasforma in noia.

— citato il

4

@ElYusubov: non sono affatto d'accordo sul fatto che sia "costoso". Sembra così per coloro che contano ancora la quantità di lavoro nei LOC. Ma il prezzo non è in LOC, è in denaro e time-to-market. E lì, TDD non è più costoso di qualsiasi altro ragionevole processo di sviluppo.

— citato il

5

Ragazzi, perché commentate invece di pubblicare risposte? Ciò che scrivi ha senso.

— Andrey Agibalov,

18

1: 3 è normale con TDD.

Dalla mia esperienza, e anche da altre citazioni che ricordo.

— erbaceo
fonte

12

... quali citazioni?

— TehShrike,

... Ricordo vagamente ... Non ricordo già dove fosse (forse nel TDD del Kent Beck, ad esempio, forse da qualche parte in c2.com). Ricordo il significato, tuttavia, che il codice di prova tre volte più del codice di produzione è ok.

— citato il

Wow, esattamente lo stesso nella mia esperienza. (Sto fissando i risultati da Cloc in questo momento e ho cercato su Google per trovare post su questo rapporto)

— Nikolay Tsenkov

9

Esistono variazioni basate su stili e lingue di codifica diversi. Tuttavia, indipendentemente dalla lingua che usi, la più grande variazione sei tu.

Robert Martin una volta disse:

"Man mano che i test diventano più specifici, il codice diventa più generico."

Questo mi ha fatto pensare. Test più specifici significano più codice di test. Codice di produzione più generico significa meno codice, quindi i rapporti test / codice dovrebbero aumentare man mano che il codice si evolve.

Ma aspetta, neanche questo va bene. In alcuni casi particolari, ad esempio quando definisci un certo algoritmo, potresti avere solo 6-10 righe di codice contenenti un paio di "if", un po 'e forse 2-3 ricorsioni. Posso dirti che quel codice avrà probabilmente più di 100 righe di codice di prova.

In un progetto reale, qualcosa di più grande di pochi algoritmi, il rapporto test / codice dovrebbe essere compreso tra 1: 1 e 2: 1. Se supera 2: 1, è un odore che tu abbia dei test che dovrebbero essere rifattorizzati o cancellati (o forse un codice che è difficile da testare). Dovresti sempre investire la stessa quantità di cura e refactoring nei tuoi test come nel tuo codice di produzione.

Ad ogni modo, la migliore risposta alla tua domanda è forse "Complessità ciclomatica" . Maggiore è la complessità ciclomatica del metodo, più esponenzialmente è il test che devi scrivere per coprire tutti i casi.

— Patkos Csaba
fonte

3

Il rapporto varia a seconda della dimensione dei metodi. Le dimensioni dei metodi varieranno in base allo stile di programmazione, al linguaggio e al dominio problematico.

Se i tuoi metodi sono brevi, 3: 1 è ragionevole. Se i tuoi metodi sono lunghi, 3: 1 è nella parte alta.

Quindi, per rispondere alla tua domanda, dipende. :-)

— Jon Strayer
fonte

Dipende da cosa intendi con "i metodi sono lunghi". Quale immagine ha creato nella mia testa, è che i metodi sono inutili a lungo, facendo troppo lavoro e avendo troppe responsabilità (spesso con troppi parametri). In questo caso, tale metodo deve proporzionalmente più combinazioni di copertura dai test, quindi non credo che il rapporto sarebbe cambiato molto ...

— erbaceo

Supponiamo per un momento di poter impostare un test, chiamare il metodo da testare e controllare il risultato in tre righe di codice. Se il metodo che si sta testando è lungo una riga (come accade in Scala), il test per la razione del codice di produzione è 3: 1. Se il metodo è lungo sei righe, allora è 1: 2. Sei righe non sono poi così lunghe.

— Jon Strayer,

2

Per applicazioni software critiche, il solito rapporto è un giorno di test per ogni 10 LoC funzionali.

E questo non conta TDD che non riguarda il test ma le specifiche.

— mouviciel
fonte

1

La dimensione del mio codice di test è circa la metà di ciò che il codice "reale" è nel complesso. Fare diversamente indica che i test sono troppo complessi e / o il codice è troppo difficile da testare e / o il codice è troppo denso / complesso.

Oppure stai semplicemente testando troppo e stai sprecando il tuo tempo in rendimenti decrescenti.

Vedi anche "quando i test unitari sono inappropriati o non necessari?"

— Telastyn
fonte

-1

Il mio rapporto è tra 2-1 e 10-1 (codice da testare). Assicurati che il test riguardi valore / comportamento e non implementazione.

— Erez A. Korn
fonte