Software evolution is an important activity during a software development lifecycle. Understanding semantic differences between two versions of a software system is a crucial yet challenging task, especially in many safety critical sectors. Consequently, various techniques have been proposed to check semantic differences between a program and its evolution. But, many current techniques are still far from being satisfactory in terms of the accuracy and efficiency. In this article, we propose a novel framework, called US 2 E , which can efficiently and effectively generate the minimal number of test cases that reveal as many semantic differences across two versions as possible. Specifically, given a unified control flow graph that denotes two versions of a program, US 2 E executes as many common nodes as possible and leaves execution of non-common nodes separately in a single concolic execution instance. We evaluate US 2 E on 86 pairs of C programs from 4 benchmarks, and experimental results show that US 2 E can efficiently and effectively generate test cases demonstrating the semantic differences across 2 versions, with better performance than 6 baseline tools.

Autonomous driving has drawn great interest from both industry and academia. Due to some serious consequences such as loss of life caused by autonomous vehicles, assurance certification has been proposed in the automotive industry to ensure safe self-adaptive behaviors at run-time in autonomous cars. Central to assurance certification are assurance cases that provide compelling, comprehensive, and valid argument structures showing a system is safe in a given environment. However, many existing approaches generate assurance cases as a by-product of a system. In this paper, we will present a novel development paradigm that employs assurance cases to guide an autonomous vehicle to operate correctly and safely at run-time. Specifically, we consider an F1TENTH racing car as an example to illustrate how the assurance case driven paradigm can guide the vehicle to achieve safe and reliable self-adaptive behavior at run-time.

As one of the most popular software testing techniques, fuzzing can find a variety of weaknesses in a program, such as software bugs and vulnerabilities, by generating numerous test inputs. Due to its effectiveness, fuzzing is regarded as a valuable bug hunting method. In this paper, we present an overview of fuzzing that concentrates on its general process, as well as classifications, followed by detailed discussion of the key obstacles and some state-of-the-art technologies which aim to overcome or mitigate these obstacles. We further investigate and classify several widely used fuzzing tools. Our primary goal is to equip the stakeholder with a better understanding of fuzzing and the potential solutions for improving fuzzing methods in the spectrum of software testing and security. To inspire future research, we also predict some future directions with regard to fuzzing.

Model Driven Engineering (MDE) aims to expedite the software development process by providing support for transforming models to running systems. Many modeling tools provide forward engineering features, which automatically translate a model into a skeletal program that developers must complete. Inconsistencies between a design model and its implementation, however, can arise, particularly when a final implementation is developed dependently on the code from which it was generated. Manually checking that an implementation conforms to its model is a daunting task. Thus, an MDE tool that developers can use to check that implementations conform to their models can significantly improve a developer's productivity. This paper presents a model-based approach for testing whether or not an implementation satisfies the constraints imposed by its design model. Our model-based testing approach aims to efficiently reduce the test input space while supporting branch coverage criteria. To evaluate the approach's ability to uncover inconsistencies, we developed a prototypical tool and applied it to the Eclipse UML2 projects. We were able to uncover inconsistencies between the models and their implementations using the tool.

Many bug localization techniques rely on Text Retrieval (TR) models. The most successful approaches have been proven to be the ones combining TR techniques with static analysis, dynamic analysis, and/or software repositories information. Dynamic software analysis and software repositories mining bring a significant overhead, as they require instrumenting and executing the software, and analyzing large amounts of data, respectively. We propose a new static technique, named Lobster (Locating Bugs using Stack Traces and text Retrieval), which is meant to improve TR-based bug localization without the overhead associated with dynamic analysis and repository mining. Specifically, we use the stack traces submitted in a bug report to compute the similarity between their code elements and the source code of a software system. We combine the stack trace based similarity and the textual similarity provided by TR techniques to retrieve code elements relevant to bug reports. We empirically evaluated Lobster using 155 bug reports containing stack traces from 14 open source software systems. We used Lucene, an optimized version of VSM, as baseline of comparison. The results show that, in average, Lobster improves or maintains the effectiveness of Lucene-based bug localization in 82% of the cases.

