Pausa caffè #87. Perché i test unitari sono importanti per gli sviluppatori? 5 modi per copiare un array in Java

Perché i test unitari sono importanti per gli sviluppatori?

Fonte: SearchSoftwareQuality Parliamo del motivo per cui il test unitario è importante e prezioso e di come semplifica il debug. Il test unitario è un potente strumento per migliorare la qualità del software. I test unitari forniscono una verifica fondamentale che un'applicazione sia conforme alle specifiche del software e si comporti come previsto. Se eseguiti correttamente, i test unitari:

• ridurre il numero di difetti e identificarli nelle prime fasi del ciclo di vita dello sviluppo;
• migliorare la leggibilità del codice;
• consentire il riutilizzo del codice;
• aumentare la velocità di distribuzione.

Diamo un'occhiata al motivo per cui il test unitario è importante, come è nato questo tipo di test e quali sono gli ostacoli alla sua implementazione.

Storia dei test unitari

Un errore rilevato in fase iniziale consente di risparmiare tempo e fatica. Per i primi 50 anni di storia del computer, i test unitari e il debugging erano essenzialmente la stessa cosa. Ma negli anni ’90 il codice era diventato così complesso che spesso era impossibile dividere il sistema in piccole parti per eseguirle isolatamente. Nel 1997, un programmatore di nome Kent Beck creò JUnit, un plugin per l'ambiente di sviluppo per testare piccole porzioni di codice. Il codice di test che valuta il codice sorgente è chiamato unit test. Questo tipo di test unitario è diventato un punto fermo da molti anni. Dopo che Beck creò JUnit, Martin Fowler scrisse un libro, Refactoring, in cui proponeva modi per trasformare il codice per renderlo più isolato e testabile. La combinazione di refactoring del codice e test unitari ha portato allo sviluppo basato sui test, in cui la creazione di test unitari è essenziale per il processo di programmazione. In esso, il codice deve essere testabile anche prima di essere creato. Pertanto, il processo di programmazione non viene completato finché non vengono eseguiti i test unitari. Il progetto può quindi passare alla fase di ricerca a livello di sistema o umano.

Esempio di test unitario

Questo esempio dimostra l'importanza dei test unitari. Qui JUnit valuta una semplice funzione che converte la temperatura da Fahrenheit a Celsius. Formula di conversione: C = (F-32) * 5/9. Solo poche righe, inclusa la firma della funzione e le parentesi graffe, possono essere implementate nel codice come funzione di libreria. Tuttavia, dalla funzione non risulta chiaramente che questi siano criteri. Queste opzioni possono includere arrotondamenti per eccesso o per difetto, numeri reali o limiti superiore e inferiore. Creiamo unit test di esempio per questa funzione di conversione della temperatura in Perl utilizzando il modulo Test::More. La prima riga è un commento che dice al programmatore cosa aspettarsi dal codice rimanente.

# is (input, expected result, comment)
is( FtoC(32),0,'Freezing point is F32, C 0');
is( FtoC(212),100,'Boiling point is F212, C 100');
is( FtoC(59038),32767, 'Upper limit of C is 32767');
is( FtoC(59039),undefined, 'One past upper limit is error');

Il framework JUnit si basa su sistemi orientati agli oggetti e oggetti di test, ma il concetto è simile.

Test unitari isolati

Uno dei vantaggi degli unit test è che isolano una funzione, una classe o un metodo e testano solo quella parte di codice. I singoli componenti migliori garantiscono la resilienza complessiva del sistema. In questo modo ottieni un codice affidabile. Gli unit test modificano anche la natura del processo di debug. Per provare a correggere un bug, i programmatori scrivono semplicemente un test fallito e poi lo ripetono in modo che passi senza violare le aspettative precedenti. Questo processo elimina il ciclo manuale del debug tradizionale attraverso l'installazione, la ricreazione, la pausa e il test. Per modificare il codice per renderlo adatto allo unit test, i programmatori devono cambiare il modo in cui lavorano. Qualsiasi pezzo di codice scritto senza test unitari sarà probabilmente considerato non testato, almeno come singoli moduli.

Adattare i test unitari

