21 research outputs found
Black- and White-Box Self-testing COTS Components
Development of a software system from existing components can surely have various benefits, but can also entail a series of problems. One type of problems is caused by a limited exchange of information between the developer and user of a component, i.e. the developer of a componentbased system. A limited exchange of information cannot only require the testing by the user but it can also complicate
this tasks, since vital artifacts, source code in particular, might not be available. Self-testing components can be one response in such situation. This paper describes an enhancement of the Self-Testing COTS Components (STECC) Method so that an appropriately enabled component is not only capable of white-box testing its methods but also capable of black-box testing
Merging components and testing tools: The Self-Testing COTS Components (STECC) Strategy
Development of a software system from existing components can surely have various benefits, but can also entail a series of problems. One type of problems is caused by a limited exchange of information between the developer and user of a component. A limited exchange and thereby a lack of information can have various consequences, among them the requirement to test a component prior to its integration into a software system. A lack of information cannot only make test prior to integration necessary, it can also complicate this tasks. This paper proposes a new strategy to testing components and making components testable. The basic idea of the strategy is to merge components and testing tools in order to make components capable of testing their own methods. Such components allow their thorough testing without disclosing detailed information, such as source code. This strategy thereby fulfills the needs of both the developer and user of a component
Test Case Generation According to the Binary Search Strategy
One of the important tasks during software testing is the generation of test cases. Unfortunately, existing approaches to test case generation often have problems limiting their use. A problem of dynamic
test case generation approaches, for instance, is that a large number of iterations can be necessary to obtain test cases. This article introduces a formal framework for the application of the well-known search strategy of binary search in path-oriented test case generation and explains the binary search-based test case generation (BINTEST) algorithm
Advanced Approach for Effective Verification of Component Based Software Systems
The development of complex systems based on reusable
components has many advantages such as lower costs and shortened
development lifecycles. At the same time this innovative approach
continues to place significant challenges towards integration and testing
of such systems. The paper analyses the difficulties of components
testing and proposes a combination of Built-In-Testing, Aspect Oriented
Software Development, Test Driven Development and Test Governance
to realize a method for effective verification in component based
systems.The work presented in this paper was partially supported
by grants from the National Science Fund in Bulgaria under the MU-01-143
(ADEESS) project and the SISTER project, funded by the European Commission
in FP7-SP4 Capacities
BINTEST: Binary Search-based Test Case Generation
One of the important tasks during software testing is the generation of test cases. Various approaches have been proposed to automate this task. The approaches available, however, often have problems limiting their use. A problem of dynamic test case generation approaches, for instance, is that a large number of iterations can be necessary to obtain test cases. This article proposes a novel algorithm for
path-oriented test case generation based on binary search and describes a possible implementation
State of the art in testing components
The use of components in development of complex software systems can surely have various benefits. Their testing, however, is still one of the open issues in software engineering. Both the developer of a component and the developer of a system using components often face the problem that information vital for certain development tasks is not available. Such a lack of information has various consequences
to both. One of the important consequences is that it might not only obligate the developer of a system to test the components used, it might also complicate these tests. This article gives an overview of component testing approaches that explicitly respect a lack of information in development
Quality Assurance of Integrated Business Software: An Approach to Testing Software Product Lines
The use of integrated business software can be instrumental in reducing the difficulties occurring when various information systems have to be integrated. As a downside of this and due to the fact that these systems are designed to be used in all sorts of enterprises, the internal complexity of these systems increases exponentially. Software product lines on the one hand promise remedy by the conscious use of variability, on the other hand create new demands on quality assurance. The article on hand provides a theoretical framework for evaluating approaches to software testing, regarding their use in the development of software product lines. It turns out that only a practice-oriented approach emphasizing the buyer’s view will be successful in the end
Model-based integration testing technique using formal finite state behavioral models for component-based software
Many issues and challenges could be identified when considering integration testing of Component-Based Software Systems (CBSS). Consequently, several research have appeared in the literature, aimed at facilitating the integration testing of CBSS. Unfortunately, they suffer from a number of drawbacks and limitations such as difficulty of understanding and describing the behavior of integrated components, lack of effective formalism for test information, difficulty of analyzing and validating the integrated components, and exposing the components implementation by providing semi-formal models. Hence, these problems have made it in effective to test today’s modern complex CBSS. To address these problems, a model-based approach such as Model-Based Testing (MBT) tends to be a suitable mechanism and could be a potential solution to be applied in the context of integration testing of CBSS. Accordingly, this thesis presents a model-based integration testing technique for CBSS. Firstly, a method to extract the formal finite state behavioral models of integrated software components using Mealy machine models was developed. The extracted formal models were used to detect faulty interactions (integration bugs) or compositional problems between integrated components in the system. Based on the experimental results, the proposed method had significant impact in reducing the number of output queries required to extract the formal models of integrated software components and its performance was 50% better compared to the existing methods. Secondly, based on the extracted formal models, an effective model-based integration testing technique (MITT) for CBSS was developed. Finally, the effectiveness of the MITT was demonstrated by employing it in the air gourmet and elevator case studies, using three evaluation parameters. The experimental results showed that the MITT was effective and outperformed Shahbaz technique on the air gourmet and elevator case studies. In terms of learned components for air gourmet and elevator case studies respectively, the MITT results were better by 98.14% and 100%, output queries based on performance were 42.13% and 25.01%, and error detection capabilities were 70.62% and 75% for each of the case study
Quality Assurance of Software Applications Using the In Vivo Testing Approach
Software products released into the field typically have some number of residual defects that either were not detected or could not have been detected during testing. This may be the result of flaws in the test cases themselves, incorrect assumptions made during the creation of test cases, or the infeasibility of testing the sheer number of possible configurations for a complex system; these defects may also be due to application states that were not considered during lab testing, or corrupted states that could arise due to a security violation. One approach to this problem is to continue to test these applications even after deployment, in hopes of finding any remaining flaws. In this paper, we present a testing methodology we call in vivo testing, in which tests are continuously executed in the deployment environment. We also describe a type of test we call in vivo tests that are specifically designed for use with such an approach: these tests execute within the current state of the program (rather than by creating a clean slate) without affecting or altering that state from the perspective of the end-user. We discuss the approach and the prototype testing framework for Java applications called Invite. We also provide the results of case studies that demonstrate Invite's effectiveness and efficiency