Software Testing

Software testing refers to the process of evaluating software to ensure its correct performance in various scenarios that may be encountered during its usage. In other words, it involves identifying potential errors in software to ensure correct, accurate, and optimal functioning throughout its lifecycle. The better the software can handle various events in a desirable and acceptable manner—both in terms of performance and user experience—the better we can expect its performance to be.

Software testing involves executing parts (components) of the program or sections of the system to evaluate the system’s specified requirements. Generally, these specifications determine whether each program component meets the following criteria during the testing process:

• Has it met the requirements that guided the software’s development and design?
• Does it respond appropriately to various inputs?
• Does it perform its function within an acceptable timeframe?
• Is it sufficiently efficient?
• Can it be installed and run in the environment for which it was planned?
•  Has it achieved the overall results desired by investors?

As the number of possible tests, even for simple program components, is often limitless, all testers use methods that conduct simple yet suitable tests for the time and resources available. Consequently, software testing generally aims to execute the program or application with an approach focused on finding programming holes. The testing process is iterative, meaning that once a programming bug is fixed, testing must be repeated because fixing one bug may reveal other, deeper, or even new bugs. Software testing can provide vital and independent information about the program’s quality and the risk of failure or inadequacy for users or system sponsors. Testing can be performed when the program is fully or partially available. The software development process typically specifies when and how software testing occurs. For instance, in phased development processes, most testing occurs when the system’s prerequisites have been identified and then implemented in a testable program. In Agile approaches, requirements, programming, and software testing generally take place simultaneously.

In recent years, surprising statistics from the National Institute of Standards and Technology (NIST) regarding the failures of software systems have emerged. In the United States, such failures cost the economy approximately $59.5 billion annually. According to studies, employing testing throughout all phases of software production could reduce these losses by $22.2 billion. Statistics from the International Data Corporation (IDC) indicate that 40% of software budgets are spent on testing. In our country, with the growth of information and communication technology over the past few years and the local production of many required software applications, the need for this process has become increasingly felt, and neglecting it could lead to a reduction in the quality of provided systems, customer dissatisfaction, and ultimately loss of market share.

Good Testing: There is a high probability of discovering previously undetected errors through testing.
Software Testing It finds at least one undetected error. Testing only indicates the presence of an error, not its absence. The absence of errors in testing does not mean that the program is error-free.

Principles of Testing:

• Based on user requirements.
• Develop a test plan before execution.
• Write test cases.
• According to the Pareto principle, 80% of undetected errors exist in 20% of the code.
• Testing should begin from small components.
• Exhaustive testing is impossible.
• For effectiveness, testing should be conducted by an impartial third party.

Criteria for Software Testability:

• Operability: The better the software works and the more environments it can operate in, the better it can be assessed.
• Observability: The ability to see the results of the evaluation.
• Controlability: The ability to execute automated tests (e.g., the ability to run unit tests automatically using JUnit for Java).
• Decomposability: Assessment can be more targeted.
• Simplicity: Reducing architectural and logical complexity.
• Stability: Evaluating changes quantitatively.
• Understandability: The ability to comprehend the design and dependencies between components.

 Levels of Testing:

• Unit Testing
• Incremental Integration Testing
• Integration Testing
• System Testing
• Acceptance Testing