Black box test cases are typically written first, followed by white box test cases, which require a good level of architectural clarity. This is unavailable during the early stages of the project; hence, it is impossible to write white box test cases early.

Unlike white-box test cases, black-box test cases, demand requirements documents, and design/project plans. These are available early in the project. Hence, we write black-box test cases first.

The right-hand thumb rule for software testing is that the later the defect is removed, the more costly its removal becomes. The best phases to remove the defects are the requirements and design phases.

Defects escaping the design and requirements phases can become as much as:

• 5 times costlier to remove in the execution/development phase,
• 8 times costlier when removed during the testing phase,
• 10 times costlier to remove during the implementation/deployment phase, and
• 20 times costlier when removed during the maintenance phase of the software product.

Following are the three primary categories of software defects:

• Wrong – Results when there is a deviation from the given specifications. This type of defect occurs when requirements are implemented incorrectly.
• Missing – This happens when customer specifications are missed, i.e., they are not implemented. This might also happen when customer requirements are not clear but implemented.
• Extra – Caused by requirements that are implemented but are not provided by the customer(s). Although this type of defect is variances from the customer specifications, they might be desired by the end-users.

Following are the important differences between functional testing and non-functional testing:

• Based On – While functional testing is based on customer requirements, non-functional testing is based on customer expectations.
• Defines – Functional testing describes what aspect of a software product. Non-functional testing, on the other hand, defines how the aspect of a software application.
• Order of Performing – Non-functional testing follows functional testing.

Bug Life Cycle explains the various phases of a software bug or defect’s entire lifetime. It starts with detecting a bug and sums up when the same is closed, and it is ensured that it will not reproduce. Its various phases are:

• Detection/new
• Assigned
• Active
  • Rejected
  • Deferred
• Tested
  • Reopened (goes to the Active phase)
• Verified
• Closed

The Bug Life Cycle, also known as Defect Life Cycle, varies according to a range of factors, most notably organization policy and the SDLC methodology used, such as agile or RAD. Other Defect Life Cycle shaping factors include project timelines and team structure.

There are three types of software testing:

1. Black Box Testing – Based completely on testing requirements and specifications. Demands no knowledge about:
   1. Internal paths,
   2. Code structures, or
   3. Software implementation.
2. White Box Testing – Necessitates advanced programming skills. This testing strategy builds upon the internal paths, code structures, and software implementation.
3. Grey Box Testing – This software testing strategy falls between the domains of black box and white box testing strategies. Here, the internal details of the software under testing are little-known.