Design a Safety critical system that satisfies all regulatory requirements is a challenging issue facing the software engineering community. In the medical systems industry, all medical devices must pass the FDA pre-market review before a new product can be deployed to the market because the FDA regulators need to ensure such new products are safe and reliable. Therefore, how to evaluate if a medical system satisfies all regulatory requirements becomes an important issue in the medical device industry. In this paper, we propose a novel profile which imposes the regulatory requirements for the generic insulin infusion pump (GIIP) example. This profile can be applied to different designs to aid the system designers in validating whether the specific design considers the regulatory requirements or not. The main contribution of our approach is that, we help the insulin infusion manufacturers to consider all the relevant regulatory requirements and also provide a mechanism for further validation. Once we deploy our profile to the industry, the insulin infusion pump manufacturers can validate whether their designs consider all the regulatory requirements. This is a fundamental step towards further validating whether a design satisfies the FDA regulatory requirements on the generic insulin infusion pump.

Design patterns have been widely accepted as a solution for solving recurring design problems in object-oriented development. Reifications of design patterns can vary from one development environment to another, and use of inappropriate reifications may impose a serious threat to quality of a software system. In this paper, we propose an approach to applying the profile mechanism in reifying a design pattern. Central to this approach are stereotypes that are defined in a profile and used to represent different roles in a design pattern. Developers can apply these stereotypes in their application model when design patterns are used. The advantage of the profile mechanism is that developers can 1) define their own reification of a pattern in a profile based on a specific software system, and 2) find errors in an application model via the conformance checking of the model against the profile. More importantly, we apply our existing tool called ICER, which is based on the profile mechanism, to provide automatic checking for the application of design patterns. To illustrate the advantage of the profile mechanism supported by ICER, we show the different reifications for the Observer pattern. Last, experimental results show that ICER does not suffer from the scalability problem as the size of an application model increases.

Compilers play an important role in software development, and it is quite necessary to perform abundant testing to ensure the correctness of compilers. A critical task in compiler testing is to validate the semantic-soundness property which requires consistence between semantics of source programs and behavior of target executables. For validating this property, one main challenging issue is generation of a test oracle. Most existing approaches fall into two main categories when dealing with this issue: reference-based approaches and assertion-based approaches. All these approaches have their weakness when new programming languages are involved or test automation is required. To overcome the weakness in the existing approaches, we propose a new automatic approach for testing compiler. Our approach is based on the technique of metamorphic testing, which validates software systems via so-called “metamorphic relations”. We select the equivalence-preservation relation as the metamorphic relation and propose an automatic metamorphic testing framework for compiler. We also propose three different techniques for automatically generating equivalent source programs as test inputs. Based on our approach, we developed a tool called Mettoc. Our mutation experiments show that Mettoc is effective to reveal compilers' errors in terms of the semantic-soundness property. Moreover, the empirical results also reveal that simple approaches for constructing test inputs are not weaker than complicated ones in terms of fault-detection capability. We also applied Mettoc in testing a number of open source compilers, and two real errors in GCC-4.4.3 and UCC-1.6 respectively have been detected by Mettoc.

In this paper, we study how to enforce the composition based on the Unified Modeling Language (UML 2.0) at the program level. We develop a novel technique for automatically detecting the inconsistency for composition between a class diagram and its implementation program using a software model checker. Specifically, given the attributes that are intended to implement composition in a UML class diagram, our approach checks the composition property in two steps. First, our approach systematically generates all valid object diagrams, i.e. valid input program states. Second, after a method to destroy the owner object is called on each object diagram, our approach checks whether all external links to the owned objects have been removed. Central to this approach is how to prune away the large search space that includes all valid input program states.

