• The KIPS Transactions:PartD
• /
• v.16D no.3
• /
• pp.371-380
• /
• 2009

Recently, lots of research on automated test data generation has been actively done. However, techniques for automated test data generation presented so far have been proved ineffective for programs with flag variables. It can present problems when considering embedded systems such as engine controllers that make extensive use of flag variables to record state information concerning devices. This paper introduces a technique for generating test data effectively for programs with flag variables. The presented technique transforms the test data generation problem into a SAT(SATisfiability) problem and makes advantage of SAT solvers for automated test data generation(ATDG). For the ends, we transform a program under test into Alloy which is the first-order relational logic and then produce test data via Alloy analyzer.

• The KIPS Transactions:PartD
• /
• v.14D no.2
• /
• pp.191-202
• /
• 2007

In general, test data generation techniques require the specification of an entire program path for automated test data generation. This paper presents a new way for generating test data automatically een without specifying a program path completely. For the ends, this paper presents a technique for transforming a program under test into Alloy which is the first order relational logic and then producing test data via Alloy analyzer. The proposed method reduces the burden of selecting a program path and also makes it easy to generate test data according to various test adequacy criteria. This paper illustrates the proposed method through simple, but illustrative examples.

• Journal of Internet Computing and Services
• /
• v.9 no.2
• /
• pp.89-105
• /
• 2008

So far, most of research on automated test data generation(ATDG) deals with programs without pointers. Recently, few works hove been done on ATDG in the presence of pointers, but they ore path-oriented techniques which require the specification of on entire program path to be tested or a program to be executed. This paper presents a new technique for generating test data even without specifying a program path completely. The presented technique is a static technique which transforms the test data generation problem into a SAT(SATisfiability) problem and makes advantage of SAT solvers for ATDG. For the ends, we transform a program under test into Alloy which is the first-order relational logic and then produce test data via Alloy analyzer.

• The KIPS Transactions:PartD
• /
• v.17D no.4
• /
• pp.297-310
• /
• 2010

Recently, a new testing technique called concolic testing receives lots of attention. Concolic testing generates test data by combining concrete program execution and symbolic execution to achieve high test coverage. CREST is a representative open-source test tool implementing concolic testing. Currently, however, CREST only deals with integer type as input. This paper presents a new rule for automated test data generation in presence of inputs of pointer type. The rules effectively handles multi-level stack-directed pointers that are mainly used in C programs. In addition, we describe a tool named vCREST implementing the proposed rules together with the results of applying the tool to some C programs.

• The Journal of the Korea Contents Association
• /
• v.12 no.11
• /
• pp.39-48
• /
• 2012

It is well known that software testing amounts for a significant portion of software development cost. In order to reduce the cost of software testing. a lot of researches on automated test data generation have been performed. Sophisticated tools for performing symbolic execution or solving a system of path constraints are required to support automated test data generation. Developing or purchasing those tools leads to another factor of increasing the cost involving software testing. In this paper, we propose a dynamic test data generation approach that does not depend on symbolic execution or constraint solving at all. The proposed approach extends Korel's path-oriented method to satisfy the branch coverage criterion effectively. We conducted an experiment to evaluate the effectiveness of the proposed technique with a triangle classification program to show that branch coverage can be easily achieved.

• Journal of KIISE:Software and Applications
• /
• v.31 no.10
• /
• pp.1304-1319
• /
• 2004

We can significantly reduce the cost o# program testing by automating the process of test data generation. Test data generation usually concerns identifying input values on which a selected path is executed. Although lots of research has been done so far, there still remains a lot of issues to be addressed. One of the issues is the shape problem. The shape problem refers to the problem of figuring out a shape of the input data structure required to cause the traversal of a given path. In this paper, we introduce a new method for the shape problem. The method converts the selected path into static single assignment (SSA) form without pointer dereferences. This allows us to consider each statement in the selected path as a constraint involving equality or inequality. We solve the constraints to get a solution which will be represented in terms of the points-to relations for each input variable. Simple, but illustrative examples are given to explain the proposed method.

• Journal of KIISE:Software and Applications
• /
• v.37 no.12
• /
• pp.882-891
• /
• 2010

Many automated dynamic test data generation technique have been proposed. The techniques evaluate fitness of test data through executing instrumented Software Under Test (SUT) and then generate new test data based on evaluated fitness values and optimization algorithms. Previous researches and experiments have been showed that these techniques generate effective test data. However, optimization algorithms in these techniques incur much time to generate test data, which results in huge test case generation cost. In this paper, we propose a technique for reducing the time of evaluating a fitness of test data among steps of dynamic test data generation methods. We introduce the concept of Fitness Evaluation Program (FEP), derived from a path constraint of SUT. We suggest a test data generation method based on FEP and implement a test generation tool, named ConGA. We also apply ConGA to generate test cases for C programs, and evaluate efficiency of the FEP-based test case generation technique. The experiments show that the proposed technique reduces 20% of test data generation time on average.

• The KIPS Transactions:PartD
• /
• v.16D no.6
• /
• pp.911-920
• /
• 2009

Airbone software must comply the DO-178B standard in order to be certified by the FAA. The standard requires the unit testing of safety-critical software to meet the coverage criterion called MC/DC(Modified Condition/Decision Coverage). Although MC/DC is known to be effective in finding errors related to safety, it is also true that generating test cases which satisfy the MC/DC criterion is not easy. This paper presents a tool named MD-SAT which generates MC/DC test cases with SAT(SATisfiability) technology. It can be employed for generating diverse test cases in tools implementing various testing techniques including decision table based test, cause-effect graphing, and state-based test.

• The Journal of the Institute of Internet, Broadcasting and Communication
• /
• v.12 no.2
• /
• pp.189-197
• /
• 2012

It is usual for test data generation to be performed using either high-level specifications or source codes written in high-level programming languages. In certain circumstances, however, such information is not always available. This paper presents a technique that generates test data based on executable object codes. The proposed technique makes use of a very simple function minimization technique without sophisticated object code analysis and produces test data dynamically. We have conducted a simple experiment to evaluate the effectiveness of the proposed test data generation technique with a triangle classification program to show that branch coverage can be easily achieved.

• KIPS Transactions on Software and Data Engineering
• /
• v.9 no.8
• /
• pp.229-234
• /
• 2020

This paper presents the design and the implementation of CRESTIVE-DX, a concolic testing tool that distribute the concolic testing process over the embedded target system and the host system for efficient test generation of a target embedded program. CRESTIVE-DX conducts the execution of a target program on the target embedded system to consider possible machine-dependent behaviors of a target program execution, and conducts machine-independent parts, such as search-strategy heuristics, constraint solving, on host systems with high-speed computation unit, and coordinates their concurrent executions. CRESTIVE-DX is implemented by extending an existing concolic testing tool for C programs CREST. We conducted experiments with a test bed that consists of an embedded target system in the Arm Cortex A54 architecture and host systems in the x86-64 architecture. The results of experiments with Unix utility programs Grep, Busybox Awk, and Busybox Ed show that test input generation of CRESTIVE-DX is 1.59 to 2.64 times faster than that of CREST.