Recent advances in test automation have seen a host of new techniques for automated test generation, which traditionally has largely been a manual and expensive process. These techniques have enabled generation of much larger numbers of tests at a much reduced cost. When executed successfully, these tests enable a significant increase in our confidence in the program's correctness. However, as our ability to generate greater numbers of tests increases, we are faced with the problem of the likely high cost of executing all the tests in terms of the total execution time. This thesis presents a novel approach - clustered test execution - to address this problem. Instead of executing each test case separately, we execute parts of several tests using a single execution, which then forks into several directions as the behaviors of the tests differ. Our insight is that in a large test suite, several tests are likely to have common initial execution segments, which do not have to be executed over and over again; rather such a segment could be executed once and the execution result shared across all those tests. As an enabling technology we use the Java PathFinder(JPF) model checker, which is a popular explicit-state model checker for Java programs. Experimental results show that our clustering approach for test execution using JPF provides speed-ups over executing each test in turn from a test suite on the JPF java virtual machine. / text

Java Pathfinder (JPF) is a tool to debug Java-based software running multiple threads or processes, with a textual output that be may hard to understand. Recent development introduced the possibility to generate a trace from JPF and visualize it in Trace Compass (TC), a general-purpose trace viewing application. Due to difficulties in maintaining and developing new features for TC, Theia Trace Viewer (TTV) has emerged as the replacement for TC. TTV is a browser-based trace viewer and makes it possible to visualize traces without any download or installation by the user. In this work, we migrate the existing functionality of JPF Trace from TC to TTV and conduct a user study on how TTV supports users analyzing JPF traces. Our results show that TTV is a good start and has great potential, but requires further development before replacing JPF results in textual format. / Java Pathfinder (JPF) är ett verktyg för att hitta fel i Javabaserad mjukvara som exekverar med flera trådar eller processer, där resultat skickas ut som text och kan vara svårt att förstå. Nyligen utvecklades möjligheten att generera ett spår och visualisera i Trace Compass (TC), ett program som kan visualisera olika typer av spårformat. På grund av svårigheter med att underhålla och utveckla nya funktioner för TC, så har Theia Trace Viewer (TTV) vuxit fram som ersättaren för TC. TTV är en webbläsare-baserad traceviewer, där det är möjligt att visualisera spår utan att användaren behöver ladda ner eller installera något. I detta arbete, migrerar vi den befintliga funktionaliteten för JPF Trace i TC till TTV och genomför en användarstudie för att ta reda på hur TTV hjälper användare analysera JPF spår. Vårat resultat visar att TTV är en bra början med god potential, men behöver utvecklas vidare innan det går att ersätta JPF resultat i textformat.

Multi-threading is commonly applied in modern computer programs, bringing many conveniences but also causing concurrency issues. Among the various error debugging tools, Java Pathfinder (JPF) can detect latent errors of multithreaded Java programs through model checking. However, the text-based format of the output trace is hard to read, and previous attempts in visualizing JPF traces show limitations. For long-term development, popular trace analytic platform such as Trace Compass (TC) is extended to adapt to JPF traces. In this thesis, the development of JPF and TC makes it possible to analyze JPF traces on TC with a user interface including visual diagrams. The development solves the conceptual differences between the tools and successfully visualize important trace data. The implementation can help provide a generic approach for analyzing JPF traces with visualization. / Multitrådning används ofta i moderna datorprogram, vilket har många fördelar men kan också orsaka samtidighetsproblem. Bland olika felsökningsverktyg kan Java Pathfinder (JPF) upptäcka latenta fel hos multitrådade Javaprogram genom modellkontroll. Spårningsinformationen i form av text har låg läsbarhet, och tidigare försök att visualsera JPF-spår har visat begränsningar. För långsiktig utveckling har populära spårningsanalysplattformar som Trace Compass (TC) utvidgats för att anpassas till JPF-spår. I examensprojektet gör utvecklingen av JPF och TC det möjligt att analysera JPF-spår på TC med ett användargränssnitt baserat på visuella diagram. Utvecklingen löser den konceptuella skillnaden mellan verktygen och visualiserar spårdata på ett framgångsrikt sätt. Implementeringen bidrar med ett generiskt tillvägagångssätt för att analysera JPF spår med hjälp av visualisering.

The aim of this work is to integrate Java PathFinder into Java Platform Debugger Architecture. That is, to allow using Java PathFinder instead of a common Java Virtual Machine for the purpose of debugging Java applications in any modern Java Integrated Development Environment with all its advantages such as various kinds of breakpoints, direct stepping in opened source files, and call stack and object inspection. The resulting work provides users with all the features they are used to while debugging Java applications. None of this requires any external tools, editors or a complicated setup. Therefore, users are able to view, debug and understand the program state while replaying an error trace in Java PathFinder. The key part of the study is an implementation of the Java Debug Wire Protocol Agent as an extension for Java PathFinder. That makes JPF more complete as a Virtual Machine in the eyes of the community and the Java users in general. Powered by TCPDF (www.tcpdf.org)

This thesis deals with the application of bounded model checking method for self-healing assurance of concurrency related problems. The self-healing is currently interested in the Java programming language. Therefore, it concetrate mainly on the model checker Java PathFinder which is built for handling Java programs. The verification method is implemented like the Record&Replay trace strategy for navigation through a state space and performance bounded model checking from reached state through the use of Record&Replay trace strategy. Java PathFinder was extended by new moduls and interfaces in order to perform the bounded model checking for self-healing assurance. Bounded model checking is applied at the neighbourhood of self-healing.