## 1. Introduction

In software testing, we use various techniques to ensure the quality and reliability of software applications. Two important approaches are positive and negative testing.

In this tutorial, we’ll explore the concepts of positive and negative testing, their objectives, and how they contribute to software quality. We’ll provide a comprehensive understanding of these testing methodologies and their significance in the software development process.

## 2. Positive Testing

Positive testing focuses on verifying the expected behavior of an application. This is done by providing valid inputs and testing if the results and behavior match those defined in software specifications. So, during positive testing, we execute test cases that cover the intended functionalities of the software.

Therefore, positive testing checks if our application functions correctly and produces the desired output when provided with valid inputs. Thus, by adopting this approach, we can validate expected behaviors and ensure the reliability of the software.

There are various techniques of positive testing. We’ll elaborate on them in the following subsections.

### 2.1. Boundary Values

Boundary Value Analysis is a technique that examines the application’s behavior at the boundaries of valid inputs. We ensure that the software effectively handles these critical edge cases by testing values at the lower and upper limits of acceptable ranges.

For example, if a system accepts a range of values from 1 to 100, we would test inputs like 1, 100, and values just below or above those limits to verify the software’s response:

### 2.2. Equivalence Partitioning

Equivalence partitioning involves grouping valid inputs into classes or partitions. From each partition, we select representative values to test the application. This approach avoids redundant test cases if the partitioning is done right.

For instance, if an application expects a username input, we can partition it into classes like lowercase strings, uppercase strings, and numbers. We would then select representative values from each class, such as “john” for lowercase strings, “JANE” for uppercase strings, and “123” for numbers. So, there’s no need to test similar inputs such as “jane”, “JOHN”, or “222”.

### 2.3. Functional Testing

Functional testing focuses on verifying the functional requirements of the software. Test cases are designed to validate user interactions, data processing, and system responses.

For example, if testing an e-commerce website, we would define test cases to verify functions such as adding items to the cart, applying discounts, and checking out. By performing functional testing, we ensure the software performs its intended functions correctly and meets the specified requirements.

### 2.4. Regression Testing

Regression testing is essential when changes or additions are made to the software. This technique involves retesting previously validated functionality to identify any regressions or unintended side effects introduced by these changes.

For instance, if a bug fix is implemented, regression testing ensures that the fixed feature continues to work as expected and doesn’t introduce new issues. By conducting regression testing, we mitigate the risk of existing features breaking or malfunctioning due to new updates.

### 2.5. Usability Testing

Usability testing evaluates the application from a user’s perspective, examining its user-friendliness, intuitiveness, and adherence to usability standards. This technique involves gathering feedback through user interactions with the software.

For example, in testing a mobile banking application, usability testing could include tasks like transferring funds, checking account balances, and setting up notifications. By observing users’ experiences and collecting their feedback, we can identify areas for improvement and enhance the overall user experience of the application.

## 3. Negative Testing

Negative testing validates the behavior of an application when exposed to invalid inputs, unexpected conditions, and error scenarios. Unlike positive testing, which verifies expected behaviors, negative testing intentionally challenges the application with abnormal or incorrect inputs to assess how it handles such situations.

Thus, negative testing can enhance the software’s resilience, improve its error-handling capabilities, and ensure a more robust and reliable application.

Negative testing complements positive testing by addressing potential areas of weakness and ensuring the application can handle unexpected scenarios effectively.

As was the case with positive testing, there are several techniques of negative testing. Let’s describe them.

### 3.1. Invalid Inputs

This technique involves testing the application with inputs that don’t conform to the expected format. By intentionally providing invalid data, such as entering alphabetic characters in a numeric field, we can assess how the software handles and responds to such inputs.

For example, in a form validation scenario, entering “ABC” in a field that expects a numerical value should trigger an appropriate error message, preventing the user from proceeding until a valid input is provided.

### 3.2. Boundary Conditions

Another important technique is testing the application at the edges of its operational limits. This involves providing inputs that exceed the defined boundaries, pushing the limits of the software’s capabilities.

For instance, entering a very large or negative value in a field that expects a numeric range can help evaluate how the software handles these extreme conditions. Testing the boundaries ensures that the software behaves correctly and handles edge cases effectively.

### 3.3. Error Handling

Thoroughly testing the application’s error-handling capabilities is crucial for ensuring robustness. This technique intentionally triggers error conditions, such as network timeouts or database connection failures, to evaluate how the software responds and recovers from such errors.

For example, simulating a scenario where the application encounters a database connection failure should prompt the software to display a user-friendly error message and gracefully handle the situation without crashing.

### 3.4. Stress Testing

This technique subjects the application to excessive loads, high traffic, or resource constraints to assess its stability and performance under challenging conditions. As a result, stress testing helps uncover potential bottlenecks, scalability issues, or weaknesses in the software’s behavior.

For example, stress testing a web application by simulating thousands of simultaneous user requests can reveal if the application can handle the load and maintain acceptable performance levels. Let’s assume we want our application to handle 4000 parallel users. Thus, stress testing can show us if our software is capable of handling such a load:

### 3.5. Compatibility Testing

Ensuring compatibility with different platforms, operating systems, or browser versions is essential for maximizing the software’s reach and usability. Compatibility testing verifies that the software functions correctly and consistently across various environments.

For instance, testing a website across different browsers such as Chrome, Firefox, and Safari ensures that the website displays correctly and functions as intended, regardless of the browser used. Compatibility testing helps identify compatibility-related issues and provides a seamless user experience across different platforms and configurations.

## 4. Comparison

The positive and negative testing methodologies are complementary:

The negative testing’s objective is to identify vulnerabilities, weaknesses, and potential points of failure within the software. So, it focuses on the application’s behavior under invalid inputs, unexpected conditions, and error scenarios. This involves providing inputs that don’t conform to the expected format or fall outside the defined boundaries.

On the other hand, positive testing aims to validate the application’s expected behavior. It involves providing valid inputs that conform to the expected format and fall within the defined boundaries. Further, the focus is on verifying the proper functioning of the application under normal operating conditions.