Posts Tagged ‘Testing’

Difference between System Testing and System Integration Testing:

1. Integration testing is a testing in which individual software modules are combined and tested as a group while System testing is a testing conducted on a complete, integrated system to evaluate the system’s compliance with its specified requirements.

2. Integration testing is testing the interface between the modules; it can be top down, bottom up, big bang while System testing is testing the end to end business scenarios in the environment which is similar to production environment.

3. System testing will be conducting at final level while Integration testing will be done at each time of module binding or a new module need to bind with the system.

4. System testing is a high level testing while Integration testing is low level testing. In simple words on completion of integration testing, system testing started not vice versa.

5. Test cases Integration testing are created with the express purpose of exercising the interfaces between the components or modules while test cases for System testing are developed to simulated the real life scenarios.

6. For Example if an application has 8 modules. Testing the entire application with all 8 modules combined, we call it System testing and if application interacts with some other applications (External systems) to retrieve or send data, to test with other application and external system or any other module we call it Integration testing or system integration testing.

Difference between Sanity and Smoke Testing:

Smoke Testing:

  • When a build is received smoke testing is done to ensure that whether the build is ready or stable for further testing.
  • Smoke testing is a wide approach where all areas of software application are tested without getting into deeper.
  • Test Cases for smoke testing can be manual or automated.
  • A smoke test is basically designed to touch each and every part of an app in a cursory way.
  • Smoke testing is Shallow and wide.
  • Smoke testing is conducted to ensure whether the most crucial functions of a program are working, but not bothering with finer details.
  • Smoke testing is like General Health Check Up

Sanity Testing:

  • After receiving a software build, with minor changes in code, or functionality, Sanity testing is performed to ascertain that the bugs have been fixed and no further issues are introduced due to these changes. The goal is to determine that the proposed functionality works roughly as expected.
  • Sanity testing exercises only the particular component of the entire system.
  • A sanity test is usually unscripted and without test scripts or test cases.
  • Sanity Testing is narrow and deep
  • Sanity testing is to verify whether requirements are met or not, checking all features breadth-first
  • Sanity Testing is like specialized health check up
English: Blue ink on the inspection sheet indi...

English: Blue ink on the inspection sheet indicates to the students that they are a “go” during the sling load hands-on testing in the Camp Robertson Training Area Oct. 8. (Photo credit: Wikipedia)

Difference between Load Testing and Stress Testing:

  • Testing the app with maximum number of user and input is defined as load testing. While testing the app with more than maximum number of user and input is defined as stress testing.
  • In Load testing we measure the system performance based on a volume of users. While in Stress testing we measure the breakpoint of a system.
  • Load Testing is testing the application for a given load requirements which may include any of the following criteria:
    •  Total number of users.
    •  Response Time
    • Through Put
    • Some parameters to check State of servers/application.
  • While stress testing is testing the application for unexpected load. It includes
    • Vusers
    • Think-Time

Example:

If an app is build for 500 users, then for load testing we check up to 500 users and for stress testing we check greater than 500.

Difference between white box testing and black box testing:

White box testing:

  • White box testing is done by the Developers. This requires knowledge of the internal coding of the software.
  • White box testing is concerned with testing the implementation of the program. The intent of this testing is not to exercise all the different input or output conditions, but to exercise different programming structures and data structures used in the program. It is commonly called structural testing.
  • White box testing mainly applicable to lower levels of testing: Unit testing and Integration Testing.
  • Implementation knowledge is required for white box testing.

Black box testing:

  • Black box testing is done by the professional testing team. This does not require knowledge of internal coding of the application. Testing the application against the functionality of the application without the knowledge of internal coding of the software.
  • In Black box testing the structure of the program is not considered. Test cases are decided solely on the basis of the requirements or specification of the program or module.
  • Black box testing mainly applicable to higher levels of testing: Acceptance Testing and System Testing.
  • Implementation knowledge is not required for black box testing.

Verification and Validation:

Verification:

Verification is to determine the right thing, which involves the testing the implementation of right process. Example: Are we building the product right?

Verification is Static. This means in Verification the s/w is inspected by looking into the code going line by line or function by function.

In verification code is reviewed, location of the defect can be found.

Verification Techniques:

