Digital Library[ Search Result ]
An Empirical Study of MISRA-C Related Source Code Changes in Open-source Software Projects
Suhyun Park, Jaechang Nam, Shin Hong
http://doi.org/10.5626/JOK.2024.51.8.718
This paper presents empirical studies on 75 open-source projects hosted on GitHub to explore how source code changes align with MISRA C coding guidelines. Through our analysis of the studied projects, we have identified eight distinctive keywords that represent the software domains where compliance with MISRA C coding guidelines is likely to be found. Additionally, we discovered that 54.75% of the studied projects utilizes at least one static rule checker. In the 75 studied projects, we found code changes associated with 75 MISRA C coding rules. The analyses of these code changes reveal that multiple MISRA C-related code changes often occur in a short timeframe, and, on average, each MISRA C-related code change modifies 1124 lines of code at once.
Bounded Search Strategies of Concolic Testing for Effective and Efficient Structural Coverage Achievement
http://doi.org/10.5626/JOK.2021.48.2.201
This paper proposes a loop-bounded search strategy for effective and efficient coverage achievement in concolic testing. In selecting a new path to explore, a loop-bounded search strategy limits the number of iterations in a loop to a certain loop-bound, so that the concolic testing is guided to explore various program behaviors within a limited range. In addition, to extend the range of path exploration gradually, this search strategy increments the loop-bound over test executions based on their coverage achievement rates. We implemented three versions of loop-bounded search strategies based on three existing concolic search strategies of CREST. The experiments with 4 real-world target programs (Vim, Grep, Busybox Awk, and Busybox Sed) showed that CREST achieves a higher branch coverage more quickly when the loop-bounded search strategies are applied.
Improving Mutation-Based Fault Localization for Better Locating Omission Faults Using Coverage Change Information
http://doi.org/10.5626/JOK.2020.47.9.863
Although omission faults are bugs commonly found in real-world programs, existing mutation-based fault localization techniques show low accuracy at locating omission faults because useful mutants are not likely generated at locations where necessary statements are missed. This paper introduces two new techniques, MUSEUM+ and Metallaxis+, an extension of two mutationbased fault localization techniques, MUSEUM and Metallaxis, by adding elements that link the change of coverage information and the change of test results. The proposed MBFL techniques additionally utilize coverage change information to consider the characteristics of omission faults. The experiment with the 16 JFreeChart faults in Defects4J, including 10 omission faults and 6 non-omission faults demonstrate that the presented techniques, MUSEUM+ and Metallaxis+, show improved faults localization accuracy.
Categories and Patterns of Java Program Unit Test Code Bugs
http://doi.org/10.5626/JOK.2019.46.4.341
Since unit testing is widely used in many software projects, the threat of unit test bugs(i.e., bugs in the test case code) is becoming a more important issue of software quality assurance. Test code bugs are critical threats because they may invalidate the quality assurance process, which consequently hurts quality of products and performance of the project. This paper presents a set of test bug categories and a set of bug patterns extracted from real-world cases. Unlike the existing work on test code bugs, this paper suggests a classification method to systematically categorize different features of test code bugs (i.e., structures, operations, and requirements). In addition, this paper defines eight new bug patterns in unit test code, based on previous bug reports from well-known open-source projects. Each pattern is formally specified as source code patterns so that it can be used for to construct a static bug pattern checker.
Mutagen4J : Effective Mutant Generation Tool for Java Programs
Yiru Jeon, Yunho Kim, Shin Hong, Moonzoo Kim
Mutation analysis (or software mutation analysis) generates variants of a target program by injecting systematic code changes to the target program, and utilizes the variants to analyze the target program behaviors. Effective mutation analyses require adequate mutation operators that generate diverse variants for use in the analysis. However, the current mutation analysis tools for Java programs have limitations, since they support only limited types of mutation operators and do not support recent language features such as Java8. In this study, we present Mutagen4J, a new mutant generation tool for Java programs. Mutagen4J additionally supports mutation operators recently shown to generate various mutants and fully supports recent Java language features. The experimental results show that Mutagen4J generates useful mutants for analyses 2.3 times more than the existing Java mutation tools used for the study.
Search
Journal of KIISE
- ISSN : 2383-630X(Print)
- ISSN : 2383-6296(Electronic)
- KCI Accredited Journal
Editorial Office
- Tel. +82-2-588-9240
- Fax. +82-2-521-1352
- E-mail. chwoo@kiise.or.kr