Fundamental Concepts

Understanding Software Testing Fundamentals

Introduction to Software Testing Concepts

• Before discussing software testing, it's crucial to understand fundamental concepts and terminology, which can often be confusing.

• The requirements engineer interviews stakeholders to gather specifications that developers use to write code. Testers also play a role by reading these requirement documents.

Role of the Tester

• Testers execute tests manually or implement automated tests that simulate system usage, ensuring the system behaves as expected.

• Tests can focus on specific parts of the system rather than the entire application, allowing for targeted validation of functionality.

User Feedback and Bug Reporting

• Users may notice discrepancies in system behavior compared to their expectations and report these issues through bug reports.

• Bug reports serve as critical information sources for testers, who analyze them alongside source code to create tests aimed at preventing recurrence of reported issues.

Quality Assurance Challenges

• The primary goal of testing is quality assurance; however, achieving absolute guarantees is often impossible for non-trivial systems.

• Testing provides evidence that key functionalities work under specific conditions but cannot ensure performance across all scenarios.

Importance of Test Suites

• A strong suite of tests offers robust evidence that main functionalities are operating correctly. The strength of this suite directly impacts confidence in the system's reliability.

Understanding Software Failures and Bugs

The Importance of Investment in Development

• High investment in development teams is essential, as it compensates for various factors beyond just identifying bugs.

• This investment aids in ensuring that the main functionalities of the system operate as expected while also improving code quality through modularity and readability via refactoring.

Clarifying Terminology: Failure, Bug, and Error

• A deeper understanding of terminology is necessary to grasp concepts discussed in literature; vague definitions can lead to confusion.

• A "failure" occurs when a user observes unexpected behavior from the system, such as exceptions or error messages during execution.

Distinctions Between Key Terms

• The term "bug" refers to a defect within the source code that causes a failure observable by users.

• An "error" represents an internal issue within the system's state that may not be visible to users but can lead to failures.

Internal vs. External Observations

• Errors manifest internally (e.g., incorrect data storage), while failures are external observations made by users (e.g., incorrect outputs).

• Understanding these distinctions helps clarify how defects in code translate into observable failures during software operation.

The Process Leading to Failures

• For a bug to cause a failure, it must first be executed under conditions that trigger its effects; merely existing does not guarantee visibility.

• A failure is characterized by user observation of incorrect results or behaviors due to underlying bugs being executed with problematic inputs.

The IPE Model: Understanding Failure Occurrence

• The IPE model outlines how failures occur: first, a defect must be reached and executed; then it needs specific values that cause an error.

• After execution with triggering values, if the resulting state leads to observable issues for users, this constitutes a failure.

Summary of Key Concepts

• In summary:

• Failure: Observable issue during execution (external).

• Bug/Defect: Incorrect lines of code causing potential issues (static).

Understanding System Representation and Testing

Internal State of the System

• The concept of internal state in a system is linked to its representation as a state machine, where transitions occur based on operations or functionalities that the system can perform.

State Machine and Scenarios

• The state machine model allows for the representation of various paths through scenarios, which detail step-by-step behavior of the system.

Testing as Path Verification

• Tests are characterized as paths within this state machine, starting from an initial state (given in scenarios) and leading to a final state after actions are performed.

Test Setup and Verification

• Each test involves setting up conditions (the "given" scenario), executing actions (represented by edges in the graph), and verifying if the final state meets expected properties.

Test Suite Composition

• A document may contain multiple test scenarios; these collectively form a test suite. In this case, two scenarios lead to three distinct test cases due to variations in inputs (e.g., different user roles).

Detailed Scenario Execution