Aamer Nadeem

A Performance Comparison of Data Encryption Algorithms

The principal goal guiding the design of any encryption algorithm must be security against unauthorized attacks. However, for all practical applications, performance and the cost of implementation are also important concerns. A data encryption algorithm would not be of much use if it is secure enough but slow in performance because it is a common practice to embed encryption algorithms in other applications such as e-commerce, banking, and online transaction processing applications. Embedding of encryption algorithms in other applications also precludes a hardware implementation, and is thus a major cause of degraded overall performance of the system. In this paper, the four of the popular secret key encryption algorithms, i.e., DES, 3DES, AES (Rijndael), and the Blowfish have been implemented, and their performance is compared by encrypting input files of varying contents and sizes, on different Hardware platforms. The algorithms have been implemented in a uniform language, using their standard specifications, to allow a fair comparison of execution speeds. The performance results have been summarized and a conclusion has been presented. Based on the experiments, it has been concluded that the Blowfish is the best performing algorithm among the algorithms chosen for implementation.

A state-based approach to integration testing based on UML models

Correct functioning of object-oriented software depends upon the successful integration of classes. While individual classes may function correctly, several new faults can arise when these classes are integrated together. In this paper, we present a technique to enhance testing of interactions among modal classes. The technique combines UML collaboration diagrams and statecharts to automatically generate an intermediate test model, called SCOTEM (State COllaboration TEst Model). The SCOTEM is then used to generate valid test paths. We also define various coverage criteria to generate test paths from the SCOTEM model. In order to assess our technique, we have developed a tool and applied it to a case study to investigate its fault detection capability. The results show that the proposed technique effectively detects all the seeded integration faults when complying with the most demanding adequacy criterion and still achieves reasonably good results for less expensive adequacy criteria.

An approach for selective state machine based regression testing

Model-based regression testing is an important activity that ensures the reliability of evolving software. One of the major issues in this type of testing is the optimal selection of test-cases to test the affected portion of the software. In this paper, we present a UML based selective regression testing strategy that uses state machines and class diagrams for change identification. We identify the changes using the UML 2.1 semantics of state machines and class diagram. The changes are classified as Class-driven (obtained from class diagram) and State-driven (obtained from state machine). The Class-driven changes are important as these changes are not reflected on the state machines and they might be helpful in identifying some fault-revealing test cases. With the help of the identified changes, we classify the test cases of the test suite as Obsolete, Reusable, and Retestable. We apply the approach on a case study to demonstrate its validity.

A Survey of Consistency Checking Techniques for UML Models

UML is the de-facto industry standard to design object-oriented software. UML provides a set of diagrams to model every aspect of an object-oriented application design in sufficient detail, but lacks any mechanism to rigorously check consistency between the models. Today, most of the effort is applied on creating accurate and consistent UML models rather than implementing the design. Automatic code generation from UML models has emerged as a promising area in recent years. The accuracy of generated code in some ways depends on UML models consistency. In this paper, we present a survey of UML consistency checking techniques. To analyze existing techniques, we identify some analysis parameters and construct an analysis table. The analysis table helps us to evaluate existing consistency checking techniques. We conclude that most of the approaches validates intra and inter level consistencies between UML models by using monitoring strategy. UML class, sequence, and statechart diagrams are used in most of the existing consistency checking techniques.

An empirical evaluation of the influence of human personality on exploratory software testing

Exploratory testing is a kind of testing in which no documentation or scripting is used. Personality characteristics including intelligence and extroversion play a significant role in exploratory testing. The main hypothesis of this research is ‘personality traits influence exploratory testing’. This research hypothesis has been unfolded into six sub-hypotheses which have been tested individually. To test the research hypothesis, an Exploratory Testing Aptitude Test (ETAT) was designed. The subjects were also given Pre-ETAT, Standard Progressive Matrices (SPM), Myers-Briggs Type Indicator, and Post-ETAT tests. The results were analyzed using Statistical Package of Social Sciences (SPSS). The results indicate that there is a positive correlation between human personality types and the ability of testers in exploratory testing. We conclude that people having extrovert personality types are good exploratory testers. Moreover, good exploratory testers have higher IQ level which is directly proportional to result of ETAT.

