T e s t R e p o r t i n g a n d M e t r i c s

Sponsored Links:

Software Defect Reports:
Reports of a basic defect level are simple:number of defects by the state & severity.Something like the diagram on the right.This shows the number of defects & their been in evidence. As the project progresses wait to see the marching through the graph from left to right - moving again to open a closed fixed.More complicated are reports of defects work possible. For example, you might require have a document on aging defects - How long were deficiencies in a particular state. This allows you to target the defects that have not advanced, they have not changed state for a period of time. Looking at the average age of defects in each state can predict how long number of defects will be fixed.By far the best document default is the default state trend as a graphic. This shows the total number of defects by the state in time (see below).The great advantage of this graph is that it allows predict the future. If you take the graph of theSeptember & draw a line down curve of the 'fixed' defects --cuts the x-axis after the final December. This means that since September,was not possible to predict all defects would be fixed in December & the project not finish on time. Similarly it follows the curve of the "new" defects that can intuit something about the progress of your project.If the peak in the curve is flat, & then, then you have a problem in development - the errors are not
remain fixed. Either the developers are the reintroduction of errors when trying to solve this problem, its
Code control is poor or there is another key issue.Time to get out the microscope.


Root Cause Analysis:
Root cause analysis is to identify the cause of a defect.Basic root cause analysis can often be enlightening - if 50% of program defects are directly attributable to the requirements of the poor then you know you require to fix your requirements specification system. Moreover, if all I know is that your client is not happy with the product quality, then you have to do a lot of digging to discover the answer.To perform root cause analysis you require to be able to grasp the cause of each defect. This is the usually done by providing an arena in the tracking system defects that can be used to classify the cause of each failure (which decides what is the root cause could be a point of contention!)
Sub-classifications are possible, depending on the level of detail you need to go. To Eg what kind of condition the errors are occurring? Are requirements changing development? Are they incomplete? Are incorrect?Two time you have this information they can quantify the proportion of defects attributable to each cause.In this table, 32% of defects are attributable to mistakes made by the check team, a massive proportion.While it is clear that there's problems with
requirements, coding & configuration,giant number of errors of proof means that there major problems with the accuracy of the tests.While most of these defects will be rejected & closed, a considerable amount of time spent the diagnosis & debating them.This table can be broken down by the absence of other attributes such as "state" & "gravity".You can find for example that "high" severity defects are attributable to coding errors, but "low" severity defects are related configuration.A fuller analysis can be done by identifying the cause (as before) & how defect was identified. This can be a classification of the phase in which the defect is identified (design, unit check, technique check, etc.) or a more detailed analysis of the system used to discovered the defect (tutorial, code inspection, automated testing, etc.) This then gives a overview of the defect & how it is detected to help choose what of their strategies for eliminating defects are most effective.

The maximum length for information capture & analysis is the use of comparative indicators.Metrics (theoretically) permit for the completion of the development cycle as a whole to be measured. To tell business decisions & method & permit development teams to implement method improvements or tailor their development strategies.The measurements are notoriously controversial, however.Provide figures only for complex processes such as program development can over-simplify things.There may be very valid reasons for program development with more defects other. Finding a comparative measure is often difficult & focus on a single standard of measurement, without understanding the complexity underlying risks to ill-informed interpretations.Most indicators focus on measuring the performance of a method or an organization. There has realized strong in recent years that the metric should be useful for individuals.The effectiveness of a method depends directly on the effectiveness of individuals within the method. The personal use of metrics at all levels of program development allows individuals to adjust habits toward more effective behaviors.

Testing Metrics for Developers:
If the aim of developers is the production of code, then a measure of their effectiveness is how well that code works. The converse of this is how buggy a particular piece of code is - the more defects,the less effective the code.A veteran of quality metrics is often to the fore is "defects per thousand lines of code" or"Defects by Kloc" (also known as the density of defects). This is the total number of defects divided by in the number of thousands of lines of code in the program under check.The problem is that each programming paradigm, the defects by Kloc becomes unstable. In the procedural languages of age the number of lines of code was reasonably proportionate. With the the introduction of development methodologies, object-oriented program that reuse of code blocks,the order will become largely irrelevant. The number of lines of code in a procedural language like C or Pascal, is not related to a new language like Java o. NET.The substitution of "defects / Kloc" is "a developer of defects per hour" or "defect injection rate.Program development larger or more complex requiring more time for developers to code and build.The number of defects injected a developer in their code during development is a direct
measure of code quality. The more defects, the poorer the quality. By dividing the the number of defects by the total hours devoted to the development to get a comparative measure of quality of different program development.
Defect injection = number of defects created/time scheduled
Note that this is not a measure of efficiency, quality only. A programmer who takes longer and isintroduce fewer defects more care than five that is sloppy and rushed. But how long is long? If a developer is only a bug-free piece of program a year, is that long? The Using a metric must be balanced by others to ensure that a balanced scorecard is used.Otherwise, it could be the manipulation of a dimension to the exclusion of all others Developing efficiency measures are beyond the scope of this text.

