Fix failing annotator test and singletonMap => Map.of

5 files changed, 43 insertions, 41 deletions

diff --git a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionConverterTestCase.java b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionConverterTestCase.java
index 72a03e938fb..52a015137aa 100644
--- a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionConverterTestCase.java
+++ b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionConverterTestCase.java
@@ -55,7 +55,6 @@ import com.yahoo.vespa.indexinglanguage.expressions.ZCurveExpression;
 import com.yahoo.vespa.indexinglanguage.linguistics.AnnotatorConfig;
 import org.junit.Test;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -109,7 +108,7 @@ public class ExpressionConverterTestCase {
         assertConvertable(new StatementExpression(new InputExpression("foo")));
         assertConvertable(new SubstringExpression(6, 9));
         assertConvertable(new SummaryExpression("foo"));
-        assertConvertable(new SwitchExpression(Collections.singletonMap("foo", (Expression)new IndexExpression("bar")),
+        assertConvertable(new SwitchExpression(Map.of("foo", (Expression)new IndexExpression("bar")),
                                                new InputExpression("baz")));
         assertConvertable(new ThisExpression());
         assertConvertable(new ToArrayExpression());
diff --git a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionSearcherTestCase.java b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionSearcherTestCase.java
index 4a8348204a6..c4f71402afa 100644
--- a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionSearcherTestCase.java
+++ b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionSearcherTestCase.java
@@ -17,8 +17,8 @@ import com.yahoo.vespa.indexinglanguage.expressions.StatementExpression;
 import com.yahoo.vespa.indexinglanguage.expressions.SwitchExpression;
 import org.junit.Test;
 
-import java.util.Arrays;
-import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
@@ -67,18 +67,18 @@ public class ExpressionSearcherTestCase {
         assertFound(exp, new ScriptExpression(new StatementExpression(new AttributeExpression("foo")),
                                               new StatementExpression(exp)));
         assertFound(exp, new SelectInputExpression(
-                Arrays.asList(new Pair<String, Expression>("foo", exp),
-                              new Pair<String, Expression>("bar", new AttributeExpression("bar")))));
+                List.of(new Pair<>("foo", exp),
+                        new Pair<>("bar", new AttributeExpression("bar")))));
         assertFound(exp, new SelectInputExpression(
-                Arrays.asList(new Pair<String, Expression>("foo", new AttributeExpression("bar")),
-                              new Pair<String, Expression>("bar", exp))));
+                List.of(new Pair<>("foo", new AttributeExpression("bar")),
+                        new Pair<>("bar", exp))));
         assertFound(exp, new StatementExpression(exp));
         assertFound(exp, new StatementExpression(new AttributeExpression("foo"), exp));
         assertFound(exp, new SwitchExpression(
-                Collections.singletonMap("foo", exp),
+                Map.of("foo", exp),
                 new AttributeExpression("bar")));
         assertFound(exp, new SwitchExpression(
-                Collections.singletonMap("foo", new AttributeExpression("bar")),
+                Map.of("foo", new AttributeExpression("bar")),
                 exp));
     }
 
diff --git a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionVisitorTestCase.java b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionVisitorTestCase.java
index 5bbf62bfff7..de512997b64 100644
--- a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionVisitorTestCase.java
+++ b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/ExpressionVisitorTestCase.java
@@ -55,7 +55,8 @@ import com.yahoo.vespa.indexinglanguage.expressions.ZCurveExpression;
 import com.yahoo.vespa.indexinglanguage.linguistics.AnnotatorConfig;
 import org.junit.Test;
 
-import java.util.Collections;
+
+import java.util.Map;
 
 import static org.junit.Assert.assertEquals;
 
