System Testing : Testing objectives and principles

 Testing objectives and principles

• TESTING OBJECTIVES : 
• 1. To Find any defects or bugs that may have been created when the software was being developed.
• 2. To increase confidence in the quality of the software.
• 3. To prevent defects in the final product.
• 4. To ensure the end product meets customer requirements as well as the company specifications.
• 5. To provide customers with a quality product and increase their confidence in the company.

TESTING PRINCIPLES : 

Software testing is a process of executing a program with the aim of finding the error. To make our software perform well it should be error free. If testing is done successfully it will remove all the errors from the software.

There are seven principles in software testing:

1. Testing shows presence of defects
2. Exhaustive testing is not possible
3. Early testing
4. Defect clustering
5. Pesticide paradox
6. Testing is context dependent
7. Absence of errors fallacy

• Testing shows presence of defects: The goal of software testing is to make the software fail. Software testing reduces the presence of defects. Software testing talks about the presence of defects and doesn’t talk about the absence of defects. Software testing can ensure that defects are present but it can not prove that software is defects free. Even multiple testing can never ensure that software is 100% bug-free. Testing can reduce the number of defects but not removes all defects.
• Exhaustive testing is not possible: It is the process of testing the functionality of a software in all possible inputs (valid or invalid) and pre-conditions is known as exhaustive testing. Exhaustive testing is impossible means the software can never test at every test cases. It can test only some test cases and assume that software is correct and it will produce the correct output in every test cases. If the software will test every test cases then it will take more cost, effort, etc. and which is impractical.
• Early Testing: To find the defect in the software, early test activity shall be started. The defect detected in early phases of SDLC will very less expensive. For better performance of software, software testing will start at initial phase i.e. testing will perform at the requirement analysis phase.
• Defect clustering: In a project, a small number of the module can contain most of the defects. Pareto Principle to software testing state that 80% of software defect comes from 20% of modules.
• Pesticide paradox: Repeating the same test cases again and again will not find new bugs. So it is necessary to review the test cases and add or update test cases to find new bugs.
• Testing is context dependent: Testing approach depends on context of software developed. Different types of software need to perform different types of testing. For example, The testing of the e-commerce site is different from the testing of the Android application.
• Absence of errors fallacy: If a built software is 99% bug-free but it does not follow the user requirement then it is unusable. It is not only necessary that software is 99% bug-free but it also mandatory to fulfill all the customer requirements.

System Testing : Testing and debugging definition

 

Testing and debugging definition

Both Testing and Debugging are the most important steps during the development and after the development of any software or application developed in any programming language. Now on the basis of features and method of software development we can distinguish between Testing and Debugging.

Differences between Testing and Debugging :-

Sr. No.	Key	Testing	Debugging
1	Definition	Technically Testing is a process to check if the application is working same as it was supposed to do, and not working as it was not supposed to do.	On other hand Debugging is the activity performed by developers to fix the bug found in the system.
2	Objective	Main objective of Testing is to find bugs and errors in an application which get missed during the unit testing by the developer.	On other hand the main objective of Debugging is to find the exact root cause at code level to fix the errors and bugs found during the testing.
3	Perform	As Testing is mainly to find out the errors and bugs is mainly performed by the testers. Also if testing is at developer end known as unit testing then it is performed by the Developer.	While on other hand Debugging is to find the missing or de-faulty code in an application hence major performed by the developers only.
4	Knowledge Required	As Testing covers the functional and behavioral flow of an application so only functional knowledge is required for the tester to perform the testing.	On other hand Debugging is to find the error at code level so technical and code level knowledge is required for the developer to perform debugging.
5	Automation	Testing can be manual or made automated with the help of different tools.	On other hand Debugging can't be get automated it is always be the manual.
6	Level	Testing on basis of level of performing is at different level i.e., unit testing, integration testing, system testing, etc.	On other hand no such level of Debugging is possible.