Arup Abhinna Acharya

A novel approach of test case generation for concurrent systems using UML Sequence Diagram

Testing concurrency is difficult yet important. Because of arbitrary interference of concurrent objects, test case explosion becomes a major problem in testing concurrent systems. Synchronization and Deadlock being the two key features of concurrent systems make the systematic testing of concurrent systems a tedious task. In this paper we present a novel approach of generating test cases for concurrent systems with the help of UML Sequence Diagram. Our approach consists of transferring the Sequence Diagram into a Concurrent Composite Graph (CCG). The CCG is traversed by an effective graph traversing technique like BFS (Breath-First-Technique) and DFS (Depth-First-search) using message sequence path criteria to generate the test cases for concurrent systems. The proposed approach is applied to concurrent systems for test case generation and found to be very effective in controlling the test case explosion problem. The generated test cases are useful to detect interaction, scenario, as well as operational faults in case of concurrent systems.

A model based prioritization technique for component based software retesting using uml state chart diagram

Regression testing is the process of testing a modified system using the old test suite. As the test suite size is large, system retesting consumes large amount of time and computing resources. This issue of retesting of software systems can be handled using a good test case prioritization technique. A prioritization technique schedules the test cases for execution so that the test cases with higher priority executed before lower priority. The objective of test case prioritization is to detect fault as early as possible so that the debuggers can begin their work earlier. In this paper we propose a new prioritization technique to prioritize the test cases to perform regression testing for Component Based Software System (CBSS). The components and the state changes for a component based software systems are being represented by UML state chart diagrams which are then converted into Component Interaction Graph (CIG) to describe the interrelation among components. Our prioritization algorithm takes this CIG as input along with the old test cases and generates a prioritized test suit taking into account total number of state changes and total number of database access, both direct and indirect, encountered due to each test case. Our algorithm is found to be very effective in maximizing the objective function and minimizing the cost of system retesting when applied to few JAVA projects.

Model Based Test Case Prioritization Using Association Rule Mining

Regression testing has gained importance due to increase in frequency of change requests made for software during maintenance phase. The retesting criteria of regression testing leads to increasing cost and time. Prioritization is an important procedure during regression testing which makes the debugging easier. This paper discusses a novel approach for test case prioritization using Association Rule Mining (ARM). In this paper, the system under test is modelled using UML Activity Diagram (AD) which is further converted into an Activity Graph (AG). A historical data store is maintained to keep details about the system which revealing more number of faults. Whenever a change is made in the system, the frequent patterns of highly affected nodes are found out. These frequent patterns reveal the probable affected nodes i.e. used to prioritize the test cases. This approach effectively prioritizes the test cases with a higher Average Percentage of Fault Detection (APFD) value.

Solving Sudoku Puzzles Using Evolutionary Techniques—A Systematic Survey

Sudoku puzzle is a game which takes the form of an N × N matrix. It requires the players to organize the number sequences from 1 to N in the submatrices of the original matrix in such a way that no numbers are reused in each sub matrices and also the numbers are not reused in each column and rows. It is mainly based on the number replacement game and is a combinatorial puzzle. Several evolutionary techniques such as Genetic algorithm, Particle Swarm Optimization, Ant Colony Optimization, and Artificial Bee Colony Optimization are used for solving, rating, and generating Sudoku Puzzles. This research paper presents a survey of solving Sudoku Puzzles using different evolutionary technique-based hybridized algorithms and analyze the results, i.e., success rates found in solving the puzzles of different levels such as Easy, Medium, Challenging, Hard, Evil, and Super Hard.

A Systematic Review of Software Testing Using Evolutionary Techniques

A best solution for decreasing software cost and reducing the cycle time during software development is automatic software testing and it has been seen by various organization. User specifications and requirements can be fully achieved by software testing. A number of issues are underlying in the field of software testing such as prioritization of test cases and automatic and effective test case generation are to be handled properly and they mostly depends on duration, cost and effort during the testing process. Testing can be done in two different ways such as manual testing and automatic testing by using different testing tools. Manual testing are very time consuming and this can be overcome by automatic testing by generating test cases automatically. Several types of evolutionary techniques like Genetic Algorithm, Particle Swarm Optimization and Bee Colony Optimization have been used for software testing. In this research paper, a survey of different evolutionary techniques used in software testing have been presented by taking the various issues in to account.

