Constraint-Based Automatic Test Data Generation
IEEE Transactions on Software Engineering
An experimental evaluation of selective mutation
ICSE '93 Proceedings of the 15th international conference on Software Engineering
The dynamic domain reduction procedure for test data generation
Software—Practice & Experience
Optimizing the Execution of Multiple Data Analysis Queries on Parallel and Distributed Environments
IEEE Transactions on Parallel and Distributed Systems
Is mutation an appropriate tool for testing experiments?
Proceedings of the 27th international conference on Software engineering
An AGENDA for testing relational database applications: Research Articles
Software Testing, Verification & Reliability
Information and Software Technology
Dynamic test input generation for database applications
Proceedings of the 2007 international symposium on Software testing and analysis
Weak Mutation Testing and Completeness of Test Sets
IEEE Transactions on Software Engineering
Proceedings of the twenty-second IEEE/ACM international conference on Automated software engineering
Query-based test generation for database applications
Proceedings of the 1st international workshop on Testing database systems
Optimizing multiple queries on scientific datasets with partial replicas
GRID '07 Proceedings of the 8th IEEE/ACM International Conference on Grid Computing
Test Case Generation by Contract Mutation in Spec#
Electronic Notes in Theoretical Computer Science (ENTCS)
Query-Aware Test Generation Using a Relational Constraint Solver
ASE '08 Proceedings of the 2008 23rd IEEE/ACM International Conference on Automated Software Engineering
Pex: white box test generation for .NET
TAP'08 Proceedings of the 2nd international conference on Tests and proofs
Dynamic symbolic database application testing
Proceedings of the Third International Workshop on Testing Database Systems
Full predicate coverage for testing SQL database queries
Software Testing, Verification & Reliability
MODA: automated test generation for database applications via mock objects
Proceedings of the IEEE/ACM international conference on Automated software engineering
Efficient Mutation Killers in Action
ICST '11 Proceedings of the 2011 Fourth IEEE International Conference on Software Testing, Verification and Validation
An Analysis and Survey of the Development of Mutation Testing
IEEE Transactions on Software Engineering
| Hi-index | 0.00 |
Database applications are built using two different programming language constructs: one that controls the behavior of the application, also referred to as the host language; and the other that allows the application to access/retrieve information from the backend database, also referred to as the query language. The interplay between these two languages makes testing of database applications a challenging process. Independent approaches have been developed to evaluate test case quality for host languages and query languages. Typically, the quality of test cases for the host language (e.g., Java) is evaluated on the basis of the number of lines, statements and blocks covered by the test cases. High quality test cases for host languages can be automatically generated using recently developed concolic testing techniques, which rely on manipulating and guiding the search of test cases based on carefully comparing the concrete and symbolic execution of the program written in the host language. Query language test case quality (e.g., SQL), on the other hand, is evaluated using mutation analysis, which is considered to be a stronger criterion for assessing quality. In this case, several mutants or variants of the original SQL query are generated and the quality is measured using a metric called mutation score. Higher mutation score indicates higher quality for the test cases. In this paper we present a framework, called ConSMutate, which guides concolic testing using mutation analysis for test case generation for database applications. The novelty of the framework is that it ensures that the test cases are of high quality not only in terms of coverage of code written in the host language, but also in terms of mutant detection of the queries written in the query language. We present a prototype implementation of our technique and show its advantages using two non-trivial case studies.