Fixes

Author: KevinMwita7

src/test/java/com/thealgorithms/datastructures/caches/RRCacheTest.java

@@ -1,17 +1,11 @@
 package com.thealgorithms.datastructures.caches;
 
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Random;
 import java.util.Set;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.function.Executable;
@@ -40,22 +34,22 @@ void setUp() {
     @Test
     void testPutAndGet() {
         cache.put("a", "apple");
-        assertEquals("apple", cache.get("a"));
+        Assertions.assertEquals("apple", cache.get("a"));
     }
 
     @Test
     void testOverwriteValue() {
         cache.put("a", "apple");
         cache.put("a", "avocado");
-        assertEquals("avocado", cache.get("a"));
+        Assertions.assertEquals("avocado", cache.get("a"));
     }
 
     @Test
     void testExpiration() throws InterruptedException {
         cache.put("temp", "value", 100); // short TTL
         Thread.sleep(200);
-        assertNull(cache.get("temp"));
-        assertTrue(evictedKeys.contains("temp"));
+        Assertions.assertNull(cache.get("temp"));
+        Assertions.assertTrue(evictedKeys.contains("temp"));
     }
 
     @Test
@@ -66,9 +60,9 @@ void testEvictionOnCapacity() {
         cache.put("d", "delta"); // triggers eviction
 
         int size = cache.size();
-        assertEquals(3, size);
-        assertEquals(1, evictedKeys.size());
-        assertEquals(1, evictedValues.size());
+        Assertions.assertEquals(3, size);
+        Assertions.assertEquals(1, evictedKeys.size());
+        Assertions.assertEquals(1, evictedValues.size());
     }
 
     @Test
@@ -78,17 +72,17 @@ void testEvictionListener() {
         cache.put("z", "three");
         cache.put("w", "four"); // one of x, y, z will be evicted
 
-        assertFalse(evictedKeys.isEmpty());
-        assertFalse(evictedValues.isEmpty());
+        Assertions.assertFalse(evictedKeys.isEmpty());
+        Assertions.assertFalse(evictedValues.isEmpty());
     }
 
     @Test
     void testHitsAndMisses() {
         cache.put("a", "apple");
-        assertEquals("apple", cache.get("a"));
-        assertNull(cache.get("b"));
-        assertEquals(1, cache.getHits());
-        assertEquals(1, cache.getMisses());
+        Assertions.assertEquals("apple", cache.get("a"));
+        Assertions.assertNull(cache.get("b"));
+        Assertions.assertEquals(1, cache.getHits());
+        Assertions.assertEquals(1, cache.getMisses());
     }
 
     @Test
@@ -97,7 +91,7 @@ void testSizeExcludesExpired() throws InterruptedException {
         cache.put("b", "b", 100);
         cache.put("c", "c", 100);
         Thread.sleep(150);
-        assertEquals(0, cache.size());
+        Assertions.assertEquals(0, cache.size());
     }
 
     @Test
@@ -106,45 +100,45 @@ void testToStringDoesNotExposeExpired() throws InterruptedException {
         cache.put("dead", "gone", 100);
         Thread.sleep(150);
         String result = cache.toString();
-        assertTrue(result.contains("live"));
-        assertFalse(result.contains("dead"));
+        Assertions.assertTrue(result.contains("live"));
+        Assertions.assertFalse(result.contains("dead"));
     }
 
     @Test
     void testNullKeyGetThrows() {
-        assertThrows(IllegalArgumentException.class, () -> cache.get(null));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> cache.get(null));
     }
 
     @Test
     void testPutNullKeyThrows() {
-        assertThrows(IllegalArgumentException.class, () -> cache.put(null, "v"));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> cache.put(null, "v"));
     }
 
     @Test
     void testPutNullValueThrows() {
-        assertThrows(IllegalArgumentException.class, () -> cache.put("k", null));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> cache.put("k", null));
     }
 
     @Test
     void testPutNegativeTTLThrows() {
-        assertThrows(IllegalArgumentException.class, () -> cache.put("k", "v", -1));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> cache.put("k", "v", -1));
     }
 
     @Test
     void testBuilderNegativeCapacityThrows() {
-        assertThrows(IllegalArgumentException.class, () -> new RRCache.Builder<>(0));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> new RRCache.Builder<>(0));
     }
 
     @Test
     void testBuilderNullRandomThrows() {
         RRCache.Builder<String, String> builder = new RRCache.Builder<>(1);
-        assertThrows(IllegalArgumentException.class, () -> builder.random(null));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> builder.random(null));
     }
 
     @Test
     void testBuilderNullEvictionListenerThrows() {
         RRCache.Builder<String, String> builder = new RRCache.Builder<>(1);
-        assertThrows(IllegalArgumentException.class, () -> builder.evictionListener(null));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> builder.evictionListener(null));
     }
 
     @Test
@@ -153,12 +147,12 @@ void testEvictionListenerExceptionDoesNotCrash() {
 
         listenerCache.put("a", "a");
         listenerCache.put("b", "b"); // causes eviction but should not crash
-        assertDoesNotThrow(() -> listenerCache.get("a"));
+        Assertions.assertDoesNotThrow(() -> listenerCache.get("a"));
     }
 
     @Test
     void testTtlZeroThrowsIllegalArgumentException() {
         Executable exec = () -> new RRCache.Builder<String, String>(3).defaultTTL(-1).build();
-        assertThrows(IllegalArgumentException.class, exec);
+        Assertions.assertThrows(IllegalArgumentException.class, exec);
     }
 }