SOFTWARE TESTING METHODOLOGIES
This paper describes about the different techniques of testing the software. This paper explicitly addresses the idea for testability is an important as testing itself-not just by saying that testability is a desirable goal, but by showing how to do it. Software testing is the process used to measure the quality of developed computer software. Software Testing is not just about error-finding and their rectification but also about underlining client requirements and testing that those requirements are met by the software solution/application. It is the most important functional phase in the SDLC (Software Development Life Cycle) as it exhibits all mistakes, flaws and errors in the developed software. Without rectifying theses errors, technically termed as ‘bugs,’ software development is not considered to be complete. Hence, software testing becomes an important parameter for assuring quality of the software product. We discuss here about when to start and when to stop the testing of software. How errors or Bugs are formed and rectified. How software testing is done i.e. with the help of Team Work.
Testing is a process used to help identify the correctness, completeness and quality of developed computer software. With that in mind, testing can never completely establish the correctness of computer software.
There are many approaches to software testing, but effective testing of complex products is essentially a process of investigation, not merely a matter of creating and following rote procedure. One definition of testing is "the process of questioning a product in order to evaluate it", where the "questions" are things the tester tries to do with the product, and the product answers with its behavior in reaction to the probing of the tester. Although most of the intellectual processes of testing are nearly identical to that of review or inspection, the word testing is connoted to mean the dynamic analysis of the product—putting the product through its paces. The quality of the application can and normally does vary widely from system to system but some of the common quality attributes include reliability, stability, portability, maintainability and usability. Testing helps is verifying and validating if the Software is working as it is intended to be working. Things involve using Static and Dynamic methodologies to Test the application. Because of the fallibility of its human designers and its own abstract, complex nature, software development must be accompanied by quality assurance activities. It is not unusual for developers to spend 40% of the total project time on testing. For life-critical software (e.g. flight control, reactor monitoring), testing can cost 3 to 5 times as much as all other activities combined. The destructive nature of testing requires that the developer discard preconceived notions of the correctness of his/her developed software. The importance of software testing and its impact on software cannot be underestimated. Software testing is a fundamental component of software quality assurance and represents a review of specification, design and coding.
Software Testing Fundamentals:
Testing is the one step in the software process that can be seen by the developer as destructive instead of constructive. Software engineers are typically constructive people and testing requires them to overcome preconceived concepts of correctness and deal with conflicts when errors are identified.
Testing objectives include
1. Testing is a process of executing a program with the intent of finding an error.
2. A good test case is one that has a high probability of finding an as yet undiscovered error.
3. A successful test is one that uncovers an as yet undiscovered error.
2. A good test case is one that has a high probability of finding an as yet undiscovered error.
3. A successful test is one that uncovers an as yet undiscovered error.
Testing should systematically uncover different classes of errors in a minimum amount of time and with a minimum amount of effort. A secondary benefit of testing is that it demonstrates that the software appears to be working as stated in the specifications. The data collected through testing can also provide an indication of the software's reliability and quality. But, testing cannot show the absence of defect -- it can only show that software defects are present.
When Testing should be started?
Testing early in the life cycle reduces the errors. Test deliverables are associated with every phase of development. The goal of Software Tester is to find bugs, find them as early as possible, and make them sure they are fixed.
The number one cause of Software bugs is the Specification. There are several reasons specifications are the largest bug producer.
In many instances a Spec simply isn’t written. Other reasons may be that the spec isn’t thorough enough, it’s constantly changing, or it’s not communicated well to the entire team. Planning software is vitally important. If it’s not done correctly bugs will be created.
The next largest source of bugs is the Design, That’s where the programmers lay the plan for their Software. Compare it to an architect creating the blue print for the building, Bugs occur here for the same reason they occur in the specification. It’s rushed, changed, or not well communicated.
Coding errors may be more familiar to you if you are a programmer. Typically these can be traced to the Software complexity, poor documentation, schedule pressure or just plain dump mistakes. It’s important to note that many bugs that appear on the surface to be programming errors can really be traced to specification. The other category is the catch-all for what is left. Some bugs can blamed for false positives, conditions that were thought to be bugs but really weren’t. There may be duplicate bugs, multiple ones that resulted from the square root cause. Some bugs can be traced to Testing errors.
When should we Stop Testing?
This can be difficult to determine. Many modern software applications are so complex, and run in such as interdependent environment, that complete testing can never be done. "When to stop testing" is one of the most difficult questions to a test engineer. Common factors in deciding when to stop are:
· Deadlines (release deadlines, testing deadlines.)
· Test cases completed with certain percentages passed
· Test budget depleted
· Coverage of code/functionality/requirements reaches a specified point
· The rate at which Bugs can be found is too small
· Beta or Alpha Testing period ends
· The risk in the project is under acceptable limit.
Practically, we feel that the decision of stopping testing is based on the level of the risk acceptable to the management. As testing is a never ending process we can never assume that 100 % testing has been done, we can only minimize the risk of shipping the product to client with X testing done. The risk can be measured by Risk analysis but for small duration / low budget / low resources project, risk can be deduced by simply: -
· Measuring Test Coverage.
· Number of test cycles.
· Number of high priority bugs.
Concepts for Application Test Management:
Testing should be pro-active following the V-model. Test execution can be a manual process, Test execution can be an automated process. It is possible to plan the start date for testing. It is not possible to accurately plan the end date of testing. Ending testing is through risk assessment. A fool with a tool is still a fool Testing is not a diagnosis process. Testing is a triage process. Testing is expensive Not testing, can be more expensive.
How Software Defects Arise?
The International Software Testing Qualifications Board says that software faults occur through the following process:
A human being can make an error (mistake), which produces a defect (fault, bug) in the code, in software or a system, or in a document. If a defect in code is executed, the system will fail to do what it should do (or do something it shouldn’t), causing a failure. Defects in software, systems or documents may result in failures, but not all defects do so.
A fault can also turn into a failure when the environment is changed. Examples of these changes in environment include the software being run on a new hardware platform, alterations in source data or interacting with different software.
Inability to find all faults:
A problem with software testing is that testing all combinations of inputs and preconditions is not feasible when testing anything other than a simple product. This means that the number of defects in a software product can be very large and defects that occur infrequently are difficult to find in testing.
When Testing is Carried Out?
A common practice of software testing is that it is performed by an independent group of testers after the functionality is developed but before it is shipped to the customer. This practice often results in the testing phase being used as project buffer to compensate for project delays, thereby compromising the time devoted to testing. Another practice is to start software testing at the same moment the project starts and it is a continuous process until the project finishes.
Another common practice is for test suites to be developed during technical support escalation procedures. Such tests are then maintained in regression testing suites to ensure that future updates to the software don't repeat any of the known mistakes.
Measuring Software Testing:
Usually, quality is constrained to such topics as correctness, completeness, security, but can also include more technical requirements as described under the ISO standard ISO 9126, such as capability, reliability, efficiency, portability, maintainability, compatibility, and usability.
Testing is a process of technical investigation, performed on behalf of stakeholders, that is intended to reveal quality-related information about the product with respect to the context in which it is intended to operate. This includes, but is not limited to, the process of executing a program or application with the intent of finding errors. Quality is not an absolute; it is value to some person. With that in mind, testing can never completely establish the correctness of arbitrary computer software; testing furnishes a criticism or comparison that compares the state and behavior of the product against a specification. An important point is that software testing should be distinguished from the separate discipline of Software Quality Assurance (SQA), which encompasses all business process areas, not just testing. Today, software has grown in complexity and size. The software product developed by a developer is according to the System Requirement Specification. Every software product has a target audience. For example, video game software has its audience completely different from banking software. Therefore, when an organization invests large sums in making a software product, it must ensure that the software product must be acceptable to the end users or its target audience. This is where Software Testing comes into play. Software testing is not merely finding defects or bugs in the software; it is the completely dedicated discipline of evaluating the quality of the software.
There are 4 Testing Steps:
1. Select what has to be measured
Code tested for correctness with respect to:
Ø Detailed Design
2. Decide how the testing is done for each level of testing
Ø Code inspection
Ø Black-box, white box, grey box.
Ø Select integration testing strategy (big bang, bottom up, top down, sandwich)
3. Develop test cases
Ø A test case is a set of test data or situations that will be used to exercise the unit (code, module, system) being tested or about the attribute being measured.
4. Create the test oracle
Ø An oracle contains of the predicted results for a set of test cases i.e., expected output for each test.
Ø The test oracle has to be written down before the actual testing takes place.
Ø This is the difficult step
White box, black box, and grey box testing:
White box and black box testing are terms used to describe the point of view that a test engineer takes when designing test cases.
Black box testing treats the software as a black-box without any understanding as to how the internals behave. It aims to test the functionality according to the requirements. Thus, the tester inputs data and only sees the output from the test object. This level of testing usually requires thorough test cases to be provided to the tester who then can simply verify that for a given input, the output value (or behavior), is the same as the expected value specified in the test case.
White box testing, however, is when the tester has access to the internal data structures, code, and algorithms. For this reason, unit testing and debugging can be classified as white-box testing and it usually requires writing code, or at a minimum, stepping through it, and thus requires more knowledge of the product than the black-box tester. If the software in test is an interface or API of any sort, white-box testing is almost always required. In recent years the term grey box testing has come into common usage. This involves having access to internal data structures and algorithms for purposes of designing the test cases, but testing at the user, or black-box level. Manipulating input data and formatting output do not qualify as grey-box because the input and output are clearly outside of the black-box we are calling the software under test. This is particularly important when conducting integration testing between two modules of code written by two different developers, where only the interfaces are exposed for test.
Grey box testing could be used in the context of testing a client-server environment when the tester has control over the input, inspects the value in a SQL database, and the output value, and then compares all three (the input, SQL value, and output), to determine if the data got corrupt on the database insertion or retrieval.
Software Testing Life Cycle:
Requirements Analysis: Testing should begin in the requirements phase of the software development life cycle. During the design phase, testers work with developers in determining what aspects of a design are testable and with what parameters those tests work.
Test Planning: Test Strategy, Test Plan(s), Test Bed creation.
A lot of activities will be carried out during testing, so that a plan is needed.
Test Development: Test Procedures, Test Scenarios, Test Cases, and Test Scripts to use in testing software.
Test Execution: Testers execute the software based on the plans and tests and report any errors found to the development team.
Test Reporting: Once testing is completed, testers generate metrics and make final reports on their test effort and whether or not the software tested is ready for release.
Retesting the Defects. Not all errors or defects reported must be fixed by a software development team. Some may be caused by errors in configuring the test software to match the development or production environment. Some defects can be handled by a workaround in the production environment. Others might be deferred to future releases of the software, or the deficiency might be accepted by the business user. There are yet other defects that may be rejected by the development team (of course, with due reason) if they deem it.
What should the Test Team do?
Ø Programmer Management
Ø Strong Change Management
Ø Strict Configuration Control
Ø Pro Active Scope Creep Management
Ø Inclusion in the decision making process
What are the Test Team Deliverables?
Ø Test Plans
Ø Test Script Planner
Ø Test Scripts
Ø Test Execution Results
Ø Defect Reports
Software testing accounts for a large percentage of effort in the software development process, but we have only recently begun to understand the subtleties of systematic planning, execution and control. For an IT organization, developing a software system that meets the business needs of clients is always a challenge. The company needs to ensure that the software system that gets delivered to their clients is free from bugs or defects and achieves the demands as per client requirements. But this can only be ensured by following rigorous software testing and quality assurance procedures.
Software testing is a process without which the Software Development Life Cycle (SDLC) stands incomplete. It is the process that identifies the correctness, completeness and quality of the software developed during the SDLC process. Software bugs and improperly tested codes cost millions in damages and millions more in time and money to fix the defect. Organizations try to develop software applications that should act in a way that cause the least amount of surprises to the user. In short they should be bug free. New paradigms of software testing are being adopted and used in the process of software development.
Due to this, the software testing field has emerged from the shadows in the world IT space and has claimed its rightful place in the IT market. Gone are the days when software testing was considered a poor cousin of software development. In this article, we talk about software testing techniques, trends that are coming up in this arena and also new software development paradigms.
The ways in which testing can be done are broadly classified as Manual Testing and Automated Testing.
Ø The manual testing of the software happens in several phases. Self-testing, which is done by developers themselves or by small development teams, should be restricted to build cycle itself and should be done while the software development is in the production stage. The errors of the Bugs can be Corrected or Verified easily by the Performance of the Team. Hence there should be a good understanding between the Team Members by which we get the Software Tested Successfully. It encourages team and organisational learning
Ø Team Work focuses team efforts towards the respective goals.(i.e., intent of finding the errors)
Ø Team Work increases motivation and accountability of individual employees by which knowledge will be shared among themselves.
Ø Team Work encourages continuous improvement.
Ø Team Work provides adequate feedback thus, allowing situational awareness, capability assessment, problem diagnosis, intervention and remediation.