Wie soll ich meinen TEST Code testen?

Eines der wenigen Dinge, denen sich die meisten Softwareentwickler einig sind, ist, dass Sie sich nicht darauf verlassen sollten, dass Code richtig funktioniert, es sei denn, Sie testen ihn. Wenn Sie es nicht testen, hat es möglicherweise versteckte Fehler, die Sie später nur noch mehr arbeiten lassen.

Ich verstehe, wie ich meinen normalen Code teste, aber wie soll ich meinen Testcode testen, um sicherzustellen, dass er Fehler effektiv findet und meldet, wenn sie vorhanden sind? Ich persönlich war dumm genug, fehlerhafte Testfälle zu schreiben, die bestanden hätten, wenn sie nicht bestanden hätten, und damit den Zweck meiner Tests überhaupt zunichte zu machen. Glücklicherweise habe ich die Fehler rechtzeitig gefunden und behoben, aber laut Test-Mantra scheint es, als ob keine Testsuite vollständig wäre, ohne eigene Tests, um sicherzustellen, dass sie funktionieren.

Mir scheint, der beste Weg, dies zu tun, besteht darin, sicherzustellen, dass der Test für fehlerhaften Code fehlschlägt. * Wenn ich 2 Minuten damit verbringe, dem Code abwechselnd Fehler hinzuzufügen und sicherzustellen, dass er fehlschlägt, sollte ich ein akzeptables Maß an Vertrauen haben Die Tests funktionieren. Dies bringt mich zu meiner zweiten Frage: Was sind gute Möglichkeiten, Fehler einzuführen, um sicherzustellen, dass sie von den Testfällen erfasst werden? Soll ich nur zufällig Anweisungen auskommentieren, sicherstellen, dass der falsche Zweig von a if-elseausgeführt wird, indem sein Zustand negiert wird, und die Ausführungsreihenfolge von Code mit Nebenwirkungen usw. ändern, bis ich zufrieden bin, dass meine Tests die meisten Ergebnisse erzielenhäufige Fehler? Wie validieren professionelle Entwickler, dass ihre Tests tatsächlich das tun, was sie tun sollen? Nehmen sie einfach an, dass die Tests funktionieren, oder nehmen sie sich auch die Zeit, sie zu testen? Wenn ja, wie testen sie die Tests?

Ich schlage nicht vor, dass die Leute so viel Zeit damit verbringen sollten, ihre Tests zu testen und dann die Tests auf ihre Tests zu testen, dass sie nie den tatsächlichen Code schreiben, aber ich habe dumm genug gehandelt, dass ich das Gefühl habe, ein bisschen davon profitieren zu können von "Meta-Testing", und war neugierig auf den besten Weg, dies zu tun. : D

_{* Ich könnte überprüfen, ob der Test bestanden wurde, wenn ich fehlerfreien Code teste, aber die Verwendung des Codes als Testspezifikation scheint ziemlich rückständig zu sein ...}

Der Standardfluss für TDD ist:

1. Schreiben Sie einen nicht bestandenen Test. (Rot)
2. Nehmen Sie die kleinste Codeänderung vor, die zum Bestehen führt (grün)
3. Refactor (Grün bleiben)

Der Test für Ihre Tests ist in diesem Fall Schritt 1 - Stellen Sie sicher, dass der Test fehlschlägt, bevor Sie Codeänderungen vornehmen.

Ein anderer Test, den ich mag, ist, ob Sie Code löschen und auf andere Weise neu implementieren können. Ihre Tests schlagen nach dem Löschen fehl, arbeiten jedoch mit einem anderen Algorithmus.

Wie bei allen Dingen gibt es kein Wundermittel. Das Vergessen, einen erforderlichen Test zu schreiben, ist für einen Entwickler genauso einfach wie das Vergessen, den Code zu schreiben. Zumindest wenn Sie beides tun, haben Sie doppelt so viele Möglichkeiten, Ihre Lücke zu schließen.

Ein Ansatz ist das Testen von Mutationen mit einem Tool wie Jester :

