What Are Positive and Negative Tests?
In the world of software testing, there are two main categories that we use to evaluate how a function behaves: Positive Tests and Negative Tests. These tests are designed to determine if a function works as expected and handles different types of input appropriately. In my own testing practices, the majority of the tests I perform fall under the category of Positive Tests.
A Positive Test is one where we test the function with valid input to check if the function produces the expected output. For example, if we have a function that calculates the square of a number, a positive test would involve providing a valid number and verifying that the result is the correct square.
On the other hand, a Negative Test involves testing the function with invalid input, such as incorrect data types or boundary cases, to see if the function appropriately handles the error. For instance, if we try to calculate the square of a string, a negative test would ensure that the function throws an error or returns a meaningful message indicating that the input is invalid.
These two types of tests are critical for ensuring that a function is both functional and robust. While positive tests confirm that the function works under normal conditions, negative tests ensure that the function gracefully handles unexpected or erroneous input.
The Importance of Positive and Negative Tests
Why do we focus on both positive and negative tests? The short answer is that each type of test serves a distinct purpose in verifying the correctness of a function. Positive tests ensure that the function performs correctly under typical use cases, whereas negative tests help identify potential issues that could arise from improper use or unexpected inputs.
Performing only positive tests would give you confidence that the function works in ideal conditions, but it would leave your software vulnerable to issues that could arise in the real world. By including negative tests, you are actively safeguarding your application against potential errors and failures.
In essence, these tests provide a safety net for your code and ensure that it works as expected in all scenarios, whether the input is valid or invalid.
Mathematical Representation
From a theoretical perspective, we can express these two test types using mathematical notation. Consider a function f(x) where x is the input, and the function is expected to produce an output f(x) for valid inputs.
- For a valid input P (such as a number), we expect the function to produce the expected output:
∀x ∈ P, f(x) = Expected Output
- For an invalid input ¬P (such as a string or null value), we expect the function to throw an error or handle the situation gracefully:
∀x ∈ ¬P, f(x) = Exception ∨ Error
Example of Testing
To illustrate this further, let’s take a look at an example of a positive test. Suppose we have a function called calculateSquare that computes the square of a number. A positive test would check if the function correctly computes the square for valid inputs.
function calculateSquare(x) {
return x * x;
}
For the positive test, we might write:
assertEquals(25, calculateSquare(5)), where we are verifying that the square of 5 is indeed 25.
In contrast, a negative test might check how the function behaves when given invalid input, such as a string:
function calculateSquare(x) {
if (typeof x !== 'number') {
throw new Error('Invalid input');
}
return x * x;
}
In this case, we could write a negative test like:
assertThrows(Error, () => calculateSquare("five")), which checks that the function throws an error when the input is a string.
Both tests are important because they validate that the function works correctly in expected scenarios (positive test) and that it fails gracefully in edge cases (negative test).