Kaffeepause Nr. 87. Warum sind Unit-Tests für Entwickler wichtig? 5 Möglichkeiten zum Kopieren eines Arrays in Java

Warum sind Unit-Tests für Entwickler wichtig?

Quelle: SearchSoftwareQuality Lassen Sie uns diskutieren, warum Unit-Tests wichtig und wertvoll sind und wie sie das Debuggen erleichtern. Unit-Tests sind ein leistungsstarkes Werkzeug zur Verbesserung der Softwarequalität. Unit-Tests bieten eine grundlegende Überprüfung, ob eine Anwendung den Softwarespezifikationen entspricht und sich wie beabsichtigt verhält. Wenn die Unit-Tests gut gemacht sind:

• Reduzieren Sie die Anzahl der Fehler und identifizieren Sie sie in frühen Phasen des Entwicklungslebenszyklus.
• Verbesserung der Lesbarkeit des Codes;
• Wiederverwendung von Code zulassen;
• Erhöhen Sie die Bereitstellungsgeschwindigkeit.

Schauen wir uns an, warum Unit-Tests wichtig sind, wie diese Art von Tests entstanden ist und welche Hindernisse bei ihrer Implementierung bestehen.

Geschichte des Unit-Tests

Ein frühzeitig erkannter Fehler spart Zeit und Aufwand. In den ersten 50 Jahren der Computergeschichte waren Unit-Tests und Debugging im Wesentlichen dasselbe. Doch in den 1990er Jahren war der Code so komplex geworden, dass es oft unmöglich war, das System in kleine Teile zu zerlegen, um sie isoliert auszuführen. 1997 entwickelte ein Programmierer namens Kent Beck JUnit, ein Entwicklungsumgebungs-Plugin zum Testen kleiner Codeteile. Der Testcode, der den Quellcode auswertet, wird Unit-Tests genannt. Diese Art von Unit-Tests ist seit vielen Jahren zu einem festen Bestandteil geworden. Nachdem Beck JUnit erstellt hatte, schrieb Martin Fowler ein Buch mit dem Titel „Refactoring“, in dem er Möglichkeiten zur Transformation von Code vorschlug, um ihn isolierter und testbarer zu machen. Die Kombination aus Code-Refactoring und Unit-Tests hat zu einer testgetriebenen Entwicklung geführt, bei der die Erstellung von Unit-Tests für den Programmierprozess von wesentlicher Bedeutung ist. Darin muss der Code bereits vor seiner Erstellung testbar sein. Daher ist der Programmiervorgang erst abgeschlossen, wenn die Unit-Tests ausgeführt werden. Das Projekt kann dann in die Forschungsphase auf Systemebene oder auf menschlicher Ebene übergehen.

Beispiel für Unit-Tests

Dieses Beispiel zeigt die Bedeutung von Unit-Tests. Hier wertet JUnit eine einfache Funktion aus, die die Temperatur von Fahrenheit in Celsius umrechnet. Umrechnungsformel: C = (F-32) * 5/9. Nur wenige Zeilen, einschließlich der Funktionssignatur und geschweiften Klammern, können als Bibliotheksfunktion im Code implementiert werden. Allerdings geht aus der Funktion nicht hervor, dass es sich hierbei um Kriterien handelt. Diese Optionen können Auf- oder Abrunden, reelle Zahlen oder Ober- und Untergrenzen umfassen. Lassen Sie uns Beispiel-Unit-Tests für diese Temperaturkonvertierungsfunktion in Perl mit dem Modul Test::More erstellen. Die erste Zeile ist ein Kommentar, der dem Programmierer sagt, was er vom restlichen Code erwarten kann.

# 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');

Das JUnit-Framework basiert auf objektorientierten Systemen und Testobjekten, das Konzept ist jedoch ähnlich.

Isolierte Unit-Tests

Einer der Vorteile von Unit-Tests besteht darin, dass sie eine Funktion, Klasse oder Methode isolieren und nur diesen Codeabschnitt testen. Bessere Einzelkomponenten sorgen für die Ausfallsicherheit des Gesamtsystems. Auf diese Weise erhalten Sie zuverlässigen Code. Unit-Tests verändern auch die Art des Debugging-Prozesses. Um einen Fehler zu beheben, schreiben Programmierer einfach einen fehlgeschlagenen Test und wiederholen ihn dann, sodass er besteht, ohne frühere Erwartungen zu verletzen. Durch diesen Prozess entfällt der manuelle Zyklus des herkömmlichen Debuggens durch Einrichten, Neuerstellen, Anhalten und Testen. Um Code so zu ändern, dass er für Unit-Tests geeignet ist, müssen Programmierer ihre Arbeitsweise ändern. Alle Codeteile, die ohne Unit-Tests geschrieben wurden, werden wahrscheinlich als ungetestet betrachtet, zumindest als einzelne Module.

