Tohru Matsuodani

An efficient software testing method by decision table verification

A typical software testing is performed by making and running test cases that consist of input pattern and expected output pattern. Because exhaustive testing requires billions of test cases and many labours, we can only perform hundreds of them in practice. As for a software logic testing, selecting test cases from many candidates to achieve enough programme path coverage is important, and specific software testing skills are required for it. In our study, we propose a knowledge creation method of software logic extracted automatically from programme source code. In our method, all possible programme paths are extracted from source code, then converted into a decision table, which is easy-readable table format for software testing engineer. The logic verification can be performed exhaustively in a short time by comparing the decision table with a specification of software. Our method would contribute to improve both efficiency and quality of software testing.

Semantic analysis technique of logics retrieval for software testing from specification documents

Software testing often targets natural language specification documents. Creating test cases depends on engineer skills, then automation of creating test cases from natural language specification is important. Logics retrieval is a required technique to automate creating test cases, because once logics are retrieved we can transform them into decision tables and also create test cases from the decision tables. Furthermore, Japanese language structure is different from English. If we target Japanese natural language, a new technique is also required. We propose a Semantic Analysis Technique of Logics Retrieval for Software Testing from Japanese Public Sectors Specification Documents. This technique is a new logics retrieval from harmonization between natural language processing technique and software testing. Applying the analysis technique to total 25 files, 1,218 pages and a million double bytes characters, the precision reached 0.93 to 0.97 and recall reached 0.65 to 0.79.

Evaluation of debug-testing efficiency by duplication of the detected fault and delay time of repair

Testing and debugging remove faults from software and ensure its reliable operation, In software developments, enormous resources are spent on testing and debugging, and the efficiencies of them are important factors when we consider software development cost. However, testing methods have been evaluated mainly on effectiveness, such as a coverage of source codes, and efficiencies of the methods have not been evaluated and no applicable criterion exists.In this paper, we firstly indicate the criterion of testing effect and efficiencies with search theory, we define the efficiency ratio of testing by duplication of the detected fault, and we define the efficiency ratio of debugging by delay time of repair. Then we evaluate actual efficiency ratio using the criterion and case data. This evaluation method considers testing and debugging as search processes and visualizes the search structure of software. As a result of analysis, it has been indicated that testing and debugging efficiencies is determined by duplication of search path on search structure, and it is possible to make extensive improvements of testing and debugging efficiencies.

A Study on the Effectiveness of Test-Categories Based Test Analysis

Along with a rapid increase in the size and complexity of software today, the number of required test cases is also increasing. Generally, a rather significant number of testers should be assigned to a project in order to manage this increase of test cases. It is necessary for such a large team to be able to collaborate and work together efficiently, and we have proposed a test analysis method for black box testing utilizing Test-Categories based on Application Under Test (AUT) and fault knowledge in order to facilitate this activity. This paper illustrates the effectiveness of Test-Categories.

A study on an approach for analysing test basis using I/O test data patterns

For software testing, it is important to derive test cases without lacking or duplication before test execution. Test basis to be analysed in test development process for black box testing is a functional specification. And it is less analysed under consistency rules. As a result, this has the potential to cause the lacking or duplication of test cases. This paper proposes an approach for analysing test basis focusing on data I/O in test execution to achieve analysing test basis can be more comprehensive. Moreover, in order to demonstrate this approach, an experiment is performed comparing with test cases in a real project.

A Method of Creating Testing Pattern for Pair-wise Method by Using Knowledge of Parameter Values☆

Abstract It is important for software testing to create high test case coverage. Test cases are almost created by manually in current situation, so test case coverage is depend on the individual skills. We discuss a method of creating testing pattern for Pair- wise method by using knowledge of parameter values. The method targets functional testing from screens for Web application systems. The method uses knowledge base for identifying pair-wise parameter values by using document analysis to specification documents, boundary analysis and defects analysis, so that it gets rid of dependencies of individual skills. We also discuss case studies which demonstrate the method of creating high test case coverage by using pair-wise parameter values.

Analysing Test Basis and Deriving Test Cases Based on Data Design Documents

In order to deal with an increase in the number of test cases in recent software testing, a test analysis method for black box testing using test categories based on Application Under Test (AUT) and fault knowledge have been proposed in previous studies. AUT is classified into elements of the reference model, and logical test cases are derived. For each element of the model, there are approaches to derive test cases. In this paper, a practiacl knowledge to derive test cases for one element of the model is proposed. This element is a classification for combination of multiple input / output test cases which is derived from data design documents. It is confirmed that the expected test cases can be derived using this approach from a concrete instance of an IT system.

A Comparative Study Using Discriminant Analysis on a Questionnaire Survey Regarding Project Managers’ Cognition and Team Characteristics

The purpose of this study is to create a model of a relationship in which the dependent variable is the result of a project and the independent variables are the characteristics of human resources. We attempted a comparative evaluation of discriminant analyses with a statistical model and a machine learning model using assessments of the results of projects and team characteristics derived from questionnaire survey data. The results of the evaluation demonstrate that the machine learning model shows a higher discrimination rate within the range of the data used in the analysis, but it became clear that the discrimination rate worsens in comparison with the statistical model when extrapolated.

Automatic Generation of UTP Models from Requirements in Natural Language

Unified Modeling Language (UML) is the language of modeling from requirements for software design. UML Testing Profile (UTP) is the definition of the modeling test from requirements analysis for software testing. UTP has Test Architecture, Test Behavior, Test Data, and Time Concepts as the test models. Requirements are described in natural language, and engineers who have modeling skills then manually generate test models. Hence the generation of test models depends upon the engineers skills, leaving the quality of test models unstable. In this paper, we present automatic generation test models from requirements in natural language by focusing on descriptions of test cases in UTP test behavior. We develop three rules to generate test models from requirements by using natural language processing techniques and experiment with our approach on requirements in language that is considered natural English. Our results in three case studies show the promise of our approach.

A Case Study of Team Learning Measurements from Groupware Utilization

In software development, there is a need to share a variety of knowledge; therefore, team learning (organizational learning) is required. As tools to support team learning, various groupware has been utilized. In groupware utilization, there is variation among development sites, which is suggested to reflect the maturity of team learning. Therefore, a case analysis on a team with a higher maturity of team learning was performed using groupware utilization as a measure of knowledge sharing. The Gini coefficient is used to represent the distribution of assets in economics. An inversion of the Gini coefficient was used to represent the groupware utilization and defined as the contribution ratio of knowledge. When the contribution ratio of knowledge is large, knowledge sharing is considered to be progressing. The contribution ratio of knowledge in this case study was observed to improve in proportion to the duration of the team. In future, we will expand the measurement range and continue to verify the measurement of team learning maturity using the contribution ratio of knowledge. This study measures the state of the team by analyzing their responses to the questionnaire. If this verification is successful, we would be able to measure the progress of team learning using the contribution ratio of knowledge, which can be measured more easily and objectively without resorting to the questionnaire.