Model-Driven Co-Evolution of Contracts, Unit-Tests and Source-Code-Proposal for Master's Thesis – Advisors: Max Kramer, Michael Langhammer, Erik Burger Supervisors: Prof. Dr. Ralf Reussner, Jun.-Prof. Dr.-Ing. Anne Koziolek

Today software systems are composed from various artifacts, which have a specific purpose and describe only a part of the whole system from a particular perspective. Source code, unit tests and contracts can be such artifacts during the implementation phase. The latter formally specifies the source code and can enforce these specifications. These artifacts have some overlap such as the signatures of methods. This overlap must not be contradictory. Otherwise, the software system cannot be composed. Therefore, an approach for the co-evolution of these artifacts is necessary in order to keep them consistent after changes. Several approaches exist for keeping code, contracts and unit tests consistent after changes. These approaches only focus, however, on a very limited amount of possible changes and often the concept for applying them in an automated way is not publicly available. To our knowledge, no comprehensive approach exists for co-evolving all artifacts in an automated way. The contribution of this thesis is an approach for co-evolution of source code, unit tests and contracts. For Java code, JUnit tests and Java Markup Language (JML) contracts we analyze the overlapping information and define reactions on possible changes. We generalize the results for object-oriented languages and arbitrary specification languages afterwards. We implemented our approach for Java code and JML contracts with modeldriven techniques based on a synchronization framework. We transform the artifacts from code into models, apply corresponding reactions for the change and serialize the models into code again. These reactions can be quite simple or complex such as the reaction on a changed method: We determine whether the method body is side-effect free and add or remove the corresponding annotation of the contract for the method and all callers if required. Additionally we use an existing approach to monitor changes in Java code and apply the changes to the other artifacts automatically. This is fully transparent to users because they only receive consistent code artifacts after performing a change and do not need to know about models or the transformations. We evaluated our approach and our implementation with a case study focusing on the correct handling of changes in a real-world project. We showed that our approach is able to keep code and contracts consistent for 1036 out of 1085 rename refactorings (ca. 95 %) and that it can support co-evolution in the implementation phase.