Jester nimmt einige Änderungen an Ihrem Code vor, führt Ihre Tests aus, und wenn die Tests bestanden werden, zeigt Jester eine Meldung an, die besagt, was sich geändert hat

Tests für Tests? Geh nicht diesen Weg. Dann brauchst du wahrscheinlich Tests für Tests und dann Tests für Tests für Tests ... wo hörst du auf?

Der übliche Testablauf sieht folgendermaßen aus: Als Entwickler verbringen Sie die meiste Zeit mit den Punkten 1 bis 3:

1. Code
2. Unit-Tests
3. Integrationstests
4. System / Sonstiges automatisiert
5. QA / Human Tester

Wenn ich 2 Minuten damit verbringe, abwechselnd Fehler zum Code hinzuzufügen (...)

Ihr Code wird irgendwann seine eigenen Fehler "wachsen" lassen. Verschwenden Sie keine Zeit damit, sie manuell einzuführen. Ganz zu schweigen davon, ist eine Sache, die Sie von vornherein kannten, wirklich ein Fehler? Es werden Käfer kommen, darüber würde ich mir keine Sorgen machen.

Soll ich Anweisungen nur zufällig auskommentieren, stelle sicher, dass der falsche Zweig eines if-else ausgeführt wird, indem seine Bedingung negiert wird (...)

Dies ist ein praktikabler Ansatz, um zu überprüfen, ob Sie tatsächlich testen, was Sie zu tun glauben. Ich denke nicht, dass es immer so gut ist, da es das gleiche Problem hat wie "Test für Test für Test ...".

Es ist auch gut, sich an den klassischen, pragmatischen Ratschlag eines Programmierers zu erinnern - Sie werden ihn nicht brauchen . Seien Sie agil, schreiben Sie Tests und Code für tatsächliche Fehler, anstatt für die hypothetischen Fehler, die möglicherweise auftreten oder nicht.

Durch die Konstruktion werden Funktionscode und Testcode gegeneinander getestet. Ein Problem bleibt bestehen: der Fall von Gleichtaktfehlern, wenn ein Fehler im Funktionscode durch einen Fehler im Testcode ausgeblendet wird. TDD ist gegen diesen Effekt nicht immun. Aus diesem Grund werden Tests in der Regel von verschiedenen Personen auf mehreren Ebenen durchgeführt, um diese Wahrscheinlichkeit zu verringern.

Sie testen Ihren Komponententest einmal, wenn Sie ihn im Debugger schreiben. Dann lässt du es in Ruhe und vergisst es. Hier gibt es kein Problem.

Bedenken Sie. Was ist der Zweck eines Komponententests? Sie werden benachrichtigt, wenn eine der zahlreichen Änderungen, die Sie an Ihrem Hauptprogramm vornehmen, versehentlich die Logik in diesem Programm ändert. Sie möchten das haben, weil Sie wissen, dass jede Änderung möglicherweise etwas kaputt macht. Genau aus diesem Grund gibt es kein Problem, wenn Sie Ihren Test nicht testen: Sie machen keinen Fehler mit Ihrem Test, bis Sie die Logik Ihres Programms absichtlich ändern (was es erforderlich machen würde, den Test erneut zu überprüfen und erneut zu testen) Es ist nicht wahrscheinlich, dass der Test versehentlich abbricht.

Es gibt einen Mutationstest , der die Eignung und Qualität des Tests bewertet und misst.

Wir können dies verwenden, um "den Test" selbst auszuwerten.

Kurz gesagt, wir können unseren Test (z. B. TestA) durch Testen auswerten. TestA kann den Unterschied zwischen dem Code und seinen Mutationscodes feststellen (sehr ähnlicher, aber geringfügig unterschiedlicher Code mit Originalcode).

Wenn TestA den Unterschied zwischen dem Code und seinen Mutationscodes nicht finden kann, bedeutet dies, dass TestA zu grobe Vorschriften hat, um den Originalcode zu testen.