APPLYING CONVENTIONAL UNIT TESTING TECHNIQUES TO ABSTRACT DATA TYPE OPERATIONS

1994 ◽  
Vol 04 (01) ◽  
pp. 103-122 ◽  
Author(s):  
ALLEN PARRISH ◽  
DAVID CORDES
Keyword(s):  
Building Blocks ◽  
Abstract Data Type ◽  
Test Case ◽  
Test Cases ◽  
Unit Testing ◽  
Data Types ◽  
Abstract Data ◽  
Testing Techniques ◽  
Single Data ◽  
Case Design

Abstract data types (ADTs) represent the fundamental building blocks of object-oriented software development. There have been a variety of techniques in the literature for testing ADT modules. Virtually all of the proposed techniques have involved testing sequences of ADT operations (e.g., for a stack ADT, test the sequence PUSH; PUSH; POP) to discover defects in their interactions. However, the operations inside an ADT module are really nothing more than conventional procedures and functions. Consequently, it is conceivable that conventional subprogram unit testing techniques can be adapted to test ADT operations. To support such testing techniques, test cases are best designed and expressed in terms of data values. When test cases are integers, for example, expressing a test case is trivial (e.g., ‘253’). However, when test cases are data abstractions (such as stacks), this problem is much more difficult due to the variety of different formats in which a single data abstraction can be legitimately viewed. In this paper, we provide a conceptual framework for applying classical white-box and black-box unit testing techniques to ADT operations. We then use this framework to develop a collection of guidelines for determining the best format for test case design, given different module characteristics and testing techniques.

scholarly journals Automated Search-Based Robustness Testing for Autonomous Vehicle Software

2016 ◽  
Vol 2016 ◽  
pp. 1-15 ◽  
Author(s):  
Kevin M. Betts ◽  
Mikel D. Petty
Keyword(s):  
Monte Carlo ◽  
Performance Metrics ◽  
Initial Conditions ◽  
Autonomous Vehicle ◽  
Vehicle Control ◽  
Test Case ◽  
Test Cases ◽  
Control Software ◽  
Robustness Testing ◽  
Testing Techniques

Autonomous systems must successfully operate in complex time-varying spatial environments even when dealing with system faults that may occur during a mission. Consequently, evaluating the robustness, or ability to operate correctly under unexpected conditions, of autonomous vehicle control software is an increasingly important issue in software testing. New methods to automatically generate test cases for robustness testing of autonomous vehicle control software in closed-loop simulation are needed. Search-based testing techniques were used to automatically generate test cases, consisting of initial conditions and fault sequences, intended to challenge the control software more than test cases generated using current methods. Two different search-based testing methods, genetic algorithms and surrogate-based optimization, were used to generate test cases for a simulated unmanned aerial vehicle attempting to fly through an entryway. The effectiveness of the search-based methods in generating challenging test cases was compared to both a truth reference (full combinatorial testing) and the method most commonly used today (Monte Carlo testing). The search-based testing techniques demonstrated better performance than Monte Carlo testing for both of the test case generation performance metrics: (1) finding the single most challenging test case and (2) finding the set of fifty test cases with the highest mean degree of challenge.

THE C++ EMBEDDABLE RULE SYSTEM

1993 ◽  
Vol 02 (01) ◽  
pp. 33-46 ◽  
Author(s):  
DANIEL P. MIRANKER ◽  
FREDERIC H. BURKE ◽  
JERI J. STEELE ◽  
JOHN KOLTS ◽  
DAVID R. HAUG
Keyword(s):  
Data Type ◽  
Third Party ◽  
Abstract Data Type ◽  
Data Types ◽  
Forward Chaining ◽  
Abstract Data ◽  
Data Objects ◽  
Rule System

Most the execution environments, having been derived from LISP, inference on internally defined data-types and come packaged with stand-alone development environments. Data derived from outside these systems must be reformatted before it can be evaluated. This mismatch leads to a duplicate representation of data, which, in turn, introduces both performance and semantic problems. This paper describes a C++ Embeddable Rule System (CERS) which avoids this mismatch. CERS is a compiled, forward-chaining rule system that inferences directly on arbitrary C++ objects. CERS can be viewed as an extension of C++, where the methods associated with a ruleset class can be defined either procedurally or declaratively. CERS is unique in that rules may match against and manipulate arbitrary, user-defined C++ objects. There is no requirement that the developer anticipated using CERS when defining the class. Thus CERS rules can inference over data objects instantiated in persistent object stores and third-party. C++ abstract data-type libraries.

The Test Case Design of the Failure Mode Judgment Software

