J12 Alexeev Serghey

src/main/java/org/redis/Main.java

@@ -1,7 +1,71 @@
 package org.redis;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class Main {
     public static void main(String[] args) {
-        System.out.println("Hello world!");
+
+        Map<String, String> redisMap = new RedisMap();
+
+        System.out.println("=== clear() ===");
+        redisMap.clear();
+
+        System.out.println("isEmpty: " + redisMap.isEmpty());
+        System.out.println("size: " + redisMap.size());
+
+        System.out.println("\n=== put() ===");
+        redisMap.put("name", "Alex");
+        redisMap.put("city", "Chisinau");
+        redisMap.put("job", "Java Developer");
+
+        System.out.println("size: " + redisMap.size());
+        System.out.println("isEmpty: " + redisMap.isEmpty());
+
+        System.out.println("\n=== get() ===");
+        System.out.println("name: " + redisMap.get("name"));
+        System.out.println("city: " + redisMap.get("city"));
+
+        System.out.println("\n=== containsKey() ===");
+        System.out.println("contains 'name': " + redisMap.containsKey("name"));
+        System.out.println("contains 'age': " + redisMap.containsKey("age"));
+
+        System.out.println("\n=== containsValue() ===");
+        System.out.println("contains 'Alex': " + redisMap.containsValue("Alex"));
+        System.out.println("contains 'Berlin': " + redisMap.containsValue("Berlin"));
+
+        System.out.println("\n=== keySet() ===");
+        System.out.println(redisMap.keySet());
+
+        System.out.println("\n=== values() ===");
+        System.out.println(redisMap.values());
+
+
+        System.out.println("\n=== entrySet() ===");
+        for (var entry : redisMap.entrySet()) {
+            System.out.println(entry.getKey() + " = " + entry.getValue());
+        }
+
+        System.out.println("\n=== remove() ===");
+        System.out.println(redisMap.remove("city"));
+        System.out.println("contains 'city': " + redisMap.containsKey("city"));
+        System.out.println("size: " + redisMap.size());
+
+        System.out.println("\n=== putAll() ===");
+        Map<String, String> newData = new HashMap<>();
+        newData.put("language", "Java");
+        newData.put("level", "Middle");
+
+        redisMap.putAll(newData);
+
+        System.out.println("entrySet after putAll:");
+        redisMap.entrySet().forEach(System.out::println);
+
+        System.out.println("\n=== final clear() ===");
+        redisMap.clear();
+
+        System.out.println("isEmpty: " +redisMap.isEmpty());
+        System.out.println("size: " + redisMap.size());
+
     }
 }

src/main/java/org/redis/RedisMap.java

@@ -0,0 +1,98 @@
+package org.redis;
+
+import redis.clients.jedis.Jedis;
+
+import java.util.*;
+
+public class RedisMap implements Map<String, String> {
+    private final Jedis jedis;
+
+
+    public RedisMap() {
+        this.jedis = new Jedis("localhost", 6379);
+    }
+
+    @Override
+    public int size() {
+        return Math.toIntExact(jedis.dbSize());
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return jedis.dbSize() == 0;
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return jedis.exists(key.toString());
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        if (isEmpty()){
+            return false;
+        }
+        Set<String> keys = jedis.keys("*");
+
+        List<String> values = jedis.mget(keys.toArray(new String[0]));
+
+        return  values.stream().anyMatch(listValue -> listValue.equals(value));
+    }
+
+    @Override
+    public String get(Object key) {
+        return jedis.get(key.toString());
+    }
+
+    @Override
+    public String put(String key, String value) {
+        String old = jedis.get(key);
+        jedis.set(key, value);
+        return old;
+    }
+
+    @Override
+    public String remove(Object key) {
+        String old = jedis.get(key.toString());
+        jedis.del(key.toString());
+        return old;
+    }
+
+    @Override
+    public void putAll(Map<? extends String, ? extends String> m) {
+        for (Entry<? extends String, ? extends String> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        jedis.flushDB();
+    }
+
+    @Override
+    public Set<String> keySet() {
+        return jedis.keys("*");
+    }
+
+    @Override
+    public Collection<String> values() {
+        return jedis.mget(keySet().toArray(new String[0]));
+    }
+
+    @Override
+    public Set<Entry<String, String>> entrySet() {
+        Set<String> keys = keySet();
+        List<String> values = (List<String>) values();
+
+        Iterator<String> keyIt = keys.iterator();
+        Iterator<String> valueIt = values.iterator();
+
+        Set<Entry<String, String>> entries = new HashSet<>();
+
+        while (keyIt.hasNext()) {
+            entries.add(Map.entry(keyIt.next(), valueIt.next()));
+        }
+        return entries;
+    }
+}

src/test/java/org/redis/RedisMapTest.java

@@ -0,0 +1,173 @@
+package org.redis;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import redis.clients.jedis.Jedis;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class RedisMapTest {
+
+    private RedisMap map;
+    private Jedis jedis;
+
+    @BeforeEach
+    void setUp() {
+        map = new RedisMap();
+        jedis = new Jedis("localhost", 6379);
+        jedis.flushDB(); // чистим Redis перед каждым тестом
+    }
+
+    @AfterEach
+    void tearDown() {
+        jedis.flushDB();
+        jedis.close();
+    }
+
+    @Test
+    void size_shouldReturnCorrectSize() {
+        assertEquals(0, map.size());
+
+        map.put("a", "1");
+        map.put("b", "2");
+
+        assertEquals(2, map.size());
+    }
+
+    @Test
+    void isEmpty_shouldWorkCorrectly() {
+        assertTrue(map.isEmpty());
+
+        map.put("key", "value");
+
+        assertFalse(map.isEmpty());
+    }
+
+    @Test
+    void containsKey_shouldReturnTrueIfKeyExists() {
+        map.put("key", "value");
+
+        assertTrue(map.containsKey("key"));
+        assertFalse(map.containsKey("unknown"));
+    }
+
+    @Test
+    void containsValue_shouldReturnTrueIfValueExists() {
+        map.put("a", "1");
+        map.put("b", "2");
+
+        assertTrue(map.containsValue("1"));
+        assertTrue(map.containsValue("2"));
+        assertFalse(map.containsValue("3"));
+    }
+
+    @Test
+    void get_shouldReturnValueByKey() {
+        map.put("name", "Alex");
+
+        assertEquals("Alex", map.get("name"));
+        assertNull(map.get("unknown"));
+    }
+
+    @Test
+    void put_shouldReturnOldValue() {
+        assertNull(map.put("key", "value1"));
+
+        String old = map.put("key", "value2");
+
+        assertEquals("value1", old);
+        assertEquals("value2", map.get("key"));
+    }
+
+    @Test
+    void remove_shouldDeleteKey() {
+        map.put("key", "value");
+
+        String result = map.remove("key");
+
+        assertEquals("value", result);
+        assertFalse(map.containsKey("key"));
+    }
+
+    @Test
+    void remove_shouldHandleMissingKey() {
+        String result = map.remove("missing");
+
+        assertNull( result);
+    }
+
+    @Test
+    void putAll_shouldInsertAllEntries() {
+        Map<String, String> data = new HashMap<>();
+        data.put("a", "1");
+        data.put("b", "2");
+
+        map.putAll(data);
+
+        assertEquals(2, map.size());
+        assertEquals("1", map.get("a"));
+        assertEquals("2", map.get("b"));
+    }
+
+    @Test
+    void clear_shouldRemoveAllEntries() {
+        map.put("a", "1");
+        map.put("b", "2");
+
+        map.clear();
+
+        assertTrue(map.isEmpty());
+        assertEquals(0, map.size());
+    }
+
+    @Test
+    void keySet_shouldReturnAllKeys() {
+        map.put("a", "1");
+        map.put("b", "2");
+
+        Set<String> keys = map.keySet();
+
+        assertEquals(2, keys.size());
+        assertTrue(keys.contains("a"));
+        assertTrue(keys.contains("b"));
+    }
+
+    @Test
+    void values_shouldReturnAllValues() {
+        map.put("a", "1");
+        map.put("b", "2");
+
+        Collection<String> values = map.values();
+
+        assertEquals(2, values.size());
+        assertTrue(values.contains("1"));
+        assertTrue(values.contains("2"));
+    }
+
+    @Test
+    void entrySet_shouldReturnAllEntries() {
+        map.put("a", "1");
+        map.put("b", "2");
+
+        Set<Map.Entry<String, String>> entries = map.entrySet();
+
+        assertEquals(2, entries.size());
+
+        Map<String, String> result = new HashMap<>();
+        for (Map.Entry<String, String> entry : entries) {
+            result.put(entry.getKey(), entry.getValue());
+        }
+
+        assertEquals("1", result.get("a"));
+        assertEquals("2", result.get("b"));
+    }
+
+
+
+}