Il software legacy è un software in esecuzione da molto tempo e molto probabilmente è stato scritto senza test unitari. Il codice legacy ha valore per l’azienda. Funziona stabilmente per molti anni. Alcuni programmi realizzati senza test unitari elaborano transazioni da milioni di dollari al giorno. Ma il codice che non ha test unitari si trasforma nel tempo in una grande palla di terra perché è stato toccato da molti programmatori di manutenzione del codice nel corso degli anni. Il refactoring consente ai programmatori di apportare gradualmente modifiche a un sistema per renderlo testabile. Tuttavia, questi cambiamenti richiedono tempo. Diversi anni fa stavo discutendo con il mio collega Bob Reselman la questione dell'utilizzo degli unit test per le applicazioni legacy. Reselman ha sostenuto che implementare i test unitari nelle applicazioni realizzate senza di essi è troppo costoso e persino stupido. Ha invece raccomandato all'organizzazione di avviare un nuovo sviluppo con test unitari e di lasciare intatte le applicazioni legacy. Questo può essere vero per COBOL, generatori di report e altre applicazioni, ma direi che nelle applicazioni scritte in linguaggi moderni (C++, C#, Java e Ruby) è abbastanza semplice aggiungere retroattivamente unit test. Invece di scriverli per l'intera applicazione, aggiungi semplicemente test unitari alla modifica corrente ed esegui il refactoring man mano che procedi.

Maggiore velocità, qualità e testabilità

I project manager affermano che la pianificazione implica compromessi tra qualità, quantità di lavoro completato, risorse e tempo. Per aggiungere qualcosa a un'area, devi togliere qualcosa a un'altra. Test unitari efficaci infrangono questa regola. Questo è il motivo per cui i test unitari sono importanti e preziosi per le organizzazioni. Buoni test unitari producono codice testabile che migliora la qualità. Questo codice avrà meno difetti, il che significa meno correzioni di bug per completare il progetto più velocemente. Quando il software rileva bug, i test unitari accelerano il debug, la correzione e la scrittura del codice. E questo avviene in modo tale da ridurre significativamente la probabilità che un difetto si ripeta, migliorando contemporaneamente la qualità e la velocità del codice. Sebbene non esista una bacchetta magica nello sviluppo del software, test unitari efficaci possono accelerare lo sviluppo, i test e persino l'ingegneria di alcuni requisiti funzionali.

5 modi per copiare un array in Java

Fonte: Dev.to Quindi hai due array A e B e devi copiare gli elementi da A a B. Bene, ci sono diversi modi per farlo in Java e te li mostrerò ora.

Metodo uno: ForLoop

È qui che il buon vecchio ciclo for ci viene in aiuto :

int[] A = {1,2,4,4};
int[] B = new int[];

 for (int i = 0; i < A.length; i++){
      B[i] = A[i];
}

Metodo due: .clone()

Anche il metodo di clonazione dell'array può aiutare a ottenere il risultato desiderato:

int[] A = {1,2,4,4};
int[] B = A.clone();//the clone method copies the content of A into B;

Metodo tre: System.arraycopy()

Il modo successivo è utilizzare il metodo System.arraycopy() , che si trova nel pacchetto java.lang . Prima di passare al suo utilizzo, discutiamo della sua firma:

public static void arraycopy(
    Object src, //:source array, in this case A
    int srcPos, //:the start index for copy, typically 0
    Object dest, //:destination object in this case B.
    int destPos, //:the index to place the copied elements
    int length //:the length of the contents to be copied
);

Applicazione:

int[] A = {1,2,4,4};
int[] B = new int[];

System.arraycopy(A, 0, B, 0, A.length);

Metodo quattro: Arrays.copyOf()

La prossima opzione di copia di cui parleremo è la classe Arrays del pacchetto java.utils . Presta attenzione alla sua firma:

public static int[] copyOf(
    int[] original, // :source array in this case A
    int newLength // :the length of the contents to be copied
);

Applicazione:

int[] A = {1,2,4,4};
int[] B = Arrays.copyOf(A, 3);

Metodo cinque: Arrays.copyOfRange()

Quindi, questa sarà l’ultima opzione che esamineremo in questo post. Proviene anche dalla classe Arrays presente nel pacchetto java.utils . Diamo un'occhiata ancora alla sua firma:

public static int[] copyOfRange​(
    int[] original, // :source array in this case A
    int from,  //:the start index for copy, typically 0
    int to // the end index exclusive
);

Applicazione:

int[] A = {1,2,3,4,5,6,7};
int[] B = Arrays.copyOfRange(A, 0, A.length);