TDD & BDD

#include <memory>
#include <vector>

class Money {
public:
    explicit Money(long cents = 0) : cents_(cents) {}
    static Money zero() { return Money(0); }
    // operators...
private:
    long cents_;
};

class Product { /* ... */ };
class LineItem { /* ... */ };

// 1. RED — Write failing test
void test_empty_cart_has_zero_total() {
    Cart cart;
    assert(cart.total() == Money::zero());
}

// 2. GREEN — Minimal implementation
class Cart {
public:
    Money total() const { return Money::zero(); }
};

// 3. REFACTOR — Clean up (none needed yet)
// Repeat for: add_item, remove_item, quantity, discounts...

// Real example after several cycles:
class Cart {
    std::vector<LineItem> items_;
public:
    void add(const Product& product, int qty = 1) {
        items_.emplace_back(product, qty);
    }

    Money total() const {
        Money total = Money::zero();
        for (const auto& item : items_)
            total += item.subtotal();
        return total;
    }
private:
    std::vector<LineItem> items_;
};

import java.util.*;

public final class Money {
    private final long cents;
    public Money(long cents) { this.cents = cents; }
    public static Money zero() { return new Money(0); }
    // operators...
}

public final class Product { /* ... */ }
public final class LineItem { /* ... */ }

// 1. RED — Write failing test
@Test
void testEmptyCartHasZeroTotal() {
    Cart cart = new Cart();
    assertEquals(Money.zero(), cart.total());
}

// 2. GREEN — Minimal implementation
public final class Cart {
    public Money total() { return Money.zero(); }
}

// 3. REFACTOR — Clean up (none needed yet)
// Repeat for: add_item, remove_item, quantity, discounts...

// Real example after several cycles:
public final class Cart {
    private final List<LineItem> items = new ArrayList<>();

    public void add(Product product, int qty) {
        items.add(new LineItem(product, qty));
    }

    public Money total() {
        Money total = Money.zero();
        for (LineItem item : items) {
            total = total.add(item.subtotal());
        }
        return total;
    }
}

using System;
using System.Collections.Generic;

public readonly record struct Money(long Cents) {
    public static Money Zero => new Money(0);
    public static Money operator +(Money a, Money b) => new Money(a.Cents + b.Cents);
}

// 1. RED — Write failing test
[Fact]
public void TestEmptyCartHasZeroTotal() {
    var cart = new Cart();
    Assert.Equal(Money.Zero, cart.Total());
}

// 2. GREEN — Minimal implementation
public sealed class Cart {
    public Money Total() => Money.Zero;
}

// 3. REFACTOR — Clean up (none needed yet)
// Repeat for: add_item, remove_item, quantity, discounts...

// Real example after several cycles:
public sealed class Cart {
    private readonly List<LineItem> _items = new();

    public void Add(Product product, int qty = 1) =>
        _items.Add(new LineItem(product, qty));

    public Money Total() => _items.Aggregate(Money.Zero, (sum, item) => sum + item.Subtotal());
}

# 1. RED — Write failing test (RSpec)
RSpec.describe Cart do
  it "has zero total when empty" do
    expect(Cart.new.total).to eq(Money.zero)
  end
end

# 2. GREEN — Minimal implementation
class Cart
  def total
    Money.zero
  end
end

# 3. REFACTOR — Clean up (none needed yet)
# Repeat for: add_item, remove_item, quantity, discounts...

# Real example after several cycles:
class Cart
  def initialize
    @items = []
  end

  def add(product, qty = 1)
    @items << LineItem.new(product, qty)
  end

  def total
    @items.sum(Money.zero, &:subtotal)
  end
end

// tests/steps/discount_steps.cpp
#include <string>
#include <cassert>

class Customer { /* ... */ };
class Cart { /* ... */ };
class Money { /* ... */ };
class PricingEngine { /* ... */ };

void customer_step(const std::string& tier, int years) {
    return Customer(tier, years);
}

void cart_step(int amount) {
    return Cart(Money(amount));
}

Money calculate_discount_step(const Customer& customer, const Cart& cart) {
    return PricingEngine().calculate_discount(customer, cart);
}

void verify_discount_step(const Money& discount, int amount) {
    assert(discount == Money(amount));
}

// tests/steps/discount_steps.java
import io.cucumber.java.en.*;

public class DiscountSteps {
    private Customer customer;
    private Cart cart;
    private Money discount;

    @Given("a customer with {string} tier and {int} years active")
    public void customer(String tier, int years) {
        customer = new Customer(tier, years);
    }

    @Given("a cart with total ${int}")
    public void cart(int amount) {
        cart = new Cart(new Money(amount));
    }

