Use CompoundName.from in tests and construction of static objects.

6 files changed, 119 insertions, 99 deletions

diff --git a/container-core/src/main/java/com/yahoo/processing/Request.java b/container-core/src/main/java/com/yahoo/processing/Request.java
index cff546f1fd4..313df855cd4 100644
--- a/container-core/src/main/java/com/yahoo/processing/Request.java
+++ b/container-core/src/main/java/com/yahoo/processing/Request.java
@@ -30,13 +30,13 @@ public class Request extends FreezableClass implements Cloneable {
      * The name of the chain of Processor instances which will be invoked when
      * executing a request.
      */
-    public static final CompoundName CHAIN = new CompoundName("chain");
+    public static final CompoundName CHAIN = CompoundName.from("chain");
 
     /**
      * The name of the request property used in the processing framework to
      * store the incoming JDisc request.
      */
-    public static final CompoundName JDISC_REQUEST = new CompoundName("jdisc.request");
+    public static final CompoundName JDISC_REQUEST = CompoundName.from("jdisc.request");
 
     /**
      * Creates a request with no properties
diff --git a/container-core/src/main/java/com/yahoo/processing/Response.java b/container-core/src/main/java/com/yahoo/processing/Response.java
index 59533900a0c..9f87f42ba65 100644
--- a/container-core/src/main/java/com/yahoo/processing/Response.java
+++ b/container-core/src/main/java/com/yahoo/processing/Response.java
@@ -35,7 +35,7 @@ import java.util.concurrent.TimeoutException;
  */
 public class Response extends ListenableFreezableClass {
 
-    private final static CompoundName freezeListenerKey =new CompoundName("processing.freezeListener");
+    private final static CompoundName freezeListenerKey = CompoundName.from("processing.freezeListener");
 
     private final DataList<?> data;
 
diff --git a/container-core/src/main/java/com/yahoo/processing/handler/AbstractProcessingHandler.java b/container-core/src/main/java/com/yahoo/processing/handler/AbstractProcessingHandler.java
index f7aea8abbd1..a838af263c1 100644
--- a/container-core/src/main/java/com/yahoo/processing/handler/AbstractProcessingHandler.java
+++ b/container-core/src/main/java/com/yahoo/processing/handler/AbstractProcessingHandler.java
@@ -46,7 +46,7 @@ import static com.yahoo.component.chain.ChainsConfigurer.prepareChainRegistry;
 @SuppressWarnings("deprecation") // super class is deprecated
 public abstract class AbstractProcessingHandler<COMPONENT extends Processor> extends LoggingRequestHandler {
 
-    private final static CompoundName freezeListenerKey =new CompoundName("processing.freezeListener");
+    private final static CompoundName freezeListenerKey = CompoundName.from("processing.freezeListener");
 
     public final static String DEFAULT_RENDERER_ID = "default";
 
diff --git a/container-core/src/main/java/com/yahoo/processing/request/CompoundName.java b/container-core/src/main/java/com/yahoo/processing/request/CompoundName.java
index ac7b3d24d08..194fcd37bd1 100644
--- a/container-core/src/main/java/com/yahoo/processing/request/CompoundName.java
+++ b/container-core/src/main/java/com/yahoo/processing/request/CompoundName.java
@@ -21,9 +21,12 @@ import static com.yahoo.text.Lowercase.toLowerCase;
  */
 public final class CompoundName {
 
-    /**
-     * The string name of this compound.
-     */
+    private static final int MAX_CACHE_SIZE = 10_000;
+    private static final Map<String, CompoundName> cache = new CopyOnWriteHashMap<>();
+    /** The empty compound */
+    public static final CompoundName empty = CompoundName.from("");
+
+    /* The string name of this compound. */
     private final String name;
     private final String lowerCasedName;
 
@@ -37,10 +40,6 @@ public final class CompoundName {
     /** This name with the last component removed */
     private final CompoundName first;
 
-    /** The empty compound */
-    public static final CompoundName empty = new CompoundName("");
-    private static final Map<String, CompoundName> cache = new CopyOnWriteHashMap<>();
-    private static final int MAX_CACHE_SIZE = 10_000;
     /**
      * Constructs this from a string which may contains dot-separated components
      *
diff --git a/container-core/src/test/java/com/yahoo/processing/request/CompoundNameTestCase.java b/container-core/src/test/java/com/yahoo/processing/request/CompoundNameTestCase.java
index 4bbece0af29..eccc4dd8842 100644
--- a/container-core/src/test/java/com/yahoo/processing/request/CompoundNameTestCase.java
+++ b/container-core/src/test/java/com/yahoo/processing/request/CompoundNameTestCase.java
@@ -18,59 +18,61 @@ import static org.junit.jupiter.api.Assertions.*;
 public class CompoundNameTestCase {
 
     private static final String NAME = "com.yahoo.processing.request.CompoundNameTestCase";
-    private final CompoundName cn = new CompoundName(NAME);
+    private static final CompoundName C_NAME = CompoundName.from(NAME);
+    private static final CompoundName C_abcde = CompoundName.from("a.b.c.d.e");
 
     void verifyStrict(CompoundName expected, CompoundName actual) {
         assertEquals(expected, actual);
         assertEquals(expected.asList(), actual.asList());
     }
     void verifyStrict(String expected, CompoundName actual) {
-        verifyStrict(new CompoundName(expected), actual);
+        verifyStrict(CompoundName.from(expected), actual);
     }
 
     @Test
     final void testLast() {
-        assertEquals(NAME.substring(NAME.lastIndexOf('.') + 1), cn.last());
+        assertEquals(NAME.substring(NAME.lastIndexOf('.') + 1), C_NAME.last());
     }
 
     @Test
     final void testFirst() {
-        assertEquals(NAME.substring(0, NAME.indexOf('.')), cn.first());
+        assertEquals(NAME.substring(0, NAME.indexOf('.')), C_NAME.first());
     }
 
     @Test
     final void testRest() {
-        verifyStrict(NAME.substring(NAME.indexOf('.') + 1), cn.rest());
+        verifyStrict(NAME.substring(NAME.indexOf('.') + 1), C_NAME.rest());
     }
 
     @Test
     final void testRestN() {
-        verifyStrict("a.b.c.d.e", new CompoundName("a.b.c.d.e").rest(0));
-        verifyStrict("b.c.d.e", new CompoundName("a.b.c.d.e").rest(1));
-        verifyStrict("c.d.e", new CompoundName("a.b.c.d.e").rest(2));
-        verifyStrict("d.e", new CompoundName("a.b.c.d.e").rest(3));
-        verifyStrict("e", new CompoundName("a.b.c.d.e").rest(4));
-        verifyStrict(CompoundName.empty, new CompoundName("a.b.c.d.e").rest(5));
+        verifyStrict("a.b.c.d.e", C_abcde.rest(0));
+        verifyStrict("b.c.d.e", C_abcde.rest(1));
+        verifyStrict("c.d.e", C_abcde.rest(2));
+        verifyStrict("d.e", C_abcde.rest(3));
+        verifyStrict("e", C_abcde.rest(4));
+        verifyStrict(CompoundName.empty, C_abcde.rest(5));
     }
     @Test
     final void testFirstN() {
-        verifyStrict("a.b.c.d.e", new CompoundName("a.b.c.d.e").first(5));
-        verifyStrict("a.b.c.d", new CompoundName("a.b.c.d.e").first(4));
-        verifyStrict("a.b.c", new CompoundName("a.b.c.d.e").first(3));
-        verifyStrict("a.b", new CompoundName("a.b.c.d.e").first(2));
-        verifyStrict("a", new CompoundName("a.b.c.d.e").first(1));
-        verifyStrict(CompoundName.empty, new CompoundName("a.b.c.d.e").first(0));
+        verifyStrict("a.b.c.d.e", C_abcde.first(5));
+        verifyStrict("a.b.c.d", C_abcde.first(4));
+        verifyStrict("a.b.c", C_abcde.first(3));
+        verifyStrict("a.b", C_abcde.first(2));
+        verifyStrict("a", C_abcde.first(1));
+        verifyStrict(CompoundName.empty, C_abcde.first(0));
     }
 
     @Test
     final void testPrefix() {
-        assertTrue(new CompoundName("a.b.c").hasPrefix(new CompoundName("")));
-        assertTrue(new CompoundName("a.b.c").hasPrefix(new CompoundName("a")));
-        assertTrue(new CompoundName("a.b.c").hasPrefix(new CompoundName("a.b")));
-        assertTrue(new CompoundName("a.b.c").hasPrefix(new CompoundName("a.b.c")));
+        CompoundName abc = CompoundName.from("a.b.c");
+        assertTrue(abc.hasPrefix(CompoundName.empty));
+        assertTrue(abc.hasPrefix(CompoundName.from("a")));
+        assertTrue(abc.hasPrefix(CompoundName.from("a.b")));
+        assertTrue(abc.hasPrefix(CompoundName.from("a.b.c")));
 
-        assertFalse(new CompoundName("a.b.c").hasPrefix(new CompoundName("a.b.c.d")));
-        assertFalse(new CompoundName("a.b.c").hasPrefix(new CompoundName("a.b.d")));
+        assertFalse(abc.hasPrefix(CompoundName.from("a.b.c.d")));
+        assertFalse(abc.hasPrefix(CompoundName.from("a.b.d")));
     }
 
     @Test
@@ -87,28 +89,28 @@ public class CompoundNameTestCase {
         for (@SuppressWarnings("unused") String x : i) {
             ++n;
         }
-        assertEquals(n, cn.size());
+        assertEquals(n, C_NAME.size());
     }
 
     @Test
     final void testGet() {
-        String s = cn.get(0);
+        String s = C_NAME.get(0);
         assertEquals(NAME.substring(0, NAME.indexOf('.')), s);
     }
 
     @Test
     final void testIsCompound() {
-        assertTrue(cn.isCompound());
+        assertTrue(C_NAME.isCompound());
     }
 
     @Test
     final void testIsEmpty() {
-        assertFalse(cn.isEmpty());
+        assertFalse(C_NAME.isEmpty());
     }
 
     @Test
     final void testAsList() {
-        List<String> l = cn.asList();
+        List<String> l = C_NAME.asList();
         Splitter peoplesFront = Splitter.on('.');
         Iterable<String> answer = peoplesFront.split(NAME);
         Iterator<String> expected = answer.iterator();
@@ -120,35 +122,35 @@ public class CompoundNameTestCase {
 
     @Test
     final void testEqualsObject() {
-        assertNotEquals(cn, NAME);
-        assertNotEquals(cn, null);
-        verifyStrict(cn, cn);
-        verifyStrict(cn, new CompoundName(NAME));
+        assertNotEquals(C_NAME, NAME);
+        assertNotEquals(C_NAME, null);
+        verifyStrict(C_NAME, C_NAME);
+        verifyStrict(C_NAME, CompoundName.from(NAME));
     }
 
     @Test
     final void testEmptyNonEmpty() {
-        assertTrue(new CompoundName("").isEmpty());
-        assertEquals(0, new CompoundName("").size());
-        assertFalse(new CompoundName("a").isEmpty());
-        assertEquals(1, new CompoundName("a").size());
-        CompoundName empty = new CompoundName("a.b.c");
+        assertTrue(CompoundName.empty.isEmpty());
+        assertEquals(0, CompoundName.empty.size());
+        assertFalse(CompoundName.from("a").isEmpty());
+        assertEquals(1, CompoundName.from("a").size());
+        CompoundName empty = CompoundName.from("a.b.c");
         verifyStrict(empty, empty.rest(0));
         assertNotEquals(empty, empty.rest(1));
     }
 
     @Test
     final void testGetLowerCasedName() {
-        assertEquals(Lowercase.toLowerCase(NAME), cn.getLowerCasedName());
+        assertEquals(Lowercase.toLowerCase(NAME), C_NAME.getLowerCasedName());
     }
 
     @Test
     void testAppendCompound() {
-        verifyStrict("a.b.c.d", new CompoundName("").append(new CompoundName("a.b.c.d")));
-        verifyStrict("a.b.c.d", new CompoundName("a").append(new CompoundName("b.c.d")));
-        verifyStrict("a.b.c.d", new CompoundName("a.b").append(new CompoundName("c.d")));
-        verifyStrict("a.b.c.d", new CompoundName("a.b.c").append(new CompoundName("d")));
-        verifyStrict("a.b.c.d", new CompoundName("a.b.c.d").append(new CompoundName("")));
+        verifyStrict("a.b.c.d", CompoundName.empty.append(CompoundName.from("a.b.c.d")));
+        verifyStrict("a.b.c.d", CompoundName.from("a").append(CompoundName.from("b.c.d")));
+        verifyStrict("a.b.c.d", CompoundName.from("a.b").append(CompoundName.from("c.d")));
+        verifyStrict("a.b.c.d", CompoundName.from("a.b.c").append(CompoundName.from("d")));
+        verifyStrict("a.b.c.d", CompoundName.from("a.b.c.d").append(CompoundName.empty));
     }
 
     @Test
@@ -156,13 +158,13 @@ public class CompoundNameTestCase {
         CompoundName empty = new CompoundName("");
 
         assertTrue(empty.hasPrefix(empty));
-        assertTrue(new CompoundName("a").hasPrefix(empty));
+        assertTrue(CompoundName.from("a").hasPrefix(empty));
     }
 
     @Test
     void whole_components_must_match_to_be_prefix() {
-        CompoundName stringPrefix = new CompoundName("a");
-        CompoundName name         = new CompoundName("aa");
+        CompoundName stringPrefix = CompoundName.from("a");
+        CompoundName name         = CompoundName.from("aa");
 
         assertFalse(name.hasPrefix(stringPrefix));
     }
@@ -171,7 +173,7 @@ public class CompoundNameTestCase {
     void testFirstRest() {
         verifyStrict(CompoundName.empty, CompoundName.empty.rest());
 
-        CompoundName n = new CompoundName("on.two.three");
+        CompoundName n = CompoundName.from("on.two.three");
         assertEquals("on", n.first());
         verifyStrict("two.three", n.rest());
         n = n.rest();
@@ -190,7 +192,7 @@ public class CompoundNameTestCase {
 
     @Test
     void testHashCodeAndEquals() {
-        CompoundName n1 = new CompoundName("venn.d.a");
+        CompoundName n1 = CompoundName.from("venn.d.a");
         CompoundName n2 = new CompoundName(n1.asList());
         assertEquals(n1.hashCode(), n2.hashCode());
         verifyStrict(n1, n2);
@@ -198,12 +200,12 @@ public class CompoundNameTestCase {
 
     @Test
     void testAppendString() {
-        verifyStrict("a", new CompoundName("a").append(""));
-        verifyStrict("a", new CompoundName("").append("a"));
-        verifyStrict("a.b", new CompoundName("a").append("b"));
-        verifyStrict("a.b.c.d", new CompoundName("a.b").append("c.d"));
+        verifyStrict("a", CompoundName.from("a").append(""));
+        verifyStrict("a", CompoundName.empty.append("a"));
+        verifyStrict("a.b", CompoundName.from("a").append("b"));
+        verifyStrict("a.b.c.d", CompoundName.from("a.b").append("c.d"));
 
-        CompoundName name = new CompoundName("a.b");
+        CompoundName name = CompoundName.from("a.b");
         verifyStrict("a.b.c", name.append("c"));
         verifyStrict("a.b.d", name.append("d"));
         verifyStrict("a.b.d.e", name.append("d.e"));
@@ -218,7 +220,7 @@ public class CompoundNameTestCase {
 
     @Test
     void testAsList2() {
-        assertEquals("[one]", new CompoundName("one").asList().toString());
-        assertEquals("[one, two, three]", new CompoundName("one.two.three").asList().toString());
+        assertEquals("[one]", CompoundName.from("one").asList().toString());
+        assertEquals("[one, two, three]", CompoundName.from("one.two.three").asList().toString());
     }
 }
diff --git a/container-core/src/test/java/com/yahoo/processing/request/test/RequestTestCase.java b/container-core/src/test/java/com/yahoo/processing/request/test/RequestTestCase.java
index c82b85d84d9..8e960bd1305 100644
--- a/container-core/src/test/java/com/yahoo/processing/request/test/RequestTestCase.java
+++ b/container-core/src/test/java/com/yahoo/processing/request/test/RequestTestCase.java
@@ -9,7 +9,9 @@ import com.yahoo.processing.request.properties.PropertyMap;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Tests using requests
@@ -19,9 +21,26 @@ import static org.junit.jupiter.api.Assertions.assertNull;
 public class RequestTestCase {
 
     private static final double delta = 0.0000000001;
+    private static final CompoundName C_a = CompoundName.from("a");
+
+    private static final CompoundName C_B = CompoundName.from("b");
+    private static final CompoundName C_C = CompoundName.from("c");
+    private static final CompoundName C_D = CompoundName.from("d");
+    private static final CompoundName C_f = CompoundName.from("f");
+    private static final CompoundName C_g = CompoundName.from("g");
+    private static final CompoundName C_I = CompoundName.from("i");
+    private static final CompoundName C_L = CompoundName.from("l");
+    private static final CompoundName C_M = CompoundName.from("m");
+    private static final CompoundName C_N = CompoundName.from("n");
+    private static final CompoundName C_o = CompoundName.from("o");
+    private static final CompoundName C_x = CompoundName.from("x");
+    private static final CompoundName C_none = CompoundName.from("none");
+
+
 
     @Test
     void testProperties() {
+
         Properties p = new PropertyMap();
         p.set("a", "a1");
         Request r = new Request(p);
@@ -33,38 +52,38 @@ public class RequestTestCase {
         assertEquals("b1", r.properties().get("b", "default"));
         assertEquals("default", r.properties().get("c", "default"));
         assertNull(r.properties().get("c"));
-        assertEquals("b1", r.properties().get(new CompoundName("b")));
-        assertEquals("b1", r.properties().get(new CompoundName("b"), "default"));
-        assertEquals("default", r.properties().get(new CompoundName("c"), "default"));
-        assertNull(r.properties().get(new CompoundName("c")));
+        assertEquals("b1", r.properties().get(C_B));
+        assertEquals("b1", r.properties().get(C_B, "default"));
+        assertEquals("default", r.properties().get(C_C, "default"));
+        assertNull(r.properties().get(C_C));
 
         assertEquals("b1", r.properties().getString("b"));
         assertEquals("b1", r.properties().getString("b", "default"));
         assertEquals("default", r.properties().getString("c", "default"));
         assertNull(r.properties().getString("c"));
-        assertEquals("b1", r.properties().getString(new CompoundName("b")));
-        assertEquals("b1", r.properties().getString(new CompoundName("b"), "default"));
-        assertEquals("default", r.properties().getString(new CompoundName("c"), "default"));
-        assertNull(r.properties().getString(new CompoundName("c")));
+        assertEquals("b1", r.properties().getString(C_B));
+        assertEquals("b1", r.properties().getString(C_B, "default"));
+        assertEquals("default", r.properties().getString(C_C, "default"));
+        assertNull(r.properties().getString(C_C));
 
         r.properties().set("i", 7);
         assertEquals(7, (int) r.properties().getInteger("i"));
         assertEquals(7, (int) r.properties().getInteger("i", 3));
         assertEquals(3, (int) r.properties().getInteger("n", 3));
         assertNull(r.properties().getInteger("n"));
-        assertEquals(7, (int) r.properties().getInteger(new CompoundName("i")));
-        assertEquals(7, (int) r.properties().getInteger(new CompoundName("i"), 3));
-        assertEquals(3, (int) r.properties().getInteger(new CompoundName("n"), 3));
+        assertEquals(7, (int) r.properties().getInteger(C_I));
+        assertEquals(7, (int) r.properties().getInteger(C_I, 3));
+        assertEquals(3, (int) r.properties().getInteger(C_N, 3));
         assertNull(r.properties().getInteger("n"));
 
-        r.properties().set(new CompoundName("l"), 7);
+        r.properties().set(C_L, 7);
         assertEquals(7, (long) r.properties().getLong("l"));
-        assertEquals(7, (long) r.properties().getLong("l", 3l));
-        assertEquals(3, (long) r.properties().getLong("m", 3l));
+        assertEquals(7, (long) r.properties().getLong("l", 3L));
+        assertEquals(3, (long) r.properties().getLong("m", 3L));
         assertNull(r.properties().getInteger("m"));
-        assertEquals(7, (long) r.properties().getLong(new CompoundName("l")));
-        assertEquals(7, (long) r.properties().getLong(new CompoundName("l"), 3l));
-        assertEquals(3, (long) r.properties().getLong(new CompoundName("m"), 3l));
+        assertEquals(7, (long) r.properties().getLong(C_L));
+        assertEquals(7, (long) r.properties().getLong(C_L, 3L));
+        assertEquals(3, (long) r.properties().getLong(C_M, 3L));
         assertNull(r.properties().getInteger("m"));
 
         r.properties().set("d", 7.3);
@@ -72,29 +91,29 @@ public class RequestTestCase {
         assertEquals(7.3, r.properties().getDouble("d", 3.4d), delta);
         assertEquals(3.4, r.properties().getDouble("f", 3.4d), delta);
         assertNull(r.properties().getDouble("f"));
-        assertEquals(7.3, r.properties().getDouble(new CompoundName("d")), delta);
-        assertEquals(7.3, r.properties().getDouble(new CompoundName("d"), 3.4d), delta);
-        assertEquals(3.4, r.properties().getDouble(new CompoundName("f"), 3.4d), delta);
+        assertEquals(7.3, r.properties().getDouble(C_D), delta);
+        assertEquals(7.3, r.properties().getDouble(C_D, 3.4d), delta);
+        assertEquals(3.4, r.properties().getDouble(C_f, 3.4d), delta);
         assertNull(r.properties().getDouble("f"));
 
         r.properties().set("o", true);
-        assertEquals(true, r.properties().getBoolean("o"));
-        assertEquals(true, r.properties().getBoolean("o", true));
-        assertEquals(true, r.properties().getBoolean("g", true));
-        assertEquals(false, r.properties().getBoolean("g"));
-        assertEquals(true, r.properties().getBoolean(new CompoundName("o")));
-        assertEquals(true, r.properties().getBoolean(new CompoundName("o"), true));
-        assertEquals(true, r.properties().getBoolean(new CompoundName("g"), true));
-        assertEquals(false, r.properties().getBoolean("g"));
-
-        r.properties().set(new CompoundName("x.y"), "x1.y1");
+        assertTrue(r.properties().getBoolean("o"));
+        assertTrue(r.properties().getBoolean("o", true));
+        assertTrue(r.properties().getBoolean("g", true));
+        assertFalse(r.properties().getBoolean("g"));
+        assertTrue(r.properties().getBoolean(C_o));
+        assertTrue(r.properties().getBoolean(C_o, true));
+        assertTrue(r.properties().getBoolean(C_g, true));
+        assertFalse(r.properties().getBoolean("g"));
+
+        r.properties().set(CompoundName.from("x.y"), "x1.y1");
         r.properties().set("x.z", "x1.z1");
 
         assertEquals(8, r.properties().listProperties().size());
         assertEquals(0, r.properties().listProperties("a").size());
-        assertEquals(0, r.properties().listProperties(new CompoundName("a")).size());
-        assertEquals(0, r.properties().listProperties(new CompoundName("none")).size());
-        assertEquals(2, r.properties().listProperties(new CompoundName("x")).size());
+        assertEquals(0, r.properties().listProperties(C_a).size());
+        assertEquals(0, r.properties().listProperties(C_none).size());
+        assertEquals(2, r.properties().listProperties(C_x).size());
         assertEquals(2, r.properties().listProperties("x").size());
     }