diff --git a/protocol/src/test/java/com/zfoo/protocol/collection/HashMapTest.java b/protocol/src/test/java/com/zfoo/protocol/collection/HashMapTest.java
index 31a8b591..c83fda46 100644
--- a/protocol/src/test/java/com/zfoo/protocol/collection/HashMapTest.java
+++ b/protocol/src/test/java/com/zfoo/protocol/collection/HashMapTest.java
@@ -325,41 +325,186 @@ public class HashMapTest {
 
     @Test
     public void intIntEqualsTest() {
-        var map = Map.of(1, 2, 3, 4, 5, 6, Integer.MAX_VALUE, Integer.MIN_VALUE);
+        var map = Map.of(1, 2, 3, 4, 5, 6, Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE);
         var myMap = new HashMapIntInt();
         myMap.putAll(map);
         Assert.assertEquals(map, myMap);
+        Assert.assertFalse(myMap.isEmpty());
+        for (var entry : map.entrySet()) {
+            Assert.assertTrue(myMap.containsKey(entry.getKey()));
+            Assert.assertTrue(myMap.containsValue(entry.getValue()));
+            Assert.assertNotNull(myMap.get(entry.getKey()));
+        }
+        myMap.clear();
+        Assert.assertTrue(myMap.isEmpty());
+        for (int i = 1; i <= 1000; i++) {
+            for (var entry : map.entrySet()) {
+                myMap.put(entry.getKey() * i, entry.getValue() * i);
+            }
+        }
+        var newMap = new HashMap<>(myMap);
+        for (var key : myMap.keySet()) {
+            Assert.assertTrue(newMap.containsKey(key));
+        }
+        for (var value : myMap.values()) {
+            Assert.assertTrue(newMap.containsValue(value));
+        }
+        for (var entry : myMap.entrySet()) {
+            Assert.assertTrue(newMap.containsKey(entry.getKey()));
+            Assert.assertTrue(newMap.containsValue(entry.getValue()));
+        }
+        Assert.assertEquals(myMap, newMap);
+        for (var key : newMap.keySet()) {
+            myMap.remove(key);
+        }
+        Assert.assertTrue(myMap.isEmpty());
     }
 
     @Test
     public void intLongEqualsTest() {
-        var map = Map.of(1, 2L, 3, 4L, 5, 6L, Integer.MAX_VALUE, Long.MIN_VALUE);
+        var map = Map.of(1, 2L, 3, 4L, 5, 6L, Integer.MAX_VALUE, Long.MIN_VALUE, Integer.MIN_VALUE, Long.MAX_VALUE);
         var myMap = new HashMapIntLong();
         myMap.putAll(map);
         Assert.assertEquals(map, myMap);
+        Assert.assertFalse(myMap.isEmpty());
+        for (var entry : map.entrySet()) {
+            Assert.assertTrue(myMap.containsKey(entry.getKey()));
+            Assert.assertTrue(myMap.containsValue(entry.getValue()));
+            Assert.assertNotNull(myMap.get(entry.getKey()));
+        }
+        myMap.clear();
+        Assert.assertTrue(myMap.isEmpty());
+        for (int i = 1; i <= 1000; i++) {
+            for (var entry : map.entrySet()) {
+                myMap.put(entry.getKey() * i, entry.getValue() * i);
+            }
+        }
+        var newMap = new HashMap<>(myMap);
+        for (var key : myMap.keySet()) {
+            Assert.assertTrue(newMap.containsKey(key));
+        }
+        for (var value : myMap.values()) {
+            Assert.assertTrue(newMap.containsValue(value));
+        }
+        for (var entry : myMap.entrySet()) {
+            Assert.assertTrue(newMap.containsKey(entry.getKey()));
+            Assert.assertTrue(newMap.containsValue(entry.getValue()));
+        }
+        Assert.assertEquals(myMap, newMap);
+        for (var key : newMap.keySet()) {
+            myMap.remove(key);
+        }
+        Assert.assertTrue(myMap.isEmpty());
     }
 
     @Test
     public void intShortEqualsTest() {
-        var map = Map.of(1, (short) 2, 3, (short) 4, 5, (short) 6, Integer.MAX_VALUE, Short.MIN_VALUE);
+        var map = Map.of(1, (short) 2, 3, (short) 4, 5, (short) 6, Integer.MAX_VALUE, Short.MIN_VALUE, Integer.MIN_VALUE, Short.MAX_VALUE);
         var myMap = new HashMapIntShort();
         myMap.putAll(map);
         Assert.assertEquals(map, myMap);
+        Assert.assertFalse(myMap.isEmpty());
+        for (var entry : map.entrySet()) {
+            Assert.assertTrue(myMap.containsKey(entry.getKey()));
+            Assert.assertTrue(myMap.containsValue(entry.getValue()));
+            Assert.assertNotNull(myMap.get(entry.getKey()));
+        }
+        myMap.clear();
+        Assert.assertTrue(myMap.isEmpty());
+        for (int i = 1; i <= 1000; i++) {
+            for (var entry : map.entrySet()) {
+                myMap.put(entry.getKey() * i, (short) (entry.getValue() * i));
+            }
+        }
+        var newMap = new HashMap<>(myMap);
+        for (var key : myMap.keySet()) {
+            Assert.assertTrue(newMap.containsKey(key));
+        }
+        for (var value : myMap.values()) {
+            Assert.assertTrue(newMap.containsValue(value));
+        }
+        for (var entry : myMap.entrySet()) {
+            Assert.assertTrue(newMap.containsKey(entry.getKey()));
+            Assert.assertTrue(newMap.containsValue(entry.getValue()));
+        }
+        Assert.assertEquals(myMap, newMap);
+        for (var key : newMap.keySet()) {
+            myMap.remove(key);
+        }
+        Assert.assertTrue(myMap.isEmpty());
     }
 
     @Test
     public void longIntEqualsTest() {
-        var map = Map.of(1L, 2, 3L, 4, 5L, 6, Long.MAX_VALUE, Integer.MIN_VALUE);
+        var map = Map.of(1L, 2, 3L, 4, 5L, 6, Long.MAX_VALUE, Integer.MIN_VALUE, Long.MIN_VALUE, Integer.MAX_VALUE);
         var myMap = new HashMapLongInt();
         myMap.putAll(map);
         Assert.assertEquals(map, myMap);
+        Assert.assertFalse(myMap.isEmpty());
+        for (var entry : map.entrySet()) {
+            Assert.assertTrue(myMap.containsKey(entry.getKey()));
+            Assert.assertTrue(myMap.containsValue(entry.getValue()));
+            Assert.assertNotNull(myMap.get(entry.getKey()));
+        }
+        myMap.clear();
+        Assert.assertTrue(myMap.isEmpty());
+        for (int i = 1; i <= 1000; i++) {
+            for (var entry : map.entrySet()) {
+                myMap.put(entry.getKey() * i, entry.getValue() * i);
+            }
+        }
+        var newMap = new HashMap<>(myMap);
+        for (var key : myMap.keySet()) {
+            Assert.assertTrue(newMap.containsKey(key));
+        }
+        for (var value : myMap.values()) {
+            Assert.assertTrue(newMap.containsValue(value));
+        }
+        for (var entry : myMap.entrySet()) {
+            Assert.assertTrue(newMap.containsKey(entry.getKey()));
+            Assert.assertTrue(newMap.containsValue(entry.getValue()));
+        }
+        Assert.assertEquals(myMap, newMap);
+        for (var key : newMap.keySet()) {
+            myMap.remove(key);
+        }
+        Assert.assertTrue(myMap.isEmpty());
     }
 
     @Test
     public void longLongEqualsTest() {
-        var map = Map.of(1L, 2L, 3L, 4L, 5L, 6L, Long.MAX_VALUE, Long.MIN_VALUE);
+        var map = Map.of(1L, 2L, 3L, 4L, 5L, 6L, Long.MAX_VALUE, Long.MIN_VALUE, Long.MIN_VALUE, Long.MAX_VALUE);
         var myMap = new HashMapLongLong();
         myMap.putAll(map);
         Assert.assertEquals(map, myMap);
+        Assert.assertFalse(myMap.isEmpty());
+        for (var entry : map.entrySet()) {
+            Assert.assertTrue(myMap.containsKey(entry.getKey()));
+            Assert.assertTrue(myMap.containsValue(entry.getValue()));
+            Assert.assertNotNull(myMap.get(entry.getKey()));
+        }
+        myMap.clear();
+        Assert.assertTrue(myMap.isEmpty());
+        for (int i = 1; i <= 1000; i++) {
+            for (var entry : map.entrySet()) {
+                myMap.put(entry.getKey() * i, entry.getValue() * i);
+            }
+        }
+        var newMap = new HashMap<>(myMap);
+        for (var key : myMap.keySet()) {
+            Assert.assertTrue(newMap.containsKey(key));
+        }
+        for (var value : myMap.values()) {
+            Assert.assertTrue(newMap.containsValue(value));
+        }
+        for (var entry : myMap.entrySet()) {
+            Assert.assertTrue(newMap.containsKey(entry.getKey()));
+            Assert.assertTrue(newMap.containsValue(entry.getValue()));
+        }
+        Assert.assertEquals(myMap, newMap);
+        for (var key : newMap.keySet()) {
+            myMap.remove(key);
+        }
+        Assert.assertTrue(myMap.isEmpty());
     }
 }