    @When("the discount is calculated")
    public void calculate_discount() {
        discount = new PricingEngine().calculate_discount(customer, cart);
    }

    @Then("the discount should be ${int}")
    public void verify_discount(int amount) {
        assert discount.equals(new Money(amount));
    }
}

// tests/steps/discount_steps.cs
using TechTalk.SpecFlow;

[Binding]
public class DiscountSteps {
    private Customer _customer;
    private Cart _cart;
    private Money _discount;

    [Given(@"a customer with ""(.*)"" tier and (\d+) years active")]
    public void Customer(string tier, int years) {
        _customer = new Customer(tier, years);
    }

    [Given(@"a cart with total \$(.*)")]
    public void Cart(int amount) {
        _cart = new Cart(new Money(amount));
    }

    [When(@"the discount is calculated")]
    public void CalculateDiscount() {
        _discount = new PricingEngine().CalculateDiscount(_customer, _cart);
    }

    [Then(@"the discount should be \$(.*)")]
    public void VerifyDiscount(int amount) {
        Assert.AreEqual(new Money(amount), _discount);
    }
}

# features/step_definitions/discount_steps.rb (Cucumber)
Given(/^a customer with "([^"]*)" tier and (\d+) years active$/) do |tier, years|
  @customer = Customer.new(tier: tier, years_active: years.to_i)
end

Given(/^a cart with total \$(\d+)$/) do |amount|
  @cart = Cart.new(Money.new(amount.to_i))
end

When("the discount is calculated") do
  @discount = PricingEngine.new.calculate_discount(@customer, @cart)
end

Then(/^the discount should be \$(\d+)$/) do |amount|
  expect(@discount).to eq(Money.new(amount.to_i))
end

// tests/unit/pricing/test_engine.cpp
#include <cassert>

void test_gold_customer_3_years_gets_15_percent() {
    Customer customer("gold", 3);
    Cart cart(Money(1000));

    Money discount = PricingEngine().calculate_discount(customer, cart);

    assert(discount == Money(150));
}

class PricingEngine {
public:
    Money calculate_discount(const Customer& customer, const Cart& cart) {
        Money base = _base_discount(customer.tier, cart.total());
        Money loyalty = _loyalty_bonus(customer.years_active);
        return base + loyalty;
    }
private:
    Money _base_discount(const std::string& tier, const Money& total);
    Money _loyalty_bonus(int years_active);
};

// tests/unit/pricing/test_engine.java
import static org.junit.jupiter.api.Assertions.*;

class PricingEngineTest {
    @Test
    void testGoldCustomer3YearsGets15Percent() {
        Customer customer = new Customer("gold", 3);
        Cart cart = new Cart(new Money(1000));

        Money discount = new PricingEngine().calculate_discount(customer, cart);

        assertEquals(new Money(150), discount);
    }
}

public class PricingEngine {
    public Money calculate_discount(Customer customer, Cart cart) {
        Money base = _base_discount(customer.tier, cart.total());
        Money loyalty = _loyalty_bonus(customer.years_active);
        return base.add(loyalty);
    }
}

// tests/unit/pricing/test_engine.cs
using Xunit;

public class PricingEngineTests {
    [Fact]
    public void TestGoldCustomer3YearsGets15Percent() {
        var customer = new Customer("gold", 3);
        var cart = new Cart(new Money(1000));

        var discount = new PricingEngine().CalculateDiscount(customer, cart);

        Assert.Equal(new Money(150), discount);
    }
}

public class PricingEngine {
    public Money CalculateDiscount(Customer customer, Cart cart) {
        var base = _base_discount(customer.Tier, cart.Total);
        var loyalty = _loyalty_bonus(customer.YearsActive);
        return base + loyalty;
    }
}

# spec/pricing/engine_spec.rb
RSpec.describe PricingEngine do
  it "gives gold customers of 3 years a 15% discount" do
    customer = Customer.new(tier: "gold", years_active: 3)
    cart = Cart.new(Money.new(1000))

    discount = described_class.new.calculate_discount(customer, cart)

    expect(discount).to eq(Money.new(150))
  end
end

# Implementation evolves:
class PricingEngine
  def calculate_discount(customer, cart)
    base = base_discount(customer.tier, cart.total)
    loyalty = loyalty_bonus(customer.years_active)
    base + loyalty
  end
end

// RapidCheck for C++
#include <rapidcheck/rapidcheck.h>

