Age testing, as the name suggests, is being done to verify the system’s behavior/performance in future. Age testing is done to check the performance of the system as the system gets older. Age testing is performed by software testers. Whenever any application/ software/Product is being developed, software testers performs a different type of testing in it to make sure that the developed application is working as expected and giving the desired results. Age testing is also a part of it if the system/application is working fine as of now and all the bugs have been fixed. How will it behave in the future? Age testing is evaluated by defect age

For example, let’s say if the user has bought any electronic product from the market in 2008 and now if we check that same product in 2018, it will not perform in the same way as in 2008, so the performance has been degraded with time. So, age testing is being done to check how the application will respond in future, how its performance degrades and what all areas will be affected the most.

 

Defect Age:

Age of the defect is measured by Time and Phases.

Defect age in Phases: This is the numerical value assigned to a defect which is calculated by finding the difference between phase when a defect is originated in the software and when the defect is caught. So, there is a formula to calculate the age of defect:

Defect Age: Defect identified – Defect originated

For example, a particular company follows this lifecycle for software development:

1. Planning
2. Requirement analysis
3. Design
4. Coding
5. Unit Testing
6. Integration testing
7. System Integration testing
8. UAT

 

Now, if the defect has been originated in ‘Design’ phase (3) and identified in ‘System integration testing’ (7) phase, then Defect age is

Defect age = Defect identified (System integration phase) – Defect originated (Design phase)

Defect age = 7-3 = 4

For the software to be more effective and successful, defect age should be less.

Defect age in Time: This is again a numerical value which is calculated by calculating the difference between the date when tester found the bug and the date when the bug has been fixed (fixed date can be the current date or Past date). This difference is usually calculated either in days or in hours.

For example: If the defect found on 07/11/2017 2:00 PM and closed on 07/14/2017 5:00 PM, then defect age is 39 Hours.

The fixed date here signifies that the defect has been by the developer, retested and closed by the tester. Duplicate and dropped defects are not considered here.

 

Defect Spoilage:

Defect Spoilage means certain factors due to which testers are finding it difficult to detect the defect. These factors can be configuration, database connectivity and If the defect spoilage value is low, then the defect discovery process is effective and if the defect spoilage value is high, then the defect discovery process is not much effective. If a defect is found in the early stage, the cost involved in fixing the defect is less but if the defect is found at a later stage, the cost involved is much more.

Defect spoilage can be calculated by the sum of a total number of defects multiplied my phase in which defect is discovered and then divided by a total number of defects found.

Defect Spoilage = (sum of total number of defects * defect discovered phase) / Total number of defects found.

For example, a particular company follows this lifecycle for software development:

1. Requirement analysis
2. Design
3. Coding
4. Unit Testing
5. Integration testing
6. System Integration testing
7. UAT

Now, 5 defects were discovered in UAT, out of which 2 defects are created in the Design phase. Now the 2 defects which have been found in UAT, could have been discovered in any phase. So the design defects which were undiscovered till UAT are weighing 5. And now the weighted number is (2*5=10) of the defects which were discovered in UAT. In the same manner, value for the phases can be measured.

Below diagram is another example for Defect spoilage. Explanation of diagram: 5 defects are found in the design phase and out of which 2 are created in requirement phase. Then 6 defects are found in unit testing phase, out of which none are created in requirement phase. Then 3 bugs are found in integration testing phase, out of which 1 was created in requirement phase. Hence the total number of defects found are 5+6+3 = 14 and sum of passed on defect multiplied by their factor is (2*1+4*1) =6.

Defect Spoilage = 6/14 = 0.428

Similarly, spoilage is calculated for all rows and then total spoilage will be calculated.

Abbreviations used in this diagram:

1. R -> Found in requirement phase
2. D -> Found in the design phase

 

By doing this, the effectiveness of each phase can be measured.

 

Conclusion:

1. Age testing is done to verify system behavior in future.
2. Defect age is measured by time and phases.
3. Defect age in phase is calculated by the difference in phase when a defect is originated and phase when a defect is caught.
4. Defect age in phase is the time when tester found the bug and time when the bug is fixed.
5. Defect spoilage is the factors by which testers find it difficult to find the bug.