Basis Path Testing Research Articles

Optimasi Sistem Informasi Konsultasi Hukum melalui Pendekatan Pengujian Kombinasi White-box dan Black-box

This study aims to test the legal consulting information system "Advogo" in the hope of finding deficiencies in the system that has been built, and opening up opportunities for improvement and further development of the system. Testing is done by 2 methods, white-box, and black-box testing. The white-box method used in this study is branch and basis path testing, while the black-box method used is the cause-effect graph. The limitation of white-box testing in this study is the SessionController.php file with Index, Create, Store, Show, and Update functions. While the limitations of the black-box are the creation of consultation sessions, authentication, and session bookings. The results of this study are the formation of 10 test cases for white-box testing with 100% valid results, and 14 test cases for black-box testing with 92% valid results, where there is 1 invalid test case so it is necessary to make improvements so that the system can function according to which are expected.

Specialized path-based technique to test Internet of Things system functionality under limited network connectivity

Contemporary Internet-of-Things (IoT) systems are hindered by several reliability-related issues, especially, the dynamic behavior of IoT systems caused by limited and often unstable network connectivity. Several intuitive ad-hoc approaches can be employed to test this behavior; however, the effectiveness of these approaches in detecting defects and their overall testing costs remain questionable. Therefore, we present a new specialized path-based technique to test the processes of an IoT system in scenarios wherein parts of these processes are influenced by limited or disrupted network connectivity. The proposed technique can be scaled using two levels of test coverage criteria to determine the strengths of the test cases. For this purpose, we propose two algorithms for generating test cases to implement the technique: an ant colony optimization-based search and a graph-traversal-based test case composition. We compared the efficiency of the proposed approach with possible solutions obtained using a standard path-based testing approach based on prime paths computed by a set-covering algorithm. We consider the total number of test case steps as the main proxy for test effort in experiments employing 150 problem models. For the less intensive of the two used test-coverage criteria, EachBorderOnce, an ant colony optimization-based algorithm, produced test sets with the same averaged number of steps as the graph traversal-based test-case composition; however, this algorithm performed with averaged number of steps 10% lower than a prime paths-based algorithm. For the more intensive test coverage criterion, AllBorderCombinations, these differences favoring the ant colony optimization-based algorithm were 18% and 25%, respectively. For these two types of defined test coverage criteria, the ant colony optimization-based search, graph-traversal-based algorithm, and standard path-based testing approach based on prime paths achieved the best results for 93 and 78, 14 and 24, and 13 and 17 models for AllBorderCombinations and EachBorderOnce criterion, respectively. Therefore, to guarantee the best test set, all compared algorithms are combined in a portfolio strategy that yields the best results based on the potential of the produced test sets to detect simulated defects caused by limited network connectivity. Additionally, this portfolio strategy also yields test sets, implying the lowest test effort for experimental problem instances.

Gravitational search algorithm: A novel approach for structural test path optimization

Structural testing is used to test the internal structure or code of the program in which knowledge to the internal structure is must to generate effective number of test cases for identifying logical and semantic errors in the program. Basis path testing is a structural based testing technique whose main objective is to test each independent test path in the program at least once. It is very difficult for the tester of the software to test each generated test path therefore, optimization of test path is required to save time, cost and effort. This paper proposes a new meta-heuristic technique i. e Gravitational Search Algorithm (GSA) for optimization of test paths. The results obtained from newly generated meta-heuristic algorithm are compared with Simple Genetic Algorithm (SGA) and the results shows that GSA gives better results as compared to SGA.

Prioritized Process Test: An Alternative to Current Process Testing Strategies

Testing processes and workflows in information and Internet of Things systems is a major part of the typical software testing effort. Consistent and efficient path-based test cases are desired to support these tests. Because certain parts of software system workflows have a higher business priority than others, this fact has to be involved in the generation of test cases. In this paper, we propose a Prioritized Process Test (PPT), which is a model-based test case generation algorithm that represents an alternative to currently established algorithms that use directed graphs and test requirements to model the system under test. The PPT accepts a directed multigraph as a model to express priorities, and edge weights are used instead of test requirements. To determine the test-coverage level of test cases, a test-depth-level concept is used. We compared the presented PPT with five alternatives (i.e. the Process Cycle Test (PCT), a naive reduction of test set created by the PCT, Brute Force algorithm, Set-covering-Based Solution and Matching-based Prefix Graph Solution) for edge coverage and edge-pair coverage. To assess the optimality of the path-based test cases produced by these strategies, we used 14 metrics based on the properties of these test cases and 59 models that were created for three real-world systems. For all edge coverage, the PPT produced more optimal test cases than the alternatives in terms of the majority of the metrics. For edge-pair coverage, the PPT strategy yielded similar results to those of the alternatives. Thus, the PPT strategy is an applicable alternative as it reflects both the required test coverage level and the business priority in parallel.

