1,146 research outputs found
StubCoder: Automated Generation and Repair of Stub Code for Mock Objects
Mocking is an essential unit testing technique for isolating the class under
test (CUT) from its dependencies. Developers often leverage mocking frameworks
to develop stub code that specifies the behaviors of mock objects. However,
developing and maintaining stub code is labor-intensive and error-prone. In
this paper, we present StubCoder to automatically generate and repair stub code
for regression testing. StubCoder implements a novel evolutionary algorithm
that synthesizes test-passing stub code guided by the runtime behavior of test
cases. We evaluated our proposed approach on 59 test cases from 13 open-source
projects. Our evaluation results show that StubCoder can effectively generate
stub code for incomplete test cases without stub code and repair obsolete test
cases with broken stub code.Comment: This paper was accepted by the ACM Transactions on Software
Engineering and Methodology (TOSEM) in July 202
Model Based Synthesis of Control Software from System Level Formal Specifications
Many Embedded Systems are indeed Software Based Control Systems, that is
control systems whose controller consists of control software running on a
microcontroller device. This motivates investigation on Formal Model Based
Design approaches for automatic synthesis of embedded systems control software.
We present an algorithm, along with a tool QKS implementing it, that from a
formal model (as a Discrete Time Linear Hybrid System) of the controlled system
(plant), implementation specifications (that is, number of bits in the
Analog-to-Digital, AD, conversion) and System Level Formal Specifications (that
is, safety and liveness requirements for the closed loop system) returns
correct-by-construction control software that has a Worst Case Execution Time
(WCET) linear in the number of AD bits and meets the given specifications.
We show feasibility of our approach by presenting experimental results on
using it to synthesize control software for a buck DC-DC converter, a widely
used mixed-mode analog circuit, and for the inverted pendulum.Comment: Accepted for publication by ACM Transactions on Software Engineering
and Methodology (TOSEM
Test Case Purification for Improving Fault Localization
Finding and fixing bugs are time-consuming activities in software
development. Spectrum-based fault localization aims to identify the faulty
position in source code based on the execution trace of test cases. Failing
test cases and their assertions form test oracles for the failing behavior of
the system under analysis. In this paper, we propose a novel concept of
spectrum driven test case purification for improving fault localization. The
goal of test case purification is to separate existing test cases into small
fractions (called purified test cases) and to enhance the test oracles to
further localize faults. Combining with an original fault localization
technique (e.g., Tarantula), test case purification results in better ranking
the program statements. Our experiments on 1800 faults in six open-source Java
programs show that test case purification can effectively improve existing
fault localization techniques
On Wasted Contributions: Understanding the Dynamics of Contributor-Abandoned Pull Requests
Pull-based development has enabled numerous volunteers to contribute to
open-source projects with fewer barriers. Nevertheless, a considerable amount
of pull requests (PRs) with valid contributions are abandoned by their
contributors, wasting the effort and time put in by both the contributors and
maintainers. To better understand the underlying dynamics of
contributor-abandoned PRs, we conduct a mixed-methods study using both
quantitative and qualitative methods. We curate a dataset consisting of 265,325
PRs including 4,450 abandoned ones from ten popular and mature GitHub projects
and measure 16 features characterizing PRs, contributors, review processes, and
projects. Using statistical and machine learning techniques, we find that
complex PRs, novice contributors, and lengthy reviews have a higher probability
of abandonment and the rate of PR abandonment fluctuates alongside the
projects' maturity or workload. To identify why contributors abandon their PRs,
we also manually examine a random sample of 354 abandoned PRs. We observe that
the most frequent abandonment reasons are related to the obstacles faced by
contributors, followed by the hurdles imposed by maintainers during the review
process. Finally, we survey the top core maintainers of the studied projects to
understand their perspectives on dealing with PR abandonment and on our
findings.Comment: Manuscript accepted for publication in ACM Transactions on Software
Engineering and Methodology (TOSEM
Stress Testing Control Loops in Cyber-Physical Systems
Cyber-Physical Systems (CPSs) are often safety-critical and deployed in
uncertain environments. Identifying scenarios where CPSs do not comply with
requirements is fundamental but difficult due to the multidisciplinary nature
of CPSs. We investigate the testing of control-based CPSs, where control and
software engineers develop the software collaboratively. Control engineers make
design assumptions during system development to leverage control theory and
obtain guarantees on CPS behaviour. In the implemented system, however, such
assumptions are not always satisfied, and their falsification can lead to
guarantees loss. We define stress testing of control-based CPSs as generating
tests to falsify such design assumptions. We highlight different types of
assumptions, focusing on the use of linearised physics models. To generate
stress tests falsifying such assumptions, we leverage control theory to
qualitatively characterise the input space of a control-based CPS. We propose a
novel test parametrisation for control-based CPSs and use it with the input
space characterisation to develop a stress testing approach. We evaluate our
approach on three case study systems, including a drone, a continuous-current
motor (in five configurations), and an aircraft.Our results show the
effectiveness of the proposed testing approach in falsifying the design
assumptions and highlighting the causes of assumption violations.Comment: Accepted for publication in August 2023 on the ACM Transactions on
Software Engineering and Methodology (TOSEM
On the Reliability and Explainability of Language Models for Program Generation
Recent studies have adopted pre-trained language models, such as CodeT5 and
CodeGPT, for automated program generation tasks like code generation, repair,
and translation. Numerous language model-based approaches have been proposed
and evaluated on various benchmark datasets, demonstrating promising
performance. However, there is still uncertainty about the reliability of these
models, particularly their realistic ability to consistently transform code
sequences. This raises the question: are these techniques sufficiently
trustworthy for automated program generation? Consequently, Further research is
needed to understand model logic and assess reliability and explainability. To
bridge these research gaps, we conduct a thorough empirical study of eight
popular language models on five representative datasets to determine the
capabilities and limitations of automated program generation approaches. We
further employ advanced explainable AI approaches to highlight the tokens that
significantly contribute to the code transformation. We discover that
state-of-the-art approaches suffer from inappropriate performance evaluation
stemming from severe data duplication, causing over-optimistic results. Our
explainability analysis reveals that, in various experimental scenarios,
language models can recognize code grammar and structural information, but they
exhibit limited robustness to changes in input sequences. Overall, more
rigorous evaluation approaches and benchmarks are critical to enhance the
reliability and explainability of automated program generation moving forward.
Our findings provide important guidelines for this goal.Comment: Accepted by ACM Transactions on Software Engineering and Methodology
(TOSEM
A study of requirements engineering practices among software developers at UUM Information Technology (UUMIT)
Requirements Engineering (RE) is a systemic and integrated process of eliciting, elaborating, negotiating, validating and managing the requirements of a system in software development project. UUM has been supported by various systems in academic, administrative, students’ affair and many others. Most of the current systems are developed and maintained by the Information Technology Department (UUMIT). The aim of this study is to review the current requirements engineering practices and proposing requirements engineering practices during software development at UUMIT. The
outsourcing of software development is rapidly growing because of its allied benefits in the limited resources of the organizations. The main problem that is discussed in this research is the lack of studies that support software
development activities at the Information Technology department (UUMIT). The study used quantitative methodology and systematic literature review to answer research questions. The main significance of this study is helping
educational institutes to produce quality software development and saving cost and time by implementing requirements engineering practices. In addition to that, the study contributes to UUM by identifying the activity needed for software development so that the management is able to allocate budget to
provide adequate and precise training as well as seminars for the software developers. The researcher investigated three variables; Requirements Description, Requirements Development (Requirements Elicitation,
Requirements Analysis and Negotiation, Requirements Validation), and Requirement Management. The results from the survey showed that the current practice of requirement engineering in IT department of UUM is encouraging, but need for further development because most of RE practices associated with
requirement development and requirement management are achieved on a regular basis and not frequently. The researcher recommended providing effective training programs for UUMIT staffs on RE practices and increases their understanding on system requirements using RE practices to develop better systems for the university. Further investigation is required in the future to understand the effect of other RE practices on software developmen
Usage of call graph for representing software component interactions
A call graph is a ubiquitous representation in most aspect in software engineering.
This paper presents an initial proposed technique to represent components relationships in the form of a call graph.To support this study, this paper will cover types of component,a technique used to extract information of component integration,and a process of constructing a call graph,
in order to represents the relationship of the component in the software
- …