@@ -64,7 +65,6 @@ import static org.junit.Assert.assertEquals;
  */
 public class ExpressionVisitorTestCase {
 
-    @SuppressWarnings("unchecked")
     @Test
     public void requireThatAllExpressionsAreVisited() {
         assertCount(3, new ArithmeticExpression(new InputExpression("foo"), ArithmeticExpression.Operator.ADD,
@@ -96,8 +96,8 @@ public class ExpressionVisitorTestCase {
         assertCount(2, new ParenthesisExpression(new InputExpression("foo")));
         assertCount(1, new RandomExpression(69));
         assertCount(3, new ScriptExpression(new StatementExpression(new InputExpression("foo"))));
-        assertCount(3, new SelectInputExpression(new Pair<String, Expression>("foo", new IndexExpression("bar")),
-                                                 new Pair<String, Expression>("bar", new IndexExpression("foo"))));
+        assertCount(3, new SelectInputExpression(new Pair<>("foo", new IndexExpression("bar")),
+                new Pair<>("bar", new IndexExpression("foo"))));
         assertCount(1, new SetLanguageExpression());
         assertCount(1, new ConstantExpression(new IntegerFieldValue(69)));
         assertCount(1, new SetVarExpression("foo"));
@@ -105,7 +105,7 @@ public class ExpressionVisitorTestCase {
         assertCount(2, new StatementExpression(new InputExpression("foo")));
         assertCount(1, new SummaryExpression("foo"));
         assertCount(1, new SubstringExpression(6, 9));
-        assertCount(3, new SwitchExpression(Collections.singletonMap("foo", (Expression)new IndexExpression("bar")),
+        assertCount(3, new SwitchExpression(Map.of("foo", (Expression)new IndexExpression("bar")),
                                             new InputExpression("baz")));
         assertCount(1, new ThisExpression());
         assertCount(1, new ToArrayExpression());
diff --git a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/expressions/SwitchTestCase.java b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/expressions/SwitchTestCase.java
index 62d333e356f..376677b6f57 100644
--- a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/expressions/SwitchTestCase.java
+++ b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/expressions/SwitchTestCase.java
@@ -7,7 +7,6 @@ import com.yahoo.document.datatypes.IntegerFieldValue;
 import com.yahoo.document.datatypes.StringFieldValue;
 import org.junit.Test;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -45,10 +44,10 @@ public class SwitchTestCase {
         cases.put("bar", bar);
         SwitchExpression exp = new SwitchExpression(cases, baz);
 
-        assertFalse(exp.equals(new Object()));
-        assertFalse(exp.equals(new SwitchExpression(Collections.singletonMap("foo", foo))));
-        assertFalse(exp.equals(new SwitchExpression(Collections.singletonMap("foo", foo), baz)));
-        assertFalse(exp.equals(new SwitchExpression(cases)));
+        assertNotEquals(exp, new Object());
+        assertNotEquals(exp, new SwitchExpression(Map.of("foo", foo)));
+        assertNotEquals(exp, new SwitchExpression(Map.of("foo", foo), baz));
+        assertNotEquals(exp, new SwitchExpression(cases));
         assertEquals(exp, new SwitchExpression(cases, baz));
         assertEquals(exp.hashCode(), new SwitchExpression(cases, baz).hashCode());
     }
@@ -56,7 +55,7 @@ public class SwitchTestCase {
     @Test
     public void requireThatExpressionCanBeVerified() {
         Expression foo = SimpleExpression.newConversion(DataType.STRING, DataType.INT);
-        Expression exp = new SwitchExpression(Collections.singletonMap("foo", foo));
+        Expression exp = new SwitchExpression(Map.of("foo", foo));
         assertVerify(DataType.STRING, exp, DataType.STRING); // does not touch output
         assertVerifyThrows(null, exp, "Expected string input, but no input is specified");
         assertVerifyThrows(DataType.INT, exp, "Expected string input, got int");
@@ -68,15 +67,14 @@ public class SwitchTestCase {
         cases.put("foo", SimpleExpression.newRequired(DataType.INT));
         assertVerifyThrows(DataType.STRING, new SwitchExpression(cases),
                            "Expected int input, got string");
-        assertVerifyThrows(DataType.STRING, new SwitchExpression(Collections.<String, Expression>emptyMap(),
-                                                                 SimpleExpression.newRequired(DataType.INT)),
+        assertVerifyThrows(DataType.STRING, new SwitchExpression(Map.of(), SimpleExpression.newRequired(DataType.INT)),
                            "Expected int input, got string");
     }
 
     @Test
     public void requireThatIllegalArgumentThrows() {
         try {
-            new SwitchExpression(Collections.<String, Expression>emptyMap()).execute(new IntegerFieldValue(69));
+            new SwitchExpression(Map.of()).execute(new IntegerFieldValue(69));
             fail();
         } catch (IllegalArgumentException e) {
             assertEquals("Expected string input, got int", e.getMessage());
@@ -85,18 +83,18 @@ public class SwitchTestCase {
 
     @Test
     public void requireThatDefaultExpressionIsNullIfNotGiven() {
-        assertNull(new SwitchExpression(Collections.<String, Expression>emptyMap()).getDefaultExpression());
+        assertNull(new SwitchExpression(Map.of()).getDefaultExpression());
     }
 
     @Test
     public void requireThatIsEmptyReflectsOnBothCasesAndDefault() {
-        assertTrue(new SwitchExpression(Collections.<String, Expression>emptyMap()).isEmpty());
-        assertTrue(new SwitchExpression(Collections.<String, Expression>emptyMap(), null).isEmpty());
-        assertFalse(new SwitchExpression(Collections.<String, Expression>emptyMap(),
+        assertTrue(new SwitchExpression(Map.of()).isEmpty());
+        assertTrue(new SwitchExpression(Map.of(), null).isEmpty());
+        assertFalse(new SwitchExpression(Map.of(),
                                          new AttributeExpression("foo")).isEmpty());
-        assertFalse(new SwitchExpression(Collections.singletonMap("foo", new AttributeExpression("foo")),
+        assertFalse(new SwitchExpression(Map.of("foo", new AttributeExpression("foo")),
                                          null).isEmpty());
-        assertFalse(new SwitchExpression(Collections.singletonMap("foo", new AttributeExpression("foo")),
+        assertFalse(new SwitchExpression(Map.of("foo", new AttributeExpression("foo")),
                                          new AttributeExpression("foo")).isEmpty());
 
     }
diff --git a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/linguistics/LinguisticsAnnotatorTestCase.java b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/linguistics/LinguisticsAnnotatorTestCase.java
index fecb89ee167..136e71564d8 100644
--- a/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/linguistics/LinguisticsAnnotatorTestCase.java
+++ b/indexinglanguage/src/test/java/com/yahoo/vespa/indexinglanguage/linguistics/LinguisticsAnnotatorTestCase.java
@@ -18,7 +18,9 @@ import com.yahoo.language.simple.SimpleToken;
 import org.junit.Test;
 import org.mockito.Mockito;
 
-import java.util.*;
+
+import java.util.List;
+import java.util.Map;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -90,7 +92,7 @@ public class LinguisticsAnnotatorTestCase {
     public void requireThatTermAnnotationsAreEmptyIfOrigIsLowerCase() {
         SpanTree expected = new SpanTree(SpanTrees.LINGUISTICS);
         expected.spanList().span(0, 3).annotate(new Annotation(AnnotationTypes.TERM));
-        for (boolean specialToken : Arrays.asList(true, false)) {
+        for (boolean specialToken : List.of(true, false)) {
             for (TokenType type : TokenType.values()) {
                 if (!specialToken && !type.isIndexable()) {
                     continue;
@@ -104,7 +106,7 @@ public class LinguisticsAnnotatorTestCase {
     public void requireThatTermAnnotationsPreserveCasing() {
         SpanTree expected = new SpanTree(SpanTrees.LINGUISTICS);
         expected.spanList().span(0, 3).annotate(new Annotation(AnnotationTypes.TERM, new StringFieldValue("BaR")));
-        for (boolean specialToken : Arrays.asList(true, false)) {
+        for (boolean specialToken : List.of(true, false)) {
             for (TokenType type : TokenType.values()) {
                 if (!specialToken && !type.isIndexable()) {
                     continue;
@@ -153,7 +155,7 @@ public class LinguisticsAnnotatorTestCase {
     public void requireThatTermReplacementsAreApplied() {
         SpanTree expected = new SpanTree(SpanTrees.LINGUISTICS);
         expected.spanList().span(0, 3).annotate(new Annotation(AnnotationTypes.TERM, new StringFieldValue("bar")));
-        for (boolean specialToken : Arrays.asList(true, false)) {
+        for (boolean specialToken : List.of(true, false)) {
             for (TokenType type : TokenType.values()) {
                 if (!specialToken && !type.isIndexable()) {
                     continue;
@@ -161,7 +163,7 @@ public class LinguisticsAnnotatorTestCase {
                 assertAnnotations(expected, "foo",
                                   new AnnotatorConfig(),
                                   newLinguistics(List.of(token("foo", "foo", type, specialToken)),
-                                                 Collections.singletonMap("foo", "bar")));
+                                                 Map.of("foo", "bar")));
             }
         }
     }
@@ -175,7 +177,7 @@ public class LinguisticsAnnotatorTestCase {
         val.setSpanTree(spanTree);
 
         Linguistics linguistics = newLinguistics(List.of(token("foo", "bar", TokenType.ALPHABETIC, false)),
-                                                 Collections.<String, String>emptyMap());
+                                                 Map.of());
         assertTrue(new LinguisticsAnnotator(linguistics, new AnnotatorConfig()).annotate(val));
         assertEquals(spanTree, val.getSpanTree(SpanTrees.LINGUISTICS));
     }
@@ -244,11 +246,11 @@ public class LinguisticsAnnotatorTestCase {
     }
 
     private static void assertAnnotations(SpanTree expected, String value, Token... tokens) {
-        assertAnnotations(expected, value, new AnnotatorConfig(), newLinguistics(Arrays.asList(tokens), Map.of()));
+        assertAnnotations(expected, value, new AnnotatorConfig(), newLinguistics(List.of(tokens), Map.of()));
     }
 
     private static void assertAnnotations(SpanTree expected, String value, AnnotatorConfig config, Token... tokens) {
-        assertAnnotations(expected, value, config, newLinguistics(Arrays.asList(tokens), Map.of()));
+        assertAnnotations(expected, value, config, newLinguistics(List.of(tokens), Map.of()));
     }
 
     private static void assertAnnotations(SpanTree expected, String str, AnnotatorConfig config, Linguistics linguistics) {
@@ -272,9 +274,12 @@ public class LinguisticsAnnotatorTestCase {
         }
 
         private Token replace(Token token, Map<String, String> replacementTerms) {
-            var simpleToken = (SimpleToken)token;
-            simpleToken.setTokenString(replacementTerms.getOrDefault(token.getTokenString(), token.getTokenString()));
-            return simpleToken;
+            String tokenString = token.getTokenString();
+            if (tokenString != null && !replacementTerms.isEmpty()) {
+                var simpleToken = (SimpleToken)token;
+                simpleToken.setTokenString(replacementTerms.getOrDefault(token.getTokenString(), token.getTokenString()));
+            }
+            return token;
         }
 
         @Override