2013 ◽  
Vol 380-384 ◽  
pp. 2403-2406
Author(s):  
Wen Hong Liu ◽  
Xin Wu
Keyword(s):  
Failure Mode ◽  
Fault Tree ◽  
Fault Analysis ◽  
Design Tool ◽  
Test Case ◽  
Test Cases ◽  
Black Box Testing ◽  
Software Fault ◽  
Testing Standards ◽  
Case Design

Failure mode judgment software is widely used in the security control system, it always has higher safety critical level than other softwares. Therefore the testing standards for such software must also be improved. In order to solve the problem of the black box testing for such software, this paper establishment the software fault tree based on the software fault analysis, and use the software fault tree as a test case design tree, then design the test case after obtained the minimal cut sets. Meanwhile, this paper establish the test case design tree for the failure mode misjudgment, and use it as the basis in designing the failure mode misjudgment test cases. We developed the test case assisted design tool based on these methods, and successfully use it in the software testing of the escape software.

SOFTWARE TESTING TECHNIQUES AND PRINCIPLES

2018 ◽  
Vol 28 (4) ◽  
pp. 1383-1387
Author(s):  
Burim Rexhepi ◽  
Ali Rexhepi
Keyword(s):  
Software Testing ◽  
Performance Testing ◽  
Software Test ◽  
Acceptance Testing ◽  
Test Case ◽  
Unit Testing ◽  
Security Testing ◽  
Road Map ◽  
Testing Strategies ◽  
Testing Techniques

This paper describes Software testing, need for software testing, Software testing goals and principles. Further it describe about different Software testing techniques and different software testing strategies. Finally it describes the difference between software testing and debugging.To perform testing effectively and efficiently, everyone involved with testing should be familiar with basic software testing goals, principles, limitations and concepts.We further explains different Software testing techniques such as Correctness testing, Performance testing, Reliability testing, Security testing. Further we have discussed the basic principles of black box testing, white box testing and gray box testing. We have surveyed some of the strategies supporting these paradigms, and have discussed their pros and cons. We also describes about different software testing strategies such as unit testing, Integration testing, acceptance testing and system testing.Finally there is comparison between debugging and testing. Testing is more than just debugging .Testing is not only used to locate defects and correct them it is also used in validation, verification process and measurement. A strategy for software Testing integrates software test case design methods into a well planned Series of steps that result in successful Construction of software that result in successful construction of software. Software testing Strategies gives the road map for testing. A software testing Strategy should be flexible enough to promote a customized testing approach at same time it must be right enough. Strategy is generally developed by project managers, software engineer and testing specialist. Software testing is an extremely creative and intellectually challenging task. When testing follows the principles given below, the creative element of test design and execution rivals any of the preceding software development steps, because testing requires high creativity and responsibility only the best personnel must be assigned to design, implement, and analyze test cases, test data and test results.

ComboRT: A New Approach for Generating Regression Test Cases for Evolving Programs

2016 ◽  
Vol 26 (06) ◽  
pp. 1001-1026 ◽  
Author(s):  
Xiaobing Sun ◽  
Xin Peng ◽  
Hareton Leung ◽  
Bin Li
Keyword(s):  
Impact Factor ◽  
Regression Testing ◽  
Software Systems ◽  
Test Case ◽  
Test Cases ◽  
Test Case Selection ◽  
Case Selection ◽  
Testing Techniques ◽  
The Impact ◽  
Ranked List

Regression testing is essential to ensure software quality during software evolution. Two widely-used regression testing techniques, test case selection and prioritization, are used to maximize the value of the continuously enlarging test suite. However, few works consider both these two techniques together, which decreases the usefulness of the independently studied techniques in practice. In the presence of changes during program evolution, regression testing is usually conducted by selecting the test cases that cover the impact results of the changes. It seldom considers the false-positives in the information covered. Hence, the effectiveness of such regression testing techniques is decreased. In this paper, we propose an approach, ComboRT, which combines test case selection and prioritization together to directly generate a ranked list of test cases. It is based on the impact results predicted by the change impact analysis (CIA) technique, FCA–CIA, which generates a ranked list of impacted methods. Test cases which cover these impacted methods are included in the new test suite. As each method predicted by FCA–CIA is assigned with an impact factor value corresponding to the probability of this method to be impacted, test cases are then ordered according to the impact factor values of the impacted methods. Empirical studies on four Java based software systems demonstrate that ComboRT can be effectively used for regression testing in object-oriented Java-based software systems during their evolution.

On lists and other abstract data types in the calculus of constructions

2000 ◽  
Vol 10 (2) ◽  
pp. 261-276 ◽  
Author(s):  
JONATHAN P. SELDIN
Keyword(s):  
Data Type ◽  
Abstract Data Type ◽  
Abstract Data Types ◽  
Natural Numbers ◽  
Data Types ◽  
Induction Principle ◽  
Calculus Of Constructions ◽  
Abstract Data ◽  
Definition Of ◽  
Future Work

