Vishnu Yash Tripathi, Veer Bhadra, Pratap Singh · 2016
Computers have become a necessity in our everyday lives, and are used in a variety of systems, ranging from sophisticated ones to home appliances. Software plays an important role in many of these systems. As a result, the usage of software for a variety of purposes in different domains of modern life is rapidly increasing. With the advancements in technology, computers and in particular their software have become quite complex. Due to this reason, the correctness of software cannot be guaranteed, even by the programmer who has designed it. Since dependence on software is continuously increasing, one do not expect it to fail. However, software often contains errors. The severity of software errors can range from minor irritations to major economical losses or catastrophic situations. Software testing is one of the main activities to be carried out in the software development life cycle. It consumes more money and time, which leads to automation that reduces the human effort in finding bugs and errors. Automation in the last phase of system development is similar to manual testing. In both cases bugs are detected only after code has been complete. So rectifications and modification of the code takes lot of time. So testing process should be started from the beginning phase of software development life cycle and should continue till the last phase. For this it is proposed to generate test cases for object oriented software using UML diagrams
Cited by 0
Jasmine Minj · 2014
This paper presents automatic test case generation technique. Multi population genetic algorithm is used to generate test cases. Fitness function is based on the multiple condition decision coverage criteria. MATLAB Gatool is used for implementing the test case generation algorithm. It generates efficient and effective test cases. Test cases are optimized using multi population genetic algorithm. MCDC coverage is used as coverage criteria. Automatic test cases generation reduce the testing effort, time and cost.
Cited by 0
Da Costa Martínez, Juán Roberto · 2013
Cited by 0
Daniel Hoffman, C. Brealey · 1989
While considerable attention has been given to techniques for developing complex systems as collections of reliable and reusable modules, little is known about testing these modules. In the literature, the special problems of module testing have been largely ignored and few tools or techniques are available to the practicing tester. Without effective testing methods, the development and maintenance of reliable and reusable modules is difficult indeed.
Cited by 16
Mr. KLIKOVITS, Stefan · CERN Document Server (European Organization for Nuclear Research) · 2015
<!--HTML-->I would like to present the concept of automated test case generation. I work on it as part of my PhD and I think it would be interesting also for other people. It is also the topic of a workshop paper that I am introducing in Paris. (abstract below) Please note that the talk itself would be more general and not about the specifics of my PhD, but about the broad field of Automated Test Case Generation.\n\nI would introduce the main approaches (combinatorial testing, symbolic execution, adaptive random testing) and their advantages and problems. (oracle problem, combinatorial explosion, ...)\n\n\nAbstract of the paper:\n\nOver the last decade code-based test case generation techniques such as combinatorial testing or dynamic symbolic execution have seen growing research popularity. Most algorithms and tool implementations are based on finding assignments for input parameter values in order to maximise the execution branch coverage. Only few of them consider dependencies from outside the Code Under Test’s scope such as global variables, database values and subroutine calls as influences to the execution path. In order to fully test all possible scenarios these dependencies have to be taken into account for the test input generation. This paper introduces ITEC, a tool for automated test case generation to support execution environment resilience in large-scaled, complex systems. One of ITEC’s corner stones is a technique called semi-purification, a source code transformation technique to overcome limitations of existing tools and to set up the required system state for software testing.
Cited by 0
Daniel Hoffman, C. Brealey · ACM SIGSOFT Software Engineering Notes · 1989
While considerable attention has been given to techniques for developing complex systems as collections of reliable and reusable modules, little is known about testing these modules. In the literature, the special problems of module testing have been largely ignored and few tools or techniques are available to the practicing tester. Without effective testing methods, the development and maintenance of reliable and reusable modules is difficult indeed. We describe an approach for systematic module regression testing. Test cases are defined formally using a language based on module traces, and a software tool is used to automatically generate test programs that apply the cases. Techniques for test case generation in C and in Prolog are presented and illustrated in detail.
Cited by 22Open access
Costa Martínez, Juan Roberto Da · RiuNet (Politechnical University of Valencia) · 2013
Software testing is a hot topic in the software development industry as it demands a large \ninvestment of time and resources for creating and maintaining the test suite, and \npossibly for running it as well. One of the alternatives to manual test creation is modelbased \ntesting, which revolves around the idea of automating the test generation process \nbased on software models of the system under test. \nIn the present thesis project, we will generate test cases based on models, assess their \noverall coverage and apply different minimisation techniques to obtain a reduced test \nset. We will also compare the impact of the various minimisations and make an effort to \ndetermine what has been lost, in terms of fault detection capability, in the process with \nrespect to the complete test set
Cited by 0
Tsong Yueh Chen, Fei‐Ching Kuo, Zhi Quan Zhou · Figshare · 2006
Software testing is a major approach to software quality assurance, but it is relatively neglected in universities' computing curricula. For students majoring in computer science or software engineering, several basic testing methods need to be taught. These testing methods generate test cases based on either specifications or program code. When introducing the testing methods based on program code, it is not easy to let the students experience automated test case generation due to the lack of supporting tools and limited teaching hours. In this paper we report our experience in teaching this topic with limited resources. The evaluation result indicates that our teaching method is effective and can also be adopted in other computer science/software engineering subjects where similar constraints exist.
Cited by 3Open access
V. Vani · 2015
Cited by 0
Wenli Dong · 2009
Cited by 0
Paul t. Berning, Eric Anderson, Frank C. Belz · 1978
Abstract : This report discusses the overall design of a software tool for the automation of validation of compilers for conformance to the specification of the high-order programming language they process. Such compiler validation is currently tedious, time-consuming, error-prone, and not completely effective. The generation of test cases for compiler validation is here envisioned as a two-step process. The starting point for this implementation is the SEMANOL tool, which consists of a machine-representable exact specification of a high-order language that is used to check the consistency of the HOL specification and to directly execute programs written in that HOL. SEMANOL is used by the Analyzer to generate constraints to which compiler test cases must adhere. The Synthesizer then uses these constraints to generate the test cases via a tree-building process. Although a considerable degree of human intervention is still required in the development of compiler test programs when a tool such as the one designed under this effort is employed, a vast improvement in the process of compiler validation and verification expected to result.
Cited by 1
Batheja, Puneet · HAL (Le Centre pour la Communication Scientifique Directe) · 2011
International audience
Cited by 0Open access
Belinfante, A., Frantzen, L., Schallhart, C. · Radboud Repository (Radboud University) · 2005
Cited by 0
Chen, Tsong, Kuo, Fei-Ching, Zhou, Zhi Quan · Swinburne Research Bank (Swinburne University of Technology) · 2005
Software testing is a major approach to software quality assurance, but it is relatively neglected in universities' computing curricula. For students majoring in computer science or software engineering, several basic testing methods need to be taught. These testing methods generate test cases based on either specifications or program code. When introducing the testing methods based on program code, it is not easy to let the students experience automated test case generation due to the lack of supporting tools and limited teaching hours. In this paper we report our experience in teaching this topic with limited resources. The evaluation result indicates that our teaching method is effective and can also be adopted in other computer science/software engineering subjects where similar constraints exist.
Cited by 0Open access
Herbert Pesch, Peter Schnupp, Hans Schaller et al. · 1985
For the validation of the kernel system calls of a family of UNIX 1) systems a knowledge based test environment was conceived. A prototype version is currently implemented in Prolog. The knowledge base consists essentially of three parts: test case specifications of the various system calls,a test suite generator with predicates including information about UNIX system properties and sound test practices, anda test protocol archive including utilities to extract and prepare reports about the test results.All information in the knowledge base is stored as Horn clauses, i.e. facts and rules immediately to be consulted and executed by a Prolog interpreter.
Cited by 15
Lu Lu, Hua Yin · 2012
GUI (Graphical User Interface) testing is complex and inefficient in nowadays software testing. This paper proposed a framework for automated GUI test case generation. The framework includes a reverse engineering of executive GUI to create GUI information and event-flow model. According to these information and model, an ant colony algorithm is applied to generate test cases. Our study shows that by identifying valid event interactions, the generated test cases are capable of finding deep faults without infeasible problems, the configuration of different parameters for ant colony and the good design of our framework provide flexible interfaces to control test suites.
Cited by 4
Belinfante, A., Frantzen, L., Schallhart, C. et al. · Oxford University Research Archive (ORA) (University of Oxford) · 2004
System vendors focus more and more on the quality of a system instead of increasing functionality. Testing is the most viable and widely used technique to improve several quality aspects, accompanying the entire development cycle of a product. Motivated by the success of model-based software development and verification approaches, model-based testing has recently drawn attention of both theory and practice. System development tools reflect this tendency in many ways, automatic model-based generation of test suites has incipiently found its way into practice. TestComposer and AutoLink are the dominating design tools in the SDL community. The UTP serves the need for test support within UML-based software development, and Microsoft's AsmL is another example for the effort major companies make to benefit from the existing theory. But whatever theory is chosen as a basis, none of them can belie the dominating problem of system complexity. Even simple behavioral models like FSMs or LTSs can generally not be specified or exploited exhaustively. In that sense testing is always a David vs. Goliath struggle, even when pragmatical approaches were chosen. Nevertheless it is worth the effort of improving the theory w.r.t. practicability. Furthermore there are system criteria which are not treated satisfactorily yet, like real-time constraints or symbolic data, e.g. infinite data domains. Although automatic testing is still in the fledgling stages it can already be exerted successfully to improve the quality of real world systems. Further research is needed to improve and ease its application. It is a promising field where formal methods find their way into practice. © Springer-Verlag Berlin Heidelberg 2005.
Cited by 0
Nguyenh, Phat, ThoQuan · 2012
Cited by 0Open access
Anuranjan Misra · 2015
Abstract: Testing of aspect oriented programs is a new programming paradigm. Many researchers had contributed their research in the field of testing AOP. Mutation testing has been shown to be one of the strongest testing criteria for the evaluation of both programs and test suites. Comprehensive sets of mutants require strong test sets to achieve acceptable testing coverage. Moreover, mutation operators are valuable for the evaluation of other testing approaches. The effectiveness of mutation testing depends on finding fault types and designing of mutation operators on the basis of faults identified. Therefore the effectiveness of testing depends upon the quality of these mutation operators. We already have the mutation operators for procedural and object oriented languages, but for aspect oriented language only a few researchers have contributed. In this paper we will study in detail about the fault types and related mutation operators for AspectJ language. This paper also proposes the implementation framework to implement these mutation operators automatically.
Cited by 0
Pakinam N. Boghdady, Nagwa L. Badr, Mohamed Hashem et al. · 2013
Abstract — the software testing immensely depends on three main phases: test case generation, test execution, and test evaluation. Test case generation is the core of any testing process; however, those generated test cases still require test data to be executed which makes the test data generation not less important than the test case generation. This kept the researchers during the past decade occupied with automating those processes which played a tremendous role in reducing the time and effort spent during the testing process. This paper explores different approaches that had emerged during the past decade regarding the generation of test cases and test data from different models as an emerging type of model based testing. Unified Modeling Language UML models took the greatest share from among those models. Many researchers had paid a great attention to optimizing and reducing the test cases rather than generating them; light is shed on some of those approaches as well.
Cited by 0