Test Case Generation For Concurrent Object-Oriented Systems Using Combinational Uml Models

Software testing is an important phase of software development to ensure the quality and reliability of the software. Due to some limitations of code based testing method, the researcher has been taken a new method to work upon UML model based testing. It is found that different UML model is having different coverage and capable of detecting different kinds of faults. Here we have taken combinational UML models to have better coverage and fault detection capability. Testing concurrent system is difficult task because due to concurrent interaction among the threads and the system results in test case explosion. In this paper we have presented an approach of generating test cases for concurrent systems using combinational UML models i.e. sequence diagram and activity diagram .Then a Sequence-Activity Graph (SAG) is constructed from these two diagrams. Then that graph is traversed to generate test cases which are able to minimize test case explosion.

Test Case Prioritization Using Association Rule Mining and Business Criticality Test Value

Regression Testing plays a vital role for the improvement in quality of product during software maintenance phase. This phase ensures that modification made to the system under test doesn’t adversely affect the performance of the existing features. Hence regression testing incurs more cost and time. Test case prioritization, which is one of the techniques of regression testing, is an efficient technique to minimize the cost and time of testing. In this paper, the author has proposed an approach for test case prioritization by maintaining information of previous and current release of the project in a repository. To represent the behavioral aspect of the system, it is modeled using both UML activity and sequence diagram. Then frequent pattern is generated by applying Association Rule Mining on the information stored in the repository. Finally the prioritization is carried out using the generated frequent patterns and Business Criticality Value of the different features.

Prioritizing Test Cases Using Business CriticalityTest Value

Software maintenance is an important and costly activity of the software development lifecycle. Regression testing is the process of validating modifications introduced in a system during software maintenance. It is very inefficient to re-execute every test case in regression testing for small changes. This issue of retesting of software systems can be handled using a good test case prioritization technique. A prioritization technique schedules the test cases for execution so that the test cases with higher priority executed before lower priority. The objective of test case prioritization is to detect fault as early as possible. Early fault detection can provide a faster feedback generating a scope for debuggers to carry out their task at an early stage. Model Based Prioritization has an edge over Code Based Prioritization techniques. The issue of dynamic changes that occur during the maintenance phase of software development can only be addressed by maintaining statistical data for system models, change models and fault models. In this paper we present a novel approach for test case prioritization by evaluating the Business Criticality Value (BCV) of the various functions present in the software using the statistical data. Then according to the business criticality value of various functions present in the change and fault model we prioritize the test cases are prioritized.

Test case generation for use case dependency fault detection

Testing is an important phase of quality control in Software development. The use case diagram present in UML 2.0 plays a vital role in describing the behavior of a system and it is widely used for generating test cases. But to identify the dependency faults that occur between use cases is a challenge for the test engineers in a Model Based Testing (MBT) environment. This paper presents a novel approach for generating test cases to detect use case dependency faults in UML use case diagrams using mulitway trees. Our approach includes transforming the UML use case diagrams into a tree representation called as Use Case Dependency Tree (UCDT). This is followed by a thorough traversal of the tree to generate the test cases so as to detect any existing intra and inter use case dependency faults among the various use cases being invoked by the different actors interacting with the software system.

Test Case Optimization and Prioritization Based on Multi-objective Genetic Algorithm

The validation of modified software depends on the success of Regression testing. For this, test cases are selected in such a way that can detect a maximum number of faults at the earliest stage of software development. The selection process in which the most beneficial test case are executed first is known as test case prioritization which improves the performance of execution of test cases in a specific or appropriate order. Many optimizing techniques like greedy algorithm, genetic algorithm, and metaheuristic search techniques have been used by many researchers for test case prioritization and optimization. This research paper presents a test case prioritization and optimization method using genetic algorithm by taking different factors of test cases like statement coverage data, requirements factors, risk exposure, and execution time.