Anpassen von Unit-Tests

Bei Legacy-Software handelt es sich um Software, die schon lange läuft und höchstwahrscheinlich ohne Unit-Tests geschrieben wurde. Legacy-Code hat einen Wert für das Unternehmen. Es funktioniert über viele Jahre hinweg stabil. Einige Programme, die ohne Unit-Tests erstellt wurden, verarbeiten täglich Millionen-Dollar-Transaktionen. Aber Code, für den es keine Unit-Tests gibt, wird mit der Zeit zu einem großen Dreckball, weil er im Laufe der Jahre von vielen Code-Wartungsprogrammierern berührt wurde. Refactoring ermöglicht es Programmierern, schrittweise Änderungen an einem System vorzunehmen, um es testbar zu machen. Allerdings brauchen diese Veränderungen Zeit. Vor einigen Jahren habe ich mit meinem Kollegen Bob Reselman die Frage der Verwendung von Unit-Tests für Legacy-Anwendungen besprochen. Reselman argumentierte, dass die Implementierung von Unit-Tests in Anwendungen, die ohne Unit-Tests erstellt wurden, zu teuer und sogar dumm sei. Stattdessen empfahl er der Organisation, neue Entwicklungen mit Unit-Tests zu beginnen und ältere Anwendungen in Ruhe zu lassen. Das mag für COBOL, Berichtsgeneratoren und andere Anwendungen zutreffen, aber ich würde behaupten, dass es in Anwendungen, die in modernen Sprachen – C++, C#, Java und Ruby – geschrieben sind, recht einfach ist, nachträglich Komponententests hinzuzufügen. Anstatt sie für die gesamte Anwendung zu schreiben, fügen Sie einfach Unit-Tests zur aktuellen Änderung hinzu und überarbeiten Sie sie nach und nach.

Erhöhte Geschwindigkeit, Qualität und Testbarkeit

Projektmanager sagen, dass die Planung Kompromisse zwischen Qualität, Umfang der abgeschlossenen Arbeit, Ressourcen und Zeit erfordert. Um einem Bereich etwas hinzuzufügen, muss man einem anderen etwas wegnehmen. Effektive Unit-Tests verstoßen gegen diese Regel. Aus diesem Grund sind Unit-Tests für Unternehmen wichtig und wertvoll. Gute Unit-Tests erzeugen testbaren Code, der die Qualität verbessert. Dieser Code wird weniger Fehler aufweisen, was bedeutet, dass weniger Fehler behoben werden müssen, um das Projekt schneller abzuschließen. Wenn Software auf Fehler stößt, beschleunigen Unit-Tests das Debuggen, Beheben und Schreiben von Code. Und das so, dass die Wahrscheinlichkeit eines erneuten Auftretens eines Fehlers deutlich reduziert wird und gleichzeitig die Qualität und Geschwindigkeit des Codes verbessert wird. Auch wenn es in der Softwareentwicklung kein Allheilmittel gibt, können effektive Unit-Tests die Entwicklung, das Testen und sogar einige der funktionalen Anforderungsanalysen beschleunigen.

5 Möglichkeiten zum Kopieren eines Arrays in Java

Quelle: Dev.to Sie haben also zwei Arrays A und B und müssen die Elemente von A nach B kopieren. Nun, es gibt verschiedene Möglichkeiten, dies in Java zu tun, und ich werde sie Ihnen jetzt zeigen.

Methode eins: ForLoop

Hier kommt uns die gute alte for- Schleife zu Hilfe :

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

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

Methode zwei: .clone()

Auch die Methode des Array-Klonens kann dabei helfen, das gewünschte Ergebnis zu erzielen:

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

Methode drei: System.arraycopy()

Die nächste Möglichkeit besteht darin, die Methode System.arraycopy() zu verwenden , die sich im Paket java.lang befindet . Bevor wir zu seiner Verwendung übergehen, besprechen wir seine Signatur:

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
);

Anwendung:

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

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

Methode 4: Arrays.copyOf()

Die nächste Kopieroption, die wir besprechen werden, ist die Arrays- Klasse aus dem java.utils- Paket . Achten Sie auf seine Unterschrift:

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

Anwendung:

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

Methode fünf: Arrays.copyOfRange()

Dies wird also die letzte Option sein, die wir in diesem Beitrag betrachten werden. Es stammt auch aus der Arrays- Klasse , die im Paket java.utils vorhanden ist . Schauen wir uns noch einmal seine Unterschrift an:

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
);

Anwendung:

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