From c9bbe506d97db73bfa10fdfeadfca88bea740359 Mon Sep 17 00:00:00 2001 From: miko <1059665047@qq.com> Date: Wed, 25 Dec 2024 18:18:55 +0800 Subject: [PATCH] =?UTF-8?q?MapUtil[partition][computeIfAbsentForJdk8][comp?= =?UTF-8?q?uteIfAbsent][entry][valuesOfKeys][clear][empty][removeNullValue?= =?UTF-8?q?][renameKey][get/getQuietly]=E6=B5=8B=E8=AF=95=E7=94=A8?= =?UTF-8?q?=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/cn/hutool/core/map/MapUtilTest.java | 575 ++++++++++++++++++ 1 file changed, 575 insertions(+) diff --git a/hutool-core/src/test/java/cn/hutool/core/map/MapUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/map/MapUtilTest.java index 0a9500135..746175321 100644 --- a/hutool-core/src/test/java/cn/hutool/core/map/MapUtilTest.java +++ b/hutool-core/src/test/java/cn/hutool/core/map/MapUtilTest.java @@ -3,12 +3,16 @@ package cn.hutool.core.map; import cn.hutool.core.convert.Convert; import cn.hutool.core.lang.Dict; import cn.hutool.core.lang.Opt; +import cn.hutool.core.lang.TypeReference; import cn.hutool.core.util.StrUtil; import lombok.Builder; import lombok.Data; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -215,6 +219,18 @@ public class MapUtilTest { assertEquals(Integer.valueOf(2), map.get("b")); } + @Test + public void ofEntriesSimpleEntryTest(){ + final Map map = MapUtil.ofEntries( + MapUtil.entry("a", 1,false), + MapUtil.entry("b", 2,false) + ); + assertEquals(2, map.size()); + + assertEquals(Integer.valueOf(1), map.get("a")); + assertEquals(Integer.valueOf(2), map.get("b")); + } + @Test public void getIntTest(){ assertThrows(NumberFormatException.class, () -> { @@ -238,6 +254,40 @@ public class MapUtilTest { assertEquals("张三", map.get("newName")); } + @Test + public void renameKeyMapEmptyNoChange() { + Map map = new HashMap<>(); + Map result = MapUtil.renameKey(map, "oldKey", "newKey"); + assertTrue(result.isEmpty()); + } + @Test + public void renameKeyOldKeyNotPresentNoChange() { + Map map = new HashMap<>(); + map.put("anotherKey", "value"); + Map result = MapUtil.renameKey(map, "oldKey", "newKey"); + assertEquals(1, result.size()); + assertEquals("value", result.get("anotherKey")); + } + + @Test + public void renameKeyOldKeyPresentNewKeyNotPresentKeyRenamed() { + Map map = new HashMap<>(); + map.put("oldKey", "value"); + Map result = MapUtil.renameKey(map, "oldKey", "newKey"); + assertEquals(1, result.size()); + assertEquals("value", result.get("newKey")); + } + + @Test + public void renameKeyNewKeyPresentThrowsException() { + Map map = new HashMap<>(); + map.put("oldKey", "value"); + map.put("newKey", "existingValue"); + assertThrows(IllegalArgumentException.class, () -> { + MapUtil.renameKey(map, "oldKey", "newKey"); + }); + } + @Test public void issue3162Test() { final Map map = new HashMap() { @@ -252,4 +302,529 @@ public class MapUtilTest { assertEquals("1", filtered.get("a")); assertEquals("2", filtered.get("b")); } + + + @Test + public void partitionNullMapThrowsException() { + assertThrows(IllegalArgumentException.class, () -> MapUtil.partition(null, 2)); + } + + @Test + public void partitionSizeZeroThrowsException() { + Map map = new HashMap<>(); + map.put("a", "1"); + assertThrows(IllegalArgumentException.class, () -> MapUtil.partition(map, 0)); + } + + @Test + public void partitionSizeNegativeThrowsException() { + Map map = new HashMap<>(); + map.put("a", "1"); + assertThrows(IllegalArgumentException.class, () -> MapUtil.partition(map, -1)); + } + + @Test + public void partitionEmptyMapReturnsEmptyList() { + Map map = new HashMap<>(); + List> result = MapUtil.partition(map, 2); + assertTrue(result.isEmpty()); + } + + @Test + public void partitionMapSizeMultipleOfSizePartitionsCorrectly() { + Map map = new HashMap<>(); + map.put("a", "1"); + map.put("b", "2"); + map.put("c", "3"); + map.put("d", "4"); + + List> result = MapUtil.partition(map, 2); + + assertEquals(2, result.size()); + assertEquals(2, result.get(0).size()); + assertEquals(2, result.get(1).size()); + } + + @Test + public void partitionMapSizeNotMultipleOfSizePartitionsCorrectly() { + Map map = new HashMap<>(); + map.put("a", "1"); + map.put("b", "2"); + map.put("c", "3"); + map.put("d", "4"); + map.put("e", "5"); + + List> result = MapUtil.partition(map, 2); + + assertEquals(3, result.size()); + assertEquals(2, result.get(0).size()); + assertEquals(2, result.get(1).size()); + assertEquals(1, result.get(2).size()); + } + + @Test + public void partitionGeneralCasePartitionsCorrectly() { + Map map = new HashMap<>(); + map.put("a", "1"); + map.put("b", "2"); + map.put("c", "3"); + map.put("d", "4"); + map.put("e", "5"); + map.put("f", "6"); + + List> result = MapUtil.partition(map, 3); + + assertEquals(2, result.size()); + assertEquals(3, result.get(0).size()); + assertEquals(3, result.get(1).size()); + } + + + // ---------MapUtil.computeIfAbsentForJdk8 + @Test + public void computeIfAbsentForJdk8KeyExistsReturnsExistingValue() { + Map map = new HashMap<>(); + map.put("key", 10); + Integer result = MapUtil.computeIfAbsentForJdk8(map, "key", k -> 20); + assertEquals(10, result); + } + + @Test + public void computeIfAbsentForJdk8KeyDoesNotExistComputesAndInsertsValue() { + Map map = new HashMap<>(); + Integer result = MapUtil.computeIfAbsentForJdk8(map, "key", k -> 20); + assertEquals(20, result); + assertEquals(20, map.get("key")); + } + + @Test + public void computeIfAbsentForJdk8ConcurrentInsertReturnsOldValue() { + ConcurrentHashMap concurrentMap = new ConcurrentHashMap<>(); + concurrentMap.put("key", 30); + AtomicInteger counter = new AtomicInteger(0); + + // 模拟并发插入 + concurrentMap.computeIfAbsent("key", k -> { + counter.incrementAndGet(); + return 40; + }); + + Integer result = MapUtil.computeIfAbsentForJdk8(concurrentMap, "key", k -> 50); + assertEquals(30, result); + assertEquals(30, concurrentMap.get("key")); + assertEquals(0, counter.get()); + } + + @Test + public void computeIfAbsentForJdk8NullValueComputesAndInsertsValue() { + Map map = new HashMap<>(); + map.put("key", null); + Integer result = MapUtil.computeIfAbsentForJdk8(map, "key", k -> 20); + assertEquals(20, result); + assertEquals(20, map.get("key")); + } + + //--------MapUtil.computeIfAbsent + @Test + public void computeIfAbsentKeyExistsReturnsExistingValue() { + Map map = new HashMap<>(); + map.put("key", 10); + Integer result = MapUtil.computeIfAbsent(map, "key", k -> 20); + assertEquals(10, result); + } + + @Test + public void computeIfAbsentKeyDoesNotExistComputesAndInsertsValue() { + Map map = new HashMap<>(); + Integer result = MapUtil.computeIfAbsent(map, "key", k -> 20); + assertEquals(20, result); + assertEquals(20, map.get("key")); + } + + @Test + public void computeIfAbsentConcurrentInsertReturnsOldValue() { + ConcurrentHashMap concurrentMap = new ConcurrentHashMap<>(); + concurrentMap.put("key", 30); + AtomicInteger counter = new AtomicInteger(0); + + // 模拟并发插入 + concurrentMap.computeIfAbsent("key", k -> { + counter.incrementAndGet(); + return 40; + }); + + Integer result = MapUtil.computeIfAbsent(concurrentMap, "key", k -> 50); + assertEquals(30, result); + assertEquals(30, concurrentMap.get("key")); + assertEquals(0, counter.get()); + } + + @Test + public void computeIfAbsentNullValueComputesAndInsertsValue() { + Map map = new HashMap<>(); + map.put("key", null); + Integer result = MapUtil.computeIfAbsent(map, "key", k -> 20); + assertEquals(20, result); + assertEquals(20, map.get("key")); + } + + @Test + public void computeIfAbsentEmptyMapInsertsValue() { + Map map = new HashMap<>(); + Integer result = MapUtil.computeIfAbsent(map, "newKey", k -> 100); + assertEquals(100, result); + assertEquals(100, map.get("newKey")); + } + + @Test + public void computeIfAbsentJdk8KeyExistsReturnsExistingValue() { + Map map = new HashMap<>(); + // 假设JdkUtil.ISJDK8为true + map.put("key", 10); + Integer result = MapUtil.computeIfAbsent(map, "key", k -> 20); + assertEquals(10, result); + } + + @Test + public void computeIfAbsentJdk8KeyDoesNotExistComputesAndInsertsValue() { + Map map = new HashMap<>(); + // 假设JdkUtil.ISJDK8为true + Integer result = MapUtil.computeIfAbsent(map, "key", k -> 20); + assertEquals(20, result); + assertEquals(20, map.get("key")); + } + + + //----------valuesOfKeys + @Test + public void valuesOfKeysEmptyIteratorReturnsEmptyList() { + Map map= new HashMap<>(); + map.put("a", "1"); + map.put("b", "2"); + map.put("c", "3"); + Iterator emptyIterator = new ArrayList().iterator(); + ArrayList result = MapUtil.valuesOfKeys(map, emptyIterator); + assertEquals(new ArrayList(), result); + } + + @Test + public void valuesOfKeysNonEmptyIteratorReturnsValuesList() { + Map map= new HashMap<>(); + map.put("a", "1"); + map.put("b", "2"); + map.put("c", "3"); + Iterator iterator = new ArrayList() {{ + add("a"); + add("b"); + }}.iterator(); + ArrayList result = MapUtil.valuesOfKeys(map, iterator); + assertEquals(new ArrayList() {{ + add("1"); + add("2"); + }}, result); + } + + @Test + public void valuesOfKeysKeysNotInMapReturnsNulls() { + Map map= new HashMap<>(); + map.put("a", "1"); + map.put("b", "2"); + map.put("c", "3"); + Iterator iterator = new ArrayList() {{ + add("d"); + add("e"); + }}.iterator(); + ArrayList result = MapUtil.valuesOfKeys(map, iterator); + assertEquals(new ArrayList() {{ + add(null); + add(null); + }}, result); + } + + @Test + public void valuesOfKeysMixedKeysReturnsMixedValues() { + Map map= new HashMap<>(); + map.put("a", "1"); + map.put("b", "2"); + map.put("c", "3"); + Iterator iterator = new ArrayList() {{ + add("a"); + add("d"); + add("b"); + }}.iterator(); + ArrayList result = MapUtil.valuesOfKeys(map, iterator); + assertEquals(new ArrayList() {{ + add("1"); + add(null); + add("2"); + }}, result); + } + + //--------clear + @Test + public void clearNoMapsProvidedNoAction() { + MapUtil.clear(); + // 预期没有异常发生，且没有Map被处理 + } + + @Test + public void clearEmptyMapNoChange() { + Map map= new HashMap<>(); + MapUtil.clear(map); + assertTrue(map.isEmpty()); + } + + @Test + public void clearNonEmptyMapClearsMap() { + Map map= new HashMap<>(); + map.put("key", "value"); + MapUtil.clear(map); + assertTrue(map.isEmpty()); + } + + @Test + public void clearMultipleMapsClearsNonEmptyMaps() { + Map map1 = new HashMap<>(); + map1.put("key1", "value1"); + + Map map2 = new HashMap<>(); + map2.put("key2", "value2"); + + Map map3 = new HashMap<>(); + + MapUtil.clear(map1, map2, map3); + + assertTrue(map1.isEmpty()); + assertTrue(map2.isEmpty()); + assertTrue(map3.isEmpty()); + } + + @Test + public void clearMixedMapsClearsNonEmptyMaps() { + Map map= new HashMap<>(); + map.put("key", "value"); + + Map emptyMap = new HashMap<>(); + + MapUtil.clear(map, emptyMap); + + assertTrue(map.isEmpty()); + assertTrue(emptyMap.isEmpty()); + } + + //-----empty + + @Test + public void emptyNoParametersReturnsEmptyMap() { + Map emptyMap = MapUtil.empty(); + assertTrue(emptyMap.isEmpty(), "The map should be empty."); + assertSame(Collections.emptyMap(), emptyMap, "The map should be the same instance as Collections.emptyMap()."); + } + + @Test + public void emptyNullMapClassReturnsEmptyMap() { + Map emptyMap = MapUtil.empty(null); + assertTrue(emptyMap.isEmpty(), "The map should be empty."); + assertSame(Collections.emptyMap(), emptyMap, "The map should be the same instance as Collections.emptyMap()."); + } + + @Test + public void emptyNavigableMapClassReturnsEmptyNavigableMap() { + Map map = MapUtil.empty(NavigableMap.class); + assertTrue(map.isEmpty()); + assertInstanceOf(NavigableMap.class, map); + } + + @Test + public void emptySortedMapClassReturnsEmptySortedMap() { + Map map = MapUtil.empty(SortedMap.class); + assertTrue(map.isEmpty()); + assertInstanceOf(SortedMap.class, map); + } + + @Test + public void emptyMapClassReturnsEmptyMap() { + Map map = MapUtil.empty(Map.class); + assertTrue(map.isEmpty()); + } + + @Test + public void emptyUnsupportedMapClassThrowsIllegalArgumentException() { + assertThrows(IllegalArgumentException.class, () -> { + MapUtil.empty(TreeMap.class); + }); + } + + //--------removeNullValue + @Test + public void removeNullValueNullMapReturnsNull() { + Map result = MapUtil.removeNullValue(null); + assertNull(result); + } + + @Test + public void removeNullValueEmptyMapReturnsEmptyMap() { + Map map= new HashMap<>(); + Map result = MapUtil.removeNullValue(map); + assertEquals(0, result.size()); + } + + @Test + public void removeNullValueNoNullValuesReturnsSameMap() { + Map map= new HashMap<>(); + map.put("key1", "value1"); + map.put("key2", "value2"); + + Map result = MapUtil.removeNullValue(map); + + assertEquals(2, result.size()); + assertEquals("value1", result.get("key1")); + assertEquals("value2", result.get("key2")); + } + + @Test + public void removeNullValueWithNullValuesRemovesNullEntries() { + Map map= new HashMap<>(); + map.put("key1", "value1"); + map.put("key2", null); + map.put("key3", "value3"); + + Map result = MapUtil.removeNullValue(map); + + assertEquals(2, result.size()); + assertEquals("value1", result.get("key1")); + assertEquals("value3", result.get("key3")); + assertNull(result.get("key2")); + } + + @Test + public void removeNullValueAllNullValuesReturnsEmptyMap() { + Map map= new HashMap<>(); + map.put("key1", null); + map.put("key2", null); + + Map result = MapUtil.removeNullValue(map); + + assertEquals(0, result.size()); + } + + + //------getQuietly + @Test + public void getQuietlyMapIsNullReturnsDefaultValue() { + String result = MapUtil.getQuietly(null, "key1", new TypeReference() {}, "default"); + assertEquals("default", result); + result = MapUtil.getQuietly(null, "key1", String.class, "default"); + assertEquals("default", result); + } + + @Test + public void getQuietlyKeyExistsReturnsConvertedValue() { + Map map= new HashMap<>(); + map.put("key1", "value1"); + map.put("key2", 123); + String result = MapUtil.getQuietly(map, "key1", new TypeReference() {}, "default"); + assertEquals("value1", result); + } + + @Test + public void getQuietlyKeyDoesNotExistReturnsDefaultValue() { + Map map= new HashMap<>(); + map.put("key1", "value1"); + map.put("key2", 123); + String result = MapUtil.getQuietly(map, "key3", new TypeReference() {}, "default"); + assertEquals("default", result); + } + + @Test + public void getQuietlyConversionFailsReturnsDefaultValue() { + Map map= new HashMap<>(); + map.put("key1", "value1"); + map.put("key2", 123); + Integer result = MapUtil.getQuietly(map, "key1", new TypeReference() {}, 0); + assertEquals(0, result); + } + + @Test + public void getQuietlyKeyExistsWithCorrectTypeReturnsValue() { + Map map= new HashMap<>(); + map.put("key1", "value1"); + map.put("key2", 123); + Integer result = MapUtil.getQuietly(map, "key2", new TypeReference() {}, 0); + assertEquals(123, result); + } + + @Test + public void getQuietlyKeyExistsWithNullValueReturnsDefaultValue() { + Map map= new HashMap<>(); + map.put("key1", "value1"); + map.put("key2", 123); + map.put("key3", null); + String result = MapUtil.getQuietly(map, "key3", new TypeReference() {}, "default"); + assertEquals("default", result); + } + + @Test + public void getMapIsNullReturnsDefaultValue() { + assertNull(MapUtil.get(null, "age", String.class)); + } + + @Test + public void getKeyExistsReturnsConvertedValue() { + Map map= new HashMap<>(); + map.put("age", "18"); + map.put("name", "Hutool"); + assertEquals("18", MapUtil.get(map, "age", String.class)); + } + + @Test + public void getKeyDoesNotExistReturnsDefaultValue() { + Map map= new HashMap<>(); + map.put("age", "18"); + map.put("name", "Hutool"); + assertEquals("default", MapUtil.get(map, "nonexistent", String.class, "default")); + } + + @Test + public void getTypeConversionFailsReturnsDefaultValue() { + Map map= new HashMap<>(); + map.put("age", "18"); + map.put("name", "Hutool"); + assertEquals(18, MapUtil.get(map, "age", Integer.class, 0)); + } + + @Test + public void getQuietlyTypeConversionFailsReturnsDefaultValue() { + Map map= new HashMap<>(); + map.put("age", "18"); + map.put("name", "Hutool"); + assertEquals(0, MapUtil.getQuietly(map, "name", Integer.class, 0)); + } + + @Test + public void getTypeReferenceReturnsConvertedValue() { + Map map= new HashMap<>(); + map.put("age", "18"); + map.put("name", "Hutool"); + assertEquals("18", MapUtil.get(map, "age", new TypeReference() {})); + } + + @Test + public void getTypeReferenceWithDefaultValueReturnsConvertedValue() { + Map map= new HashMap<>(); + map.put("age", "18"); + map.put("name", "Hutool"); + assertEquals("18", MapUtil.get(map, "age", new TypeReference() {}, "default")); + } + + @Test + public void getTypeReferenceWithDefaultValueTypeConversionFailsReturnsDefaultValue() { + Map map= new HashMap<>(); + map.put("age", "18"); + map.put("name", "Hutool"); + assertEquals(18, MapUtil.get(map, "age", new TypeReference() {}, 0)); + + map = null; + assertEquals(0, MapUtil.get(map, "age", new TypeReference() {}, 0)); + } }