void test_sort_idempotent() {
    rc::check("sort is idempotent", [](const std::vector<int>& xs) {
        auto sorted_once = xs;
        std::sort(sorted_once.begin(), sorted_once.end());
        auto sorted_twice = sorted_once;
        std::sort(sorted_twice.begin(), sorted_twice.end());
        RC_ASSERT(sorted_once == sorted_twice);
    });
}

// jqwik for Java property-based testing
import net.jqwik.api.*;

class PropertyTests {
    @Property
    boolean sortIsIdempotent(@ForAll List<Integer> xs) {
        var sortedOnce = new ArrayList<>(xs);
        Collections.sort(sortedOnce);
        var sortedTwice = new ArrayList<>(sortedOnce);
        Collections.sort(sortedTwice);
        return sortedOnce.equals(sortedTwice);
    }
}

// FsCheck for C#
using FsCheck;
using FsCheck.Xunit;

public class PropertyTests {
    [Property]
    public bool SortIsIdempotent(List<int> xs) {
        var sortedOnce = xs.OrderBy(x => x).ToList();
        var sortedTwice = sortedOnce.OrderBy(x => x).ToList();
        return sortedOnce.SequenceEqual(sortedTwice);
    }
}

# property-based testing with the prop_check gem
require "prop_check"
G = PropCheck::Generators

PropCheck.forall(G.array(G.integer)) do |xs|
  raise "sort is not idempotent" unless xs.sort.sort == xs.sort
end

PropCheck.forall(G.string) do |s|
  raise "reverse is not an involution" unless s.reverse.reverse == s
end

// Mull for C++
// clang -fprofile-instr-generate -fcoverage-mapping
// mull-cxx --thread-count=4 --mutation-score-threshold=80

// PITest for Java
<plugin>
    <groupId>org.pitest</groupId>
    <artifactId>pitest-maven</artifactId>
    <version>1.15.0</version>
    <configuration>
        <targetClasses>
            <param>com.myapp.*</param>
        </targetClasses>
        <mutationThreshold>80</mutationThreshold>
    </configuration>
</plugin>

// Stryker.NET for C#
// dotnet tool install -g dotnet-stryker
// dotnet stryker --threshold-break 80

# mutant for Ruby
# gem install mutant mutant-rspec
# bundle exec mutant run --integration rspec 'PricingEngine*'

# In CI:
# - bundle exec mutant run
# - mutant reports killed vs alive mutations
# - Threshold: >80% mutation coverage

// Pact C++ is limited
// Use pact-verifier CLI for verification
# pact-verifier --provider-base-url=http://localhost:8080 \
#   --pact-url=./pacts/order_service-payment_service.json

// Pact JVM
@ExtendWith(PactConsumerTestExt.class)
@PactTestFor(providerName = "PaymentService")
class PaymentContractTest {
    @Test
    @Pact(consumer = "OrderService", provider = "PaymentService")
    V2RequestResponsePact createPact(PactDslWithProvider builder) {
        return builder
            .given("a valid payment request")
            .uponReceiving("a charge request")
            .path("/payment/charge")
            .method("POST")
            .body(newJsonBody(o -> o
                .numberType("amount_cents", 1999)
                .stringType("currency", "USD")
                .stringType("source", "tok_visa")
            ))
            .willRespondWith()
            .status(200)
            .body(newJsonBody(o -> o
                .stringType("transaction_id", "txn_123")
                .stringType("status", "succeeded")
            ))
            .toPact(V2Pact.class);
    }
}

// PactNet
using PactNet;
using Xunit;

public class PaymentContractTests {
    [Fact]
    public void PaymentContract() {
        var config = new PactConfig { PactDir = "./pacts" };
        var pact = new PactVerifier(new PactConfig { PactDir = "./pacts" });

        var builder = new V2PactBuilder("OrderService", "PaymentService");
        builder
            .Given("a valid payment request")
            .UponReceiving("a charge request")
            .With(new ProviderServiceRequest {
                Method = HttpVerb.Post,
                Path = "/payment/charge",
                Body = new { amount_cents = 1999, currency = "USD", source = "tok_visa" }
            })
            .WillRespondWith(200, new {
                transaction_id = "txn_123",
                status = "succeeded"
            });
    }
}

# Consumer-driven contract testing with Pact
require "pact/consumer/rspec"

Pact.service_consumer "OrderService" do
  has_pact_with "PaymentService" do
    mock_service :payment_service do
      port 1234
    end
  end
end

payment_service
  .given("a valid payment request")
  .upon_receiving("a charge request")
  .with(method: :post, path: "/payment/charge",
        body: { amount_cents: 1999, currency: "USD", source: "tok_visa" })
  .will_respond_with(status: 200,
                     body: { transaction_id: "txn_123", status: "succeeded" })