Archive for the ‘SoftwareTesting’ Category

Software testing

Software testing, depending on the testing method employed, can be implemented at any time in the development process. However, most of the test efforts occurs after the requirements have been defined and the coding process has been completed. As such, the methodology of the test is governed by the software development methodology adopted.

Testing Methods:

  • White box testing: when the tester have the access to the internal data structure and algorithm including the code that implement those; Types of white box testing:
    • API testing ::: testing of the application using public or private API
    • Code coverage ::: creating tests to satisfy some criteria of code coverage, e.g., the test designer can create tests to cause all statements in the program to be executed at least once
    • Fault injection ::: improving the coverage of a test by introducing faults to test code paths
    • Mutation testing :::
    • Static testing :::

White box test coverage:

  1. Function coverage: which reports on functions executed
  2. Statements coverage: which reports on the number of lines executed to complete the test
  • Black box testing: when the tester has no any knowledge of internal implementation; Types of black box testing:
    • equivalence partitioning
    • boundary value analysis
    • all-pairs testing
    • fuzz testing
    • model-based testing
    • traceability matrix
    • exploratory testing

Testing Levels:

  • Unit testing: refers to tests that verify the functionality of a specific section of code, usually at the function level. In OO environment, this is usually at the class level, and the minimal unit tests include the constructors and destructors. These type of tests are usually written by developers as they work on code, to ensure that the specific function is working as expected.
  • Integration testing: a type of software testing that seeks to verify the interface between components against a software design. Integration testing works to expose defects in the interface and interaction between integrated components. Progressively larger groups of tested software components corresponding to elements of the architectural design are integrated and tested until the software works as a system.
  • System testing: tests a completely integrated system to verify that it meets its requirements
  • System integration testing: verifies that a system is integrated to any external or third-party systems defined in the system requirements.
  • Regression testing: focuses on finding defects after a major code change has occurred. Specifically, it seeks to uncover software regressions, or old bugs that have come back.Such regressions occur whenever software functionality that was previously working correctly stops working as intended. Typically, regressions occur as an unintended consequence of program changes, when the newly developed part of the software collides with the previously existing code. Common methods of regression testing include re-running previously run tests and checking whether previously fixed faults have re-emerged. The depth of testing depends on the phase in the release process and the rish of the added features. They can either be complete, for changes added late in the release or deemed to be risky, to very shallow, consisting of positive tests on each feature, if the changes are early in the release or deemed to be of low risk.

Sample testing cycle

  1. requirements analysis: Testing should start 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.
  2. testing plan: Test strategy, test plan, testbed creation.
  3. test development: Test procedure, test scenario, test cases, test datasets, test scripts to use in testing software.
  4. test execution: Testers execute the software based on the test plan and test documents then reports error to R&D if any
  5. test reporting: Testers generate test matrix and make final reports on there test efforts
  6. test analysis: Defect analysis
  7. defect retesting: Once a defect has been dealt with by R&D team, retest by the testing team
  8. Regression testing: It is common to have a small test program built of a subset of tests, for each integration of new, modified, or fixed software, in order to ensure that latest delivery has not ruined anything

Read Full Post »