The representation of the inductively defined abstract data type for lists was left incomplete in Seldin (1997, Section 9). Here that representation is completed, and it is proved that all extra axioms needed are consistent. Among the innovations of this paper is a definition of cdr, whose definition was left for future work in Seldin (1997, Section 9). The results are then extended to other abstract data types – those of Berardi (1993). The method used to define cdr for lists is extended to obtain the definition of an inverse for each argument of each constructor of an abstract data type. These inverses are used to prove the injective property for the constructors. Also, Dedekind's method of defining the natural numbers is used to define a predicate associated with each abstract data type, and the use of this predicate makes it unnecessary to postulate the induction principle. The only axioms left to be proved are those asserting the disjointness of the co-domains of different constructors, and it is shown that those axioms can be proved consistent.

On the Power of Model Theory in Specifying Abstract Data Types and in Capturing Their Recursiveness

1983 ◽  
Vol 6 (2) ◽  
pp. 127-170
Author(s):  
Alberto Bertoni ◽  
Giancarlo Mauri ◽  
Pierangelo Miglioli
Keyword(s):  
Model Theory ◽  
Point Of View ◽  
Necessary Condition ◽  
Abstract Data Type ◽  
Abstract Data Types ◽  
Data Types ◽  
Abstract Data ◽  
Definition Of ◽  
Recursive Data ◽  
Better Than

In this paper a comparative analysis of some algebraic and model-theoretic tools to specify abstract data types is presented: our aim is to show that, in order to capture a quite relevant feature such as the recursiveness of abstract data types, Model Theory works better than Category Theory. To do so, we analyze various notions such as “initiality”, “finality”, “monoinitiality”, “epifinality”, “weak monoinitiality” and “weak epifinality”, both from the point of view of “abstractness” and of “cardinality”, in a general model theoretical frame. For the second aspect, it is shown that only “initiality”, “monoinitiality”, “epifinality” and “weak epifinality” allow us to select countable models (for theories with a countable language), a necessary condition to get recursive data types, while this is not the case for “finality” and “weak monoinitiality”. An extensive analysis is then devoted to the problem of the recursiveness of abstract data types: we provide a formal definition of recursiveness and show that it neither collapses, nor it is incompatible with the “abstractness” requirement. We also show that none of the above quoted categorial notions captures recursiveness. Finally, we consider our own definition of “abstract data type”, based on typically model-theoretic notions, and illustrate the sense according to which it captures recursiveness.

scholarly journals Adding Alternative Access Paths to Abstract Data Types

2002 ◽  
pp. 256-267 ◽  
Author(s):  
Xavier Franch ◽  
Jordi Marco
Keyword(s):  
Information Hiding ◽  
Data Type ◽  
Modular Structure ◽  
Abstract Data Type ◽  
Abstract Data Types ◽  
Data Types ◽  
Programming Framework ◽  
Algebraic Specifications ◽  
Abstract Data ◽  
Adequate Representation

We present in this paper a proposal for developing efficient programs in the abstract data type (ADT) programming framework, keeping the modular structure of programs and without violating the information hiding principle. The proposal focuses in the concept of “shortcut” as an efficient way of accessing to data, alternative to the access by means of the primitive operations of the ADT. We develop our approach in a particular ADT, a store of items. We define shortcuts in a formal manner, using algebraic specifications interpreted with initial semantics, and so the result has a well-defined meaning and fits in the ADT framework. Efficiency is assured with an adequate representation of the type, which provides O(1) access to items in the store without penalising the primitive operations of the ADT.

STUDI ALGORITMA babelRTS UNTUK PELAKSANAAN REGRESSION TEST SELECTION (RST)

2020 ◽  
Vol 3 (2) ◽  
Author(s):  
Ani - Rahmani
Keyword(s):  
Execution Time ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Selection ◽  
Test Execution ◽  
Regression Test Selection ◽  
Regression Test ◽  
Long Time ◽  
Testing Techniques

Software testing (testing) is a crucial stage in software development. The success of the testing process will ensure the quality of the software. In the regression testing process, one issue is that not all test cases (retest all) in the test suite need to be executed. Retest all will consume massive resources, as well as a long time. Regression testing techniques seek to find ways to reduce test execution time. One of the regression testing techniques is test case selection, also known as regression test selection (RTS). This paper describes a study on babelRTS, an RTS algorithm, to see its effectiveness. Effectiveness is measured by comparing the execution time of the execution retest all and babelRTS. Experiments were carried out on five software under tests (SUT) that had some faults. Test cases are prepared by designing for each SUT. The results showed a reduction in time so that the effectiveness reached a maximum of 32%, and average of 23% .

Sign in / Sign up

Export Citation Format

Share Document