Test Metrics for Testers:
An obvious measure of the effectiveness of the check is how lots of defects are found - the more the better.But this is a comparative measure.You can measure the defects of a particular check phase as a proportion of total the number of defects in the product. The higher the percentage the more effective check. But how lots of defects in the product at any given time? If each phase presents more defects, this is a moving target. & how long you expect your customers to find all the defects you missed in testing? A month? A year? & let developers write programs that have small or no fault? This means that found small or no defects. Does that mean that your check is not effective? Probably not, basically fewer defects to find that a product of poor application.In lieu, you can measure the performance of individual testers.In a script 'heavy' environmental measures of the efficiency check are easily met. The number of check
cases or scripts of a tester is prepared in an hour might be considered a measure of its productivity during preparation. Also, the total number of people executed during the day can be considered a measure of efficiency in the execution of the check.But is it ?Consider a light script, or else the script environment. These testers do not script their cases so how can to measure their efficiency? Does this mean that can not be efficient? I would say they can.What if the evidence does not find fault? Are they effective, no matter how you write?Let us return to the effects of the tests - to identify & eliminate application defects That being the case, a gauge of efficiency of finding & removing defects faster than an inefficient process four. The number of check cases is not relevant. If you can eliminate lots of defects, no scripts,then the time of the scripts would be better used carrying out the tests, not write them.So the time to find a defect is a direct measure of the effectiveness of testing.Measurement of the shortcomings of this individual can be difficult. The total time involved in finding a fault cannot be apparent unless individuals keep close track of time spent in testing particular functions. In the script of heavy environments should also take in to account the time Scripting of a particular defect, which is another complication.But to measure this hard work by a particular check is easy - basically divide the total number of hours passed the check by the total number of defects recorded (recall to include preparation time).
Defect Discovery Rate = Number of defects found check hours
Note that you ought to only count those defects that are fixed in these equations.Why?New defects that have not been validated are not defects. Defects which are rejected are also defects. A flaw has been fixed, it is definitely a mistake to be corrected. If you have the wrong numbers, come to the wrongconclusions.

Other Metrics for Testing and Development:
as developers are responsible for the errors in your code, so that testers should be responsible for mistakes in its reporting of defects. A lot of time can be wasted by both the development & testing equipment to hunt down the poorly specified on deficiencies or defects that arise in error.So a measure of the effectiveness of evidence therefore becomes the number of reports rejected by default development. Of coursework, you ought to minimize this value, or use it as a proportion of defects in session & purpose of each check & the check team with an overall objective of 0% - no errors.You may also target other indicators such as response times to reports of defects.If a developer has much time to respond to a defect document can have the whole process up. If
take a long time to correct a defect of the same can happen. Testers can also sit on the defects,retest them & sustaining the project.But beware of using these measures prescriptive.Defects are funny beasts. Are inconsistent & erratic. No comparability. A "minor"absence of gravity may look like another, but might take ten times longer to diagnose & resolve.The idiosyncrasies of different application products & programming languages can make a kind of
defects more difficult to repair than the other.& although these probably will average in time, do you need to penalize a developer orTester since been fitted with all the difficult problems?Food for thought \.\.You are measuring the rate of injection of defects.You are measuring the rate of detection.
If you do this for a long time may have an idea of the injection rate of the "media" defect, & the'average detection' defect rate (per process, computer, whatever). So when a new projectcomes, you can try to predict what will happen.If the average injection rate of default is 0. 5 defects per hour of development, & the new project has 800 hours of development, six could reasonably expect 400 defects in the project. If the mean defect detection rate is 0.2 defects per hour tester, tester probably going to take 2000 hours to find all of them. Are you so long? What do you do?Numbers dashboard But beware - use these indicators as "to highlight potential problems but not hung up on them. They are indicative at best.Things alter, people alter, application changes.
So will their indicators.

No comments: