Characterization Tests in C++ for Legacy Code

Welcome to the second lesson of the "Increasing Code Test Coverage" course! In our previous lesson, we explored the importance of code test coverage and how it ensures software quality and developer confidence. Today, we will delve into a specific type of testing known as characterization tests. These tests are invaluable when working with legacy code, as they help document the current behavior of a system without altering its functionality. By the end of this lesson, you'll understand how to use characterization tests to increase code coverage effectively.

Characterization tests are designed to capture the existing behavior of a system. They are particularly useful when dealing with legacy code that lacks documentation or tests. The primary goal of these tests is not to find bugs but to document what the code currently does. This understanding is crucial when you need to make changes or refactor the code, as it provides a safety net that ensures you don't inadvertently alter the intended behavior.

Another important aspect of characterization tests is their ability to capture the subtle nuances of a system that aren't immediately apparent from class or method names alone.

For example, consider a method in an order processing system that calculates the total order amount and applies discounts. A characterization test for this method would verify that the current logic correctly calculates the total and applies discounts as expected, even if the logic is flawed. This way, you can confidently refactor the code, knowing that the test will alert you if the behavior changes unexpectedly.

Without tests, it's difficult to understand the code's behavior, making modifications risky. Characterization tests offer a solution by allowing you to explore and document the code's behavior safely. By writing tests that capture the current functionality, you create a baseline that helps identify unintended changes during future modifications.

Writing characterization tests involves creating tests that reflect the current behavior of the code. Let's look at a practical example using the OrderProcessor class from our order processing system. Suppose we have a method that processes orders and applies discounts based on the total amount:

class Order {
public:
    std::vector<OrderItem> items;
    bool hasBulkDiscount = false;
    double orderTotal = 0.0;
    OrderStatus status = OrderStatus::Pending;
};

bool ProcessOrder(Order& order) {
    const double BULK_ORDER_THRESHOLD = 1000.0;
    const double BULK_ORDER_DISCOUNT = 0.10;

    double totalAmount = 0.0;
    for (const auto& item : order.items) {
        double itemPrice = item.price * item.quantity;
        totalAmount += itemPrice;
    }

    // Apply bulk order discount if applicable
    if (totalAmount >= BULK_ORDER_THRESHOLD) {
        totalAmount = totalAmount * (1 - BULK_ORDER_DISCOUNT);
        order.hasBulkDiscount = true;
    }

    order.orderTotal = totalAmount;
    return order.status == OrderStatus::Approved;
}

TEST(OrderProcessorTest, WhenOrderExceedsBulkThreshold_DiscountIsApplied) {
    // Arrange
    Order order;
    order.items = { OrderItem{1000.0, 1} };

    // Act
    bool result = ProcessOrder(order);

    // Assert
    EXPECT_TRUE(result);
    EXPECT_TRUE(order.hasBulkDiscount);
    EXPECT_DOUBLE_EQ(900.0, order.orderTotal); // 10% discount applied
}

In the above test, we arrange an order with a total amount that qualifies for a bulk discount. The test then verifies that the discount is applied correctly, capturing the current behavior of the method.