Wesentliche Erkenntnisse
- API-Testing validiert die Kommunikation zwischen Softwarekomponenten über Endpunkte, mit Fokus auf Anfrage/Antwort-Zyklen, Datenformate und Authentifizierungsmechanismen.
- Unit-Testing untersucht einzelne Funktionen oder Methoden isoliert mit gemockten Abhängigkeiten und liefert Feedback im Millisekundenbereich zu spezifischer Code-Funktionalität.
- API-Tests bleiben während internem Refactoring stabil, erfordern jedoch komplexe Umgebungseinrichtung, während Unit-Tests schneller sind, aber bei Implementierungsänderungen fehlschlagen.
- Effektive Teststrategien kombinieren beide Ansätze, wobei Unit-Tests frühzeitig Logikfehler erkennen und API-Tests Integrationspunkte zwischen Services überprüfen.
Dieser Leitfaden vergleicht API-Test vs Unit-Test nach Umfang, Geschwindigkeit, Fehlersignalen und Pipeline-Einbindung, damit Sie beide effektiv strukturieren können. 👇
Was ist API-Testing?
API-Testing prüft, ob Ihre Endpunkte die richtige Antwort für die richtige Anfrage zurückgeben, ohne über eine Benutzeroberfläche zu gehen. In der Praxis umfasst das Anfrage/Antwort-Verhalten, HTTP-Statuscodes, Datenformatgenauigkeit und Authentifizierungsabläufe über den gesamten Zyklus.
Praktisches Beispiel: Betrachten Sie eine mobile App, die Benutzerprofildaten von Ihrem Server anfordert. Ein API-Test bestätigt, dass die Anfrage die korrekte JSON-Struktur mit ordnungsgemäßer Authentifizierung innerhalb akzeptabler Zeitrahmen zurückgibt. Sie wird durch direkte HTTP-Aufrufe ausgewertet. Dieser Umfang ist wichtig, weil APIs Daten zwischen Frontend, Backend und externen Diensten transportieren. Ein einziger unzuverlässiger Endpunkt kann fehlgeschlagene Transaktionen verursachen oder Benutzer ohne Feedback auf einem Ladebildschirm warten lassen.
Test-Automatisierungstools ermöglichen Ihrem Team, eine Reihe von Szenarien abzudecken, von gültigen Anfragen und Grenzfällen mit fehlenden Parametern bis hin zu gleichzeitigen Lastbedingungen und Sicherheitslücken wie SQL-Injection. API-Testing testet die Kommunikationsebene, die Ihre Microservices und Integrationen zusammenhält.
Die Verwaltung von API- und Unit-Tests in einer wachsenden Codebasis wird schnell kompliziert. Testfälle häufen sich an und es wird schwieriger zu erkennen, welche Endpunkte und Funktionen in Ihrem System tatsächlich abgedeckt sind. aqua cloud, eine KI-gestützte Test- und Anforderungsmanagement-Plattform, hält beide Testebenen in einem einzigen Repository organisiert. Die vollständige Rückverfolgbarkeit zwischen Tests, Anforderungen und Ergebnissen ist gewährleistet. Der KI-Copilot der Plattform generiert kontextbezogene Testfälle für API- und Unit-Testing-Szenarien. Er wendet Grenzwertanalyse und Äquivalenzklassenbildung an, um die Abdeckung effizient aufzubauen. Nach internen Benchmarks von aqua spart dies bis zu 12,8 Stunden pro Tester wöchentlich. aqua integriert sich auch mit SoapUI für API-Validierung, Jira, Selenium und anderen Lösungen, sodass Ihr Team keine separaten Toolchains über beide Ebenen hinweg verwalten muss. Alles verbindet sich direkt mit Ihrer CI/CD-Pipeline und vorhandenen Testframeworks.
Steigern Sie Ihre QA-Effizienz um 80% mit der KI von aqua
Wichtige Methoden des API-Testings
- Funktionstests überprüfen, ob jeder Endpunkt für eine bestimmte Eingabe die erwartete Ausgabe erzeugt. Antwortschemas, Statuscodes und Datengenauigkeit werden gegen definierte Erwartungen bestätigt.
- Lasttests messen, wie Ihre Endpunkte unter gleichzeitigen Anfragen bestehen, und identifizieren Durchsatzgrenzen und Latenzerhöhungen, bevor Produktionsverkehr sie erreicht.
- Sicherheitstests überprüfen Endpunkte auf Schwachstellen wie fehlerhafte Authentifizierung, Datenexposition und Injektionsschwachstellen durch strukturierte Angriffssimulationen.
- Vertragstests bestätigen, dass Ihre APIs über Versionen hinweg abwärtskompatibel bleiben und erkennen breaking Changes, bevor sie nachgelagerte Konsumenten beeinflussen.
- Integrationstests überprüfen, ob mehrere Endpunkte korrekt funktionieren, wenn sie in realistischen Benutzer-Workflows verkettet werden, und decken Fehler auf, die bei Einzelendpunkttests nicht erkannt werden.
Vorteile und Herausforderungen des API-Testings
Vor allem passt API-Testing natürlich zu polyglotten Umgebungen, also Softwareprojekten, die mehrere Programmiersprachen mischen. Das funktioniert, weil Tests auf HTTP-Ebene ausgeführt werden, unabhängig von der Implementierungssprache. Auf diese Weise können Ihre Frontend- und Backend-Teams sie unabhängig vom jeweiligen Stack schreiben und ausführen. Ein weiterer praktischer Vorteil ist das Timing: Ihr Team kann API-Tests durchführen, bevor eine UI gebaut wird. Das bedeutet, dass Integrationsprobleme zwischen Diensten Wochen früher im Entwicklungszyklus gekennzeichnet werden. Da APIs vorhersehbar auf programmatische Anfragen reagieren, ist die automatisierte Datenvalidierung einfach zu konfigurieren und über Testläufe hinweg zu pflegen.
Wesentliche Vorteile in der Praxis:
- Sprachunabhängige Testausführung, nützlich über Ihre gemischten Technologiestacks hinweg.
- Frühes Integrationsfeedback, bevor die UI-Entwicklung beginnt.
- Vorhersehbare, automatisierbare Anfrage-/Antwortzyklen, die konsistente Regressionstests unterstützen.
- Klare Leistungsdaten, einschließlich Antwortzeiten und Durchsatzgrenzen, ohne GUI-Komplexität.
API-Testing bringt jedoch reale Kompromisse mit sich. Realistische Testszenarien erfordern oft spezifische Datenbankzustände, vorbereitete Testdaten und manchmal vollständige Umgebungsbereitstellung. Auth-Token-Management, d.h. das Generieren, Speichern, Verwenden und Invalidieren digitaler Token wie JWTs über Testfälle hinweg, fügt laufenden Wartungsaufwand hinzu. Veraltete API-Dokumentation verursacht häufig falsche Testerwartungen und verschwendete Debugging-Zyklen.
Spezifische Herausforderungen, die zu berücksichtigen sind:
- Umgebungseinrichtungskomplexität für datenabhängige Szenarien.
- Auth-Flow-Management über Testfälle hinweg.
- Dokumentationsdrift, die falsche Testerwartungen verursacht.
- Versionsverwaltungsaufwand über parallele API-Releases.
Wann sollte API-Testing durchgeführt werden?
- Nach der Implementierung oder Änderung von Endpunkten. Die Durchführung von Tests in dieser Phase erkennt Regressionen vor dem Code-Review, wenn Korrekturen am günstigsten sind.
- Während Integrationsphasen. Wenn Ihre Dienste miteinander oder mit Drittanbieter-APIs verbunden werden, bestätigen API-Tests, dass Verträge unter verschiedenen Bedingungen eingehalten werden.
- Bei jedem Merge in den Hauptzweig. In Ihrer CI-Pipeline funktionieren API-Tests gut als Merge-Gates und lösen eine automatisierte Suite aus, die Deployments blockiert, wenn kritische Endpunkte fehlschlagen.
- Vor größeren Releases. Lasttests gegen Staging-Umgebungen identifizieren Leistungseinbußen, bevor Ihre Benutzer darauf stoßen.
- Während Penetrationstestzyklen. Sicherheitsorientierte Tests profitieren von einem dedizierten API-Testdurchlauf, da Injektions- und Auth-Bypass-Probleme gezielte Szenarien erfordern, um aufgedeckt zu werden.
Gleichzeitig deckt Unit-Testing eine kleine Schicht in der Entwicklung ab. Das untersucht der nächste Abschnitt.
Was ist Unit-Testing?
Unit-Testing ist eine Entwicklungspraxis, die sich auf das Testen einzelner Funktionen, Methoden oder Klassen isoliert konzentriert.
Beim Unit-Testing werden Abhängigkeiten wie Datenbanken und externe APIs durch Mocks oder Stubs ersetzt, wodurch jeder Test auf die Logik beschränkt bleibt, für die er geschrieben wurde. Dadurch können Tests in Millisekunden ausgeführt werden und geben Ihrem Team nahezu sofortiges Feedback darüber, ob eine Codeänderung eine Regression eingeführt hat.
Praktisches Beispiel: Nehmen Sie eine Funktion, die Rabattprozentwerte für Treuemitglieder berechnet. Ein Unit-Test liefert Eingaben wie Mitgliedsstufe und Kaufbetrag und prüft dann, ob die Funktion korrekte Rabattwerte zurückgibt. Grenzfälle wie Null-Beträge, negative Zahlen und Null-Eingaben werden jeweils in separaten Szenarien behandelt. Die Funktion hat keine Verbindung zur Datenbank, die Mitgliedsdaten speichert, oder zum Dienst, der Produktpreise bereitstellt. Mock-Objekte ersetzen diese Abhängigkeiten, sodass der Test nur die Logik der Funktion bewertet. Das erwartete Ergebnis ist, dass bei einem Testfehler der Fehler direkt auf die fehlerhafte Funktion hinweist, was genau das Ziel ist.
Wichtige Methoden des Unit-Testings
- Zustandsverifizierung untersucht den resultierenden Zustand eines Objekts oder Rückgabewert, nachdem eine Methode ausgeführt wurde. Es ist die häufigste Form: Prüfen Sie, dass der Aufruf von
applyDiscount(user, cart) mit einem Gold-Tier-Mitglied einen Wert zurückgibt, der 20% niedriger ist als die Eingabesumme. Der Fokus liegt nur auf Ergebnissen, ohne Annahmen über die interne Implementierung.
- Verhaltensverifizierung verwendet Mock-Objekte, um zu bestätigen, dass bestimmte Mitarbeiter mit bestimmten Argumenten aufgerufen wurden. Dies gilt, wenn die zu testende Einheit Arbeit an eine Abhängigkeit delegiert, wie z.B. die Bestätigung, dass die
charge()-Methode eines Zahlungsdienstes genau einmal mit dem richtigen Betrag und der richtigen Währung aufgerufen wurde.
- Parametrisiertes Testen führt eine einzelne Testdefinition gegen eine Matrix von Eingaben und erwarteten Ausgaben aus. Es ist besonders effektiv für Grenzbedingungen, wie das Testen einer Rate-Limiting-Funktion über null, Schwellenwert-minus-eins, Schwellenwert und Schwellenwert-plus-eins Anfragen, ohne Testcode für jedes Szenario zu duplizieren.
- Testgetriebene Entwicklung (TDD) schreibt Tests, die vor der Implementierungsphase ausgeführt werden. Der Zyklus ist: Schreiben eines fehlschlagenden Tests, der das gewünschte Verhalten definiert, Schreiben des minimalen Codes, um ihn zu bestehen, dann Refaktorisierung. Code, der auf diese Weise geschrieben wird, neigt dazu, kleiner und modularer zu sein, weil Funktionen, die schwer isoliert zu testen sind, meist auch schwer zu warten sind.
- Mutationstests führen kleine, absichtliche Code-Mutationen ein, wie das Umkehren von
> zu >= oder das Entfernen eines bedingten Zweigs, und prüfen dann, ob Ihre bestehenden Tests sie erkennen. Eine Suite, die trotz Mutationen besteht, hat Lücken in ihren Assertions. Diese Technik quantifiziert, wie viel der Logik tatsächlich getestet wird.
Vorteile und Herausforderungen des Unit-Testings
Der unmittelbarste Vorteil des Unit-Testings für Ihr Testteam ist die Geschwindigkeit. Im Gegensatz zu vielen anderen QA-Verfahren werden Unit-Tests in Millisekunden ausgeführt, sodass Regressionssignale ohne Warten auf Builds oder Umgebungsbereitstellung erscheinen. Das macht es praktikabel, die gesamte Suite sowohl während der lokalen Entwicklung als auch in CI-Pipelines auszuführen. Eine gut gewartete Suite schützt auch vor der Wiedereinführung alter Defekte während der Featurearbeit, da jede Regression gegen ein zuvor getestetes Verhalten sichtbar fehlschlägt. Letztendlich reduzieren Tests, die das erwartete Softwareverhalten beschreiben, die Zeit, die benötigt wird, um unbekannten Code zu verstehen. Das ist besonders nützlich, wenn Ihr Team neue Ingenieure einarbeitet.
Wesentliche Vorteile in der Praxis:
- Ausführungszeit in Millisekunden, was kontinuierliches lokales Feedback während der Entwicklung ermöglicht.
- Persistenter Regressionsschutz über Refactorings und neue Feature-Arbeit hinweg.
- Ausführbare Dokumentation, die naturgemäß aktuell bleibt.
- Architektonischer Druck in Richtung besserer Trennung von Belangen und locker gekoppelter Komponenten.
Wartungskosten verdienen andererseits einen Posten in Ihrer Sprint-Planung. Tests koppeln sich an Implementierungsdetails, sodass interne Refactorings, die das externe Verhalten beibehalten, dennoch Test-Updates erfordern. Starke Mock-Nutzung kann Tests erzeugen, die trotz fehlerhaftem Integrationsverhalten bestehen, was irreführende Abdeckungsmetriken erzeugt. Das Schreiben gründlicher Tests braucht Zeit, und für komplexe Logik kann der Aufwand die anfängliche Entwicklungszeit ungefähr verdoppeln. Diese Kosten werden typischerweise durch reduziertes Debugging und Vorfallbehebung später wiedergewonnen.
Spezifische Herausforderungen, die zu planen sind:
- Implementierungskopplung bedeutet, dass Refactorings Test-Updates auslösen, auch wenn das Verhalten unverändert bleibt.
- Mock-lastige Suites können bestehen, während sie echte Integrationsfehler verbergen.
- Hohe Abdeckungsprozentsätze bestätigen nicht die systemweite Korrektheit.
- Die anfängliche Schreibzeit ist für komplexe Geschäftslogik erheblich.
Wann Unit-Testing durchführen?
Unit-Testing funktioniert am besten als kontinuierliche QA-Praxis. Mit anderen Worten, es sollte ein Teil der Testroutine zu allen Zeiten sein, wenn neue Funktionen entwickelt und zur Hinzufügung geplant werden. Ein lokaler Suite-Lauf vor jedem Commit verhindert offensichtliche Regressionen, die Ihre gemeinsamen Branches erreichen.
Das Beste an Unit-Tests ist, dass ihre Ausführungszeit diese Häufigkeit praktikabel macht. Wenn ein Fehler bestätigt wird, schreibt man einen fehlschlagenden Test, der ihn reproduziert, bevor man den Code korrigiert, wodurch der Defekt langfristig dokumentiert und überprüfbar bleibt. Während Refactoring-Sitzungen gibt kontinuierliches Testen Ihren Ingenieuren das Vertrauen, strukturelle Änderungen vorzunehmen, ohne Verhaltensregressionen einzuführen. Und das ist etwas, das Tech-Leads jederzeit gerne haben.
Unit-Tests testen spezifischen Code, sie nehmen an, dass Abhängigkeiten wie erwartet funktionieren. Abhängigkeiten werden daher gemockt, um sicherzustellen, dass Unit-Tests schnell (kein Netzwerk) und deterministisch laufen.
Unterschied zwischen API-Testing und Unit-Testing
Der Hauptunterschied zwischen API-Test vs Unit-Test liegt in Umfang und Geschwindigkeit. Unit-Tests testen einzelne Funktionen isoliert, während API-Tests vollständige Anfrage-/Antwortzyklen über Netzwerkgrenzen hinweg abdecken. Dieser Unterschied prägt, wo jeder in Ihren Workflow passt.
Unit-Testing:
- Testet einzelne Funktionen isoliert mit Mocks, um externe Abhängigkeiten zu eliminieren
- Läuft in Millisekunden ohne beteiligte I/O-Operationen
- Gibt Ihren Entwicklern sofortiges Feedback während des Codierens
API-Testing:
- Deckt vollständige Anfrage-/Antwortzyklen ab und prüft, wie Ihre Komponenten unter realistischen Bedingungen funktionieren
- Beinhaltet Netzwerkaufrufe, Datenbankabfragen und manchmal komplexe Authentifizierungsabläufe
- Dauert Sekunden oder Minuten, sodass umfassende Suites wegen der Ausführungskosten weniger häufig laufen
Wartungsmuster unterscheiden sich auch in einer Weise, die Ihre langfristige Planung beeinflusst:
- Unit-Tests brechen, wenn sich die interne Implementierung ändert, selbst wenn das externe Verhalten identisch bleibt. Ein Funktionsrefactoring, das die gleiche Ausgabe durch andere Logik erzeugt, erfordert dennoch Test-Updates.
- API-Tests bleiben stabil, solange Endpunktverträge konsistent bleiben, d.h. URLs, Anforderungsformate und Antwortschemas unverändert bleiben. Ein signifikantes Backend-Refactoring kann API-Tests bestehen lassen, während es umfassende Unit-Test-Updates in Ihrer Codebasis erfordert.
| Aspekt |
Unit-Testing |
API-Testing |
| Umfang |
Einzelne Funktionen/Methoden |
Endpunkt-Anfrage-/Antwortzyklen |
| Abhängigkeiten |
Gemockt oder gestubbt |
Echte oder simulierte Dienste |
| Ausführungsgeschwindigkeit |
Millisekunden pro Test |
Sekunden bis Minuten pro Suite |
| Fehlerlokalisierung |
Identifiziert exakte Funktion |
Identifiziert Integrations-Bruchstelle |
| Umgebungsanforderungen |
Minimal, läuft lokal |
Erfordert Testumgebung/Dienste |
| Teststabilität |
Bricht bei Implementierungsänderungen |
Stabil über Refactorings hinweg |
Für Ihr Team, wenn Sie API-Testing vs Unit-Testing vergleichen, weisen diese Unterschiede nicht auf einen Ansatz gegenüber dem anderen hin. Die praktische Frage zum Testen von API-Unit-Testing dreht sich um die Sequenzierung: Entscheiden, wann jeder Typ in Ihrer Pipeline läuft. Unit-Tests fangen Logikdefekte früh und kostengünstig ab. Gleichzeitig bestätigen API-Tests, dass Ihre Komponenten unter realistischen Bedingungen zusammenarbeiten und Fehlermodi abdecken, die Unit-Tests allein nicht erreichen.
Best Practices für effektives API- und Unit-Testing
Tests sollten so gestaltet sein, dass sie das meiste aus dem Budget herausholen - d.h., sie sollten möglichst viel Verhalten der Anwendung mit dem geringsten Aufwand an Zeit und Komplexität verifizieren. Jede Anwendung hat einen anderen Sweet Spot, und dort sollten die meisten Tests angesiedelt sein.
Die QA-Praxis zeigt, dass eine Teststrategie nur dann Bestand hat, wenn sie bei wachsender Codebasis gut wartbar bleibt. Im Folgenden finden Sie Praktiken, die sich in Produktionsumgebungen konsequent bewährt haben.
- Passen Sie den Testtyp an den Fehlermodus an. Logikfehler in einer Berechnungsfunktion gehören in einen Unit-Test. Ein fehlerhafter Authentifizierungs-Handshake zwischen zwei Ihrer Dienste gehört in einen API-Test. Nicht übereinstimmende Testtypen erzeugen Suiten, die teuer zu warten und unzuverlässig sind.
- Automatisieren Sie mit der richtigen Frequenz. Unit-Tests gehören zu jedem Commit. API-Smoke-Tests gehören zu jedem Merge in den Hauptzweig. Vollständige Regressions- und Lasttest-Suiten eignen sich besser für nächtliche Builds oder Pre-Release-Zyklen, wo langsamere Ausführung weniger störend für den Workflow Ihres Teams ist.
- Priorisieren Sie die Abdeckung nach Geschäftsrisiko. Ihre Authentifizierungsabläufe, Checkout-Prozesse und Kernendpunkte für den Datenabruf tragen mehr Risiko als selten genutzte Admin-Seiten. Die Konzentration der API-Testabdeckung auf Pfade mit hohem Verkehr und hohen Konsequenzen liefert mehr Wert pro Stunde Entwicklungszeit Ihres Teams als das Streben nach einheitlicher Abdeckung über die gesamte Codebasis.
- Schreiben Sie beschreibende Testnamen. Ein Test mit dem Namen
test_user_login_with_expired_token_returns_401 sagt Ihnen, was kaputt ist, ohne dass Sie überhaupt die Datei selbst prüfen müssen. Beschreibende Benennung gilt gleichermaßen für Unit- und API-Tests und ist am wichtigsten, wenn Ihr Team schnell Vorfälle diagnostiziert.
- Halten Sie Testdaten deterministisch. Randomisierte oder umgebungsabhängige Testdaten machen es Ihrem Team schwer, Fehler zu reproduzieren und zu debuggen. Versionierte, konsistente Datensätze erzeugen stabile Ergebnisse über Läufe und Umgebungen hinweg.
- Setzen Sie ein hartes Limit für die Ausführungszeit der Suite. Suiten, die 30 Minuten dauern, werden übersprungen. Die Parallelisierung von Tests und das Stubben teurer externer Aufrufe hält die Ausführungszeit niedrig genug, dass das Ausführen der Suite ein praktischer Teil Ihres täglichen Entwicklungsworkflows bleibt.
- Beheben Sie fehlschlagende Tests sofort. Ein Test, der tagelang im fehlgeschlagenen Zustand verbleibt, hört auf, als Signal zu funktionieren. Beheben Sie ihn umgehend oder entfernen Sie ihn, wenn er nicht mehr das aktuelle Verhalten in Ihrem System widerspiegelt.
Eine Testmanagement-Lösung hilft Ihrem Team, diese Struktur zu erhalten, wenn sowohl die Mitarbeiterzahl als auch die Testsuiten wachsen, und hält Unit- und API-Testergebnisse, Anforderungen und Abdeckungsdaten an einem Ort, um Tests, Anforderungen, Ergebnisse und CI/CD-Status gemeinsam zu verfolgen.
Die Abstimmung Ihrer API- und Unit-Tests mit sich ändernden Anforderungen ist der Punkt, an dem die meisten QA-Prozesse zu versagen beginnen. aqua cloud, eine KI-gestützte Test- und Anforderungsmanagement-Lösung, adressiert dies auf Workflow-Ebene. Es verfügt über ein einheitliches Test-Repository, das Testfälle mit Anforderungen verknüpft und die Abdeckung über beide Testtypen verfolgt. Wenn sich Anforderungen ändern, ist die Auswirkung auf Ihre bestehenden Tests sofort sichtbar. Teams, die sich mit der Frage des Unit-Testings vs API-Testings beschäftigen, stellen oft fest, dass das größere Problem die Sichtbarkeit ist: nicht zu wissen, wo Lücken existieren, bis etwas in der Produktion fehlschlägt. aquas anpassbare Dashboards zeigen den Abdeckungsstatus über alle Testebenen hinweg und helfen Ihrem Team, Schwachstellen vor der Freigabe zu identifizieren. Die SoapUI-Integration übernimmt das API-Testmanagement, während Unit-Testergebnisse in dieselbe Berichtsansicht einfließen. In Kombination mit über 12 Integrationen mit Tools wie Jira und Selenium gibt dies Ihren Entwicklungs- und Produktteams ein gemeinsames Bild der Systemqualität über alle Integrationspunkte hinweg.
Verbessern Sie die Sichtbarkeit über APIs und erreichen Sie 100% Unit-Test-Abdeckung
Fazit
Unit-Tests bestätigen, dass einzelne Funktionen wie beabsichtigt funktionieren, während API-Tests bestätigen, dass diese Funktionen korrekt kommunizieren, wenn sie zu einem funktionierenden System zusammengesetzt werden. Überspringen Sie eine dieser Ebenen, und eine Kategorie von Fehlern bleibt unentdeckt bis zur Produktion. Es wird empfohlen, mit einem risikoreichen Endpunkt und einer geschäftskritischen Funktion in Ihrer Codebasis zu beginnen. Fügen Sie dort zuerst Abdeckung hinzu, automatisieren Sie beide Ebenen und beheben Sie Fehler, wenn sie auftreten. Langfristig ist Konsistenz über Sprints hinweg wichtiger als perfekte Abdeckung.
Bankwesenaqua ALM hilft Banken, die Produktivität beim Testen um mehr als 50 % zu steigern