Regression Testing Based on UML Design Models

This paper presents a methodology for identifying changes and test case selection based on the UML designs of the system. Design artifacts used for this purpose are UML class diagram and sequence diagrams, which are used to generate an extended concurrent control flow graph (ECCFG) which is further used for regression testing, i.e., change identification and test case selection. A proof- of-concept tool has been developed and used on a case study, which shows that our approach selects a precise set of test cases from an existing test suite.

TestFilter: A Statement-Coverage Based Test Case Reduction Technique

Software testing is an important but expensive phase of software development life cycle. During software testing and retesting, development organizations always desire to validate the software from different views. But exhaustive testing requires program execution with all possible combinations of values for program variables, which is impractical due to resource constraints. For many applications, it is possible to generate test cases automatically. But the core problem is the selection of effective test cases necessary to validate the program during the maintenance phase. This target can only be achieved by eliminating all the redundant test cases from the generated pool of test suites. In this paper, we propose a novel test case reduction technique called TestFilter that uses the statement-coverage criterion for reduction of test cases. To demonstrate the applicability of this approach, we conduct an experimental study. The results show that our technique is beneficial in identifying non-redundant test cases at a little cost. Ultimately it is beneficial to optimize time & cost spent on testing and it is also helpful during regression testing.

A Survey of UML Based Regression Testing

Regression testing is the process of ensuring software quality by analyzing whether changed parts behave as intended, and unchanged parts are not affected by the modifications. Since it is a costly process, a lot of techniques are proposed in the research literature that suggest testers how to build regression test suite from existing test suite with minimum cost. In this paper, we discuss the advantages and drawbacks of using UML diagrams for regression testing and analyze that UML model helps in identifying changes for regression test selection effectively. We survey the existing UML based regression testing techniques and provide an analysis matrix to give a quick insight into prominent features of the literature work. We discuss the open research issues like managing and reducing the size of regression test suite, prioritization of the test cases that would be helpful during strict schedule and resources that remain to be addressed for UML based regression testing.

Test suite optimization using fuzzy logic

Regression Test suite optimization is an effective technique to reduce time and cost of testing. Many researchers have used computational intelligence techniques to enhance the effectiveness of test suite. These approaches optimize test suite for a single objective. Introduction of fuzzy logic with genetic algorithm and swarm optimization may be used to optimize test suite for multi-objective selection criteria. Secondly, human intervention or expert judgment is required to opt for level of testing, technique used and quality aspect to be tested. Fuzzy logic has proved its worth in many other domains like communication, bio informatics, embedded applications, industrial and engineering control and network optimization. We propose an expert system that finds a trade off among the quality aspects, technique used and level of testing based on objective function defined by the tester, quite similar to human judgment using fuzzy logic based classification. Main focus of our approach is to find a test suite that is optimal for multi-objective regression testing. For proof of our concept, initially we focused on three quality aspects, i.e., performance, throughput and code coverage.

UJECTOR: A Tool for Executable Code Generation from UML Models

Automated translation of UML models to executable code is a growing area of interest due to its benefits such as cost reduction and accuracy. However, major challenges in this area include checking consistency of UML models, and ensuring accuracy, maintainability, and efficiency of the generated code. This paper presents a tool called UJECTOR for automatic translation of UML models to executable Java code. The tool uses UML class diagram, sequence diagrams and activity diagrams for automated code generation. The tool generates structural code from the class diagram, and then adds behavioral aspects from sequence and activity diagrams. A case study is used for experimental validation of the code generation tool. The results show that the generated code is consistent with UML models, fully functional, and understandable.