Test Point Analysis

March 23, 2017

Software engineering world consists of many tasks and activities to design, develop and deliver quality product to their targeted users. Some of them are easy to perform while some are difficult or complex to execute. A task could be made be easy, if the efforts required in its execution are known, so as to organize and manage the whole task, accordingly.

Similarly, testing process also needs the estimation of efforts, required in the terms of budget, resources and time. It helps a QA team to plan the whole testing phase with respect to the estimated efforts and to execute the testing process effectively and efficiently within the stipulated time period. There are multiple number of methods available to estimate the testing efforts. Test Point Analysis is one of them.

What is Test Point Analysis (TPA)?

As stated above, Test Point Analysis (TPA) is a software testing estimate approach, which is specifically designed to estimate the black box testing efforts. Unlike, the functional point analysis (FPA), which is used to project the white box testing efforts, TPA is used to estimate the black box testing efforts, especially in performing the system and the acceptance test of the software application.

TPA's Methodology

To understand the working of the TPA approach, first try to understand the below given diagram.

In the above given diagram, it may be seen that the test point analysis makes use of the functional points derived from the functional point analysis and is used to calculate the functional points for the black box testing estimation. Now, coming to the TPA method. It usually, consists of three entities to estimate the black box testing efforts. These are:

Size
Test Strategy.
Productivity.

Size

First element is size, which may be defined in the terms of functional points for a particular project. However, the size of the project does not focus on the following parameters.

Complexity: Complexity of a project may be defined in the terms of the conditions existing in a project. Larger the conditions, greater will be the test cases and subsequently the more test estimate.
Interfacing: It defines the degree of impact of a condition or a function over other existing system's functions. The degree of impact may be assessed and determined by studying the logical data set and the changes in the other existing functions brought by them. Below given is the table, which provides the degree of interfacing, based on the logical dataset and its corresponding resulting modifications in the other existing functions.

Logical Data Sets	Functions
	1	2-5	>5
1	L	L	A
2-5	L	A	H
>5	A	H	H

L- Low, A- Average and H- High

Uniformity It basically defines the re-usability of the application and finds outs the existence of similar functions or conditions persisting in the application. It provides the degree up to which a function may be tested, using existing specification or slightly changed specification. It could be the second occurrence of the virtually unique function, or a clone or a dummy for which its value is 0.6, otherwise the value would be 1. Below given is the mathematical formula to measure.

Test Impact:

Test Impact defines the weighting factor for the function-dependent factors based on the above stated attributes i.e., complexity, interfacing, uniformity. It's mathematical formula is

T(f)= ((Ue + Uy + I + C)/16)*U, where
Ue→ User Importance*;
Uy→ Usage Intensity#;
I→ Interfacing;
C→ Complexity;
U→ Uniformity

* User Importance: It defines the how important is the function for the user in comparison to other existing function. Below given is the rating for the user importance.
Low- 3
Normal- 6
High- 12

# Usage Intensity: It defines the frequency of a particular function being used and processed by a user or the group of the user. Below given is the rating for the usage intensity.
Low- 2
Normal- 4
High- 12

Static and Dynamic Testing

To proceed further, we need to calculate static and dynamic test points. But before that, let's see the meaning of both static and dynamic testing.

Static testing:It's a verification activity which examines the whole structure of the application without executing it.
Dynamic testing: It's an actual testing activity performed over the application to evaluate and assess its different features, functionalities and quality aspects. It may consist of both explicit and implicit type of testing.

Now, coming to the Dynamic and Static test points.
Dynamic Testing points = ∑(QD* T(f)*FP), where
FP→ function points for each function, calculated through functional point analysis.
T(f)→ Test Impact/function
QD→Dynamic Quality attributes

Now, what are the dynamic qualities attributes (QD)?

Dynamic Quality Attributes (QD) reflects the dynamically assessed qualities of the application. It broadly consists of two quality characteristics- Implicit quality characteristics (Qi) and explicit quality characteristics(Qe) with respect to the coverage of the requirements.

QD = Qi + Qe

Explicit quality attribute (Qe)

It measures the depth coverage of the explicit test cases and consists of following quality characteristics.

Functionality.
Security.
Suitability.
Performance.
Portability.

Below given is the rating of the quality attribute with respect to the importance of the requirement.

0- Requirement is not so important, therefore is not considered for the test.
3- Relatively unimportant requirement, therefore may not be considered for the test.
4- Requirements are important.
5- Very Important requirements.
6- Extremely important requirements.
→Balanced, using a weight factor-
functionality   (0.75) 0 3 4 5 6
security    (0.05) 0 3 4 5 6
suitability   (0.10) 0 3 4 5 6
performance   (0.10) 0 3 4 5 6

Implicit quality attribute (Qi)

It generally consists of following quality characteristics.
User friendliness → 0.02
Resource usage →0.02
Performance → 0.02
Maintainability → 0.04
Above given, is the 4 implicit quality characteristic along with their corresponding rating. If the application possess all the 4 implicit qualities then Qi = 0.02 + 0.02 +0.02 + 0.04= 0.1. Similarly, if it shows only resource usage and maintainability quality, then the Qi = 0.02+0.04= 0.06.

How to calculate static test points?

Similar to dynamic test points, static test points can be calculated from the static quality attributes as stated below.

Flexibility.
Testability.
Security..
Continuity
Traceability.

Each of these quality characteristics have the value of 16 Test points/500 functional points

Static test points= Qs* (FP/500), where
FP- Function points showing the functional size of the application; and
Qs reflects the static quality attribute to be tested. For example, if all the 5 quality characteristics needs to be tested, then Qs will be 16*5=80. Similarly, if 3 quality needs to be tested, then Qs=16*3=48.

The combined value of Static and Dynamic test points gives the Total Test Points i.e.
Total Test Points= Static Test Points + Dynamic Test Points

Environment Factor

The factors influencing the environment of a software application may comprise of following elements:

Test Tools

Development Tests

Testing performed at an early stage of development.

test plan

Development Environment

Test Environment.

Testware

testwares

test cases

Productivity Factor

Productivity factor depends upon the following factor:

Skills and experience of the human resources engaged in the testing.
Working Approach.

Primary Test Hours

Below given is the general mathematical formula for estimating the primary test hours.
Primary Test Hours= Total Test points* Environment factor* Productivity factor

Total Number of Test Hours

Primary test hours along with the allowance spent on the planning and controlling activities produces out the total number of test hours. The allowance may depend upon the following factors: