Unify on Set.of

a-dubaj · Apr 11, 2024 · 48b9513 · 48b9513
1 parent ef1cf91
commit 48b9513
Show file tree

Hide file tree

Showing 30 changed files with 152 additions and 182 deletions.
diff --git a/abi-check-plugin/src/test/java/com/yahoo/abicheck/mojo/AbiCheckTest.java b/abi-check-plugin/src/test/java/com/yahoo/abicheck/mojo/AbiCheckTest.java
@@ -13,8 +13,9 @@
 import com.yahoo.abicheck.signature.JavaClassSignature;
 import java.io.IOException;
 import java.util.Arrays;
-import java.util.Collections;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import org.apache.maven.plugin.logging.Log;
 import org.junit.jupiter.api.Test;
 import root.Root;
@@ -30,9 +31,9 @@ private static ClassFileTree.Package buildClassFileTree() throws IOException {
     ClassFileTree.ClassFile rootPkgClass = mock(ClassFileTree.ClassFile.class);
     ClassFileTree.ClassFile subPkgClass = mock(ClassFileTree.ClassFile.class);
 
-    when(rootPkg.getSubPackages()).thenReturn(Collections.singleton(subPkg));
+    when(rootPkg.getSubPackages()).thenReturn(Set.of(subPkg));
     when(rootPkg.getClassFiles()).thenReturn(Arrays.asList(rootPkgClass, rootPkgInfoClass));
-    when(subPkg.getClassFiles()).thenReturn(Collections.singleton(subPkgClass));
+    when(subPkg.getClassFiles()).thenReturn(Set.of(subPkgClass));
 
     when(rootPkgInfoClass.getName()).thenReturn("package-info.class");
     when(rootPkgInfoClass.getInputStream())
@@ -68,16 +69,16 @@ public void testCompareSignatures() {
 
     JavaClassSignature signatureA = new JavaClassSignature(
         "java.lang.Object",
-        Collections.emptySet(),
-        Collections.singletonList("public"),
-        Collections.singleton("public void foo()"),
-        Collections.singleton("public int bar"));
+        Set.of(),
+        List.of("public"),
+        Set.of("public void foo()"),
+        Set.of("public int bar"));
     JavaClassSignature signatureB = new JavaClassSignature(
         "java.lang.Exception",
-        Collections.singleton("java.lang.Runnable"),
-        Collections.singletonList("protected"),
-        Collections.singleton("public void foo(int)"),
-        Collections.singleton("public boolean bar"));
+        Set.of("java.lang.Runnable"),
+        List.of("protected"),
+        Set.of("public void foo(int)"),
+        Set.of("public boolean bar"));
 
     Map<String, JavaClassSignature> expected = ImmutableMap.<String, JavaClassSignature>builder()
         .put("test.Missing", signatureA)

diff --git a/application/src/test/java/com/yahoo/application/container/handler/HeadersTestCase.java b/application/src/test/java/com/yahoo/application/container/handler/HeadersTestCase.java
@@ -3,11 +3,7 @@
 
 import org.junit.jupiter.api.Test;
 
