[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":84,"_71":85,"_35":86},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":32,"_52":32,"_53":54,"_55":56,"_57":58,"_59":32,"_60":16,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70},"id",21,"title","Characterization Testing","slug","clean-code-part-20-characterization-testing","excerpt","Write tests that document actual behavior of existing code as a safety net before refactoring legacy systems.","# Advanced Clean Code Patterns Part 20: Characterization Testing\n\nCharacterization tests document the actual behavior of existing code. Unlike unit tests that verify intended behavior, characterization tests capture current behavior—bugs and all. They're essential for safely modifying legacy code.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| Purpose | Document existing behavior, detect regressions |\n| Approach | Test what code DOES, not what it SHOULD do |\n| Coverage | Focus on code paths you'll modify |\n| Output | Tests as executable documentation |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Writing characterization tests** for legacy code\n- **Golden Master testing** for complex outputs\n- **Testing without seams** (when dependency injection isn't available)\n- **Dealing with side effects** in tests\n- **Test coverage strategy** for legacy systems\n\n---\n\n## Production Story: The Refactoring Disaster\n\nA team refactored a pricing engine without tests:\n\n```java\n// Before refactoring - \"ugly but works\"\npublic double calculatePrice(Product p, Customer c) {\n double price = p.getBasePrice();\n if (c.getType() == 1) price *= 0.9; // 10% discount\n if (c.getType() == 2) price *= 0.85; // 15% discount\n if (p.getCategory() == 3) price += 5.0; // Handling fee\n if (c.getOrders() > 10) price *= 0.95; // Loyalty discount\n // 50 more lines of similar logic...\n return Math.round(price * 100.0) / 100.0;\n}\n\n// After \"clean\" refactoring\npublic Money calculatePrice(Product product, Customer customer) {\n return basePrice(product)\n .applyDiscount(customerDiscount(customer))\n .addFees(productFees(product))\n .applyLoyaltyDiscount(customer)\n .round(2);\n}\n```\n\n**Result:** 500 customers got wrong prices. The \"clean\" code had subtle differences:\n- Discount order changed (loyalty applied before category fee)\n- Rounding happened at different point\n- Edge case for `null` customer behaved differently\n\n**The fix should have been:** Characterization tests FIRST:\n\n```java\n@ParameterizedTest\n@MethodSource(\"realCustomerScenarios\")\nvoid priceCalculation_matchesProduction(Product p, Customer c, double expected) {\n double actual = calculator.calculatePrice(p, c);\n assertEquals(expected, actual, 0.001);\n}\n\n// Run with production data to capture REAL behavior\nstatic Stream realCustomerScenarios() {\n return loadProductionScenarios(\"pricing_audit_log.csv\");\n}\n```\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Basic Characterization Test\n\n```java\n// Step 1: Write test with WRONG assertion\n@Test\nvoid calculateTotal_documentBehavior() {\n Order order = createOrder(100.0, 2);\n\n double result = service.calculateTotal(order);\n\n assertEquals(0.0, result); // Wrong! Run to see actual value\n}\n\n// Step 2: Test fails, shows actual: 216.0\n// Step 3: Update with actual value\n@Test\nvoid calculateTotal_documentBehavior() {\n Order order = createOrder(100.0, 2);\n\n double result = service.calculateTotal(order);\n\n assertEquals(216.0, result); // Now documents actual behavior\n // NOTE: 100 * 2 = 200, plus 8% tax = 216\n}\n\n// Step 4: Add more scenarios to understand behavior\n@Test\nvoid calculateTotal_withDiscount() {\n Order order = createOrderWithDiscount(100.0, 2, \"VIP10\");\n\n double result = service.calculateTotal(order);\n\n assertEquals(194.4, result); // 200 - 10% = 180, + 8% tax = 194.4\n // Discovery: Discount applied BEFORE tax\n}\n\n@Test\nvoid calculateTotal_withNullCustomer() {\n Order order = createOrder(100.0, 2);\n order.setCustomer(null);\n\n // Discovery: Throws NullPointerException on line 42\n // This is current behavior - might be a bug, but document it!\n assertThrows(NullPointerException.class,\n () -> service.calculateTotal(order));\n}\n```\n\n---\n\n### Pattern 2: Systematic Exploration\n\n```java\n// Explore behavior systematically with parameterized tests\n\n@ParameterizedTest(name = \"quantity={0}, price={1}, discount={2} -> {3}\")\n@CsvSource({\n // quantity, price, discount, expected\n \"1, 100.0, 0, 108.0\", // Base case: price + 8% tax\n \"2, 100.0, 0, 216.0\", // Multiple items\n \"1, 100.0, 10, 97.2\", // With 10% discount\n \"1, 0.0, 0, 0.0\", // Zero price\n \"0, 100.0, 0, 0.0\", // Zero quantity\n \"1, -10.0, 0, -10.8\", // Negative price (is this valid?)\n})\nvoid calculateTotal_behaviorMatrix(int qty, double price, int discount, double expected) {\n Order order = createOrder(price, qty, discount);\n\n double result = service.calculateTotal(order);\n\n assertEquals(expected, result, 0.01);\n}\n\n// Explore edge cases\n@ParameterizedTest(name = \"Edge case: {0}\")\n@MethodSource(\"edgeCases\")\nvoid calculateTotal_edgeCases(String scenario, Order order, Object expectedResult) {\n if (expectedResult instanceof Double expected) {\n assertEquals(expected, service.calculateTotal(order), 0.01);\n } else if (expectedResult instanceof Class exceptionClass) {\n assertThrows((Class) exceptionClass,\n () -> service.calculateTotal(order));\n }\n}\n\nstatic Stream edgeCases() {\n return Stream.of(\n Arguments.of(\"null order\", null, NullPointerException.class),\n Arguments.of(\"null items\", orderWithNullItems(), NullPointerException.class),\n Arguments.of(\"empty items\", orderWithEmptyItems(), 0.0),\n Arguments.of(\"max int quantity\", orderWithMaxQuantity(), 2.32e11), // Overflow?\n Arguments.of(\"special chars in discount\", orderWithDiscount(\"'; DROP TABLE--\"), 108.0)\n );\n}\n```\n\n---\n\n### Pattern 3: Golden Master Testing\n\n```java\n// For complex outputs, capture entire output as \"golden master\"\n\npublic class ReportGeneratorCharacterizationTest {\n\n private static final Path GOLDEN_MASTER =\n Path.of(\"src/test/resources/golden-master/monthly-report.txt\");\n\n @Test\n void monthlyReport_matchesGoldenMaster() throws IOException {\n // Generate report\n String actual = reportGenerator.generateMonthlyReport(\n LocalDate.of(2024, 1, 1),\n testData());\n\n if (Files.exists(GOLDEN_MASTER)) {\n // Compare with golden master\n String expected = Files.readString(GOLDEN_MASTER);\n assertEquals(expected, actual);\n } else {\n // First run: create golden master\n Files.createDirectories(GOLDEN_MASTER.getParent());\n Files.writeString(GOLDEN_MASTER, actual);\n fail(\"Golden master created at \" + GOLDEN_MASTER +\n \". Review and re-run test.\");\n }\n }\n\n @Test\n void jsonOutput_matchesGoldenMaster() throws IOException {\n String actual = service.exportToJson(testData());\n\n // For JSON, use semantic comparison\n JSONAssert.assertEquals(\n loadGoldenMaster(\"export.json\"),\n actual,\n JSONCompareMode.STRICT);\n }\n}\n\n// Approval testing library approach (e.g., ApprovalTests)\n@Test\nvoid complexOutput_approval() {\n ComplexResult result = service.processComplex(input);\n\n // Creates .approved file on first run\n // Subsequent runs compare against approved file\n Approvals.verify(result.toString());\n}\n```\n\n---\n\n### Pattern 4: Testing Without Seams\n\n```java\n// Legacy code often has static methods and hardcoded dependencies\n\n// Original - untestable\npublic class LegacyOrderProcessor {\n public void process(Order order) {\n // Static dependency - can't mock!\n if (!Database.isConnected()) {\n throw new RuntimeException(\"No database\");\n }\n Database.save(order);\n\n // Another static dependency\n EmailService.send(order.getCustomerEmail(), \"Order processed\");\n\n // Global state\n GlobalCounter.increment();\n }\n}\n\n// Strategy 1: Subclass and Override\npublic class TestableLegacyProcessor extends LegacyOrderProcessor {\n private boolean databaseSavesCalled = false;\n private String lastEmailSent = null;\n\n @Override\n protected void saveToDatabase(Order order) {\n databaseSavesCalled = true;\n // Don't actually save\n }\n\n @Override\n protected void sendEmail(String email, String message) {\n lastEmailSent = email;\n // Don't actually send\n }\n\n // Test accessors\n public boolean wasDatabaseSaveCalled() { return databaseSavesCalled; }\n public String getLastEmailSent() { return lastEmailSent; }\n}\n\n// But first, we need to make static calls overridable:\npublic class LegacyOrderProcessor {\n public void process(Order order) {\n if (!isDatabaseConnected()) { // Now overridable\n throw new RuntimeException(\"No database\");\n }\n saveToDatabase(order); // Now overridable\n sendEmail(order.getCustomerEmail(), \"processed\");\n }\n\n protected boolean isDatabaseConnected() {\n return Database.isConnected(); // Original static call\n }\n\n protected void saveToDatabase(Order order) {\n Database.save(order);\n }\n\n protected void sendEmail(String email, String message) {\n EmailService.send(email, message);\n }\n}\n\n// Strategy 2: Use PowerMock (last resort)\n@ExtendWith(MockitoExtension.class)\n@PrepareForTest({Database.class, EmailService.class})\nclass LegacyProcessorTest {\n\n @Test\n void process_savesToDatabase() {\n // Mock static method (PowerMock)\n PowerMockito.mockStatic(Database.class);\n PowerMockito.when(Database.isConnected()).thenReturn(true);\n\n processor.process(order);\n\n PowerMockito.verifyStatic(Database.class);\n Database.save(order);\n }\n}\n```\n\n---\n\n### Pattern 5: Capturing Side Effects\n\n```java\n// Test side effects by capturing them\n\npublic class AuditingCharacterizationTest {\n\n @Test\n void processPayment_logsToAudit() {\n // Capture database inserts\n List capturedRecords = new ArrayList<>();\n AuditRepository mockRepo = new AuditRepository() {\n @Override\n public void save(AuditRecord record) {\n capturedRecords.add(record);\n }\n };\n\n PaymentService service = new PaymentService(mockRepo);\n service.process(payment);\n\n // Document what gets logged\n assertEquals(2, capturedRecords.size());\n assertEquals(\"PAYMENT_STARTED\", capturedRecords.get(0).getType());\n assertEquals(\"PAYMENT_COMPLETED\", capturedRecords.get(1).getType());\n }\n\n @Test\n void processPayment_sendsEmail() {\n // Capture emails\n List sentEmails = new ArrayList<>();\n EmailService mockEmail = email -> sentEmails.add(email);\n\n PaymentService service = createServiceWithMockEmail(mockEmail);\n service.process(payment);\n\n // Document email behavior\n assertEquals(1, sentEmails.size());\n assertTrue(sentEmails.get(0).getSubject().contains(\"Payment Confirmation\"));\n assertTrue(sentEmails.get(0).getBody().contains(payment.getAmount().toString()));\n }\n\n @Test\n void processPayment_modifiesGlobalState() {\n // Capture global state changes\n GlobalState.reset(); // Start clean\n\n service.process(payment);\n\n // Document what global state is modified\n assertEquals(payment.getId(), GlobalState.getLastPaymentId());\n assertEquals(1, GlobalState.getPaymentCount());\n }\n}\n```\n\n---\n\n### Pattern 6: Database-Dependent Tests\n\n```java\n// For tests that require database\n\n@TestInstance(Lifecycle.PER_CLASS)\npublic class OrderServiceCharacterizationTest {\n\n @Container\n static PostgreSQLContainer postgres = new PostgreSQLContainer<>(\"postgres:14\")\n .withInitScript(\"schema.sql\");\n\n private OrderService service;\n private JdbcTemplate jdbc;\n\n @BeforeAll\n void setup() {\n DataSource ds = createDataSource(postgres);\n jdbc = new JdbcTemplate(ds);\n service = new OrderService(new JdbcOrderRepository(ds));\n\n // Load production-like test data\n loadTestData(jdbc, \"production_sample.sql\");\n }\n\n @Test\n void findByCustomer_returnsCorrectOrders() {\n // Characterize query behavior\n List orders = service.findByCustomer(1001L);\n\n assertEquals(5, orders.size());\n assertTrue(orders.stream().allMatch(o -> o.getCustomerId() == 1001L));\n // Document: orders are sorted by date DESC\n assertTrue(isSortedByDateDesc(orders));\n }\n\n @Test\n void findByCustomer_includesItems() {\n List orders = service.findByCustomer(1001L);\n\n // Document: items are eagerly loaded\n Order firstOrder = orders.get(0);\n assertFalse(firstOrder.getItems().isEmpty());\n // Document: item product details are loaded\n assertNotNull(firstOrder.getItems().get(0).getProduct().getName());\n }\n\n @Test\n void findByDateRange_boundaryBehavior() {\n LocalDate start = LocalDate.of(2024, 1, 1);\n LocalDate end = LocalDate.of(2024, 1, 31);\n\n List orders = service.findByDateRange(start, end);\n\n // Document: start is INCLUSIVE\n assertTrue(orders.stream().anyMatch(o ->\n o.getCreatedAt().toLocalDate().equals(start)));\n\n // Document: end is EXCLUSIVE (or inclusive?)\n // Run test to find out!\n }\n}\n```\n\n---\n\n### Pattern 7: Documenting Discovered Behavior\n\n```java\n// Tests as documentation\n\npublic class PaymentProcessorCharacterizationTest {\n\n /**\n * DISCOVERED BEHAVIOR:\n * Payment processing follows this sequence:\n * 1. Validate payment data\n * 2. Check fraud score (if amount > $100)\n * 3. Authorize with gateway\n * 4. Log to audit table\n * 5. Send confirmation email\n *\n * Edge cases:\n * - Null customer: Throws NPE (line 42)\n * - Zero amount: Silently succeeds (probably a bug)\n * - Gateway timeout: Retries 3 times, then throws\n *\n * Side effects:\n * - Writes to: audit_log, payment_history tables\n * - Sends: confirmation email\n * - Updates: customer.last_payment_date\n */\n @Nested\n class ProcessPayment {\n\n @Test\n @DisplayName(\"Basic payment processing succeeds\")\n void basicPayment_succeeds() {\n Payment payment = validPayment(100.0);\n\n PaymentResult result = processor.process(payment);\n\n assertEquals(PaymentStatus.SUCCESS, result.getStatus());\n }\n\n @Test\n @DisplayName(\"KNOWN BUG: Zero amount succeeds (should fail)\")\n void zeroAmount_succeeds_BUG() {\n Payment payment = validPayment(0.0);\n\n // This succeeds but shouldn't - documenting for now\n PaymentResult result = processor.process(payment);\n\n assertEquals(PaymentStatus.SUCCESS, result.getStatus());\n // TODO: File bug, fix after characterization complete\n }\n\n @Test\n @DisplayName(\"Amount > $100 triggers fraud check\")\n void largeAmount_triggersFraudCheck() {\n Payment payment = validPayment(150.0);\n\n processor.process(payment);\n\n verify(fraudService).checkFraud(payment);\n }\n\n @Test\n @DisplayName(\"Amount <= $100 skips fraud check\")\n void smallAmount_skipsFraudCheck() {\n Payment payment = validPayment(100.0);\n\n processor.process(payment);\n\n verify(fraudService, never()).checkFraud(any());\n }\n }\n}\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Fixing Bugs in Characterization Tests\n\n```java\n// ❌ Don't fix bugs while characterizing!\n@Test\nvoid calculateDiscount_buggyBehavior() {\n // Code returns 15% when it should be 10%\n assertEquals(10.0, service.calculateDiscount(order)); // \"Correct\" value\n}\n\n// ✅ Document actual behavior\n@Test\nvoid calculateDiscount_returns15PercentInsteadOf10() {\n // KNOWN BUG: Returns 15% instead of 10%\n // See ticket #1234\n assertEquals(15.0, service.calculateDiscount(order)); // Actual value\n}\n```\n\n### Mistake 2: Over-Specifying Tests\n\n```java\n// ❌ Too specific - tests break with any change\n@Test\nvoid processOrder() {\n service.process(order);\n verify(repo).save(argThat(o ->\n o.getId() == 123 &&\n o.getStatus().equals(\"PENDING\") &&\n o.getCreatedAt().isAfter(LocalDateTime.now().minusSeconds(1))));\n}\n\n// ✅ Focus on what matters for your change\n@Test\nvoid processOrder_savesWithPendingStatus() {\n service.process(order);\n verify(repo).save(argThat(o -> o.getStatus().equals(\"PENDING\")));\n}\n```\n\n---\n\n## 🐛 Debug This: The False Safety Net\n\nA developer wrote characterization tests before refactoring. The tests passed before and after the refactoring. But production crashed with wrong calculations. \"I had tests! How did this get through?\"\n\n```java\n// The legacy code being tested\npublic class TaxCalculator {\n private final TaxRateRepository taxRateRepo;\n\n public TaxCalculator(TaxRateRepository taxRateRepo) {\n this.taxRateRepo = taxRateRepo;\n }\n\n public BigDecimal calculate(Order order) {\n BigDecimal subtotal = order.getSubtotal();\n String state = order.getShippingAddress().getState();\n\n TaxRate rate = taxRateRepo.findByState(state);\n if (rate == null) {\n return BigDecimal.ZERO; // No tax for unknown states\n }\n\n BigDecimal tax = subtotal.multiply(rate.getRate());\n\n // Apply special rules\n if (order.getItems().stream().anyMatch(Item::isTaxExempt)) {\n tax = recalculateWithExemptions(order, rate);\n }\n\n return tax.setScale(2, RoundingMode.HALF_UP);\n }\n\n private BigDecimal recalculateWithExemptions(Order order, TaxRate rate) {\n // Complex exemption logic...\n return order.getItems().stream()\n .filter(item -> !item.isTaxExempt())\n .map(item -> item.getPrice().multiply(rate.getRate()))\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n }\n}\n\n// The \"characterization\" tests\npublic class TaxCalculatorCharacterizationTest {\n\n @Mock\n private TaxRateRepository taxRateRepo;\n\n @InjectMocks\n private TaxCalculator calculator;\n\n @BeforeEach\n void setup() {\n MockitoAnnotations.openMocks(this);\n }\n\n @Test\n void calculate_returnsZeroForUnknownState() {\n Order order = createOrder(\"XX\", new BigDecimal(\"100\"));\n // taxRateRepo.findByState returns null by default (Mockito)\n\n BigDecimal result = calculator.calculate(order);\n\n assertEquals(BigDecimal.ZERO, result);\n }\n\n @Test\n void calculate_appliesTaxRate() {\n Order order = createOrder(\"CA\", new BigDecimal(\"100\"));\n when(taxRateRepo.findByState(\"CA\"))\n .thenReturn(new TaxRate(\"CA\", new BigDecimal(\"0.0725\")));\n\n BigDecimal result = calculator.calculate(order);\n\n assertEquals(new BigDecimal(\"7.25\"), result);\n }\n\n @Test\n void calculate_handlesExemptItems() {\n Order order = createOrderWithExemptItem(\"CA\", new BigDecimal(\"100\"));\n when(taxRateRepo.findByState(\"CA\"))\n .thenReturn(new TaxRate(\"CA\", new BigDecimal(\"0.0725\")));\n\n BigDecimal result = calculator.calculate(order);\n\n // Just checking it doesn't throw...\n assertNotNull(result);\n }\n}\n```\n\n**The refactoring broke production but tests passed. What's wrong with these tests?**\n\n---\n\n**✅ Solution:**\n\nThese aren't characterization tests - they're just regular mocked unit tests!\n\n**Problems:**\n\n1. **Mocks don't capture real behavior**\n ```java\n @Mock\n private TaxRateRepository taxRateRepo;\n ```\n The mock doesn't return real tax rates. Characterization tests should use real data or captured production data.\n\n2. **Expected values are guessed, not discovered**\n ```java\n assertEquals(new BigDecimal(\"7.25\"), result);\n ```\n The developer calculated 100 * 0.0725 = 7.25 mentally. But what if the real code does something different (like adding fees)?\n\n3. **Weak assertion on complex logic**\n ```java\n assertNotNull(result); // Doesn't verify actual value!\n ```\n The exemption test only checks for non-null. Actual exemption logic isn't characterized at all.\n\n4. **Missing edge cases from production**\n - What happens with zero subtotal?\n - What about negative amounts (returns)?\n - Multiple exempt items?\n - Tax rate of 0%?\n\n**Correct characterization tests:**\n\n```java\npublic class TaxCalculatorCharacterizationTest {\n\n // Use REAL repository with test database or embedded DB\n private TaxCalculator calculator;\n private TaxRateRepository realRepo;\n\n @BeforeAll\n static void loadProductionTaxRates() {\n // Load actual tax rates from production export\n loadTaxRates(\"production_tax_rates_2024.csv\");\n }\n\n @Test\n void calculate_discoverActualBehavior() {\n Order order = createOrder(\"CA\", new BigDecimal(\"100\"));\n\n BigDecimal result = calculator.calculate(order);\n\n // First run: assertEquals(BigDecimal.ZERO, result); // See what we get\n // Actual: 7.97 (includes city tax we didn't know about!)\n assertEquals(new BigDecimal(\"7.97\"), result);\n }\n\n @ParameterizedTest\n @CsvFileSource(resources = \"/production_tax_calculations.csv\")\n void calculate_matchesProductionBehavior(\n String state, String subtotal, String expectedTax) {\n // Use REAL calculations from production logs\n Order order = createOrder(state, new BigDecimal(subtotal));\n\n BigDecimal result = calculator.calculate(order);\n\n assertEquals(new BigDecimal(expectedTax), result);\n }\n\n @Test\n void calculate_exemptItems_discoverActualBehavior() {\n Order order = createOrderWithExemptItem(\"CA\", new BigDecimal(\"100\"));\n\n BigDecimal result = calculator.calculate(order);\n\n // Discovery: exempt items are completely excluded,\n // remaining taxable amount: $70, tax: $5.58\n assertEquals(new BigDecimal(\"5.58\"), result);\n }\n}\n```\n\n**The lesson:** Characterization tests must capture ACTUAL behavior, not expected behavior. Use real data, not mocks. Discover values by running tests, don't calculate them.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Write Basic Characterization Test\n⭐ Difficulty: Easy | ⏱️ Time: 10 minutes\n\n**Task:** Write a characterization test for this legacy code to discover its actual behavior.\n\n```java\npublic class PriceFormatter {\n public String format(double price, String locale) {\n if (locale == null) locale = \"US\";\n\n if (locale.equals(\"US\")) {\n return String.format(\"$%.2f\", price);\n } else if (locale.equals(\"EU\")) {\n return String.format(\"€%.2f\", price).replace(\".\", \",\");\n } else if (locale.equals(\"UK\")) {\n return String.format(\"£%.2f\", price);\n }\n return String.valueOf(price);\n }\n}\n```\n\n**Write tests to discover: formatting for all locales, negative numbers, zero, large numbers, unknown locale.**\n\n**✅ Solution:**\n\n```java\npublic class PriceFormatterCharacterizationTest {\n\n private PriceFormatter formatter = new PriceFormatter();\n\n // Step 1: Write with wrong assertion to discover actual behavior\n @Test\n void format_US_discoverBehavior() {\n String result = formatter.format(1234.56, \"US\");\n // Run test, see actual: \"$1234.56\"\n assertEquals(\"$1234.56\", result);\n }\n\n @Test\n void format_EU_discoverBehavior() {\n String result = formatter.format(1234.56, \"EU\");\n // Discovery: Uses comma as decimal separator\n assertEquals(\"€1234,56\", result);\n }\n\n @Test\n void format_UK_discoverBehavior() {\n String result = formatter.format(1234.56, \"UK\");\n assertEquals(\"£1234.56\", result);\n }\n\n @Test\n void format_unknownLocale_discoverBehavior() {\n String result = formatter.format(1234.56, \"JP\");\n // Discovery: Returns raw number without currency symbol\n assertEquals(\"1234.56\", result);\n }\n\n @Test\n void format_nullLocale_discoverBehavior() {\n String result = formatter.format(1234.56, null);\n // Discovery: Defaults to US format\n assertEquals(\"$1234.56\", result);\n }\n\n @Test\n void format_negativePrice_discoverBehavior() {\n String result = formatter.format(-50.00, \"US\");\n // Discovery: Shows negative sign before dollar\n assertEquals(\"$-50.00\", result);\n }\n\n @Test\n void format_zero_discoverBehavior() {\n String result = formatter.format(0.0, \"US\");\n assertEquals(\"$0.00\", result);\n }\n\n @Test\n void format_veryLargeNumber_discoverBehavior() {\n String result = formatter.format(1234567890.12, \"US\");\n // Discovery: No thousand separators\n assertEquals(\"$1234567890.12\", result);\n }\n\n @Test\n void format_manyDecimalPlaces_discoverBehavior() {\n String result = formatter.format(10.999, \"US\");\n // Discovery: Rounds to 2 decimal places (banker's rounding)\n assertEquals(\"$11.00\", result);\n }\n}\n```\n\n---\n\n### Exercise 2: Golden Master Test\n⭐⭐ Difficulty: Medium | ⏱️ Time: 20 minutes\n\n**Task:** Create a golden master test for this report generator.\n\n```java\npublic class InvoiceGenerator {\n public String generate(Invoice invoice) {\n StringBuilder sb = new StringBuilder();\n sb.append(\"INVOICE #\").append(invoice.getNumber()).append(\"\\n\");\n sb.append(\"Date: \").append(invoice.getDate()).append(\"\\n\");\n sb.append(\"Customer: \").append(invoice.getCustomer().getName()).append(\"\\n\");\n sb.append(\"\\n\");\n sb.append(\"Items:\\n\");\n for (InvoiceItem item : invoice.getItems()) {\n sb.append(\" - \").append(item.getDescription())\n .append(\" x\").append(item.getQuantity())\n .append(\" @ $\").append(item.getUnitPrice())\n .append(\" = $\").append(item.getTotal())\n .append(\"\\n\");\n }\n sb.append(\"\\n\");\n sb.append(\"Subtotal: $\").append(invoice.getSubtotal()).append(\"\\n\");\n sb.append(\"Tax (\").append(invoice.getTaxRate()).append(\"%): $\")\n .append(invoice.getTaxAmount()).append(\"\\n\");\n sb.append(\"TOTAL: $\").append(invoice.getTotal()).append(\"\\n\");\n return sb.toString();\n }\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class InvoiceGeneratorGoldenMasterTest {\n\n private static final Path GOLDEN_MASTER_DIR =\n Path.of(\"src/test/resources/golden-master/invoices\");\n\n private InvoiceGenerator generator = new InvoiceGenerator();\n\n @Test\n void generate_standardInvoice_matchesGoldenMaster() throws IOException {\n Invoice invoice = createStandardInvoice();\n\n String actual = generator.generate(invoice);\n\n compareOrCreateGoldenMaster(\"standard-invoice.txt\", actual);\n }\n\n @Test\n void generate_multiItemInvoice_matchesGoldenMaster() throws IOException {\n Invoice invoice = createMultiItemInvoice();\n\n String actual = generator.generate(invoice);\n\n compareOrCreateGoldenMaster(\"multi-item-invoice.txt\", actual);\n }\n\n @Test\n void generate_zeroTaxInvoice_matchesGoldenMaster() throws IOException {\n Invoice invoice = createZeroTaxInvoice();\n\n String actual = generator.generate(invoice);\n\n compareOrCreateGoldenMaster(\"zero-tax-invoice.txt\", actual);\n }\n\n private void compareOrCreateGoldenMaster(String filename, String actual) throws IOException {\n Path goldenMasterPath = GOLDEN_MASTER_DIR.resolve(filename);\n\n if (Files.exists(goldenMasterPath)) {\n String expected = Files.readString(goldenMasterPath);\n assertEquals(expected, actual,\n \"Output differs from golden master. \" +\n \"If change is intentional, delete \" + goldenMasterPath + \" and re-run.\");\n } else {\n Files.createDirectories(GOLDEN_MASTER_DIR);\n Files.writeString(goldenMasterPath, actual);\n fail(\"Golden master created at \" + goldenMasterPath +\n \". Review the file and re-run the test.\");\n }\n }\n\n private Invoice createStandardInvoice() {\n return Invoice.builder()\n .number(\"INV-001\")\n .date(LocalDate.of(2024, 1, 15))\n .customer(new Customer(\"Acme Corp\"))\n .items(List.of(\n new InvoiceItem(\"Widget\", 2, new BigDecimal(\"25.00\"))\n ))\n .taxRate(new BigDecimal(\"8.25\"))\n .build();\n }\n\n private Invoice createMultiItemInvoice() {\n return Invoice.builder()\n .number(\"INV-002\")\n .date(LocalDate.of(2024, 1, 16))\n .customer(new Customer(\"Tech Inc\"))\n .items(List.of(\n new InvoiceItem(\"Widget\", 5, new BigDecimal(\"25.00\")),\n new InvoiceItem(\"Gadget\", 3, new BigDecimal(\"45.00\")),\n new InvoiceItem(\"Service Fee\", 1, new BigDecimal(\"100.00\"))\n ))\n .taxRate(new BigDecimal(\"8.25\"))\n .build();\n }\n\n private Invoice createZeroTaxInvoice() {\n return Invoice.builder()\n .number(\"INV-003\")\n .date(LocalDate.of(2024, 1, 17))\n .customer(new Customer(\"Non-Profit Org\"))\n .items(List.of(\n new InvoiceItem(\"Donation\", 1, new BigDecimal(\"500.00\"))\n ))\n .taxRate(BigDecimal.ZERO)\n .build();\n }\n}\n\n// Example golden master file: standard-invoice.txt\n/*\nINVOICE #INV-001\nDate: 2024-01-15\nCustomer: Acme Corp\n\nItems:\n - Widget x2 @ $25.00 = $50.00\n\nSubtotal: $50.00\nTax (8.25%): $4.13\nTOTAL: $54.13\n*/\n```\n\n---\n\n### Exercise 3: Capture Side Effects\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Write characterization tests that capture all side effects of this order processor.\n\n```java\npublic class OrderProcessor {\n private final OrderRepository orderRepo;\n private final InventoryService inventory;\n private final EmailService email;\n private final MetricsService metrics;\n\n public void process(Order order) {\n order.setStatus(OrderStatus.PROCESSING);\n order.setProcessedAt(Instant.now());\n orderRepo.save(order);\n\n for (OrderItem item : order.getItems()) {\n inventory.reserve(item.getProductId(), item.getQuantity());\n }\n\n email.send(order.getCustomerEmail(), \"Order Confirmed\",\n \"Your order \" + order.getId() + \" is being processed.\");\n\n metrics.increment(\"orders.processed\");\n metrics.record(\"order.value\", order.getTotal().doubleValue());\n }\n}\n```\n\n**Document all side effects: what is saved, reserved, sent, and recorded.**\n\n**✅ Solution:**\n\n```java\npublic class OrderProcessorCharacterizationTest {\n\n private OrderProcessor processor;\n\n // Capture repositories\n private List savedOrders = new ArrayList<>();\n private List reservations = new ArrayList<>();\n private List sentEmails = new ArrayList<>();\n private Map recordedMetrics = new HashMap<>();\n\n @BeforeEach\n void setup() {\n OrderRepository orderRepo = order -> savedOrders.add(order);\n\n InventoryService inventory = (productId, qty) ->\n reservations.add(new InventoryReservation(productId, qty));\n\n EmailService email = (to, subject, body) ->\n sentEmails.add(new SentEmail(to, subject, body));\n\n MetricsService metrics = new MetricsService() {\n @Override\n public void increment(String name) {\n recordedMetrics.merge(name, 1, (a, b) -> (int) a + (int) b);\n }\n @Override\n public void record(String name, double value) {\n recordedMetrics.put(name, value);\n }\n };\n\n processor = new OrderProcessor(orderRepo, inventory, email, metrics);\n }\n\n @BeforeEach\n void clearCaptures() {\n savedOrders.clear();\n reservations.clear();\n sentEmails.clear();\n recordedMetrics.clear();\n }\n\n @Test\n void process_savesOrderWithUpdatedStatus() {\n Order order = createOrder();\n Instant before = Instant.now();\n\n processor.process(order);\n\n // Characterization: Order is saved once\n assertEquals(1, savedOrders.size());\n\n // Characterization: Status changed to PROCESSING\n Order saved = savedOrders.get(0);\n assertEquals(OrderStatus.PROCESSING, saved.getStatus());\n\n // Characterization: processedAt is set\n assertNotNull(saved.getProcessedAt());\n assertTrue(saved.getProcessedAt().isAfter(before));\n }\n\n @Test\n void process_reservesInventoryForEachItem() {\n Order order = createOrderWithItems(\n new OrderItem(\"PROD-1\", 2),\n new OrderItem(\"PROD-2\", 5),\n new OrderItem(\"PROD-3\", 1)\n );\n\n processor.process(order);\n\n // Characterization: One reservation per item\n assertEquals(3, reservations.size());\n\n // Characterization: Reservations match items\n assertEquals(\"PROD-1\", reservations.get(0).productId());\n assertEquals(2, reservations.get(0).quantity());\n assertEquals(\"PROD-2\", reservations.get(1).productId());\n assertEquals(5, reservations.get(1).quantity());\n assertEquals(\"PROD-3\", reservations.get(2).productId());\n assertEquals(1, reservations.get(2).quantity());\n }\n\n @Test\n void process_sendsConfirmationEmail() {\n Order order = createOrder();\n order.setCustomerEmail(\"test@example.com\");\n order.setId(\"ORD-123\");\n\n processor.process(order);\n\n // Characterization: One email sent\n assertEquals(1, sentEmails.size());\n\n SentEmail email = sentEmails.get(0);\n // Characterization: Sent to customer email\n assertEquals(\"test@example.com\", email.to());\n // Characterization: Subject is \"Order Confirmed\"\n assertEquals(\"Order Confirmed\", email.subject());\n // Characterization: Body contains order ID\n assertTrue(email.body().contains(\"ORD-123\"));\n }\n\n @Test\n void process_recordsMetrics() {\n Order order = createOrder();\n order.setTotal(new BigDecimal(\"150.00\"));\n\n processor.process(order);\n\n // Characterization: Increments orders.processed counter\n assertEquals(1, recordedMetrics.get(\"orders.processed\"));\n\n // Characterization: Records order value\n assertEquals(150.0, recordedMetrics.get(\"order.value\"));\n }\n\n record InventoryReservation(String productId, int quantity) {}\n record SentEmail(String to, String subject, String body) {}\n}\n```\n\n---\n\n### Exercise 4: Parameterized Characterization\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Create comprehensive parameterized tests to fully characterize this discount calculator's behavior.\n\n```java\npublic class DiscountCalculator {\n public BigDecimal calculate(Customer customer, BigDecimal orderTotal) {\n BigDecimal discount = BigDecimal.ZERO;\n\n // Tier discounts\n if (customer.getTier() == Tier.GOLD) {\n discount = discount.add(orderTotal.multiply(new BigDecimal(\"0.10\")));\n } else if (customer.getTier() == Tier.PLATINUM) {\n discount = discount.add(orderTotal.multiply(new BigDecimal(\"0.15\")));\n }\n\n // Volume discounts\n if (orderTotal.compareTo(new BigDecimal(\"500\")) >= 0) {\n discount = discount.add(new BigDecimal(\"25\"));\n }\n if (orderTotal.compareTo(new BigDecimal(\"1000\")) >= 0) {\n discount = discount.add(new BigDecimal(\"50\"));\n }\n\n // Loyalty bonus\n if (customer.getOrderCount() > 10) {\n discount = discount.add(orderTotal.multiply(new BigDecimal(\"0.02\")));\n }\n\n // Cap at 30%\n BigDecimal maxDiscount = orderTotal.multiply(new BigDecimal(\"0.30\"));\n return discount.min(maxDiscount).setScale(2, RoundingMode.HALF_UP);\n }\n}\n```\n\n**Cover: all tiers, volume thresholds, loyalty bonus, discount cap.**\n\n**✅ Solution:**\n\n```java\npublic class DiscountCalculatorCharacterizationTest {\n\n private DiscountCalculator calculator = new DiscountCalculator();\n\n // Tier discount characterization\n @ParameterizedTest(name = \"Tier {0}, order ${1} -> discount ${2}\")\n @CsvSource({\n // tier, orderTotal, expectedDiscount\n \"BRONZE, 100.00, 0.00\", // No tier discount\n \"SILVER, 100.00, 0.00\", // No tier discount\n \"GOLD, 100.00, 10.00\", // 10% tier discount\n \"PLATINUM, 100.00, 15.00\", // 15% tier discount\n })\n void tierDiscount(Tier tier, String total, String expected) {\n Customer customer = customerWithTier(tier);\n BigDecimal result = calculator.calculate(customer, new BigDecimal(total));\n assertEquals(new BigDecimal(expected), result);\n }\n\n // Volume discount characterization\n @ParameterizedTest(name = \"Order ${0} -> discount ${1} (volume)\")\n @CsvSource({\n // orderTotal, expectedDiscount (BRONZE customer, no orders)\n \"499.99, 0.00\", // Below first threshold\n \"500.00, 25.00\", // At first threshold: +$25\n \"999.99, 25.00\", // Below second threshold\n \"1000.00, 75.00\", // At second threshold: +$25 +$50 = $75\n \"1500.00, 75.00\", // Above both thresholds\n })\n void volumeDiscount(String total, String expected) {\n Customer customer = customerWithTier(Tier.BRONZE);\n BigDecimal result = calculator.calculate(customer, new BigDecimal(total));\n assertEquals(new BigDecimal(expected), result);\n }\n\n // Loyalty bonus characterization\n @ParameterizedTest(name = \"{0} orders on ${1} -> discount ${2}\")\n @CsvSource({\n // orderCount, orderTotal, expectedDiscount\n \"5, 100.00, 0.00\", // Below loyalty threshold\n \"10, 100.00, 0.00\", // At threshold - no bonus (> not >=)\n \"11, 100.00, 2.00\", // Above threshold: 2% bonus\n \"100, 100.00, 2.00\", // Well above threshold\n })\n void loyaltyBonus(int orders, String total, String expected) {\n Customer customer = customerWithOrders(orders);\n BigDecimal result = calculator.calculate(customer, new BigDecimal(total));\n assertEquals(new BigDecimal(expected), result);\n }\n\n // Combined discount characterization\n @ParameterizedTest(name = \"Combined: {0}, ${1}, {2} orders -> ${3}\")\n @CsvSource({\n // tier, orderTotal, orderCount, expectedDiscount\n \"GOLD, 100.00, 5, 10.00\", // Tier only\n \"GOLD, 500.00, 5, 75.00\", // Tier (50) + Volume (25)\n \"GOLD, 1000.00, 5, 175.00\", // Tier (100) + Volume (75)\n \"GOLD, 1000.00, 11, 195.00\", // Tier (100) + Volume (75) + Loyalty (20)\n \"PLATINUM, 1000.00, 11, 220.00\", // Tier (150) + Volume (75) + Loyalty (20) = 245, but...\n })\n void combinedDiscount(Tier tier, String total, int orders, String expected) {\n Customer customer = customer(tier, orders);\n BigDecimal result = calculator.calculate(customer, new BigDecimal(total));\n assertEquals(new BigDecimal(expected), result);\n }\n\n // Discount cap characterization\n @Test\n void discountCap_capsAt30Percent() {\n // PLATINUM (15%) + Loyalty (2%) + Volume ($75) on $500 order\n // Would be: 75 + 10 + 25 = 110, which is 22% (under cap)\n Customer customer = customer(Tier.PLATINUM, 15);\n\n BigDecimal result = calculator.calculate(customer, new BigDecimal(\"500.00\"));\n\n assertEquals(new BigDecimal(\"110.00\"), result);\n }\n\n @Test\n void discountCap_limitedTo30PercentOfOrder() {\n // PLATINUM (15%) + Loyalty (2%) on $100 = $17\n // Plus volume if over threshold... test extreme case\n Customer customer = customer(Tier.PLATINUM, 100);\n\n // $1000 order: Tier (150) + Volume (75) + Loyalty (20) = 245\n // 30% of $1000 = $300, so not capped\n BigDecimal result1 = calculator.calculate(customer, new BigDecimal(\"1000.00\"));\n assertEquals(new BigDecimal(\"245.00\"), result1);\n\n // $500 order: Tier (75) + Volume (25) + Loyalty (10) = 110\n // 30% of $500 = $150, so not capped\n BigDecimal result2 = calculator.calculate(customer, new BigDecimal(\"500.00\"));\n assertEquals(new BigDecimal(\"110.00\"), result2);\n\n // For cap to trigger, need very high discount %\n // Actually discovering: cap rarely triggers in normal scenarios\n }\n\n // Edge cases\n @ParameterizedTest(name = \"Edge: {0}\")\n @MethodSource(\"edgeCases\")\n void edgeCases(String scenario, Customer customer, BigDecimal total, BigDecimal expected) {\n BigDecimal result = calculator.calculate(customer, total);\n assertEquals(expected, result);\n }\n\n static Stream edgeCases() {\n return Stream.of(\n Arguments.of(\"Zero order\", customerWithTier(Tier.GOLD),\n BigDecimal.ZERO, new BigDecimal(\"0.00\")),\n Arguments.of(\"Negative order\", customerWithTier(Tier.GOLD),\n new BigDecimal(\"-100\"), new BigDecimal(\"-10.00\")),\n Arguments.of(\"Very small order\", customerWithTier(Tier.PLATINUM),\n new BigDecimal(\"0.01\"), new BigDecimal(\"0.00\")) // Rounds to 0\n );\n }\n\n // Helper methods\n private static Customer customerWithTier(Tier tier) {\n return customer(tier, 0);\n }\n\n private static Customer customerWithOrders(int orders) {\n return customer(Tier.BRONZE, orders);\n }\n\n private static Customer customer(Tier tier, int orders) {\n Customer c = new Customer();\n c.setTier(tier);\n c.setOrderCount(orders);\n return c;\n }\n}\n```\n\n---\n\n### Exercise 5: Database Characterization Test\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 25 minutes\n\n**Task:** Write characterization tests for this query-heavy service using TestContainers.\n\n```java\npublic class ReportService {\n private final JdbcTemplate jdbc;\n\n public SalesReport generateMonthlySales(int year, int month) {\n String sql = \"\"\"\n SELECT\n p.category,\n COUNT(*) as order_count,\n SUM(oi.quantity) as units_sold,\n SUM(oi.quantity * oi.unit_price) as revenue\n FROM orders o\n JOIN order_items oi ON o.id = oi.order_id\n JOIN products p ON oi.product_id = p.id\n WHERE EXTRACT(YEAR FROM o.created_at) = ?\n AND EXTRACT(MONTH FROM o.created_at) = ?\n AND o.status = 'COMPLETED'\n GROUP BY p.category\n ORDER BY revenue DESC\n \"\"\";\n\n List categories = jdbc.query(sql,\n (rs, i) -> new CategorySales(\n rs.getString(\"category\"),\n rs.getInt(\"order_count\"),\n rs.getInt(\"units_sold\"),\n rs.getBigDecimal(\"revenue\")\n ),\n year, month);\n\n return new SalesReport(year, month, categories);\n }\n}\n```\n\n**Test with real database: verify query behavior, edge cases, ordering, data types.**\n\n**✅ Solution:**\n\n```java\n@Testcontainers\npublic class ReportServiceCharacterizationTest {\n\n @Container\n static PostgreSQLContainer postgres = new PostgreSQLContainer<>(\"postgres:14\")\n .withDatabaseName(\"testdb\");\n\n private JdbcTemplate jdbc;\n private ReportService service;\n\n @BeforeAll\n static void setupSchema(@Autowired JdbcTemplate jdbc) {\n jdbc.execute(\"\"\"\n CREATE TABLE products (\n id SERIAL PRIMARY KEY,\n name VARCHAR(100),\n category VARCHAR(50)\n )\n \"\"\");\n jdbc.execute(\"\"\"\n CREATE TABLE orders (\n id SERIAL PRIMARY KEY,\n customer_id INTEGER,\n status VARCHAR(20),\n created_at TIMESTAMP\n )\n \"\"\");\n jdbc.execute(\"\"\"\n CREATE TABLE order_items (\n id SERIAL PRIMARY KEY,\n order_id INTEGER REFERENCES orders(id),\n product_id INTEGER REFERENCES products(id),\n quantity INTEGER,\n unit_price DECIMAL(10,2)\n )\n \"\"\");\n }\n\n @BeforeEach\n void setup() {\n DataSource ds = DataSourceBuilder.create()\n .url(postgres.getJdbcUrl())\n .username(postgres.getUsername())\n .password(postgres.getPassword())\n .build();\n jdbc = new JdbcTemplate(ds);\n service = new ReportService(jdbc);\n\n // Clear data\n jdbc.execute(\"TRUNCATE order_items, orders, products CASCADE\");\n }\n\n @Test\n void generateMonthlySales_basicBehavior() {\n // Setup test data\n setupProducts();\n createCompletedOrder(2024, 1, \"Electronics\", 2, new BigDecimal(\"100.00\"));\n createCompletedOrder(2024, 1, \"Electronics\", 1, new BigDecimal(\"200.00\"));\n createCompletedOrder(2024, 1, \"Clothing\", 3, new BigDecimal(\"50.00\"));\n\n SalesReport report = service.generateMonthlySales(2024, 1);\n\n // Characterization: Returns categories ordered by revenue DESC\n assertEquals(2, report.getCategories().size());\n assertEquals(\"Electronics\", report.getCategories().get(0).category());\n assertEquals(\"Clothing\", report.getCategories().get(1).category());\n\n // Characterization: Aggregates correctly\n CategorySales electronics = report.getCategories().get(0);\n assertEquals(2, electronics.orderCount()); // 2 orders\n assertEquals(3, electronics.unitsSold()); // 2 + 1 items\n assertEquals(new BigDecimal(\"400.00\"), electronics.revenue()); // 200 + 200\n }\n\n @Test\n void generateMonthlySales_onlyIncludesCompletedOrders() {\n setupProducts();\n createOrder(2024, 1, \"COMPLETED\", \"Electronics\", 1, new BigDecimal(\"100.00\"));\n createOrder(2024, 1, \"PENDING\", \"Electronics\", 1, new BigDecimal(\"100.00\"));\n createOrder(2024, 1, \"CANCELLED\", \"Electronics\", 1, new BigDecimal(\"100.00\"));\n\n SalesReport report = service.generateMonthlySales(2024, 1);\n\n // Characterization: Only COMPLETED orders counted\n assertEquals(1, report.getCategories().get(0).orderCount());\n }\n\n @Test\n void generateMonthlySales_filtersCorrectMonth() {\n setupProducts();\n createCompletedOrder(2024, 1, \"Electronics\", 1, new BigDecimal(\"100.00\"));\n createCompletedOrder(2024, 2, \"Electronics\", 1, new BigDecimal(\"200.00\"));\n createCompletedOrder(2023, 1, \"Electronics\", 1, new BigDecimal(\"300.00\"));\n\n SalesReport report = service.generateMonthlySales(2024, 1);\n\n // Characterization: Only January 2024\n assertEquals(new BigDecimal(\"100.00\"), report.getCategories().get(0).revenue());\n }\n\n @Test\n void generateMonthlySales_emptyResults() {\n setupProducts();\n // No orders\n\n SalesReport report = service.generateMonthlySales(2024, 1);\n\n // Characterization: Returns empty list, not null\n assertNotNull(report.getCategories());\n assertTrue(report.getCategories().isEmpty());\n }\n\n @Test\n void generateMonthlySales_boundaryDates() {\n setupProducts();\n // Order at very start of month\n createOrderAtTime(LocalDateTime.of(2024, 1, 1, 0, 0, 0), \"Electronics\", 1, new BigDecimal(\"50.00\"));\n // Order at very end of month\n createOrderAtTime(LocalDateTime.of(2024, 1, 31, 23, 59, 59), \"Electronics\", 1, new BigDecimal(\"50.00\"));\n // Order in next month\n createOrderAtTime(LocalDateTime.of(2024, 2, 1, 0, 0, 0), \"Electronics\", 1, new BigDecimal(\"100.00\"));\n\n SalesReport report = service.generateMonthlySales(2024, 1);\n\n // Characterization: Includes both boundary dates\n assertEquals(new BigDecimal(\"100.00\"), report.getCategories().get(0).revenue());\n }\n\n @Test\n void generateMonthlySales_handlesNullCategory() {\n // Product with null category\n jdbc.execute(\"INSERT INTO products (id, name, category) VALUES (1, 'Test', NULL)\");\n createCompletedOrder(2024, 1, null, 1, new BigDecimal(\"100.00\"));\n\n SalesReport report = service.generateMonthlySales(2024, 1);\n\n // Characterization: NULL category is included\n assertEquals(1, report.getCategories().size());\n assertNull(report.getCategories().get(0).category());\n }\n\n @Test\n void generateMonthlySales_decimalPrecision() {\n setupProducts();\n createCompletedOrder(2024, 1, \"Electronics\", 3, new BigDecimal(\"33.33\"));\n\n SalesReport report = service.generateMonthlySales(2024, 1);\n\n // Characterization: Maintains decimal precision\n assertEquals(new BigDecimal(\"99.99\"), report.getCategories().get(0).revenue());\n }\n\n // Helper methods\n private void setupProducts() {\n jdbc.execute(\"INSERT INTO products (id, name, category) VALUES (1, 'Phone', 'Electronics')\");\n jdbc.execute(\"INSERT INTO products (id, name, category) VALUES (2, 'Shirt', 'Clothing')\");\n }\n\n private void createCompletedOrder(int year, int month, String category, int qty, BigDecimal price) {\n createOrder(year, month, \"COMPLETED\", category, qty, price);\n }\n\n private void createOrder(int year, int month, String status, String category, int qty, BigDecimal price) {\n LocalDateTime date = LocalDateTime.of(year, month, 15, 12, 0);\n createOrderAtTime(date, category, qty, price, status);\n }\n\n private void createOrderAtTime(LocalDateTime date, String category, int qty, BigDecimal price) {\n createOrderAtTime(date, category, qty, price, \"COMPLETED\");\n }\n\n private void createOrderAtTime(LocalDateTime date, String category, int qty, BigDecimal price, String status) {\n int productId = \"Electronics\".equals(category) ? 1 : 2;\n jdbc.update(\"INSERT INTO orders (customer_id, status, created_at) VALUES (1, ?, ?)\",\n status, Timestamp.valueOf(date));\n Long orderId = jdbc.queryForObject(\"SELECT MAX(id) FROM orders\", Long.class);\n jdbc.update(\"INSERT INTO order_items (order_id, product_id, quantity, unit_price) VALUES (?, ?, ?, ?)\",\n orderId, productId, qty, price);\n }\n}\n```\n\n---\n\n## 📝 Summary\n\n| Technique | When to Use |\n|-----------|-------------|\n| Basic Characterization | Single method behavior |\n| Parameterized Tests | Exploring input/output matrix |\n| Golden Master | Complex outputs (reports, JSON) |\n| Subclass and Override | Static dependencies |\n| Side Effect Capture | Database writes, emails, etc. |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review difference between characterization tests and unit tests | 5 min |\n| Day 3 | Redo Exercise 1 (Basic Characterization Test) | 10 min |\n| Day 7 | Practice golden master testing on a report in your codebase | 15 min |\n| Day 14 | Redo Debug This (The False Safety Net) | 10 min |\n| Day 30 | Write characterization tests for a legacy feature you'll modify | 25 min |\n\n---\n\n*Next: [Part 21: Breaking Dependencies]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.895388Z","createdAt","2026-06-10T07:19:24.896291Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes","estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",20,"author",{"_31":54,"_96":56,"_97":98,"_99":100,"_101":-5,"_102":-5,"_103":-5,"_104":-5,"_105":-5},"category",{"_31":92,"_71":58,"_35":93,"_74":94,"_95":-5},"tags",[77,78,79,80],"series",{"_31":16,"_71":72,"_35":73,"_74":75,"_76":23},"name","Advanced Clean Code Patterns: From Principles to Production Mastery","advanced-clean-code-patterns","description","A comprehensive 26-part series covering enterprise-grade clean code patterns for Java developers. From SOLID principles and code smells through refactoring patterns, error handling, validation, to legacy modernization and modern Java 21+ features. Includes real production stories, mental models, exercises, and 150+ interview questions.","isActive",{"_31":89,"_71":90,"_35":91},{"_31":87,"_71":34,"_35":88},{"_31":84,"_71":85,"_35":86},{"_31":81,"_71":82,"_35":83},93,"Legacy Testing","legacy-testing",92,"Golden Master","golden-master",91,"characterization-testing",94,"Approval Testing","approval-testing",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]