[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":87,"_73":88,"_35":89},"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":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70,"_71":72},"id",123,"title","Testing and Debugging Collections","slug","java-collections-part-27-testing-debugging","excerpt","Build comprehensive collection test suites with AssertJ/Hamcrest, debug ConcurrentModificationException, diagnose memory leaks, and test thread-safety.","# Java Collections Compendium Part 27: Testing & Debugging Collections\n\nMaster collection testing with AssertJ and Hamcrest, debug ConcurrentModificationException and memory leaks, and build comprehensive test suites for collection-heavy code.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| **Topic** | AssertJ assertions, Hamcrest matchers, debugging techniques, memory analysis |\n| **Complexity** | Intermediate |\n| **Prerequisites** | Part 1 (Collection Architecture), JUnit basics |\n| **Time to Master** | 3-4 hours |\n| **Interview Frequency** | Medium (testing knowledge valued) |\n\n## 🎯 What You'll Learn\n\nAfter completing this article, you will be able to:\n\n1. Write expressive collection tests with AssertJ\n2. Debug ConcurrentModificationException effectively\n3. Find and fix collection-related memory leaks\n4. Test thread-safety of concurrent collections\n5. Use IntelliJ debugger features for collection inspection\n\n---\n\n## Production Story: The Test That Passed But Shouldn't Have\n\n### The Incident\n\nOur test suite was green, but production had duplicates in what should be a unique collection:\n\n```java\n// ProductService.java\npublic Set getActiveSkus() {\n return products.stream()\n .filter(Product::isActive)\n .map(Product::getSku)\n .collect(Collectors.toSet());\n}\n\n// ProductServiceTest.java - The misleading test\n@Test\nvoid shouldReturnActiveSkus() {\n // Setup: Products with SKUs\n productService.addProduct(new Product(\"SKU-001\", true));\n productService.addProduct(new Product(\"SKU-002\", true));\n productService.addProduct(new Product(\"SKU-003\", false));\n\n Set activeSkus = productService.getActiveSkus();\n\n // ❌ This test passes even with duplicates!\n assertEquals(2, activeSkus.size());\n assertTrue(activeSkus.contains(\"SKU-001\"));\n assertTrue(activeSkus.contains(\"SKU-002\"));\n}\n```\n\n### The Problem\n\n```text\nThe test passed, but production failed because:\n\nActual production data:\n├─ Product(SKU-001, active=true)\n├─ Product(SKU-001, active=true) ← Duplicate SKU!\n├─ Product(SKU-002, active=true)\n└─ Product(SKU-003, active=false)\n\nExpected behavior: Error or deduplicate\nActual behavior: Silent deduplication (Set semantics)\n\nThe test didn't catch this because:\n├─ Test data had no duplicates\n├─ Assertions only checked contains, not exact content\n└─ No assertion verified \"no unexpected elements\"\n\nProduction Impact:\n├─ Inventory count wrong (2 vs 3 active products)\n├─ Orders shipped to wrong quantities\n├─ 50 customer complaints\n└─ Manual inventory reconciliation needed\n```\n\n### The Better Test\n\n```java\n// ProductServiceTest.java - Comprehensive test\n@Test\nvoid shouldReturnExactlyActiveSkus() {\n // Setup with realistic data (including potential duplicates)\n productService.addProduct(new Product(\"SKU-001\", true));\n productService.addProduct(new Product(\"SKU-001\", true)); // Duplicate!\n productService.addProduct(new Product(\"SKU-002\", true));\n productService.addProduct(new Product(\"SKU-003\", false));\n\n Set activeSkus = productService.getActiveSkus();\n\n // ✅ AssertJ: Exact content verification\n assertThat(activeSkus)\n .containsExactlyInAnyOrder(\"SKU-001\", \"SKU-002\")\n .hasSize(2)\n .doesNotContain(\"SKU-003\");\n\n // ✅ If duplicates should cause error:\n assertThatThrownBy(() -> productService.getActiveSkusStrict())\n .isInstanceOf(DuplicateSkuException.class)\n .hasMessageContaining(\"SKU-001\");\n}\n\n@Test\nvoid shouldDetectDuplicateSkus() {\n productService.addProduct(new Product(\"SKU-001\", true));\n productService.addProduct(new Product(\"SKU-001\", true));\n\n // Verify duplicate detection\n List duplicates = productService.findDuplicateSkus();\n assertThat(duplicates).containsExactly(\"SKU-001\");\n}\n```\n\n---\n\n## Mental Model: Test Coverage Pyramid for Collections\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ COLLECTION TEST COVERAGE │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ ┌───────────┐ │\n│ │ E2E/Perf │ Few: Full system behavior │\n│ /│ │\\ - Memory under load │\n│ / └───────────┘ \\ - Concurrent access │\n│ / Integration \\ │\n│ /┌─────────────────┐\\ │\n│ / │ Service + Repo │ \\ Some: Component behavior │\n│ / │ │ \\ - Repository queries │\n│ / └─────────────────┘ \\ - Service layer logic │\n│ / Unit Tests \\ │\n│ /┌───────────────────────────┐\\ │\n│ / │ Individual methods │ \\ Many: Method behavior│\n│ / │ - Edge cases (empty, null) │ \\ │\n│ / │ - Boundary conditions │ \\ │\n│ / │ - All collection operations│ \\ │\n│ / └───────────────────────────┘ \\ │\n│ │\n│ TEST DIMENSIONS FOR COLLECTIONS: │\n│ ┌──────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ 1. SIZE: empty, one, many, boundary (MAX_INT) │ │\n│ │ 2. CONTENT: expected, unexpected, duplicates, nulls │ │\n│ │ 3. ORDER: insertion, sorted, reversed, random │ │\n│ │ 4. MUTATION: add, remove, update, clear │ │\n│ │ 5. THREAD SAFETY: concurrent reads, writes, iteration │ │\n│ │ 6. MEMORY: growth, leaks, large collections │ │\n│ │ │ │\n│ └──────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Deep Dive: AssertJ Collection Assertions\n\n### Basic Assertions\n\n```java\nimport static org.assertj.core.api.Assertions.*;\n\n// Size assertions\nassertThat(list).isEmpty();\nassertThat(list).isNotEmpty();\nassertThat(list).hasSize(3);\nassertThat(list).hasSizeGreaterThan(2);\nassertThat(list).hasSizeLessThanOrEqualTo(10);\nassertThat(list).hasSameSizeAs(otherList);\n\n// Null assertions\nassertThat(list).isNull();\nassertThat(list).isNotNull();\nassertThat(list).isNullOrEmpty();\n```\n\n### Content Assertions\n\n```java\nList colors = List.of(\"red\", \"green\", \"blue\");\n\n// Contains (order doesn't matter, can have extras)\nassertThat(colors).contains(\"red\");\nassertThat(colors).contains(\"red\", \"green\");\nassertThat(colors).containsOnly(\"red\", \"green\", \"blue\"); // Only these, any order\nassertThat(colors).containsExactly(\"red\", \"green\", \"blue\"); // Exact order!\nassertThat(colors).containsExactlyInAnyOrder(\"blue\", \"red\", \"green\"); // Any order\n\n// Does not contain\nassertThat(colors).doesNotContain(\"yellow\");\nassertThat(colors).doesNotContainNull();\n\n// Contains duplicates\nassertThat(List.of(\"a\", \"a\", \"b\")).containsDuplicates();\nassertThat(List.of(\"a\", \"b\", \"c\")).doesNotHaveDuplicates();\n\n// Start/end\nassertThat(colors).startsWith(\"red\");\nassertThat(colors).endsWith(\"blue\");\nassertThat(colors).containsSequence(\"green\", \"blue\");\n```\n\n### Condition-Based Assertions\n\n```java\nList users = getUsers();\n\n// All match\nassertThat(users).allMatch(u -> u.getAge() >= 18);\nassertThat(users).allSatisfy(u -> {\n assertThat(u.getName()).isNotBlank();\n assertThat(u.getEmail()).contains(\"@\");\n});\n\n// Any match\nassertThat(users).anyMatch(u -> u.isAdmin());\nassertThat(users).anySatisfy(u -> assertThat(u.getRole()).isEqualTo(\"ADMIN\"));\n\n// None match\nassertThat(users).noneMatch(u -> u.getAge() < 0);\n\n// Single element matching\nassertThat(users).singleElement()\n .satisfies(u -> assertThat(u.getName()).isEqualTo(\"Alice\"));\n```\n\n### Extracting Properties\n\n```java\nList users = List.of(\n new User(\"Alice\", 30),\n new User(\"Bob\", 25),\n new User(\"Charlie\", 35)\n);\n\n// Extract single property\nassertThat(users)\n .extracting(User::getName)\n .containsExactly(\"Alice\", \"Bob\", \"Charlie\");\n\n// Extract multiple properties\nassertThat(users)\n .extracting(User::getName, User::getAge)\n .containsExactly(\n tuple(\"Alice\", 30),\n tuple(\"Bob\", 25),\n tuple(\"Charlie\", 35)\n );\n\n// Flat extracting (for nested collections)\nassertThat(orders)\n .flatExtracting(Order::getItems)\n .extracting(Item::getSku)\n .contains(\"SKU-001\", \"SKU-002\");\n```\n\n### Filtering\n\n```java\nList users = getUsers();\n\n// Filter then assert\nassertThat(users)\n .filteredOn(u -> u.getAge() >= 18)\n .hasSize(5)\n .allMatch(User::isAdult);\n\n// Filter by property\nassertThat(users)\n .filteredOn(\"role\", \"ADMIN\")\n .hasSize(2);\n\n// Filter on condition\nassertThat(users)\n .filteredOn(u -> u.isActive())\n .extracting(User::getName)\n .containsOnly(\"Alice\", \"Bob\");\n```\n\n### Map Assertions\n\n```java\nMap scores = Map.of(\"Alice\", 100, \"Bob\", 95);\n\n// Basic\nassertThat(scores).isEmpty();\nassertThat(scores).isNotEmpty();\nassertThat(scores).hasSize(2);\n\n// Keys\nassertThat(scores).containsKey(\"Alice\");\nassertThat(scores).containsKeys(\"Alice\", \"Bob\");\nassertThat(scores).containsOnlyKeys(\"Alice\", \"Bob\");\nassertThat(scores).doesNotContainKey(\"Charlie\");\n\n// Values\nassertThat(scores).containsValue(100);\nassertThat(scores).containsValues(100, 95);\n\n// Entries\nassertThat(scores).containsEntry(\"Alice\", 100);\nassertThat(scores).containsExactly(\n entry(\"Alice\", 100),\n entry(\"Bob\", 95)\n);\n\n// Extract from entries\nassertThat(scores)\n .extractingFromEntries(Map.Entry::getKey)\n .contains(\"Alice\", \"Bob\");\n```\n\n---\n\n## Deep Dive: Hamcrest Matchers\n\n### Collection Matchers\n\n```java\nimport static org.hamcrest.MatcherAssert.assertThat;\nimport static org.hamcrest.Matchers.*;\n\nList colors = List.of(\"red\", \"green\", \"blue\");\n\n// Size\nassertThat(colors, hasSize(3));\nassertThat(colors, empty());\nassertThat(colors, not(empty()));\n\n// Contains\nassertThat(colors, hasItem(\"red\"));\nassertThat(colors, hasItems(\"red\", \"green\"));\nassertThat(colors, contains(\"red\", \"green\", \"blue\")); // Exact order\nassertThat(colors, containsInAnyOrder(\"blue\", \"red\", \"green\"));\n\n// Every item\nassertThat(colors, everyItem(not(emptyString())));\nassertThat(colors, everyItem(containsString(\"e\"))); // All contain 'e'? No!\n```\n\n### Map Matchers\n\n```java\nMap scores = Map.of(\"Alice\", 100, \"Bob\", 95);\n\nassertThat(scores, hasKey(\"Alice\"));\nassertThat(scores, hasValue(100));\nassertThat(scores, hasEntry(\"Alice\", 100));\nassertThat(scores, aMapWithSize(2));\n```\n\n### Combining Matchers\n\n```java\n// allOf - AND\nassertThat(colors, allOf(\n hasSize(3),\n hasItem(\"red\"),\n not(hasItem(\"yellow\"))\n));\n\n// anyOf - OR\nassertThat(colors, anyOf(\n hasItem(\"red\"),\n hasItem(\"yellow\")\n));\n\n// both/either\nassertThat(colors, both(hasItem(\"red\")).and(hasSize(3)));\nassertThat(colors, either(empty()).or(hasItem(\"red\")));\n```\n\n---\n\n## Deep Dive: Debugging Collection Issues\n\n### ConcurrentModificationException\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// CAUSE 1: Modifying during for-each\n// ═══════════════════════════════════════════════════════════════\nList items = new ArrayList<>(List.of(\"a\", \"b\", \"c\"));\nfor (String item : items) {\n if (item.equals(\"b\")) {\n items.remove(item); // ConcurrentModificationException!\n }\n}\n\n// Fix 1: Use Iterator.remove()\nIterator it = items.iterator();\nwhile (it.hasNext()) {\n if (it.next().equals(\"b\")) {\n it.remove(); // Safe!\n }\n}\n\n// Fix 2: Use removeIf()\nitems.removeIf(item -> item.equals(\"b\"));\n\n// Fix 3: Collect then remove\nList toRemove = items.stream()\n .filter(item -> item.equals(\"b\"))\n .toList();\nitems.removeAll(toRemove);\n\n// ═══════════════════════════════════════════════════════════════\n// CAUSE 2: Multi-threaded access\n// ═══════════════════════════════════════════════════════════════\n// Thread 1\nfor (String item : sharedList) { // Iterating\n process(item);\n}\n// Thread 2\nsharedList.add(\"new\"); // Concurrent modification!\n\n// Fix: Use ConcurrentHashMap, CopyOnWriteArrayList, or explicit synchronization\n```\n\n### Memory Leak Detection\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// COMMON LEAK: Static collection growing forever\n// ═══════════════════════════════════════════════════════════════\npublic class LeakyCache {\n // ❌ Static map that only grows\n private static final Map cache = new HashMap<>();\n\n public void process(String key, byte[] data) {\n cache.put(key, data); // Never removed!\n }\n}\n\n// ═══════════════════════════════════════════════════════════════\n// DETECTION: Using VisualVM or JFR\n// ═══════════════════════════════════════════════════════════════\n// 1. Take heap dump\n// jcmd GC.heap_dump /tmp/heap.hprof\n\n// 2. Analyze in VisualVM or IntelliJ\n// Look for: Collections with many elements, growing over time\n\n// 3. Or use weak references\nprivate static final Map> cache = new WeakHashMap<>();\n\n// ═══════════════════════════════════════════════════════════════\n// TEST FOR MEMORY LEAK\n// ═══════════════════════════════════════════════════════════════\n@Test\nvoid shouldNotLeakMemory() {\n Runtime runtime = Runtime.getRuntime();\n long beforeMemory = runtime.totalMemory() - runtime.freeMemory();\n\n for (int i = 0; i < 100_000; i++) {\n service.process(\"key-\" + i, new byte[1024]);\n }\n\n System.gc();\n Thread.sleep(1000);\n\n long afterMemory = runtime.totalMemory() - runtime.freeMemory();\n long leaked = afterMemory - beforeMemory;\n\n assertThat(leaked).isLessThan(50 * 1024 * 1024); // Less than 50MB\n}\n```\n\n### Debugging with IntelliJ\n\n```java\n// ═══════════════════════════════════════════════════════════════\n// TIP 1: Stream Trace (Debug menu when stopped at stream)\n// ═══════════════════════════════════════════════════════════════\nList result = items.stream()\n .filter(s -> s.length() > 3) // Set breakpoint here\n .map(String::toUpperCase)\n .collect(toList());\n// Click \"Trace Current Stream Chain\" in debugger\n\n// ═══════════════════════════════════════════════════════════════\n// TIP 2: Collection renderer customization\n// ═══════════════════════════════════════════════════════════════\n// Settings → Build, Execution, Deployment → Debugger → Data Views\n// Add custom renderer for your types\n\n// ═══════════════════════════════════════════════════════════════\n// TIP 3: Conditional breakpoints on collection state\n// ═══════════════════════════════════════════════════════════════\n// Right-click breakpoint → Condition:\n// items.size() > 100 || items.contains(\"suspicious\")\n\n// ═══════════════════════════════════════════════════════════════\n// TIP 4: Watch expressions for collections\n// ═══════════════════════════════════════════════════════════════\n// Add to watches:\n// items.stream().filter(s -> s.startsWith(\"ERROR\")).count()\n// map.entrySet().stream().filter(e -> e.getValue() == null).toList()\n```\n\n---\n\n## Deep Dive: Testing Thread Safety\n\n### Basic Concurrent Test\n\n```java\n@Test\nvoid shouldHandleConcurrentAccess() throws InterruptedException {\n ConcurrentMap map = new ConcurrentHashMap<>();\n int threadCount = 10;\n int operationsPerThread = 1000;\n CountDownLatch latch = new CountDownLatch(threadCount);\n\n for (int t = 0; t < threadCount; t++) {\n new Thread(() -> {\n for (int i = 0; i < operationsPerThread; i++) {\n map.merge(\"counter\", 1, Integer::sum);\n }\n latch.countDown();\n }).start();\n }\n\n latch.await(10, TimeUnit.SECONDS);\n\n assertThat(map.get(\"counter\"))\n .isEqualTo(threadCount * operationsPerThread);\n}\n```\n\n### Testing for Race Conditions\n\n```java\n@Test\n@RepeatedTest(100) // Run many times to catch intermittent issues\nvoid shouldBeThreadSafe() throws Exception {\n var service = new InventoryService();\n service.setStock(\"item\", 100);\n\n int threadCount = 10;\n int reservationsPerThread = 10;\n ExecutorService executor = Executors.newFixedThreadPool(threadCount);\n CountDownLatch startLatch = new CountDownLatch(1);\n CountDownLatch doneLatch = new CountDownLatch(threadCount);\n AtomicInteger successCount = new AtomicInteger(0);\n\n for (int i = 0; i < threadCount; i++) {\n executor.submit(() -> {\n try {\n startLatch.await(); // All threads start together\n for (int j = 0; j < reservationsPerThread; j++) {\n if (service.reserve(\"item\", 1)) {\n successCount.incrementAndGet();\n }\n }\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n } finally {\n doneLatch.countDown();\n }\n });\n }\n\n startLatch.countDown(); // GO!\n doneLatch.await(10, TimeUnit.SECONDS);\n executor.shutdown();\n\n // Exactly 100 reservations should succeed (starting stock)\n assertThat(successCount.get()).isEqualTo(100);\n assertThat(service.getStock(\"item\")).isZero();\n}\n```\n\n### Using JCStress (for serious concurrency testing)\n\n```java\n// JCStress is a specialized framework for testing concurrency\n// See: https://github.com/openjdk/jcstress\n\n@JCStressTest\n@Outcome(id = \"1, 1\", expect = Expect.ACCEPTABLE)\n@Outcome(id = \"0, 0\", expect = Expect.FORBIDDEN)\n@State\npublic class MapRaceTest {\n private final Map map = new HashMap<>();\n\n @Actor\n public void actor1(II_Result r) {\n map.put(\"key\", 1);\n r.r1 = map.get(\"key\");\n }\n\n @Actor\n public void actor2(II_Result r) {\n map.put(\"key\", 2);\n r.r2 = map.get(\"key\");\n }\n}\n```\n\n---\n\n## Deep Dive: Testing Edge Cases\n\n### Null Handling\n\n```java\n@Test\nvoid shouldHandleNullElements() {\n List withNulls = Arrays.asList(\"a\", null, \"c\");\n\n // Test null filtering\n List filtered = service.filterNulls(withNulls);\n assertThat(filtered)\n .doesNotContainNull()\n .containsExactly(\"a\", \"c\");\n}\n\n@Test\nvoid shouldRejectNullInput() {\n assertThatThrownBy(() -> service.process(null))\n .isInstanceOf(NullPointerException.class)\n .hasMessageContaining(\"input must not be null\");\n}\n\n@Test\nvoid shouldHandleCollectionWithNulls() {\n List input = Arrays.asList(\"a\", null, \"b\");\n\n assertThatThrownBy(() -> Set.copyOf(input))\n .isInstanceOf(NullPointerException.class);\n}\n```\n\n### Empty Collection Handling\n\n```java\n@Test\nvoid shouldHandleEmptyCollection() {\n List empty = List.of();\n\n assertThat(service.findMax(empty)).isEmpty();\n assertThat(service.findMin(empty)).isEmpty();\n assertThat(service.average(empty)).isNaN();\n}\n\n@Test\nvoid shouldReturnEmptyNotNull() {\n List users = userService.findByRole(\"NONEXISTENT\");\n\n assertThat(users)\n .isNotNull()\n .isEmpty();\n}\n```\n\n### Boundary Conditions\n\n```java\n@Test\nvoid shouldHandleSingleElement() {\n List single = List.of(42);\n\n assertThat(service.findMax(single)).hasValue(42);\n assertThat(service.findMin(single)).hasValue(42);\n assertThat(service.sort(single)).containsExactly(42);\n}\n\n@Test\nvoid shouldHandleLargeCollection() {\n List large = IntStream.range(0, 1_000_000)\n .boxed()\n .collect(Collectors.toList());\n\n // Should complete in reasonable time\n assertTimeout(Duration.ofSeconds(5), () -> {\n service.process(large);\n });\n}\n\n@Test\nvoid shouldHandleDuplicates() {\n List withDupes = List.of(\"a\", \"a\", \"b\", \"b\", \"b\");\n\n Set unique = service.toUniqueSet(withDupes);\n assertThat(unique).containsExactlyInAnyOrder(\"a\", \"b\");\n\n Map counts = service.countOccurrences(withDupes);\n assertThat(counts)\n .containsEntry(\"a\", 2L)\n .containsEntry(\"b\", 3L);\n}\n```\n\n### Order Verification\n\n```java\n@Test\nvoid shouldMaintainInsertionOrder() {\n SequencedSet set = new LinkedHashSet<>();\n set.add(\"first\");\n set.add(\"second\");\n set.add(\"third\");\n\n assertThat(set).containsExactly(\"first\", \"second\", \"third\");\n assertThat(set.getFirst()).isEqualTo(\"first\");\n assertThat(set.getLast()).isEqualTo(\"third\");\n}\n\n@Test\nvoid shouldSortCorrectly() {\n List users = List.of(\n new User(\"Charlie\", 30),\n new User(\"Alice\", 25),\n new User(\"Bob\", 35)\n );\n\n List sorted = service.sortByName(users);\n\n assertThat(sorted)\n .extracting(User::getName)\n .containsExactly(\"Alice\", \"Bob\", \"Charlie\");\n}\n\n@Test\nvoid shouldReverseCorrectly() {\n List original = List.of(1, 2, 3, 4, 5);\n List reversed = service.reverse(original);\n\n assertThat(reversed).containsExactly(5, 4, 3, 2, 1);\n assertThat(original).containsExactly(1, 2, 3, 4, 5); // Original unchanged\n}\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Not Testing Exact Content\n\n```java\n// ❌ WRONG: Passes even with unexpected elements\n@Test\nvoid testBad() {\n Set result = service.getActiveUsers();\n assertTrue(result.contains(\"Alice\"));\n assertTrue(result.contains(\"Bob\"));\n // What if result also contains \"Hacker\"?\n}\n\n// ✅ CORRECT: Verify exact content\n@Test\nvoid testGood() {\n Set result = service.getActiveUsers();\n assertThat(result).containsExactlyInAnyOrder(\"Alice\", \"Bob\");\n}\n```\n\n### Mistake 2: Order Sensitivity in Set Tests\n\n```java\n// ❌ WRONG: Sets don't guarantee order\n@Test\nvoid testBad() {\n Set result = service.getTags();\n assertThat(result).containsExactly(\"a\", \"b\", \"c\");\n // Fails randomly depending on hash order!\n}\n\n// ✅ CORRECT: Use order-insensitive assertion\n@Test\nvoid testGood() {\n Set result = service.getTags();\n assertThat(result).containsExactlyInAnyOrder(\"a\", \"b\", \"c\");\n}\n```\n\n### Mistake 3: Shallow Collection Comparison\n\n```java\n// ❌ WRONG: Only checks references, not content\n@Test\nvoid testBad() {\n List result = service.getUsers();\n User expected = new User(\"Alice\", 25);\n assertTrue(result.contains(expected));\n // Fails if User doesn't implement equals()!\n}\n\n// ✅ CORRECT: Use field extractors\n@Test\nvoid testGood() {\n List result = service.getUsers();\n assertThat(result)\n .extracting(User::getName, User::getAge)\n .contains(tuple(\"Alice\", 25));\n}\n```\n\n### Mistake 4: Not Testing Immutability\n\n```java\n// ❌ WRONG: Doesn't verify immutability\n@Test\nvoid testBad() {\n List result = service.getImmutableList();\n assertThat(result).containsExactly(\"a\", \"b\");\n // But is it actually immutable?\n}\n\n// ✅ CORRECT: Verify modification throws\n@Test\nvoid testGood() {\n List result = service.getImmutableList();\n assertThat(result).containsExactly(\"a\", \"b\");\n\n assertThatThrownBy(() -> result.add(\"c\"))\n .isInstanceOf(UnsupportedOperationException.class);\n}\n```\n\n### Mistake 5: Flaky Concurrent Tests\n\n```java\n// ❌ WRONG: Race condition in test itself\n@Test\nvoid testBad() {\n var service = new MyService();\n new Thread(() -> service.addItem(\"a\")).start();\n new Thread(() -> service.addItem(\"b\")).start();\n\n Thread.sleep(100); // Hope threads finished!\n assertThat(service.getItems()).hasSize(2);\n}\n\n// ✅ CORRECT: Use proper synchronization\n@Test\nvoid testGood() throws InterruptedException {\n var service = new MyService();\n var latch = new CountDownLatch(2);\n\n new Thread(() -> { service.addItem(\"a\"); latch.countDown(); }).start();\n new Thread(() -> { service.addItem(\"b\"); latch.countDown(); }).start();\n\n assertTrue(latch.await(5, TimeUnit.SECONDS));\n assertThat(service.getItems()).hasSize(2);\n}\n```\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Collection Test Suite\n\nWrite comprehensive tests for this method:\n\n```java\npublic class ListUtils {\n public static List removeDuplicates(List input) {\n return new ArrayList<>(new LinkedHashSet<>(input));\n }\n}\n```\n\n**✅ Solution:**\n\n```java\nclass ListUtilsTest {\n\n @Test\n void shouldRemoveDuplicatesPreservingOrder() {\n List input = List.of(\"a\", \"b\", \"a\", \"c\", \"b\");\n List result = ListUtils.removeDuplicates(input);\n assertThat(result).containsExactly(\"a\", \"b\", \"c\");\n }\n\n @Test\n void shouldHandleEmptyList() {\n List result = ListUtils.removeDuplicates(List.of());\n assertThat(result).isEmpty();\n }\n\n @Test\n void shouldHandleSingleElement() {\n List result = ListUtils.removeDuplicates(List.of(\"only\"));\n assertThat(result).containsExactly(\"only\");\n }\n\n @Test\n void shouldHandleNoDuplicates() {\n List input = List.of(1, 2, 3);\n List result = ListUtils.removeDuplicates(input);\n assertThat(result).containsExactly(1, 2, 3);\n }\n\n @Test\n void shouldHandleAllDuplicates() {\n List input = List.of(\"x\", \"x\", \"x\");\n List result = ListUtils.removeDuplicates(input);\n assertThat(result).containsExactly(\"x\");\n }\n\n @Test\n void shouldHandleNullInList() {\n List input = Arrays.asList(\"a\", null, \"b\", null);\n List result = ListUtils.removeDuplicates(input);\n assertThat(result).containsExactly(\"a\", null, \"b\");\n }\n\n @Test\n void shouldReturnMutableList() {\n List result = ListUtils.removeDuplicates(List.of(\"a\"));\n assertThatCode(() -> result.add(\"b\")).doesNotThrowAnyException();\n }\n\n @Test\n void shouldNotModifyOriginal() {\n List original = new ArrayList<>(List.of(\"a\", \"b\", \"a\"));\n ListUtils.removeDuplicates(original);\n assertThat(original).containsExactly(\"a\", \"b\", \"a\");\n }\n}\n```\n\n### Exercise 2: Debug the Race Condition\n\nFix this thread-unsafe code and write a test that catches the bug:\n\n```java\npublic class Counter {\n private Map counts = new HashMap<>();\n\n public void increment(String key) {\n Integer current = counts.get(key);\n counts.put(key, current == null ? 1 : current + 1);\n }\n\n public int get(String key) {\n return counts.getOrDefault(key, 0);\n }\n}\n```\n\n**✅ Solution:**\n\n```java\n// Fixed implementation\npublic class Counter {\n private final ConcurrentMap counts = new ConcurrentHashMap<>();\n\n public void increment(String key) {\n counts.computeIfAbsent(key, k -> new AtomicInteger(0))\n .incrementAndGet();\n }\n\n public int get(String key) {\n AtomicInteger counter = counts.get(key);\n return counter == null ? 0 : counter.get();\n }\n}\n\n// Test that catches the race condition\n@Test\n@RepeatedTest(10)\nvoid shouldIncrementAtomically() throws InterruptedException {\n Counter counter = new Counter();\n int threadCount = 100;\n int incrementsPerThread = 1000;\n ExecutorService executor = Executors.newFixedThreadPool(threadCount);\n CountDownLatch latch = new CountDownLatch(threadCount);\n\n for (int i = 0; i < threadCount; i++) {\n executor.submit(() -> {\n for (int j = 0; j < incrementsPerThread; j++) {\n counter.increment(\"key\");\n }\n latch.countDown();\n });\n }\n\n latch.await(30, TimeUnit.SECONDS);\n executor.shutdown();\n\n assertThat(counter.get(\"key\"))\n .isEqualTo(threadCount * incrementsPerThread); // 100,000\n}\n```\n\n### Exercise 3: Memory Leak Test\n\nWrite a test that detects if a cache is leaking memory:\n\n```java\npublic class SimpleCache {\n private final Map cache = new HashMap<>();\n private final int maxSize;\n\n public SimpleCache(int maxSize) {\n this.maxSize = maxSize;\n }\n\n public void put(K key, V value) {\n if (cache.size() >= maxSize) {\n // Should evict old entries, but doesn't!\n }\n cache.put(key, value);\n }\n\n public V get(K key) {\n return cache.get(key);\n }\n}\n```\n\n**✅ Solution:**\n\n```java\n@Test\nvoid shouldNotExceedMaxSize() {\n SimpleCache cache = new SimpleCache<>(100);\n\n // Add more than maxSize entries\n for (int i = 0; i < 1000; i++) {\n cache.put(i, new byte[1024]); // 1KB each\n }\n\n // If leaking, we'll have 1000 entries (~1MB)\n // If working, we'll have 100 entries (~100KB)\n\n // Test via reflection or add a size() method\n assertThat(getCacheSize(cache)).isLessThanOrEqualTo(100);\n}\n\n@Test\nvoid shouldNotLeakMemory() {\n SimpleCache cache = new SimpleCache<>(100);\n\n // Get baseline memory\n System.gc();\n long baseline = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();\n\n // Add entries that should be evicted\n for (int i = 0; i < 10_000; i++) {\n cache.put(i, new byte[10_000]); // 10KB each\n }\n\n System.gc();\n Thread.sleep(100);\n\n long after = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();\n long used = after - baseline;\n\n // If working correctly: ~100 entries * 10KB = ~1MB\n // If leaking: 10000 entries * 10KB = ~100MB\n assertThat(used).isLessThan(10_000_000); // Less than 10MB\n}\n\n// Fixed cache\npublic class FixedCache {\n private final Map cache = new LinkedHashMap<>() {\n @Override\n protected boolean removeEldestEntry(Map.Entry eldest) {\n return size() > maxSize;\n }\n };\n private final int maxSize;\n\n // ... rest of implementation\n}\n```\n\n---\n\n## 🎤 Senior-Level Interview Questions\n\n### Question 1: contains() vs containsExactly()\n\n**Q: What's the difference between AssertJ's contains() and containsExactly()?**\n\n**A:**\n\n```java\nList list = List.of(\"a\", \"b\", \"c\");\n\n// contains: Element exists, allows others, any order\nassertThat(list).contains(\"a\"); // ✓\nassertThat(list).contains(\"a\", \"b\"); // ✓ (subset OK)\nassertThat(list).contains(\"b\", \"a\"); // ✓ (any order)\n\n// containsExactly: Exact elements in exact order\nassertThat(list).containsExactly(\"a\", \"b\", \"c\"); // ✓\nassertThat(list).containsExactly(\"a\", \"b\"); // ✗ (missing c)\nassertThat(list).containsExactly(\"c\", \"b\", \"a\"); // ✗ (wrong order)\n\n// containsExactlyInAnyOrder: Exact elements, any order\nassertThat(list).containsExactlyInAnyOrder(\"c\", \"b\", \"a\"); // ✓\n```\n\n### Question 2: Testing Thread Safety\n\n**Q: How do you test that a collection implementation is thread-safe?**\n\n**A:**\n\n1. **Multiple threads hitting same operation**:\n```java\nExecutorService executor = Executors.newFixedThreadPool(10);\nCountDownLatch latch = new CountDownLatch(10);\n\nfor (int i = 0; i < 10; i++) {\n executor.submit(() -> {\n for (int j = 0; j < 1000; j++) {\n collection.add(\"item-\" + j);\n }\n latch.countDown();\n });\n}\n\nlatch.await();\n// Verify final state is consistent\n```\n\n2. **Race condition tests with CountDownLatch**:\n```java\nCountDownLatch startGate = new CountDownLatch(1);\n// All threads wait at gate, then start simultaneously\n```\n\n3. **JCStress** for thorough analysis\n4. **@RepeatedTest** to catch intermittent failures\n\n### Question 3: Debugging ConcurrentModificationException\n\n**Q: How do you debug a ConcurrentModificationException that only happens in production?**\n\n**A:**\n\n1. **Add logging around collection operations**:\n```java\nlog.debug(\"Before iteration, size={}\", list.size());\nfor (Item item : list) {\n log.trace(\"Processing {}\", item);\n // ...\n}\n```\n\n2. **Check for multi-threaded access**:\n```java\n// Temporarily wrap with checked wrapper\nList checked = Collections.checkedList(\n Collections.synchronizedList(list), String.class);\n```\n\n3. **Use stack traces from the exception**:\n- The exception includes both the iterator creation and modification point\n- Compare thread IDs in logs around those times\n\n4. **Consider using CopyOnWriteArrayList temporarily** to see if problem disappears\n\n### Question 4: Memory Leak Detection\n\n**Q: How would you detect if a Map is causing a memory leak?**\n\n**A:**\n\n1. **Heap dump analysis**:\n```bash\njcmd GC.heap_dump /tmp/heap.hprof\n# Open in VisualVM or IntelliJ\n```\n\n2. **JFR recording**:\n```bash\njcmd JFR.start name=leak duration=60s filename=/tmp/leak.jfr\n```\n\n3. **Test with assertions**:\n```java\n@Test\nvoid mapShouldNotGrowUnbounded() {\n for (int i = 0; i < 100_000; i++) {\n service.process(\"key-\" + i);\n }\n assertThat(service.getCacheSize()).isLessThan(1000);\n}\n```\n\n4. **WeakHashMap test**:\n```java\n// If using WeakHashMap, test that entries can be GC'd\nmap.put(key, value);\nkey = null;\nSystem.gc();\nassertThat(map).isEmpty(); // Key was weak-referenced\n```\n\n### Question 5: Test Isolation\n\n**Q: How do you ensure tests don't affect each other when testing shared collections?**\n\n**A:**\n\n1. **Create fresh instances**:\n```java\n@BeforeEach\nvoid setUp() {\n collection = new ArrayList<>();\n}\n```\n\n2. **Use defensive copies**:\n```java\nprivate static final List TEST_DATA = List.of(\"a\", \"b\", \"c\");\n\n@Test\nvoid test1() {\n List data = new ArrayList<>(TEST_DATA); // Copy\n // Modify data safely\n}\n```\n\n3. **Avoid static shared state**\n4. **Clear collections in @AfterEach if reusing**\n5. **Use @DirtiesContext in Spring if needed**\n\n---\n\n## 📝 Summary & Key Takeaways\n\n### AssertJ Essentials\n\n| Assertion | Use Case |\n|-----------|----------|\n| `contains()` | Element exists, others OK |\n| `containsExactly()` | Exact elements, exact order |\n| `containsExactlyInAnyOrder()` | Exact elements, any order |\n| `extracting()` | Test object properties |\n| `filteredOn()` | Filter then assert |\n\n### Test Coverage Areas\n\n1. **Size**: Empty, one, many, boundary\n2. **Content**: Expected, unexpected, duplicates, nulls\n3. **Order**: Insertion, sorted, reversed\n4. **Mutation**: Add, remove, update, clear\n5. **Thread safety**: Concurrent operations\n6. **Memory**: Growth, leaks\n\n### Debugging Tools\n\n- IntelliJ Stream Trace\n- Conditional breakpoints\n- JFR and heap dumps\n- WeakHashMap for leak tests\n\n---\n\n## 🏁 Conclusion\n\nEffective collection testing requires comprehensive coverage of edge cases and clear assertions. The key insights are:\n\n1. **Use assertThat(list).containsExactly()** for precise verification\n2. **Test edge cases**: empty, single, large, with nulls\n3. **Verify immutability** by attempting modification\n4. **Use proper synchronization** in concurrent tests\n5. **Monitor memory** for leak detection\n\nIn the next article, we'll explore Performance and Production Pitfalls - real-world issues and how to avoid them.\n\n---\n\n## 📅 Review Schedule\n\nTo solidify your understanding:\n- **Tomorrow**: Rewrite one test using AssertJ\n- **In 3 days**: Add edge case tests to existing code\n- **In 1 week**: Run a concurrent test repeatedly\n- **In 2 weeks**: Analyze heap dump for a production app\n\n---\n\n**Next in Series**: [Part 28: Performance, Memory & Production Pitfalls](/articles/java-collections-part-28-performance-pitfalls)\n\n**Series Navigation**: [Part 0: How to Use This Series](/articles/java-collections-part-0-how-to-use-this-series) | [Full Index](/articles/java-collections-compendium)\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:26.199243Z","createdAt","2026-06-10T07:19:26.199996Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",15,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId",5,"seriesOrder",27,"author",{"_31":55,"_100":57,"_101":102,"_103":104,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5},"category",{"_31":62,"_73":59,"_35":91,"_76":98,"_99":-5},"tags",[79,80,81,82,83],"series",{"_31":62,"_73":74,"_35":75,"_76":77,"_78":23},"name","Java Collections Compendium: From Fundamentals to Production Mastery","java-collections-compendium","description","A comprehensive 30-part series covering everything about Java Collections Framework. From foundational concepts like generics and equals/hashCode contract, through deep dives into ArrayList, LinkedList, HashMap, TreeMap, ConcurrentHashMap, to modern features like immutable collections, Java 21 sequenced collections, streams & collectors, and production patterns with JPA, Jackson & Spring. Includes real production stories, mental models, exercises, and 50+ interview questions.","isActive",{"_31":95,"_73":96,"_35":97},{"_31":92,"_73":93,"_35":94},{"_31":90,"_73":59,"_35":91},{"_31":87,"_73":88,"_35":89},{"_31":84,"_73":85,"_35":86},379,"Testing","testing",380,"Junit","junit",14,"java",240,"Debugging","debugging",381,"Assertj","assertj","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]