Employment of multiple algorithms for optimal path-based test selection strategy

Executing various sequences of system functions in a system under test represents one of the primary techniques in software testing. The natural way to create effective, consistent and efficient test sequences is to model the system under test and employ an algorithm to generate the tests that satisfy a defined test coverage criterion. Several criteria of test set optimality can be defined. In addition, to optimize the test set from an economic viewpoint, the priorities of the various parts of the system model under test must be defined. Using this prioritization, the test cases exercise the high priority parts of the system under test more intensely than those with low priority. Evidence from the literature and our observations confirm that finding a universal algorithm that produces an optimal test set for all test coverage and test set optimality criteria is a challenging task. Moreover, for different individual problem instances, different algorithms provide optimal results. In this paper, we present a path-based strategy to perform optimal test selection. The strategy first employs a set of current algorithms to generate test sets; then, it assesses the optimality of each test set by the selected criteria, and finally, chooses the optimal test set. The experimental results confirm the validity and usefulness of this strategy. For individual instances of 50 system under test models, different algorithms provided optimal results; these results varied by the required test coverage level, the size of the priority parts of the model, and the selected test set optimality criteria.

Workflow difference detection based on basis paths

Detecting workflow difference is meaningful for many applications, e.g., in-vehicle system testing. However, current workflow difference detection methods stress on structural differences while ignoring the behavioral aspects of the workflow models. Due to the large number of possible behaviors for a workflow model, it is challenging to detect the behavioral difference. To address this problem, this paper introduces the idea of basis path testing from the software testing field, and presents an efficient method for detecting the workflow difference in terms of their behaviors. First, we compute the cyclomatic complexity according to the number of nodes and arcs in the workflow model. Then, based on the cyclomatic complexity we design an algorithm that can retrieve the basis paths from a tree structure converted from the workflow model. At last, the Kuhn–Munkres (KM) algorithm is used to map the independent paths from two workflow models and generate the optimal mapping that the overall distance is the minimum. The experimental evaluation shows that our proposed method has been proved feasible in terms of both efficiency and effectiveness.

Automation Of Independent Path Searching using Depth First Search

In a basis path testing, there are independent paths that must be passed/tested at least once to make sure there are no errors in the code and ensure all pseudocode have implemented on the code. Previously, the independent path was generated using the Genetic Algorithm, but the number of iterations influenced the likelihood of the emergence of the corresponding the independent path. Besides, the pseudocode was also unable to be used directly since it must be implemented first, this makes finding an independent path longer because it has to implement the code. This research aims to find out how to find the independent path directly from pseudocode using a graph and how well the Depth First Search algorithm in finding the independent path. It was chosen because it was able to find the paths from a point to a particular point in a graph. The result of the system accuracy test was able to find the correct independent path as much as 52 from 76 test data, where the result of accuracy is 68.4% on average.

Basis Path Testing of Iterative Deepening Search and Held-Karp on Pathfinding Algorithm

This research is a continuation of previous research, where in previous research discussed about the implementation of both methods. Implementation is done using visual basic programming language. Both methods are compared based on the results obtained. While in the current study, research is more focused on the analysis of the program flow that has been made. Evaluation is done by using basis path method, there are several processes performed on the method, such as: flowgraph, independent path, cyclomatic complexity and graph matrix. In addition to the evaluation of program flow, evaluation is also done based on program performance. Performance tests are based, time, cpu and memory. Based on the evaluation using the base path, obtained flowgraph structure and independent path different, but obtained the result of CC and Graph Matrix calculation of the same between IDS and HK method is 4. Based on evaluation in terms of performance, process the program from entering data and until getting the result, the HK method takes a longer time than the IDS method. The IDS method takes 2.7 seconds while the HK method takes 2.8 seconds.

Conventional Software Testing Using White Box Method

Software development process highly relates to analysis, design, coding, testing and implementation processes. Testing process becomes imperative process to maintain a quality product running well. Testing process can be conducted both for structural and object-oriented software. However, the method utilized for structural and object-oriented software is significantly different. Testing structural program can utilize White Box, Black Box, or Gray testing methods. This study White Box Testing has been employed to test a simple application. The testing process using White Box Testing employs some testing techniques based on path testing consisting of some processes, namely testing independent path, developing flow graph, calculating cyclomatic complexity, and developing graph matrices. Hence, the testing process employing White Box method with basis path testing technique can be executed.

Optimization of Genetic Algorithm Performance Using Naïve Bayes for Basis Path Generation

Basis path testing is a method used to identify code defects. The determination of independent paths on basis path testing can be generated by using Genetic Algorithm. However, this method has a weakness. In example, the number of iterations can affect the emersion of basis path. When the iteration is low, it results in the incomplete path occurences. Conversely, if iteration is plentiful resulting to path occurences, after a certain iteration, unfortunately, the result does not change. This study aims to perform the optimization of Genetic Algorithm performance for independent path determination by determining how many iteration levels match the characteristics of the code. The characteristics of the code used include Node, Edge, VG, NBD, and LOC. Moreover, Naïve Bayes is a method used to predict the exact number of iterations based on 17 selected code data into training data, and 16 data into test data. The result of system accuracy test is able to predict the exact iteration of 93.75% from 16 test data. Time-test results show that the new system was able to complete an independent search path being faster 15% than the old system.

Quantification of Software Code Coverage Using Artificial Bee Colony Optimization Based on Markov Approach

Software test suite generation and development of techniques to optimize the test suite are vital parts of the software development life cycle. In this paper, a combination of Markov chain and artificial bee colony (ABC) optimization techniques are adopted to attain the software code coverage. Initially, dd-graph is captured from the control flow graph of the source code and is represented as a Markov chain. The number of paths is obtained based on linear code sequence and jump (LCSAJ) coverage. LCSAJ is used to reduce the number of independent paths as compared to paths obtained by basis path testing. Automatic test cases are generated and based on the operation profile of the test suite; transition probabilities are obtained using gcov analysis tool. Further, ABC optimization is adopted to ensure software code coverage. The initial population is randomly selected from the test suite and populated for subsequent generations using the ABC algorithm. The test cases are generated for three mixed data type variables, namely integer, float and Boolean. The quality of the test cases is improved during every iteration of ABC optimization and traversed through number of LCSAJ-based independent paths thereby ensuring software code coverage. Finally, software code coverage is quantified using the fitness/happiness value computed as a product of node coverage and the corresponding transition probability values based on the path covered.

Automatic Generation of Basis Component Path Coverage for Software Architecture Testing

Architecture-centric development is one of the most promising methods for improving software quality, reducing software cost and raising software productivity. Software architecture research not only focuses on the design phase, but also covers every phase of software life cycle. Software architecture has characteristics different from traditional software, conventional testing methods do not apply directly to software architecture. Basis path testing is a very simple and efficient white-box testing method. Traditional methods generate basis path according to the control flow graph, they are not suitable for generating component path when we detect more software architecture errors. This paper presents a new concept - Basis Component Path (BCP) for C2-style architecture, and proposes a method to generate the BCPs. C2-style architecture is represented by components, connectors, and interfaces, and uses an architecture component interaction graph (CIG) to describe interface connection relationship. We also provide an algorithm to generate BCP set. Experiments apply the proposed method in a typical C2-style architecture and the result shows that the proposed method can generate BCP set which contains as many BCPs as possible efficiently, and it meets the requirements of the basis component path testing.

QEFSM model and Markov Algorithm for translating Quran reciting rules into Braille code

The Holy Quran is the central religious verbal text of Islam. Muslims are expected to read, understand, and apply the teachings of the Holy Quran. The Holy Quran was translated to Braille code as a normal Arabic text without having its reciting rules included. It is obvious that the users of this transliteration will not be able to recite the Quran the right way. Through this work, Quran Braille Translator (QBT) presents a specific translator to translate Quran verses and their reciting rules into the Braille code. Quran Extended Finite State Machine (QEFSM) model is proposed through this study as it is able to detect the Quran reciting rules (QRR) from the Quran text. Basis path testing was used to evaluate the inner work for the model by checking all the test cases for the model. Markov Algorithm (MA) was used for translating the detected QRR and Quran text into the matched Braille code. The data entries for QBT are Arabic letters and diacritics. The outputs of this study are seen in the double lines of Braille symbols; the first line is the proposed Quran reciting rules and the second line is for the Quran scripts.

Basis Path Testing Using SGA & HGA with ExLB Fitness Function

