Domanda

Qual è il modo migliore per testare unità di dati di grandi dimensioni? Alcuni codici legacy che sto mantenendo hanno strutture di un centinaio di membri o più; altre parti del codice su cui stiamo lavorando creano o analizzano set di dati di centinaia di campioni.

L'approccio migliore che ho trovato finora è serializzare le strutture o i set di dati dal disco, eseguire le operazioni sotto test, serializzare i risultati su disco, quindi diff i file contenenti i risultati serializzati rispetto ai file che contengono i risultati previsti. Questo non è tremendamente veloce e viola il " non toccare il disco " principio del test unitario. Tuttavia, l'unica alternativa che mi viene in mente (scrivere codice per inizializzare e testare centinaia di membri e punti dati) sembra insopportabilmente noiosa.

Ci sono soluzioni migliori?

Nessuna soluzione corretta

Altri suggerimenti

Se ciò che stai cercando di ottenere è, in effetti, un test unitario, dovresti deridere le strutture di dati sottostanti e simulare i dati. Questa tecnica ti dà il controllo completo sugli input. Ad esempio, ogni test che scrivi può gestire un singolo punto dati e avrai una serie molto concisa di test per ogni condizione. Esistono diversi framework di derisione open source, consiglio personalmente Rhino Mocks ( http: // ayende.com/projects/rhino-mocks/downloads.aspx ) o NMock ( http: //www.nmock .org ).

Se non è possibile per te deridere le strutture dati, ti consiglio di effettuare il refactoring in modo da poter :-) Ne vale la pena! Oppure potresti anche provare TypeMock ( http://www.typemock.com/ ) che consente di deridere di classi concrete.

Se, tuttavia, se stai eseguendo test su set di dati di grandi dimensioni, stai davvero eseguendo test funzionali e non test unitari. Nel qual caso il caricamento di dati in un database o da disco è un'operazione tipica. Invece di evitarlo, dovresti lavorare per farlo funzionare in parallelo con il resto del tuo processo di compilazione automatizzato in modo che l'impatto sulle prestazioni non stia ostacolando nessuno dei tuoi sviluppatori.

Questo è ancora un approccio praticabile. Anche se, classificherei questo come un test funzionale, o semplicemente non un test unitario puro. Un buon test unitario sarebbe quello di fare un campionamento di quei record che dia una buona distribuzione dei casi limite che potresti incontrare e scriverli. Quindi, hai la tua ultima "accettazione" o "funzionale" prova con il tuo test collettivo su tutti i dati.

Ho usato questo approccio durante il test di grandi quantità di dati e trovo che funzioni abbastanza bene perché le piccole unità sono gestibili, quindi so che il test di massa funziona ed è tutto automatico.

  

L'approccio migliore che ho trovato finora è serializzare le strutture o i set di dati dal disco, eseguire le operazioni sotto test, serializzare i risultati su disco, quindi diff i file contenenti i risultati serializzati rispetto ai file che contengono i risultati previsti.

Ho scritto del codice che utilizza la tecnica sopra menzionata, tranne che per la serializzazione dal disco nel test, ho convertito i dati serializzati in un array di byte che il compilatore può inserire nell'eseguibile per te.

Ad esempio, i dati serializzati possono essere convertiti in:

unsigned char mySerialisedData[] = { 0xFF, 0xFF, 0xFF, 0xFF, ... };

test()
{
    MyStruct* s = (MyStruct*) mySerialisedData;

}

Per un esempio più dettagliato (in C #) vedi unit test . Mostra un esempio dell'utilizzo di alcuni dati serializzati codificati come input per i test, test della firma degli assembly.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top