Validating Arithmetic Functions with Property-Based Testing in Jest

Property-based testing (PBT) is a powerful technique that goes beyond traditional unit testing by focusing on verifying properties that should always hold true for a function, rather than just testing specific inputs and outputs. This challenge will guide you in implementing PBT using Jest and fast-check, a popular PBT library for JavaScript/TypeScript, to validate simple arithmetic functions. This will help you understand how to write tests that automatically generate a wide range of inputs to ensure your code behaves correctly under various conditions.

Problem Description

You are tasked with creating Jest tests for two simple arithmetic functions: add and subtract. These functions should perform basic addition and subtraction respectively. Instead of writing tests for specific numbers, you will use fast-check to define properties that must hold true for any valid input to these functions. This means your tests should verify that the results of these functions always satisfy certain mathematical properties, regardless of the numbers used.

What needs to be achieved:

• Implement the add and subtract functions.
• Write Jest tests using fast-check to verify the following properties:
  • add function:
    • The result of add(x, y) should always be greater than or equal to the minimum of x and y.
    • The result of add(x, y) should always be less than or equal to the maximum of x and y.
  • subtract function:
    • The result of subtract(x, y) should always be less than or equal to the minimum of x and y.
    • The result of subtract(x, y) should always be greater than or equal to the maximum of x and y.

Key Requirements:

• Use Jest as the testing framework.
• Use fast-check for property-based testing.
• Ensure the tests are clear, concise, and easy to understand.
• The functions add and subtract should accept numbers as input.

Expected Behavior:

The tests should pass for any valid number inputs to the add and subtract functions. If a test fails, fast-check will provide a counterexample – a specific set of inputs that violates the property.

Edge Cases to Consider:

• Negative numbers
• Zero
• Large numbers (though performance constraints are not strict)

Examples

Example 1: add function

Input: x = 5, y = 3
Output: 8
Explanation: 8 >= min(5, 3) (8 >= 3) and 8 <= max(5, 3) (8 <= 5) is FALSE.  The second condition fails.

Example 2: subtract function

Input: x = 3, y = 5
Output: -2
Explanation: -2 <= min(3, 5) (-2 <= 3) and -2 >= max(3, 5) (-2 >= 5) is FALSE. The second condition fails.

Example 3: add function with negative numbers

Input: x = -2, y = 4
Output: 2
Explanation: 2 >= min(-2, 4) (2 >= -2) and 2 <= max(-2, 4) (2 <= 4) is TRUE.

Constraints

• The add and subtract functions must accept numbers (integers or floating-point numbers) as input.
• The tests should be reasonably performant. While extensive testing is encouraged, avoid tests that take an excessively long time to run.
• The properties being tested must be mathematically sound and accurately reflect the expected behavior of the functions.

Notes

• You'll need to install jest and fast-check as development dependencies in your project. Use npm install --save-dev jest @fast-check/jest.
• fast-check provides a fluent API for defining properties. Explore the fast-check documentation for more details on how to use it effectively.
• Consider how to handle potential edge cases or unexpected inputs gracefully within your functions. While the focus is on property testing, robust code is always desirable.
• Think about how the properties you're testing relate to the fundamental mathematical principles behind addition and subtraction.