From e0c7ddb52e1dece9cab52b901b5e66aa86395f7a Mon Sep 17 00:00:00 2001 From: mcasari Date: Mon, 6 Nov 2023 20:38:18 +0100 Subject: [PATCH 1/6] BAEL-6600 - limit max size by LinkedHashMap and custom HashMap --- .../baeldung/map/HashMapWithMaxSizeLimit.java | 25 +++++++++++ ...MaxSizeHashMapByCustomHashMapUnitTest.java | 43 +++++++++++++++++++ ...MaxSizeHashMapByLinkedHashMapUnitTest.java | 35 +++++++++++++++ 3 files changed, 103 insertions(+) create mode 100644 core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java create mode 100644 core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java create mode 100644 core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java diff --git a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java new file mode 100644 index 0000000000..4d2d6e8d53 --- /dev/null +++ b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java @@ -0,0 +1,25 @@ +package com.baeldung.map; + +import java.util.HashMap; + +public class HashMapWithMaxSizeLimit extends HashMap { + + private static final long serialVersionUID = 1L; + + private int maxSize = -1; + + + public HashMapWithMaxSizeLimit(int maxSize) { + super(); + this.maxSize = maxSize; + } + + + public V putWithLimit(K key, V value) throws Exception { + if (this.maxSize != - 1 && this.size() >= this.maxSize && !this.containsKey(key)) { + throw new Exception("Max size exceeded!"); + } + return this.put(key, value); + } + +} diff --git a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java new file mode 100644 index 0000000000..5be9c61245 --- /dev/null +++ b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java @@ -0,0 +1,43 @@ +package com.baeldung.map; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +import java.util.LinkedHashMap; +import java.util.Map; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class LimitMaxSizeHashMapByCustomHashMapUnitTest { + + private final int MAX_SIZE = 4; + private LinkedHashMap linkedHashMap; + + @BeforeEach + void setUp() { + linkedHashMap = new LinkedHashMap() { + private static final long serialVersionUID = 1L; + + protected boolean removeEldestEntry(Map.Entry eldest) { + return size() > MAX_SIZE; + } + }; + linkedHashMap.put(1, "One"); + linkedHashMap.put(2, "Two"); + linkedHashMap.put(3, "Three"); + linkedHashMap.put(4, "Four"); + } + + @Test + void givenLinkedHashMapObject_whenAddingNewEntry_thenEldestEntryIsRemoved() { + linkedHashMap.put(5, "Five"); + String[] expectedArrayAfterFive = { "Two", "Three", "Four", "Five" }; + assertArrayEquals(expectedArrayAfterFive, linkedHashMap.values() + .toArray()); + linkedHashMap.put(6, "Six"); + String[] expectedArrayAfterSix = { "Three", "Four", "Five", "Six" }; + assertArrayEquals(expectedArrayAfterSix, linkedHashMap.values() + .toArray()); + } + +} diff --git a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java new file mode 100644 index 0000000000..20fcd94011 --- /dev/null +++ b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java @@ -0,0 +1,35 @@ +package com.baeldung.map; + +import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class LimitMaxSizeHashMapByLinkedHashMapUnitTest { + + private final int MAX_SIZE = 4; + private HashMapWithMaxSizeLimit hashMapWithMaxSizeLimit; + + @BeforeEach + void setUp() { + hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit(MAX_SIZE); + } + + @Test + void givenCustomHashMapObject_whenAddingNewEntryAndLimitExceeded_thenThrowsException() { + Exception exception = assertThrows(Exception.class, () -> { + hashMapWithMaxSizeLimit.putWithLimit(1, "One"); + hashMapWithMaxSizeLimit.putWithLimit(2, "Two"); + hashMapWithMaxSizeLimit.putWithLimit(3, "Three"); + hashMapWithMaxSizeLimit.putWithLimit(4, "Four"); + hashMapWithMaxSizeLimit.putWithLimit(5, "Five"); + }); + + String messageThrownWhenSizeExceedsLimit = "Max size exceeded!"; + String actualMessage = exception.getMessage(); + + assertTrue(actualMessage.equals(messageThrownWhenSizeExceedsLimit)); + } + +} From 5ecbb1b7c8c6fd4ccca44cbce687edd265278c85 Mon Sep 17 00:00:00 2001 From: mcasari Date: Mon, 13 Nov 2023 23:39:30 +0100 Subject: [PATCH 2/6] BAEL-6600: override put instead of additional method --- .../baeldung/map/HashMapWithMaxSizeLimit.java | 16 +++---- ...MaxSizeHashMapByCustomHashMapUnitTest.java | 41 ++++++++---------- ...MaxSizeHashMapByLinkedHashMapUnitTest.java | 42 +++++++++++-------- 3 files changed, 52 insertions(+), 47 deletions(-) diff --git a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java index 4d2d6e8d53..11845e6aa0 100644 --- a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java +++ b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java @@ -7,19 +7,21 @@ public class HashMapWithMaxSizeLimit extends HashMap { private static final long serialVersionUID = 1L; private int maxSize = -1; - - + public HashMapWithMaxSizeLimit(int maxSize) { super(); this.maxSize = maxSize; } - - public V putWithLimit(K key, V value) throws Exception { - if (this.maxSize != - 1 && this.size() >= this.maxSize && !this.containsKey(key)) { - throw new Exception("Max size exceeded!"); + @Override + public V put(K key, V value) { + V res = null; + if (this.maxSize == -1 || this.size() < this.maxSize) { + res = super.put(key, value); + } else if (this.maxSize != -1) { + throw new RuntimeException("Max size exceeded!"); } - return this.put(key, value); + return res; } } diff --git a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java index 5be9c61245..f351bcc3cc 100644 --- a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java +++ b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java @@ -1,8 +1,9 @@ package com.baeldung.map; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertThrows; -import java.util.LinkedHashMap; +import java.util.HashMap; import java.util.Map; import org.junit.jupiter.api.BeforeEach; @@ -11,33 +12,27 @@ import org.junit.jupiter.api.Test; class LimitMaxSizeHashMapByCustomHashMapUnitTest { private final int MAX_SIZE = 4; - private LinkedHashMap linkedHashMap; + private HashMapWithMaxSizeLimit hashMapWithMaxSizeLimit; @BeforeEach void setUp() { - linkedHashMap = new LinkedHashMap() { - private static final long serialVersionUID = 1L; - - protected boolean removeEldestEntry(Map.Entry eldest) { - return size() > MAX_SIZE; - } - }; - linkedHashMap.put(1, "One"); - linkedHashMap.put(2, "Two"); - linkedHashMap.put(3, "Three"); - linkedHashMap.put(4, "Four"); + hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit(MAX_SIZE); } @Test - void givenLinkedHashMapObject_whenAddingNewEntry_thenEldestEntryIsRemoved() { - linkedHashMap.put(5, "Five"); - String[] expectedArrayAfterFive = { "Two", "Three", "Four", "Five" }; - assertArrayEquals(expectedArrayAfterFive, linkedHashMap.values() - .toArray()); - linkedHashMap.put(6, "Six"); - String[] expectedArrayAfterSix = { "Three", "Four", "Five", "Six" }; - assertArrayEquals(expectedArrayAfterSix, linkedHashMap.values() - .toArray()); + void givenCustomHashMapObject_whenAddingNewEntryAndLimitExceeded_thenThrowsException() { + Exception exception = assertThrows(RuntimeException.class, () -> { + hashMapWithMaxSizeLimit.put(1, "One"); + hashMapWithMaxSizeLimit.put(2, "Two"); + hashMapWithMaxSizeLimit.put(3, "Three"); + hashMapWithMaxSizeLimit.put(4, "Four"); + hashMapWithMaxSizeLimit.put(5, "Five"); + }); + + String messageThrownWhenSizeExceedsLimit = "Max size exceeded!"; + String actualMessage = exception.getMessage(); + + assertTrue(actualMessage.equals(messageThrownWhenSizeExceedsLimit)); } } diff --git a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java index 20fcd94011..0986f426d9 100644 --- a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java +++ b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java @@ -1,7 +1,9 @@ package com.baeldung.map; -import static org.junit.Assert.assertTrue; -import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +import java.util.LinkedHashMap; +import java.util.Map; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -9,27 +11,33 @@ import org.junit.jupiter.api.Test; class LimitMaxSizeHashMapByLinkedHashMapUnitTest { private final int MAX_SIZE = 4; - private HashMapWithMaxSizeLimit hashMapWithMaxSizeLimit; + private LinkedHashMap linkedHashMap; @BeforeEach void setUp() { - hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit(MAX_SIZE); + linkedHashMap = new LinkedHashMap() { + private static final long serialVersionUID = 1L; + + protected boolean removeEldestEntry(Map.Entry eldest) { + return size() > MAX_SIZE; + } + }; + linkedHashMap.put(1, "One"); + linkedHashMap.put(2, "Two"); + linkedHashMap.put(3, "Three"); + linkedHashMap.put(4, "Four"); } @Test - void givenCustomHashMapObject_whenAddingNewEntryAndLimitExceeded_thenThrowsException() { - Exception exception = assertThrows(Exception.class, () -> { - hashMapWithMaxSizeLimit.putWithLimit(1, "One"); - hashMapWithMaxSizeLimit.putWithLimit(2, "Two"); - hashMapWithMaxSizeLimit.putWithLimit(3, "Three"); - hashMapWithMaxSizeLimit.putWithLimit(4, "Four"); - hashMapWithMaxSizeLimit.putWithLimit(5, "Five"); - }); - - String messageThrownWhenSizeExceedsLimit = "Max size exceeded!"; - String actualMessage = exception.getMessage(); - - assertTrue(actualMessage.equals(messageThrownWhenSizeExceedsLimit)); + void givenLinkedHashMapObject_whenAddingNewEntry_thenEldestEntryIsRemoved() { + linkedHashMap.put(5, "Five"); + String[] expectedArrayAfterFive = { "Two", "Three", "Four", "Five" }; + assertArrayEquals(expectedArrayAfterFive, linkedHashMap.values() + .toArray()); + linkedHashMap.put(6, "Six"); + String[] expectedArrayAfterSix = { "Three", "Four", "Five", "Six" }; + assertArrayEquals(expectedArrayAfterSix, linkedHashMap.values() + .toArray()); } } From 9973d9aec3dbc58db08de0c4eb9d4274710696db Mon Sep 17 00:00:00 2001 From: mcasari Date: Mon, 13 Nov 2023 23:51:31 +0100 Subject: [PATCH 3/6] BAEL-6600: minor fixing --- .../map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java index f351bcc3cc..09b2e2122a 100644 --- a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java +++ b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java @@ -3,9 +3,6 @@ package com.baeldung.map; import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertThrows; -import java.util.HashMap; -import java.util.Map; - import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; From 8a31837a3e9006aa2aea36f64a5bed17fe61e33e Mon Sep 17 00:00:00 2001 From: mcasari Date: Tue, 14 Nov 2023 23:22:44 +0100 Subject: [PATCH 4/6] BAEL-6600: fix flaws in the logic of put method --- .../com/baeldung/map/HashMapWithMaxSizeLimit.java | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java index 11845e6aa0..79c08dcb7c 100644 --- a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java +++ b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java @@ -11,17 +11,14 @@ public class HashMapWithMaxSizeLimit extends HashMap { public HashMapWithMaxSizeLimit(int maxSize) { super(); this.maxSize = maxSize; - } + } @Override public V put(K key, V value) { - V res = null; - if (this.maxSize == -1 || this.size() < this.maxSize) { - res = super.put(key, value); - } else if (this.maxSize != -1) { - throw new RuntimeException("Max size exceeded!"); - } - return res; + if (this.maxSize == -1 || this.containsKey(key) || this.size() < this.maxSize) { + return super.put(key, value); + } + throw new RuntimeException("Max size exceeded!"); } } From 5942a934cf5d78e0b363e8625dc4a7fd140b8c8e Mon Sep 17 00:00:00 2001 From: macasari Date: Wed, 15 Nov 2023 23:53:42 +0100 Subject: [PATCH 5/6] BAEL-6600: add further test cases --- .../baeldung/map/HashMapWithMaxSizeLimit.java | 8 +++- ...MaxSizeHashMapByCustomHashMapUnitTest.java | 41 +++++++++++++++---- 2 files changed, 39 insertions(+), 10 deletions(-) diff --git a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java index 79c08dcb7c..517dac6362 100644 --- a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java +++ b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java @@ -7,17 +7,21 @@ public class HashMapWithMaxSizeLimit extends HashMap { private static final long serialVersionUID = 1L; private int maxSize = -1; + + public HashMapWithMaxSizeLimit() { + super(); + } public HashMapWithMaxSizeLimit(int maxSize) { super(); this.maxSize = maxSize; - } + } @Override public V put(K key, V value) { if (this.maxSize == -1 || this.containsKey(key) || this.size() < this.maxSize) { return super.put(key, value); - } + } throw new RuntimeException("Max size exceeded!"); } diff --git a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java index 09b2e2122a..0846baae1a 100644 --- a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java +++ b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByCustomHashMapUnitTest.java @@ -1,9 +1,9 @@ package com.baeldung.map; import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertThrows; -import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; class LimitMaxSizeHashMapByCustomHashMapUnitTest { @@ -11,24 +11,49 @@ class LimitMaxSizeHashMapByCustomHashMapUnitTest { private final int MAX_SIZE = 4; private HashMapWithMaxSizeLimit hashMapWithMaxSizeLimit; - @BeforeEach - void setUp() { - hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit(MAX_SIZE); + @Test + void givenCustomHashMapObject_whenThereIsNoLimit_thenDoesNotThrowException() { + hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit(); + assertDoesNotThrow(() -> { + for (int i = 0; i < 10000; i++) { + hashMapWithMaxSizeLimit.put(i, i + ""); + } + }); } @Test - void givenCustomHashMapObject_whenAddingNewEntryAndLimitExceeded_thenThrowsException() { - Exception exception = assertThrows(RuntimeException.class, () -> { + void givenCustomHashMapObject_whenLimitNotReached_thenDoesNotThrowException() { + hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit(MAX_SIZE); + assertDoesNotThrow(() -> { + for (int i = 0; i < 4; i++) { + hashMapWithMaxSizeLimit.put(i, i + ""); + } + }); + } + + @Test + void givenCustomHashMapObject_whenReplacingValueWhenLimitIsReached_thenDoesNotThrowException() { + hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit(MAX_SIZE); + assertDoesNotThrow(() -> { hashMapWithMaxSizeLimit.put(1, "One"); hashMapWithMaxSizeLimit.put(2, "Two"); hashMapWithMaxSizeLimit.put(3, "Three"); hashMapWithMaxSizeLimit.put(4, "Four"); - hashMapWithMaxSizeLimit.put(5, "Five"); + hashMapWithMaxSizeLimit.put(4, "4"); + }); + } + + @Test + void givenCustomHashMapObject_whenLimitExceeded_thenThrowsException() { + hashMapWithMaxSizeLimit = new HashMapWithMaxSizeLimit(MAX_SIZE); + Exception exception = assertThrows(RuntimeException.class, () -> { + for (int i = 0; i < 5; i++) { + hashMapWithMaxSizeLimit.put(i, i + ""); + } }); String messageThrownWhenSizeExceedsLimit = "Max size exceeded!"; String actualMessage = exception.getMessage(); - assertTrue(actualMessage.equals(messageThrownWhenSizeExceedsLimit)); } From b64a40f6f4f11c517c95dcdde684d3dec55a0f44 Mon Sep 17 00:00:00 2001 From: macasari Date: Wed, 22 Nov 2023 10:40:38 +0100 Subject: [PATCH 6/6] BAEL-6600 - fix various reported issues --- .../baeldung/map/HashMapWithMaxSizeLimit.java | 3 --- ...itMaxSizeHashMapByLinkedHashMapUnitTest.java | 17 ++++++----------- 2 files changed, 6 insertions(+), 14 deletions(-) diff --git a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java index 517dac6362..63736e49f3 100644 --- a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java +++ b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/HashMapWithMaxSizeLimit.java @@ -3,9 +3,6 @@ package com.baeldung.map; import java.util.HashMap; public class HashMapWithMaxSizeLimit extends HashMap { - - private static final long serialVersionUID = 1L; - private int maxSize = -1; public HashMapWithMaxSizeLimit() { diff --git a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java index 0986f426d9..d32d98da3a 100644 --- a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java +++ b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/LimitMaxSizeHashMapByLinkedHashMapUnitTest.java @@ -5,19 +5,18 @@ import static org.junit.jupiter.api.Assertions.assertArrayEquals; import java.util.LinkedHashMap; import java.util.Map; -import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; class LimitMaxSizeHashMapByLinkedHashMapUnitTest { - private final int MAX_SIZE = 4; - private LinkedHashMap linkedHashMap; - - @BeforeEach - void setUp() { + @Test + void givenLinkedHashMapObject_whenAddingNewEntry_thenEldestEntryIsRemoved() { + final int MAX_SIZE = 4; + LinkedHashMap linkedHashMap; linkedHashMap = new LinkedHashMap() { private static final long serialVersionUID = 1L; - + + @Override protected boolean removeEldestEntry(Map.Entry eldest) { return size() > MAX_SIZE; } @@ -26,10 +25,6 @@ class LimitMaxSizeHashMapByLinkedHashMapUnitTest { linkedHashMap.put(2, "Two"); linkedHashMap.put(3, "Three"); linkedHashMap.put(4, "Four"); - } - - @Test - void givenLinkedHashMapObject_whenAddingNewEntry_thenEldestEntryIsRemoved() { linkedHashMap.put(5, "Five"); String[] expectedArrayAfterFive = { "Two", "Three", "Four", "Five" }; assertArrayEquals(expectedArrayAfterFive, linkedHashMap.values()