Today, programmers benefit immensely from Integrated Development Environments (IDEs), where errors are highlighted within seconds of their introduction. Yet, designers rarely benefit from such an instant feedback in modeling tools. This paper focuses on the refinement of UML-style class models with instant feedback on correctness. Following the Model-Driven Architecture (MDA) paradigm, we strongly believe in the benefit of maintaining high-level and low-level models separately to 1) document the lower level model and 2) continuously ensure the correctness of the low-level model during later evolution (i.e., high- or low-level models may be evolved independently). However, currently the refinement and subsequent evolution lack automated support, let alone an instant feedback on their correctness (i.e., consistency). Traditional approaches to consistency checking fail here because of the computational cost of comparing class models. Our proposed instant approach first transforms the low-level model into an intermediate model that is then easier comparable with the high-level model. The key to computational scalability is the separation of transformation and comparison so that each can react optimally to changes-changes that could happen concurrently in both the high- and low-level class models. We evaluate our approach on eight third-party design models. The empirical data show that the separation of transformation and comparison results in a 6 to 11-fold performance gain and a ninefold reduction in producing irrelevant feedback. While this work emphasizes the refinement of class models, we do believe that the concepts are more generally applicable to other kinds of modeling languages, where transformation and subsequent comparison are computationally expensive.

An aspect-oriented design model is composed of a primary design model and an aspect model, each of which has a different origin and pursues different goals. How to ensure the correctness of the composition of a primary design model and an aspect model has become an important issue. In this paper, we validate an aspect-oriented design model using the UML profile extension mechanism. With this mechanism, engineers can utilize the ICER tool to find errors in an aspect-oriented design model using the instance-of relationship. Moreover, the profile extension mechanism also provides engineers with an ability to introduce their own validation of an aspect-oriented design model. This flexibility allows engineers to express the special requirements in a particular development environment. We also illustrate how ICER can find errors in a real aspect-oriented design model composed by the UML metamodel and a creation aspect model.

The gap between UML class models and their implementations impedes program understanding and analysis, and is a source of program errors. Although many reverse engineering techniques were proposed to bridge this gap, two major problems still exist. First, the accuracy of association inference from container classes is not adequate without considering iterators. Second, associations implemented by inherited fields are missed by existing techniques. In this paper, we present an approach to precisely and automatically recover a class model from Java byte code. Our approach tackles the above problems and improves the accuracy of the recovered models. The preliminary empirical results show that our approach achieved a higher accuracy for association inference than existing reverse engineering tools.

With modern software development being a complicated process, refinement has become an inevitable step in software development. To date, however, supporting a refinement process during software development has not received much attention in the research community. In this paper we present a tool which can support class diagram refinement based on a set of proposed rules, each of which is represented by a class diagram together with an object constraint language (OCL) constraint. By applying our existing tool supporting the metadata architecture, a new tool helping software developers find some discrepancies between two class diagrams during software refinement can be generated. A Web-based online learning system is illustrated in this paper to show how the tool can be applied to find discrepancies between the two models at two different levels.

UML has become a standard language for designing software systems. To help software developers design a correct UML model for a software system has become an important goal for many UML CASE tools. We propose a new UML virtual machine based on abstract state machines. We combine the UML meta-model, UML model and user objects model into one under the ASM virtual machine for UML. Since the ASM virtual machine for UML supports OCL, software developers can precisely design a software model and then find some errors such as inconsistency in the model with the help of the ASM virtual machine.

The Unified Modeling Language has become widely accepted as a standard in software development. Several tools have been produced to support UML model validation. However most of them support either static or dynamic model checking; and no tools support to check both static and dynamic aspects of a UML model. But a UML model should include the static and dynamic aspects of a software system. Furthermore, these UML tools translate a UML model into a validation language such as PROMELA. But they have some shortcomings: there is no proof of correctness (with respect to the UML semantics) for these tools. In order to overcome these shortcomings, we present a toolset which can validate both static and dynamic aspects of a model; and this toolset is based on the semantic model using Abstract State Machines. Since the toolset is derived from the semantic model, the toolset is correct with respect to the semantic model.

The Unified Modeling Language has become widely accepted as a standard in software development. Several tools have been produced to support UML model validation. These tools translate a UML model into a validation language such as PROMELA. However they have some shortcomings: there is no proof of correctness (with respect to the UML semantics) for these tools; and there is no tool that supports validation for both the static and dynamic aspects of a UML model. In order to overcome these shortcomings, we present a toolset which is based on the semantic model using abstract state machines. Since the toolset is derived from the semantic model, the toolset is correct with respect to the semantic model. In addition, this toolset can be used to validate both the static and dynamic aspects of a model.