There are many different verification techniques but they all basically fall into 2 major categories – dynamic testing and static testing.

  • Dynamic testing – Testing that involves the execution of a system or component. Basically, a number of test cases are chosen where each test case consists of test data. These input test cases are used to determine output test results. Dynamic testing can be further divided into three categories – functional testing, structural testing, and random testing.
  • Structural testing – Testing that has full knowledge of the implementation of the system and is an example of white-box testing. It uses the information from the internal structure of a system to devise tests to check the operation of individual components. Functional and structural testing both chooses test cases that investigate a particular characteristic of the system.
  • Functional testing – Testing that involves identifying and testing all the functions of the system as defined within the requirements. This form of testing is an example of black-box testing since it involves no knowledge of the implementation of the system.
  • Random testing – Testing that freely chooses test cases among the set of all possible test cases. The use of randomly determined inputs can detect faults that go undetected by other systematic testing techniques. Exhaustive testing, where the input test cases consists of every possible set of input values, is a form of random testing. Although exhaustive testing performed at every stage in the life cycle results in a complete verification of the system, it is realistically impossible to accomplish.
  • Static testing – Testing that does not involve the operation of the system or component. Some of these techniques are performed manually while others are automated. Static testing can be further divided into 2 categories – techniques that analyze consistency and techniques that measure some program property.
  • Measurement techniques – Techniques that measure properties such as error proneness, understandability, and well-structuredness.

Validation – is to perform the things in right direction, like checking the developed software adheres the requirements of the client. Ex: right product was built.Validation is Dynamic. In Validation, code is executed and s/w is run to find defects.In Validation location of the defect can’t be found.

Validation Techniques:

There are also numerous validation techniques, including formal methods, fault injection, and dependability analysis.

  • Formal methods – Formal methods is not only a verification technique but also a validation technique. Formal methods mean the use of mathematical and logical techniques to express, investigate, and analyze the specification, design, documentation, and behavior of both hardware and software.
  • Fault injection – Fault injection is the intentional activation of faults by either hardware or software means to observe the system operation under fault conditions.
  • Software fault injection – Errors are injected into the memory of the computer by software techniques. Software fault injection is basically a simulation of hardware fault injection.
  • Risk analysis – Takes hazard analysis further by identifying the possible consequences of each hazard and their probability of occurring.
  • Hardware fault injection – Can also be called physical fault injection because we are actually injecting faults into the physical hardware.

STLC (Software Test Life Cycle):

Software testing life cycle (STLC) identifies what test activities to carry out i.e. the process of testing software in a well planned and systematic way is known as software testing lifecycle (STLC).STLC consists of six different phases.

1.Requirements Analysis:

In this phase testers analyze the customer requirements and work with developers during the design phase to see which requirements are testable.

2.Test Planning:

In this phase all the planning about testing is done like what needs to be tested, how the testing will be done, test strategy to be followed, what will be the test environment, what test methodologies will be followed, hardware and software availability, resources, risks etc. During the planning stage, the team of senior level persons comes out with an outline of Testing Plan at High Level. Test plan describe the following:

o   Scope of testing

o   Identification of resources

o   Identification of test strategies

o   Identification of Risks

o   Time schedule

3. Test Case Development:

In this phase test cases are created by tester for testing. In case of automation testing test scripts are created by the tester. This phase also involves the following activities:

o   Revision & finalization of Matrix for Functional Validation.

o   Revision & finalization of testing environment.

o   Review and baseline test cases and scripts

4.     Test Environment setup:

This phase involves the following activities:

  • Understand the required architecture, environment set-up.
  • Prepare hardware and software requirement list
  • Finalize connectivity requirements
  • Setup test Environment and test data
  • Prepare environment setup checklist

5.   Test Execution and Bug Reporting:

In this phase test cases are executed and defects are reported in bug tracking tool, after the test execution is complete and all the defects are reported. After developers fixes the bugs which are reported by the tester, tester conduct the regression testing to ensure that bug has been fixed and not affected any other areas of software

6. Test Cycle closure:

This phase involves the following activities:

  • Track the defects to closure
  • Evaluate cycle completion criteria based on – Time, Test coverage , Cost , Software Quality , Critical  Business ObjectivesPrepare test metrics based on the above parameters.
  •  Prepare Test closure report
  • Test result analysis to find out the defect distribution by type and severity