German Title: Testen in sehr großen Softwareprojekten

Preview

PDF, English - main document Download (20MB) | Lizenz: Testing in Very Large Software Projects by Bach, Thomas underlies the terms of Creative Commons Attribution 4.0

Abstract

Testing is an important activity for software projects. However, testing requires effort and therefore creates so-called test costs. They consist of factors such as human effort for testing, or costs for required software and hardware. Test costs can contribute considerably to the total cost of a software project. Therefore, it is desirable to reduce test costs without affecting the quality of the software. With agile development processes and short test cycles, this aim is even more important.

Consequently, prior work propose a wide range of techniques for test cost reduction. However, while studying a very large industrial software project, we found that techniques proposed in related work can often not be applied for a project of such a size. We attribute this to problems that are only significant in large projects and may not be noticed in smaller projects.

The amount of test execution grows superlinearly over time in large projects. This superlinear increase cannot be sustainably solved by increases in hardware. Additionally, tests with long execution times have several negative consequences. A large number of changes and the long execution times of tests create a conflict that does not exist in smaller projects.

Therefore, approaches for test cost reduction must consider the specific characteristics of large projects. In our work, we tackle this challenge in multiple ways. We describe an approach to replace the superlinear increase in test executions with a linear increase by utilizing a multi-stage test strategy that provides economic incentives to decrease test costs. We also design an approach that extracts unit tests from system tests and utilizes the multi-stage test strategy to reduce test costs without reductions in quality. Our approach builds upon time-travel debugging and reverse-executes a system test to identify dependencies. We combine coverage-based differential analysis and source code analysis via a compiler plugin to enable accurate identification of the test core. Our approach extends previous work by creating maintainable source code instead of binary data and by focusing on the test core instead of extracting tests for all parts of the software.

In addition to our core contributions, we also provide two empirical studies that investigate the relationship between coverage data and faults. The first study investigates the distribution of bugs and coverage. The second study investigates Granger-causality between coverage and bugs.

Finally, as a byproduct of our core contributions, we provide approaches for automatically determining the creation of objects with complex dependencies, for automated mock recommendation, for combining combinatorial testing with coverage-based test amplification, for reductions of coverage data sizes, and we solve coverage-based algorithmic problems.

Translation of abstract (German)

Das Testen von Software ist ein wichtiger Bestandteil der Softwareentwicklung. Es erzeugt allerdings auch sogenannte Testkosten. Diese können Softwareprojekte erheblich teurer machen. Insbesondere in Zeiten von agiler Softwareentwicklung sind Testzyklen kürzer geworden und die Testkosten entsprechend gestiegen. Deshalb ist eine Testkostenreduktion wichtig.

Bei der Analyse eines sehr großen Softwareprojekts haben wir festgestellt, dass viele Ansätze aus der Literatur nicht für ein Projekt dieser Größe übertragbar sind. Die Größe des Projekts führt zu besonderen Herausforderungen, die in kleineren Projekten nicht auftreten oder ignoriert werden.

In großen Projekten wächst die Anzahl der Testausführungen superlinear über die Zeit. Dies ist nicht nachhaltig mit Investitionen in Hardware ausgleichbar. Weiterhin gibt es mehr Tests mit langen Ausführungszeiten. Die große Anzahl von Änderungen und die langen Testlaufzeiten in großen Projekten erzeugen einen Konflikt, der in kleinen Projekten nicht auftritt.

Ansätze für die Testkostenreduzierung müssen deshalb die Gegebenheiten von großen Projekten berücksichtigen. Wir erweitern den Stand der Forschung um mehrere solche Ansätze. Zur Evaluation nutzen wir große \Cpp Projekte, ein industrielles und mehrere Open-Source Projekte.

Wir stellen eine Methode vor zur Überführung des superlinearen Wachstums von Testausführungen in lineares Wachstum mittels einer mehrstufigen Teststrategie mit ökonomischen Anreizen für die Testkostenreduzierung.

Weiterhin konzipieren wir eine Technik welche unit tests von system tests extrahiert. Diese Technik kombinieren wir mit der mehrstufigen Teststrategie um eine Testkostenreduzierung ohne Qualitätsverluste zu ermöglichen. Unsere Technik nutzt time-travel debugging. Dabei werden system tests rückwärts ausgeführt um Abhängigkeiten zu identifizieren. Wir kombinieren Differentialanalyse auf Coveragedaten und Quelltextanalyse mithilfe eines Compilerplugins zur akkuraten Bestimmung des Testkerns. Im Vergleich zu vorherigen Arbeiten erzeugt unsere Technik unit tests mit wartbarem Quelltext statt Binärdaten und wir fokussieren uns bei der Extraktion auf den Testkern anstatt für die gesamte Testausführung unit tests zu erstellen.

Weiterhin präsentieren wir die Ergebnisse von zwei empirischen Studien. Die erste Studie untersucht die Verteilung von Bugs und Coverage. Die zweite Studie untersucht Granger-Kausalität zwischen Coverage und Bugs.

Schließlich stellen wir noch Methoden vor, um Objekte mit komplexen Abhängigkeitsgraphen zu erstellen, um Vorschläge für mocks von Objekten zu erstellen, zur Reduzierung der Größe von Coveragedaten, und wir lösen algorithmische Probleme im Zusammenhang mit Coveragedaten.