Software testing is the most significant analytic quality assurance for software products, but it is very expensive and time consuming process. This limitation is overcome by automatic testing to reduce high cost and to increase reliability & efficiency as compared to manual testing. Basis path testing is a coverage criterion of software testing that can detect almost sixty five percent of errors in program under test. In this paper a new fitness function has been proposed named as Extended Level Branch (ExLB) Fitness function for basis path testing using simple genetic algorithm (SGA) and hybrid genetic algorithm (hill climbing with selection operator). Using a triangle classifier as program under test, performance of SGA with Simply Combined Fitness Function, SGA with ExLB Fitness Function and HGA with ExLB Fitness Function have been compared using MATLAB. Experimental results showed that SGA with ExLB Fitness Function (proposed approach) performs better than the SGA with Simply Combined Fitness Function and HGA using ExLB Fitness Function is better than all these approaches in terms of test data generation under basis path coverage criteria.

Accelerated model-based robustness testing of state machine implementations

In this paper, we present an approach for accelerating model-based robustness testing of state-based software components. We use the Z3 SAT solver to derive executable test cases fully automatically from a state model based on a UML Statechart. The test cases are paths along the Statechart comprising states and transitions. The main advantage of our approach is an accelerated execution of the test cases by refining already reached states as starting points for further test cases using reverse execution. Furthermore, the presented approach is able to check whether a correct target state has been reached or not when executing the path-based test cases using runtime verification and therefore increases the test significance. The runtime verification is done without instrumenting the source code of the component under test.

Basis Path Analysis for Testing Complex System of Systems

In Systems of Systems (SoS), a major challenge is to determine how to design a test suite that will check that the complete SoS mission and objectives are achieved. Combinatorial strategies that test for every interface in the SoS are not always optimal due to their exponential nature, and given the mission of the SoS, not all the constituent systems might have to actually interact with each other. To overcome these problems, this paper proposes the use of Basis Path Testing, which is a white-box software testing technique that makes use of Graph Theory to analyse the complexity of a structured system by creating a control flow graph from each of the program's functions to design an optimal test suite. This test suite is a set of paths that traverse through the functions, which are assumed linearly independent and that can be used to create a test strategy that will exercise all of the program's functions at least once to verify and validate their functionality. By applying Basis Path Testing analysis to the constituent systems in a SoS, the tester can develop an optimal test suite that will guarantee that all possible independent paths, all possible logical decisions, and all their interfaces are executed at least once. This paper presents a SoS sample architecture and show how to generate a test suite using Basis Path Testing analysis.

Strategies for scalable symbolic execution-driven test generation for programs

With the advent of advanced program analysis and constraint solving techniques, several test generation tools use variants of symbolic execution. Symbolic techniques have been shown to be very effective in path-based test generation; however, they fail to scale to large programs due to the exponential number of paths to be explored. In this paper, we focus on tackling this path explosion problem and propose search strategies to achieve quick branch coverage under symbolic execution, while exploring only a fraction of paths in the program. We present a reachability-guided strategy that makes use of the reachability graph of the program to explore unvisited portions of the program and a conflict-driven backtracking strategy that utilizes conflict analysis to perform nonchronological backtracking. We present experimental evidence that these strategies can significantly reduce the search space and improve the speed of test generation for programs.

Basis path test suite and testing process for WS-BPEL

Web services technology offers a WS-BPEL language for business process execution. The building block of WS-BPEL is those Web services components that collaborate to realize a certain function of th...

An efficient method to generate feasible paths for basis path testing

Basis path testing is a very powerful structural testing criterion. The number of test paths equals to the cyclomatic complexity of program defined by McCabe. Traditional test generation methods select the paths either without consideration of the constraints of variables or interactively. In this note, an efficient method is presented to generate a set of feasible basis paths. The experiments show that this method can generate feasible basis paths for real-world C programs automatically in acceptable time.

A scheme on automated test data generation and its evaluation

By analyzing some existing test data generation methods, a new automated test data generation approach was presented. The linear predicate functions on a given path was directly used to construct a linear constrain system for input variables. Only when the predicate function is nonlinear, does the linear arithmetic representation need to be computed. If the entire predicate functions on the given path are linear, either the desired test data or the guarantee that the path is infeasible can be gotten from the solution of the constrain system. Otherwise, the iterative refining for the input is required to obtain the desired test data. Theoretical analysis and test results show that the approach is simple and effective, and takes less computation. The scheme can also be used to generate path-based test data for the programs with arrays and loops.