-import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -66,9 +62,9 @@ void requireThatContainsKeyWorksAsExpected() {
     @Test
     void requireThatContainsValueWorksAsExpected() {
         Headers headers = new Headers();
-        assertFalse(headers.containsValue(Arrays.asList("bar")));
+        assertFalse(headers.containsValue(List.of("bar")));
         headers.add("foo", "bar");
-        assertTrue(headers.containsValue(Arrays.asList("bar")));
+        assertTrue(headers.containsValue(List.of("bar")));
     }
 
     @Test
@@ -104,93 +100,89 @@ void requireThatAddStringWorksAsExpected() {
         Headers headers = new Headers();
         assertNull(headers.get("foo"));
         headers.add("foo", "bar");
-        assertEquals(Arrays.asList("bar"), headers.get("foo"));
+        assertEquals(List.of("bar"), headers.get("foo"));
         headers.add("foo", "baz");
-        assertEquals(Arrays.asList("bar", "baz"), headers.get("foo"));
+        assertEquals(List.of("bar", "baz"), headers.get("foo"));
     }
 
     @Test
     void requireThatAddListWorksAsExpected() {
         Headers headers = new Headers();
         assertNull(headers.get("foo"));
-        headers.add("foo", Arrays.asList("bar"));
-        assertEquals(Arrays.asList("bar"), headers.get("foo"));
-        headers.add("foo", Arrays.asList("baz", "cox"));
-        assertEquals(Arrays.asList("bar", "baz", "cox"), headers.get("foo"));
+        headers.add("foo", List.of("bar"));
+        assertEquals(List.of("bar"), headers.get("foo"));
+        headers.add("foo", List.of("baz", "cox"));
+        assertEquals(List.of("bar", "baz", "cox"), headers.get("foo"));
     }
 
     @Test
     void requireThatAddAllWorksAsExpected() {
         Headers headers = new Headers();
         headers.add("foo", "bar");
         headers.add("bar", "baz");
-        assertEquals(Arrays.asList("bar"), headers.get("foo"));
-        assertEquals(Arrays.asList("baz"), headers.get("bar"));
+        assertEquals(List.of("bar"), headers.get("foo"));
+        assertEquals(List.of("baz"), headers.get("bar"));
 
-        Map<String, List<String>> map = new HashMap<>();
-        map.put("foo", Arrays.asList("baz", "cox"));
-        map.put("bar", Arrays.asList("cox"));
+        Map<String, List<String>> map = Map.of("foo", List.of("baz", "cox"), "bar", List.of("cox"));
         headers.addAll(map);
 
-        assertEquals(Arrays.asList("bar", "baz", "cox"), headers.get("foo"));
-        assertEquals(Arrays.asList("baz", "cox"), headers.get("bar"));
+        assertEquals(List.of("bar", "baz", "cox"), headers.get("foo"));
+        assertEquals(List.of("baz", "cox"), headers.get("bar"));
     }
 
     @Test
     void requireThatPutStringWorksAsExpected() {
         Headers headers = new Headers();
         assertNull(headers.get("foo"));
         headers.put("foo", "bar");
-        assertEquals(Arrays.asList("bar"), headers.get("foo"));
+        assertEquals(List.of("bar"), headers.get("foo"));
         headers.put("foo", "baz");
-        assertEquals(Arrays.asList("baz"), headers.get("foo"));
+        assertEquals(List.of("baz"), headers.get("foo"));
     }
 
     @Test
     void requireThatPutListWorksAsExpected() {
         Headers headers = new Headers();
         assertNull(headers.get("foo"));
-        headers.put("foo", Arrays.asList("bar"));
-        assertEquals(Arrays.asList("bar"), headers.get("foo"));
-        headers.put("foo", Arrays.asList("baz", "cox"));
-        assertEquals(Arrays.asList("baz", "cox"), headers.get("foo"));
+        headers.put("foo", List.of("bar"));
+        assertEquals(List.of("bar"), headers.get("foo"));
+        headers.put("foo", List.of("baz", "cox"));
+        assertEquals(List.of("baz", "cox"), headers.get("foo"));
     }
 
     @Test
     void requireThatPutAllWorksAsExpected() {
         Headers headers = new Headers();
         headers.add("foo", "bar");
         headers.add("bar", "baz");
-        assertEquals(Arrays.asList("bar"), headers.get("foo"));
-        assertEquals(Arrays.asList("baz"), headers.get("bar"));
+        assertEquals(List.of("bar"), headers.get("foo"));
+        assertEquals(List.of("baz"), headers.get("bar"));
 
-        Map<String, List<String>> map = new HashMap<>();
-        map.put("foo", Arrays.asList("baz", "cox"));
-        map.put("bar", Arrays.asList("cox"));
+        Map<String, List<String>> map = Map.of("foo", List.of("baz", "cox"), "bar", List.of("cox"));
         headers.putAll(map);
 
-        assertEquals(Arrays.asList("baz", "cox"), headers.get("foo"));
-        assertEquals(Arrays.asList("cox"), headers.get("bar"));
+        assertEquals(List.of("baz", "cox"), headers.get("foo"));
+        assertEquals(List.of("cox"), headers.get("bar"));
     }
 
     @Test
     void requireThatRemoveWorksAsExpected() {
         Headers headers = new Headers();
-        headers.put("foo", Arrays.asList("bar", "baz"));
-        assertEquals(Arrays.asList("bar", "baz"), headers.get("foo"));
-        assertEquals(Arrays.asList("bar", "baz"), headers.remove("foo"));
+        headers.put("foo", List.of("bar", "baz"));
+        assertEquals(List.of("bar", "baz"), headers.get("foo"));
+        assertEquals(List.of("bar", "baz"), headers.remove("foo"));
         assertNull(headers.get("foo"));
         assertNull(headers.remove("foo"));
     }
 
     @Test
     void requireThatRemoveStringWorksAsExpected() {
         Headers headers = new Headers();
-        headers.put("foo", Arrays.asList("bar", "baz"));
-        assertEquals(Arrays.asList("bar", "baz"), headers.get("foo"));
+        headers.put("foo", List.of("bar", "baz"));
+        assertEquals(List.of("bar", "baz"), headers.get("foo"));
         assertTrue(headers.remove("foo", "bar"));
         assertFalse(headers.remove("foo", "cox"));
-        assertEquals(Arrays.asList("baz"), headers.get("foo"));
+        assertEquals(List.of("baz"), headers.get("foo"));
         assertTrue(headers.remove("foo", "baz"));
         assertFalse(headers.remove("foo", "cox"));
         assertNull(headers.get("foo"));
@@ -201,8 +193,8 @@ void requireThatClearWorksAsExpected() {
         Headers headers = new Headers();
         headers.add("foo", "bar");
         headers.add("bar", "baz");
-        assertEquals(Arrays.asList("bar"), headers.get("foo"));
-        assertEquals(Arrays.asList("baz"), headers.get("bar"));
+        assertEquals(List.of("bar"), headers.get("foo"));
+        assertEquals(List.of("baz"), headers.get("bar"));
         headers.clear();
         assertNull(headers.get("foo"));
         assertNull(headers.get("bar"));
@@ -213,43 +205,43 @@ void requireThatGetWorksAsExpected() {
         Headers headers = new Headers();
         assertNull(headers.get("foo"));
         headers.add("foo", "bar");
-        assertEquals(Arrays.asList("bar"), headers.get("foo"));
+        assertEquals(List.of("bar"), headers.get("foo"));
     }
 
     @Test
     void requireThatGetFirstWorksAsExpected() {
         Headers headers = new Headers();
         assertNull(headers.getFirst("foo"));
-        headers.add("foo", Arrays.asList("bar", "baz"));
+        headers.add("foo", List.of("bar", "baz"));
         assertEquals("bar", headers.getFirst("foo"));
     }
 
     @Test
     void requireThatIsTrueWorksAsExpected() {
         Headers headers = new Headers();
         assertFalse(headers.isTrue("foo"));
-        headers.put("foo", Arrays.asList("true"));
+        headers.put("foo", List.of("true"));
         assertTrue(headers.isTrue("foo"));
-        headers.put("foo", Arrays.asList("true", "true"));
+        headers.put("foo", List.of("true", "true"));
         assertTrue(headers.isTrue("foo"));
-        headers.put("foo", Arrays.asList("true", "false"));
+        headers.put("foo", List.of("true", "false"));
         assertFalse(headers.isTrue("foo"));
-        headers.put("foo", Arrays.asList("false", "true"));
+        headers.put("foo", List.of("false", "true"));
         assertFalse(headers.isTrue("foo"));
-        headers.put("foo", Arrays.asList("false", "false"));
+        headers.put("foo", List.of("false", "false"));
         assertFalse(headers.isTrue("foo"));
-        headers.put("foo", Arrays.asList("false"));
+        headers.put("foo", List.of("false"));
         assertFalse(headers.isTrue("foo"));
     }
 
     @Test
     void requireThatKeySetWorksAsExpected() {
         Headers headers = new Headers();
-        assertEquals(Collections.<Set<String>>emptySet(), headers.keySet());
+        assertEquals(Set.of(), headers.keySet());
         headers.add("foo", "bar");
-        assertEquals(new HashSet<>(Arrays.asList("foo")), headers.keySet());
+        assertEquals(Set.of("foo"), headers.keySet());
         headers.add("bar", "baz");
-        assertEquals(new HashSet<>(Arrays.asList("foo", "bar")), headers.keySet());
+        assertEquals(Set.of("foo", "bar"), headers.keySet());
     }
 
     @Test
@@ -259,34 +251,34 @@ void requireThatValuesWorksAsExpected() {
         headers.add("foo", "bar");
         Collection<List<String>> values = headers.values();
         assertEquals(1, values.size());
-        assertTrue(values.contains(Arrays.asList("bar")));
+        assertTrue(values.contains(List.of("bar")));
 
         headers.add("bar", "baz");
         values = headers.values();
         assertEquals(2, values.size());
-        assertTrue(values.contains(Arrays.asList("bar")));
-        assertTrue(values.contains(Arrays.asList("baz")));
+        assertTrue(values.contains(List.of("bar")));
+        assertTrue(values.contains(List.of("baz")));
     }
 
     @Test
     void requireThatEntrySetWorksAsExpected() {
         Headers headers = new Headers();
-        assertEquals(Collections.emptySet(), headers.entrySet());
-        headers.put("foo", Arrays.asList("bar", "baz"));
+        assertEquals(Set.of(), headers.entrySet());
+        headers.put("foo", List.of("bar", "baz"));
 
         Set<Map.Entry<String, List<String>>> entries = headers.entrySet();
         assertEquals(1, entries.size());
         Map.Entry<String, List<String>> entry = entries.iterator().next();
         assertNotNull(entry);
         assertEquals("foo", entry.getKey());
-        assertEquals(Arrays.asList("bar", "baz"), entry.getValue());
+        assertEquals(List.of("bar", "baz"), entry.getValue());
     }
 
     @Test
     void requireThatEntriesWorksAsExpected() {
         Headers headers = new Headers();
-        assertEquals(Collections.emptyList(), headers.entries());
-        headers.put("foo", Arrays.asList("bar", "baz"));
+        assertEquals(List.of(), headers.entries());
+        headers.put("foo", List.of("bar", "baz"));
 
         List<Map.Entry<String, String>> entries = headers.entries();
         assertEquals(2, entries.size());

diff --git a/...roller-core/src/main/java/com/yahoo/vespa/clustercontroller/core/EventDiffCalculator.java b/...roller-core/src/main/java/com/yahoo/vespa/clustercontroller/core/EventDiffCalculator.java
@@ -9,7 +9,6 @@
 import com.yahoo.vdslib.state.State;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
@@ -174,8 +173,8 @@ private static <T> Set<T> setSubtraction(Set<T> a, Set<T> b) {
 
     private static void emitNodeResourceExhaustionEvents(PerStateParams params, List<Event> events, ContentCluster cluster) {
         // Feed block events are not ordered by node
-        Set<NodeResourceExhaustion> fromBlockSet = params.feedBlockFrom != null ? params.feedBlockFrom.getConcreteExhaustions() : Collections.emptySet();
-        Set<NodeResourceExhaustion> toBlockSet   = params.feedBlockTo   != null ? params.feedBlockTo.getConcreteExhaustions()   : Collections.emptySet();
+        Set<NodeResourceExhaustion> fromBlockSet = params.feedBlockFrom != null ? params.feedBlockFrom.getConcreteExhaustions() : Set.of();
+        Set<NodeResourceExhaustion> toBlockSet   = params.feedBlockTo   != null ? params.feedBlockTo.getConcreteExhaustions()   : Set.of();
 
         for (var ex : setSubtraction(fromBlockSet, toBlockSet)) {
             var info = cluster.getNodeInfo(ex.node);

diff --git a/...re/src/main/java/com/yahoo/vespa/clustercontroller/core/ResourceExhaustionCalculator.java b/...re/src/main/java/com/yahoo/vespa/clustercontroller/core/ResourceExhaustionCalculator.java
@@ -4,7 +4,6 @@
 import com.yahoo.vespa.clustercontroller.core.hostinfo.HostInfo;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Objects;
@@ -60,7 +59,7 @@ public ResourceExhaustionCalculator(boolean feedBlockEnabled, Map<String, Double
         this.feedBlockEnabled = feedBlockEnabled;
         this.feedBlockLimits = feedBlockLimits;
         this.feedBlockNoiseLevel = 0.0;
-        this.previouslyBlockedNodeResources = Collections.emptySet();
+        this.previouslyBlockedNodeResources = Set.of();
     }
 
     public ResourceExhaustionCalculator(boolean feedBlockEnabled, Map<String, Double> feedBlockLimits,
@@ -74,7 +73,7 @@ public ResourceExhaustionCalculator(boolean feedBlockEnabled, Map<String, Double
                     .map(ex -> NodeAndResourceType.of(ex.node.getIndex(), ex.resourceType))
                     .collect(Collectors.toSet());
         } else {
-            this.previouslyBlockedNodeResources = Collections.emptySet();
+            this.previouslyBlockedNodeResources = Set.of();
         }
     }
 
@@ -124,12 +123,12 @@ public Set<NodeResourceExhaustion> resourceExhaustionsFromHostInfo(NodeInfo node
                                                               effectiveLimit, nodeInfo.getRpcAddress()));
             }
         }
-        return (exceedingLimit != null) ? exceedingLimit : Collections.emptySet();
+        return (exceedingLimit != null) ? exceedingLimit : Set.of();
     }
 
     public Set<NodeResourceExhaustion> enumerateNodeResourceExhaustions(NodeInfo nodeInfo) {
         if (!nodeInfo.isStorage()) {
-            return Collections.emptySet();
+            return Set.of();
         }
         return resourceExhaustionsFromHostInfo(nodeInfo, nodeInfo.getHostInfo());
     }

diff --git a/...ontroller-core/src/test/java/com/yahoo/vespa/clustercontroller/core/testutils/Waiter.java b/...ontroller-core/src/test/java/com/yahoo/vespa/clustercontroller/core/testutils/Waiter.java
@@ -8,7 +8,6 @@
 import com.yahoo.vespa.clustercontroller.core.FleetController;
 import java.time.Duration;
 import java.time.Instant;
-import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Objects;
@@ -62,13 +61,13 @@ public ClusterState waitForState(String state) {
             return waitForState(state, data.getTimeout());
         }
         public ClusterState waitForStateInAllSpaces(String state) {
-            return waitForState(state, data.getTimeout(), true, Collections.emptySet());
+            return waitForState(state, data.getTimeout(), true, Set.of());
         }
         public ClusterState waitForStateInSpace(String space, String state) {
-            return waitForState(state, data.getTimeout(), false, Collections.singleton(space));
+            return waitForState(state, data.getTimeout(), false, Set.of(space));
         }
         public ClusterState waitForState(String state, Duration timeoutMS) {
-            return waitForState(state, timeoutMS, false, Collections.emptySet());
+            return waitForState(state, timeoutMS, false, Set.of());
         }
         public ClusterState waitForStableSystem() {
             return waitForStableSystem(data.getDummyNodes().size() / 2);