1. Testing Vs. Inspection Research Paper Diala T. Gammoh, Ph.D. Student Dr. Damla Turgut, Ph.D. University of Central Florida, Orlando Florida - 2007

2. Paper Outline – IEEE paper format using Latex Abstract Introduction Description 2.1 Testing 2.2 Inspection Testing Vs. Inspection Conclusion References

3. Abstract This research addresses the use of the inspection and testing tools, their definitions, importance, and principles. There are different perspectives among companies and organization about the applicability of each. This research will address these perspectives.

4. Introduction Several studies were done to compare inspection and testing with the result that the inspection is more favorable than the testing but it is not as widely used as testing. Both inspection and testing have the same objective to raise the quality of the software product which will save time and money, developers should be aware of the advantages and disadvantages of both of them in order to make their decisions, this research will help developers to make such a decision.

5. Software Testing Software testing is a process, or a series of processes, designed to make sure computer code does what it was designed to do and that it does not do anything unintended. Software should be predictable and consistent, offering no surprises to users

6. Software Testing Testing shouldn’t be done to show that the program works; rather, you should start with the assumption that the program contains errors (a valid assumption for almost any program) and then test the program to find as many of the errors as possible. “Testing is the process of executing a program with the intent of finding error”.

7. Software Testing To combat the challenges associated with testing economics, some strategies should be established before beginning. Two of the most prevalent strategies include: 1.Black-box – input/output driven testing 2.White-box – logic driven testing

8. Software Testing A set of vital testing principles or guidelines were Identified from “The Art of Software Testing” Book Principle 1: A necessary part of a test case is a definition of the expected output or result. Principle 2: A programmer should avoid attempting to test his or her own program. Principle 3: A programming organization should not test its own programs. Principle 4: Thoroughly inspect the results of each test. Principle 5: Test cases must be written for input conditions that are invalid and unexpected, as well as for those that are valid and expected.

9. Software Testing A set of vital testing principles or guidelines were Identified: Principle 6: Examining a program to see if it does not do what it is supposed to do is only half the battle, the other half is seeing whether the program does what it is not supposed to do. Principle 7: Avoid throwaway test cases unless the program is truly a throwaway program. Principle 8: Do not plan a testing effort under the tacit assumption that no errors will be found. Principle 9: The probability of the existence of more errors in a section of a program is proportional to the number of errors already found in that section. Principle 10: Testing is an extremely creative and intellectually challenging task.

10. Software Testing Moving beyond the psychological issues mentioned in the principles above, the most important consideration in program testing is the design and creation of effective test cases. The recommended procedure is to develop test cases using the black-box methods and then develop supplementary test cases as necessary with white-box methods.

11. Software Testing

12. From the previous figure, we can see that: -Defects are generated in each life cycle production activity. -Injected defects are removed in testing activities after code is completed. -Not all defects are removed at SHIP.

13. Software Inspection We need inspections to remove software defects at early stages and reduced cost. Inspections enable us to remove defects early in the software life cycle and it is always cheaper to remove defects earlier than later in the software life cycle. It is important to note that inspections are a way to remove defects at a lower cost, not a way to prevent defects from occurring.

14. Software Inspection

15. After Inspections, residual defects are removed during testing, but typically not all injected defects are removed. There is still a gap of latent defects that the users could potentially find. In the scenario, with inspections, the gap is smaller, due to the defects removed by inspections. This reduced gap represents a quality improvement in the product delivered to the users.

16. Testing Vs. Inspection We can notice that the inspections provide significant benefit and the publicly published data clearly demonstrate their effectiveness: -Defects are not discovered all at once during test or by the users -The increased labor hours required for fixing defects after the product is shipped is often due to loss of project team knowledge. -When fewer defects enter test, the productivity of test improves; i.e., the costs of test are lower and the time to complete test is reduced.

17. Testing Vs. Inspection It is found that testing is more popular than inspection. This is partially due to: 1- Views that Inspections can only be done one way 2- Views that they are not easy to do well 3- Management often views Inspections as an added cost, when in fact and as mentioned above will reduce costs during a project 4- With the advent of each new development tool or language, the providers and users seem to believe that Inspections do not add value or are less necessary

18. Conclusion Because of these and other factors, shortcuts in Inspection process have been taken without any proof that the change is an improvement. Some of these homegrown changes cause the Inspections process to be less effective. In turn the value of what was defined as the Inspection process is diminished.

19. Conclusion Inspections may not be the most enjoyable engineering task compared to designing and coding. Also, programmers are very possessive about artifacts they create. Inspections are labor intensive and low tech, but they do work.

20. Conclusion Since Inspections do work, they should be used until the software community has truly evolved to a position where the software process and environment permit fewer defects to be generated when software products are created.

21. References − The Art of Software Testing Book, Glenford J. Myers,2004 − High Quality Low Cost Software Inspections Book, Ronald A. Radice,2002 − Inspection vs. Testing, Gustav Evertsson, 2002 − Improvement of design specifications with inspection and testing, Winkler, D.; Riedl, B.; Biffl, S.,IEEE 2005 − http://www.featuredrivendevelopment.com/nod e/566 http://www.featuredrivendevelopment.com/nod e/566 − http://en.wikipedia.org/wiki/Main_Page http://en.wikipedia.org/wiki/Main_Page