Remove unused 'feedback' list

6 files changed, 172 insertions, 227 deletions

diff --git a/config/src/main/java/com/yahoo/vespa/config/ConfigDefinition.java b/config/src/main/java/com/yahoo/vespa/config/ConfigDefinition.java
index 9b4f8d12756..8906782de9e 100644
--- a/config/src/main/java/com/yahoo/vespa/config/ConfigDefinition.java
+++ b/config/src/main/java/com/yahoo/vespa/config/ConfigDefinition.java
@@ -85,65 +85,65 @@ public class ConfigDefinition implements Comparable<ConfigDefinition> {
         return ancestor;
     }
 
-    private static void defFail(String id, String val, String type, Exception e, List<String> warnings) {
-        defFail("Invalid value '" + val + "' for " + type + " '" + id + "'. "+ Exceptions.toMessageString(e), warnings);
+    private static void defFail(String id, String val, String type, Exception e) {
+        defFail("Invalid value '" + val + "' for " + type + " '" + id + "'. "+ Exceptions.toMessageString(e));
     }
 
-    public void verify(String id, String val, List<String> warnings) {
+    public void verify(String id, String val) {
         if (stringDefs.containsKey(id)) {
-            verifyString(id, warnings);
+            verifyString(id);
         } else if (enumDefs.containsKey(id)) {
-            verifyEnum(id ,val, warnings);
+            verifyEnum(id ,val);
         } else if (referenceDefs.containsKey(id)) {
-            verifyReference(id, warnings);
+            verifyReference(id);
         } else if (fileDefs.containsKey(id)) {
-            verifyFile(id, warnings);
+            verifyFile(id);
         } else if (pathDefs.containsKey(id)) {
-            verifyPath(id, warnings);
+            verifyPath(id);
         } else if (boolDefs.containsKey(id)) {
-            verifyBool(id, val, warnings);
+            verifyBool(id, val);
         } else if (intDefs.containsKey(id)) {
-            verifyInt(id, val, warnings);
+            verifyInt(id, val);
         } else if (longDefs.containsKey(id)) {
-            verifyLong(id, val, warnings);
+            verifyLong(id, val);
         } else if (doubleDefs.containsKey(id)) {
-            verifyDouble(id, val, warnings);
+            verifyDouble(id, val);
         } else if (structDefs.containsKey(id)) {
-            verifyStruct(id, warnings);
+            verifyStruct(id);
         } else if (arrayDefs.containsKey(id)) {
-            verifyArray(id, warnings);
+            verifyArray(id);
         } else if (innerArrayDefs.containsKey(id)) {
-            verifyInnerArray(id, warnings);
+            verifyInnerArray(id);
         } else if (leafMapDefs.containsKey(id)) {
-		verifyLeafMap(id, warnings);
+		verifyLeafMap(id);
         } else if (structMapDefs.containsKey(id)) {
-            verifyStructMap(id, warnings);
+            verifyStructMap(id);
         } else {
             defFail("No such field in definition " + getRoot().getNamespace() + "." + getRoot().getName() +
-                    ": " + getAncestorString() + id, warnings);
+                    ": " + getAncestorString() + id);
         }
     }
 
-    private boolean verifyDouble(String id, String val, List<String> warnings) {
+    private boolean verifyDouble(String id, String val) {
         try {
-            return verifyDouble(id, Double.parseDouble(val), warnings);
+            return verifyDouble(id, Double.parseDouble(val));
         } catch (NumberFormatException e) {
-            defFail(id, val, "double", e, warnings);
+            defFail(id, val, "double", e);
             return false;
         }
     }
 
-    private boolean verifyBool(String id, String val, List<String> warnings) {
+    private boolean verifyBool(String id, String val) {
         if ("true".equalsIgnoreCase(val) || "false".equalsIgnoreCase(val)) {
-            return verifyBool(id, warnings);
+            return verifyBool(id);
         } else {
-            defFail(id, val, "bool", null, warnings);
+            defFail(id, val, "bool", null);
             return false;
         }
     }
 
-    public void verify(String id, List<String> warnings) {
-        verify(id, null, warnings);
+    public void verify(String id) {
+        verify(id, null);
     }
 
     /**
@@ -230,97 +230,97 @@ public class ConfigDefinition implements Comparable<ConfigDefinition> {
             return enumVals;
         }
 
-        public boolean checkValue(String id, String val, int index, List<String> warnings) {
+        public boolean checkValue(String id, String val, int index) {
             if ("int".equals(getType())) {
-                return checkInt(id, val, index, warnings);
+                return checkInt(id, val, index);
             } else if ("long".equals(getType())) {
-                return checkLong(id, val, index, warnings);
+                return checkLong(id, val, index);
             } else if ("double".equals(getType())) {
-                return checkDouble(id, val, index, warnings);
+                return checkDouble(id, val, index);
             } else if ("enum".equals(getType())) {
-                return checkEnum(id, val, index, warnings);
+                return checkEnum(id, val, index);
             }
             return true;
         }
 
-        private boolean checkEnum(String id, String val, int index, List<String> warnings) {
+        private boolean checkEnum(String id, String val, int index) {
             if (!getEnumVals().contains(val)) {
-                ConfigDefinition.failInvalidEnum(val, id, id+"["+index+"]", warnings);
+                ConfigDefinition.failInvalidEnum(val, id, id+"["+index+"]");
                 return false;
             }
             return true;
         }
 
-        private boolean checkDouble(String id, String val, int index, List<String> warnings) {
+        private boolean checkDouble(String id, String val, int index) {
             try {
-                return checkDouble(Double.parseDouble(val), id, index, warnings);
+                return checkDouble(Double.parseDouble(val), id, index);
             } catch (NumberFormatException e) {
-                ConfigDefinition.defFail(id, val, "double", e, warnings);
+                ConfigDefinition.defFail(id, val, "double", e);
                 return false;
             }
         }
 
-        private boolean checkLong(String id, String val, int index, List<String> warnings) {
+        private boolean checkLong(String id, String val, int index) {
             try {
-                return checkLong(Long.parseLong(val), id, index, warnings);
+                return checkLong(Long.parseLong(val), id, index);
             } catch (NumberFormatException e) {
-                ConfigDefinition.defFail(id, val, "long", e, warnings);
+                ConfigDefinition.defFail(id, val, "long", e);
                 return false;
             }
         }
 
-        private boolean checkInt(String id, String val, int index, List<String> warnings) {
+        private boolean checkInt(String id, String val, int index) {
             try {
-                return checkInt(Integer.parseInt(val), id, index, warnings);
+                return checkInt(Integer.parseInt(val), id, index);
             } catch (NumberFormatException e) {
-                ConfigDefinition.defFail(id, val, "int", e, warnings);
+                ConfigDefinition.defFail(id, val, "int", e);
                 return false;
             }
         }
 
-        private boolean checkInt(Integer theVal, String id, int arrayIndex, List<String> warnings) {
+        private boolean checkInt(Integer theVal, String id, int arrayIndex) {
             if (!"int".equals(getType())) {
-                ConfigDefinition.defFail("Illegal value \""+theVal+"\" for array \""+id+"\"", warnings);
+                ConfigDefinition.defFail("Illegal value \""+theVal+"\" for array \""+id+"\"");
                 return false;
             }
             if (getMax()!=null && theVal>(Integer)getMax()) {
-                ConfigDefinition.failTooBig(theVal, getMax(), id, id+"["+arrayIndex+"]", warnings);
+                ConfigDefinition.failTooBig(theVal, getMax(), id, id+"["+arrayIndex+"]");
                 return false;
             }
             if (getMin()!=null && theVal<(Integer)getMin()) {
-                ConfigDefinition.failTooSmall(theVal, getMin(), id, id+"["+arrayIndex+"]", warnings);
+                ConfigDefinition.failTooSmall(theVal, getMin(), id, id+"["+arrayIndex+"]");
                 return false;
             }
             return true;
         }
 
-        private boolean checkLong(Long theVal, String id, int arrayIndex, List<String> warnings) {
+        private boolean checkLong(Long theVal, String id, int arrayIndex) {
             if (!"long".equals(getType())) {
-                ConfigDefinition.defFail("Illegal value \""+theVal+"\" for array \""+id+"\"", warnings);
+                ConfigDefinition.defFail("Illegal value \""+theVal+"\" for array \""+id+"\"");
                 return false;
             }
             if (getMax()!=null && theVal>(Long)getMax()) {
-                ConfigDefinition.failTooBig(theVal, getMax(), id, id+"["+arrayIndex+"]", warnings);
+                ConfigDefinition.failTooBig(theVal, getMax(), id, id+"["+arrayIndex+"]");
                 return false;
             }
             if (getMin()!=null && theVal<(Long)getMin()) {
-                ConfigDefinition.failTooSmall(theVal, getMin(), id, id+"["+arrayIndex+"]", warnings);
+                ConfigDefinition.failTooSmall(theVal, getMin(), id, id+"["+arrayIndex+"]");
                 return false;
             }
             return true;
         }
 
-        private boolean checkDouble(Double theVal, String id, int arrayIndex, List<String> warnings) {
+        private boolean checkDouble(Double theVal, String id, int arrayIndex) {
             if (!"double".equals(getType())) {
-                ConfigDefinition.defFail("Illegal value \""+theVal+"\" for array \""+id+"\", array type is "+getType(), warnings);
+                ConfigDefinition.defFail("Illegal value \""+theVal+"\" for array \""+id+"\", array type is "+getType());
                 return false;
             }
             if (getMax()!=null && (theVal>(Double)getMax())) {
-                ConfigDefinition.failTooBig(theVal, getMax(), id, id+"["+arrayIndex+"]", warnings);
+                ConfigDefinition.failTooBig(theVal, getMax(), id, id+"["+arrayIndex+"]");
                 return false;
             }
             if (getMin()!=null && theVal<(Double)getMin()) {
-                ConfigDefinition.failTooSmall(theVal, getMin(), id, id+"["+arrayIndex+"]", warnings);
+                ConfigDefinition.failTooSmall(theVal, getMin(), id, id+"["+arrayIndex+"]");
                 return false;
             }
             return true;
@@ -375,10 +375,10 @@ public class ConfigDefinition implements Comparable<ConfigDefinition> {
             this.typeSpec = typeSpec;
         }
 
-        public void verify(String val, int index, List<String> warnings) {
+        public void verify(String val, int index) {
             if (val != null && getTypeSpec() != null) {
                 TypeSpec spec = getTypeSpec();
-                spec.checkValue(getName(), val, index, warnings);
+                spec.checkValue(getName(), val, index);
             }
         }
     }
@@ -815,21 +815,21 @@ public class ConfigDefinition implements Comparable<ConfigDefinition> {
     /**
      * Throws if the given value is not legal
      */
-    private boolean verifyDouble(String id, Double val, List<String> warnings) {
+    private boolean verifyDouble(String id, Double val) {
         DoubleDef def = doubleDefs.get(id);
         if (def==null) {
-            defFail("No such double in " + verifyWarning(id), warnings);
+            defFail("No such double in " + verifyWarning(id));
             return false;
         }
         if (val==null) {
             return true;
         }
         if (def.getMin()!=null && val<def.getMin()) {
-            failTooSmall(val, def.getMin(), toString(), getAncestorString()+id, warnings);
+            failTooSmall(val, def.getMin(), toString(), getAncestorString()+id);
             return false;
         }
         if (def.getMax()!=null && val>def.getMax()) {
-            failTooBig(val, def.getMax(), toString(), getAncestorString()+id, warnings);
+            failTooBig(val, def.getMax(), toString(), getAncestorString()+id);
             return false;
         }
         return true;
@@ -838,15 +838,15 @@ public class ConfigDefinition implements Comparable<ConfigDefinition> {
     /**
      * Throws if the given value is not legal
      */
-    private boolean verifyEnum(String id, String val, List<String> warnings) {
+    private boolean verifyEnum(String id, String val) {
         EnumDef def = enumDefs.get(id);
         if (def==null) {
-            defFail("No such enum in " + verifyWarning(id), warnings);
+            defFail("No such enum in " + verifyWarning(id));
             return false;
         }
         if (!def.getVals().contains(val)) {
             defFail("Invalid enum value '"+val+"' in def "+toString()+
-                    " enum '"+getAncestorString()+id+"'.", warnings);
+                    " enum '"+getAncestorString()+id+"'.");
             return false;
         }
         return true;
@@ -855,40 +855,40 @@ public class ConfigDefinition implements Comparable<ConfigDefinition> {
     /**
      * Throws if the given value is not legal
      */
-    private boolean verifyInt(String id, Integer val, List<String> warnings) {
+    private boolean verifyInt(String id, Integer val) {
         IntDef def = intDefs.get(id);
         if (def==null) {
-            defFail("No such integer in " + verifyWarning(id), warnings);
+            defFail("No such integer in " + verifyWarning(id));
             return false;
         }
         if (val==null) {
             return true;
         }
         if (def.getMin()!=null && val<def.getMin()) {
-            failTooSmall(val, def.getMin(), name, id, warnings);
+            failTooSmall(val, def.getMin(), name, id);
             return false;
         }
         if (def.getMax()!=null && val>def.getMax()) {
-            failTooBig(val, def.getMax(), name, id, warnings);
+            failTooBig(val, def.getMax(), name, id);
             return false;
         }
         return true;
     }
 
-    private boolean verifyInt(String id, String val, List<String> warnings) {
+    private boolean verifyInt(String id, String val) {
         try {
-            return verifyInt(id, Integer.parseInt(val), warnings);
+            return verifyInt(id, Integer.parseInt(val));
         } catch (NumberFormatException e) {
-            ConfigDefinition.defFail(id, val, "int", e, warnings);
+            ConfigDefinition.defFail(id, val, "int", e);
             return false;
         }
     }
 
-    private boolean verifyLong(String id, String val, List<String> warnings) {
+    private boolean verifyLong(String id, String val) {
         try {
-            return verifyLong(id, Long.parseLong(val), warnings);
+            return verifyLong(id, Long.parseLong(val));
         } catch (NumberFormatException e) {
-            ConfigDefinition.defFail(id, val, "long", e, warnings);
+            ConfigDefinition.defFail(id, val, "long", e);
             return false;
         }
     }
@@ -896,135 +896,130 @@ public class ConfigDefinition implements Comparable<ConfigDefinition> {
     /**
      * Throws if the given value is not legal
      */
-    private boolean verifyLong(String id, Long val, List<String> warnings) {
+    private boolean verifyLong(String id, Long val) {
         LongDef def = longDefs.get(id);
         if (def==null) {
-            defFail("No such long in " + verifyWarning(id), warnings);
+            defFail("No such long in " + verifyWarning(id));
             return false;
         }
         if (val==null) {
             return true;
         }
         if (def.getMin()!=null && val<def.getMin()) {
-            failTooSmall(val, def.getMin(), name, id, warnings);
+            failTooSmall(val, def.getMin(), name, id);
             return false;
         }
         if (def.getMax()!=null && val>def.getMax()) {
-            failTooBig(val, def.getMax(), name, id, warnings);
+            failTooBig(val, def.getMax(), name, id);
             return false;
         }
         return true;
     }
 
-    static void failTooSmall(Object val, Object min, String defName, String valKey, List<String> warnings) {
-        defFail("Value \""+valKey+"\" outside range in definition \""+defName+"\": "+val+"<"+min, warnings);
+    static void failTooSmall(Object val, Object min, String defName, String valKey) {
+        defFail("Value \""+valKey+"\" outside range in definition \""+defName+"\": "+val+"<"+min);
     }
 
-    static void failTooBig(Object val, Object max, String defName, String valKey, List<String> warnings) {
-        defFail("Value \""+valKey+"\" outside range in definition \""+defName+"\": "+val+">"+max, warnings);
+    static void failTooBig(Object val, Object max, String defName, String valKey) {
+        defFail("Value \""+valKey+"\" outside range in definition \""+defName+"\": "+val+">"+max);
     }
 
-    static void failInvalidEnum(Object val, String defName, String defKey, List<String> warnings) {
-        defFail("Invalid enum value \""+val+"\" for \""+defKey+"\" in definition \""+defName, warnings);
+    static void failInvalidEnum(Object val, String defName, String defKey) {
+        defFail("Invalid enum value \""+val+"\" for \""+defKey+"\" in definition \""+defName);
     }
 
     /**
      * Adds the given log msg to list, and logs it
      * @param msg failure message
-     * @param warnings list of warnings collected during model building.
      * @return warnings list with msg added
      */
-    static List<String> defFail(String msg, List<String> warnings) {
+    static List<String> defFail(String msg) {
         throw new IllegalArgumentException(msg);
-        // Idea here is to store errors in list instead, and throw from model builder in vespamodel instead. But not so important.
-        /*warnings.add(msg);
-        log.log(LogLevel.WARNING, msg);
-        return warnings;*/
     }
 
-    private boolean verifyString(String id, List<String> warnings) {
+    private boolean verifyString(String id) {
         if (!stringDefs.containsKey(id)) {
-            defFail("No such string in " + verifyWarning(id), warnings);
+            defFail("No such string in " + verifyWarning(id));
             return false;
         }
         return true;
     }
 
-    private boolean verifyReference(String id, List<String> warnings) {
+    private boolean verifyReference(String id) {
         if (!referenceDefs.containsKey(id)) {
-            defFail("No such reference in " + verifyWarning(id), warnings);
+            defFail("No such reference in " + verifyWarning(id));
             return false;
         }
         return true;
     }
 
-    private boolean verifyFile(String id, List<String> warnings) {
+    private boolean verifyFile(String id) {
         if (!fileDefs.containsKey(id)) {
-            defFail("No such file in " + verifyWarning(id), warnings);
+            defFail("No such file in " + verifyWarning(id));
             return false;
         }
         return true;
     }
 
-    private boolean verifyPath(String id, List<String> warnings) {
+    private boolean verifyPath(String id) {
         if (!pathDefs.containsKey(id)) {
-            defFail("No such path in " + verifyWarning(id), warnings);
+            defFail("No such path in " + verifyWarning(id));
             return false;
         }
         return true;
     }
 
-    private boolean verifyBool(String id, List<String> warnings) {
+    private boolean verifyBool(String id) {
         if (!boolDefs.containsKey(id)) {
-            defFail("No such bool in " + verifyWarning(id), warnings);
+            defFail("No such bool in " + verifyWarning(id));
             return false;
         }
         return true;
     }
 
-    private boolean verifyArray(String id, List<String> warnings) {
+    private boolean verifyArray(String id) {
         String failString = "No such array in " + verifyWarning(id);
         if (!arrayDefs.containsKey(id)) {
             if (innerArrayDefs.containsKey(id)) {
                 failString += ". However, the definition does contain an inner array with the same name.";
             }
-            defFail(failString, warnings);
+            defFail(failString);
             return false;
         }
         return true;
     }
 
-    private boolean verifyInnerArray(String id, List<String> warnings) {
+    private boolean verifyInnerArray(String id) {
         String failString = "No such inner array in " + verifyWarning(id);
         if (!innerArrayDefs.containsKey(id)) {
             if (arrayDefs.containsKey(id)) {
                 failString += ". However, the definition does contain an array with the same name.";
             }
-            defFail(failString, warnings);
+            defFail(failString);
             return false;
         }
         return true;
     }
 
-    private boolean verifyStruct(String id, List<String> warnings) {
+    private boolean verifyStruct(String id) {
         if (!structDefs.containsKey(id)) {
-            defFail("No such struct in " + verifyWarning(id), warnings);
+            defFail("No such struct in " + verifyWarning(id));
             return false;
         }
         return true;
     }
 
-    private boolean verifyLeafMap(String id, List<String> warnings) {
+    private boolean verifyLeafMap(String id) {
 	if (!leafMapDefs.containsKey(id)) {
-		defFail("No such leaf map in " + verifyWarning(id), warnings);
+		defFail("No such leaf map in " + verifyWarning(id));
             return false;
 	}
 	return true;
     }
 
-    private boolean verifyStructMap(String id, List<String> warnings) {
+    private boolean verifyStructMap(String id) {
 	if (!structMapDefs.containsKey(id)) {
-		defFail("No such struct map in " + verifyWarning(id), warnings);
+		defFail("No such struct map in " + verifyWarning(id));
             return false;
 	}
 	return true;
diff --git a/config/src/main/java/com/yahoo/vespa/config/ConfigPayloadBuilder.java b/config/src/main/java/com/yahoo/vespa/config/ConfigPayloadBuilder.java
index 90f02e59346..65533dc74f0 100644
--- a/config/src/main/java/com/yahoo/vespa/config/ConfigPayloadBuilder.java
+++ b/config/src/main/java/com/yahoo/vespa/config/ConfigPayloadBuilder.java
@@ -21,17 +21,16 @@ public class ConfigPayloadBuilder {
     private final Map<String, Array> arrayMap;
     private final Map<String, MapBuilder> mapBuilderMap;
     private final ConfigDefinition configDefinition;
-    private List<String> warnings = new ArrayList<>();
 
     /**
      * Construct a payload builder that is not a leaf.
      */
     public ConfigPayloadBuilder() {
-        this(null, null, null);
+        this(null, null);
     }
 
-    public ConfigPayloadBuilder(ConfigDefinition configDefinition, List<String> warnings) {
-        this(configDefinition, null, warnings);
+    public ConfigPayloadBuilder(ConfigDefinition configDefinition) {
+        this(configDefinition, null);
     }
 
     /**
@@ -39,17 +38,16 @@ public class ConfigPayloadBuilder {
      *
      * @param value The value of this leaf.
      */
-    private ConfigPayloadBuilder(String value, List<String> warnings) {
-        this(null, value, warnings);
+    private ConfigPayloadBuilder(String value) {
+        this(null, value);
     }
 
-    private ConfigPayloadBuilder(ConfigDefinition configDefinition, String value, List<String> warnings) {
+    private ConfigPayloadBuilder(ConfigDefinition configDefinition, String value) {
         this.objectMap = new LinkedHashMap<>();
         this.arrayMap = new LinkedHashMap<>();
         this.mapBuilderMap = new LinkedHashMap<>();
         this.value = value;
         this.configDefinition = configDefinition;
-        this.warnings=warnings;
     }
 
     /**
@@ -59,13 +57,13 @@ public class ConfigPayloadBuilder {
      * @param value Value of the config field.
      */
     public void setField(String name, String value) {
-        validateField(name, value, warnings);
-        objectMap.put(name, new ConfigPayloadBuilder(value, warnings));
+        validateField(name, value);
+        objectMap.put(name, new ConfigPayloadBuilder(value));
     }
 
-    private void validateField(String name, String value, List<String> warnings) {
+    private void validateField(String name, String value) {
         if (configDefinition != null) {
-            configDefinition.verify(name, value, warnings);
+            configDefinition.verify(name, value);
         }
     }
 
@@ -78,8 +76,8 @@ public class ConfigPayloadBuilder {
     public ConfigPayloadBuilder getObject(String name) {
         ConfigPayloadBuilder p = objectMap.get(name);
         if (p == null) {
-            validateObject(name, warnings);
-            p = new ConfigPayloadBuilder(getStructDef(name), warnings);
+            validateObject(name);
+            p = new ConfigPayloadBuilder(getStructDef(name));
             objectMap.put(name, p);
         }
         return p;
@@ -89,9 +87,9 @@ public class ConfigPayloadBuilder {
         return (configDefinition == null ? null : configDefinition.getStructDefs().get(name));
     }
 
-    private void validateObject(String name, List<String> warnings) {
+    private void validateObject(String name) {
         if (configDefinition != null) {
-            configDefinition.verify(name, warnings);
+            configDefinition.verify(name);
         }
     }
 
@@ -104,16 +102,16 @@ public class ConfigPayloadBuilder {
     public Array getArray(String name) {
         Array a = arrayMap.get(name);
         if (a == null) {
-            validateArray(name, warnings);
+            validateArray(name);
             a = new Array(configDefinition, name);
             arrayMap.put(name, a);
         }
         return a;
     }
 
-    private void validateArray(String name, List<String> warnings) {
+    private void validateArray(String name) {
         if (configDefinition != null) {
-            configDefinition.verify(name, warnings);
+            configDefinition.verify(name);
         }
     }
 
@@ -194,24 +192,16 @@ public class ConfigPayloadBuilder {
     public MapBuilder getMap(String name) {
         MapBuilder a = mapBuilderMap.get(name);
         if (a == null) {
-            validateMap(name, warnings);
+            validateMap(name);
             a = new MapBuilder(configDefinition, name);
             mapBuilderMap.put(name, a);
         }
         return a;
     }
 
-    /**
-     * The definition warnings issued for this payload
-     * @return list of warnings
-     */
-    public List<String> warnings() {
-        return warnings;
-    }
-
-    private void validateMap(String name, List<String> warnings) {
+    private void validateMap(String name) {
         if (configDefinition != null) {
-            configDefinition.verify(name, warnings);
+            configDefinition.verify(name);
         }
     }
 
@@ -229,11 +219,11 @@ public class ConfigPayloadBuilder {
         }
 
         public void put(String key, String value) {
-            elements.put(key, new ConfigPayloadBuilder(getLeafMapDef(name), value, warnings));
+            elements.put(key, new ConfigPayloadBuilder(getLeafMapDef(name), value));
         }
 
         public ConfigPayloadBuilder put(String key) {
-            ConfigPayloadBuilder p = new ConfigPayloadBuilder(getStructMapDef(name), warnings);
+            ConfigPayloadBuilder p = new ConfigPayloadBuilder(getStructMapDef(name));
             elements.put(key, p);
             return p;
         }
@@ -308,13 +298,13 @@ public class ConfigPayloadBuilder {
         public void append(String value) {
             setAppend();
             validateArrayElement(getArrayDef(name), value, elements.size());
-            ConfigPayloadBuilder p = new ConfigPayloadBuilder(getArrayDef(name), value, warnings);
+            ConfigPayloadBuilder p = new ConfigPayloadBuilder(getArrayDef(name), value);
             elements.put(elements.size(), p);
         }
 
         private void validateArrayElement(ConfigDefinition.ArrayDef arrayDef, String value, int index) {
             if (arrayDef != null) {
-                arrayDef.verify(value, index, warnings);
+                arrayDef.verify(value, index);
             }
         }
 
@@ -338,7 +328,7 @@ public class ConfigPayloadBuilder {
          */
         public ConfigPayloadBuilder append() {
             setAppend();
-            ConfigPayloadBuilder p = new ConfigPayloadBuilder(getInnerArrayDef(name), warnings);
+            ConfigPayloadBuilder p = new ConfigPayloadBuilder(getInnerArrayDef(name));
             elements.put(elements.size(), p);
             return p;
         }
@@ -351,7 +341,7 @@ public class ConfigPayloadBuilder {
          */
         public void set(int index, String value) {
             verifyIndex();
-            ConfigPayloadBuilder p = new ConfigPayloadBuilder(value, warnings);
+            ConfigPayloadBuilder p = new ConfigPayloadBuilder(value);
             elements.put(index, p);
         }
 
@@ -364,7 +354,7 @@ public class ConfigPayloadBuilder {
          */
         public ConfigPayloadBuilder set(int index) {
             verifyIndex();
-            ConfigPayloadBuilder p = new ConfigPayloadBuilder(getInnerArrayDef(name), warnings);
+            ConfigPayloadBuilder p = new ConfigPayloadBuilder(getInnerArrayDef(name));
             elements.put(index, p);
             return p;
         }
@@ -435,7 +425,6 @@ public class ConfigPayloadBuilder {
         this.value = other.value;
         this.objectMap = other.objectMap;
         this.configDefinition = other.configDefinition;
-        this.warnings = other.warnings;
     }
 
     public ConfigPayloadBuilder(ConfigPayload payload) {
diff --git a/config/src/test/java/com/yahoo/vespa/config/ConfigDefinitionKeyTest.java b/config/src/test/java/com/yahoo/vespa/config/ConfigDefinitionKeyTest.java
index 193bf4caf25..bbd01f12b78 100644
--- a/config/src/test/java/com/yahoo/vespa/config/ConfigDefinitionKeyTest.java
+++ b/config/src/test/java/com/yahoo/vespa/config/ConfigDefinitionKeyTest.java
@@ -18,11 +18,11 @@ public class ConfigDefinitionKeyTest {
 
     @Test
     public void testBasic() {
-        ConfigDefinitionKey def1 = new ConfigDefinitionKey("foo", "");
+        ConfigDefinitionKey def1 = new ConfigDefinitionKey("foo", "fuz");
         ConfigDefinitionKey def2 = new ConfigDefinitionKey("foo", "bar");
 
         assertThat(def1.getName(), is("foo"));
-        assertThat(def1.getNamespace(), is(""));
+        assertThat(def1.getNamespace(), is("fuz"));
 
         assertTrue(def1.equals(def1));
         assertFalse(def1.equals(def2));
diff --git a/config/src/test/java/com/yahoo/vespa/config/ConfigDefinitionTest.java b/config/src/test/java/com/yahoo/vespa/config/ConfigDefinitionTest.java
index 9a7d9cad754..de2e30d66d7 100755
--- a/config/src/test/java/com/yahoo/vespa/config/ConfigDefinitionTest.java
+++ b/config/src/test/java/com/yahoo/vespa/config/ConfigDefinitionTest.java
@@ -153,56 +153,54 @@ public class ConfigDefinitionTest {
 
         def.structDef("struct");
 
-        assertVerify(def, "boolval", "true", 0);
-        assertVerify(def, "boolval", "false", 0);
+        assertVerify(def, "boolval", "true");
+        assertVerify(def, "boolval", "false");
         assertVerify(def, "boolval", "invalid", IllegalArgumentException.class);
 
 
-        assertVerify(def, "stringval", "foobar", 0);
-        assertVerify(def, "stringval", "foobar", 0);
-        assertVerify(def, "intval", "123", 0);
+        assertVerify(def, "stringval", "foobar");
+        assertVerify(def, "stringval", "foobar");
+        assertVerify(def, "intval", "123");
         assertVerify(def, "intval", "foobar", IllegalArgumentException.class);
-        assertVerify(def, "longval", "1234", 0);
+        assertVerify(def, "longval", "1234");
         assertVerify(def, "longval", "foobar", IllegalArgumentException.class);
         assertVerify(def, "doubleval", "foobar", IllegalArgumentException.class);
-        assertVerify(def, "doubleval", "3", 0);
-        assertVerify(def, "doubleval", "3.14", 0);
+        assertVerify(def, "doubleval", "3");
+        assertVerify(def, "doubleval", "3.14");
         assertVerify(def, "enumval", "foobar", IllegalArgumentException.class);
         assertVerify(def, "enumval", "foo", IllegalArgumentException.class);
-        assertVerify(def, "enumval", "FOO", 0);
-        assertVerify(def, "refval", "foobar", 0);
-        assertVerify(def, "fileval", "foobar", 0);
-
-        assertVerifyComplex(def, "innerarr", 0);
-        assertVerifyComplex(def, "leafmap", 0);
-        assertVerifyComplex(def, "intArray", 0);
-        assertVerifyComplex(def, "longArray", 0);
-        assertVerifyComplex(def, "doubleArray", 0);
-        assertVerifyComplex(def, "enumArray", 0);
-        assertVerifyComplex(def, "stringArray", 0);
-        assertVerifyArray(intArray, "1345", 0, 0);
+        assertVerify(def, "enumval", "FOO");
+        assertVerify(def, "refval", "foobar");
+        assertVerify(def, "fileval", "foobar");
+
+        assertVerifyComplex(def, "innerarr");
+        assertVerifyComplex(def, "leafmap");
+        assertVerifyComplex(def, "intArray");
+        assertVerifyComplex(def, "longArray");
+        assertVerifyComplex(def, "doubleArray");
+        assertVerifyComplex(def, "enumArray");
+        assertVerifyComplex(def, "stringArray");
+        assertVerifyArray(intArray, "1345", 0);
         assertVerifyArray(intArray, "invalid", 0, IllegalArgumentException.class);
-        assertVerifyArray(longArray, "1345", 0, 0);
+        assertVerifyArray(longArray, "1345", 0);
         assertVerifyArray(longArray, "invalid", 0, IllegalArgumentException.class);
-        assertVerifyArray(doubleArray, "1345", 0, 0);
-        assertVerifyArray(doubleArray, "1345.3", 0, 0);
+        assertVerifyArray(doubleArray, "1345", 0);
+        assertVerifyArray(doubleArray, "1345.3", 0);
         assertVerifyArray(doubleArray, "invalid", 0, IllegalArgumentException.class);
         assertVerifyArray(enumArray, "valid", 0, IllegalArgumentException.class);
-        assertVerifyArray(enumArray, "VALID", 0, 0);
+        assertVerifyArray(enumArray, "VALID", 0);
         assertVerifyArray(enumArray, "inVALID", 0, IllegalArgumentException.class);
-        assertVerifyArray(stringArray, "VALID", 0, 0);
-        assertVerifyComplex(def, "struct", 0);
+        assertVerifyArray(stringArray, "VALID", 0);
+        assertVerifyComplex(def, "struct");
     }
 
-    private void assertVerifyArray(ConfigDefinition.ArrayDef def, String val, int index, int expectedNumWarnings) {
-        List<String> issuedWarnings = new ArrayList<>();
-        def.verify(val, index, issuedWarnings);
-        assertThat(issuedWarnings.size(), is(expectedNumWarnings));
+    private void assertVerifyArray(ConfigDefinition.ArrayDef def, String val, int index) {
+        def.verify(val, index);
     }
 
     private void assertVerifyArray(ConfigDefinition.ArrayDef def, String val, int index, Class<?> expectedException) {
         try {
-            def.verify(val, index, new ArrayList<String>());
+            def.verify(val, index);
         } catch (Exception e) {
             if (!(e.getClass().isAssignableFrom(expectedException))) {
                 throw e;
@@ -210,15 +208,13 @@ public class ConfigDefinitionTest {
         }
     }
 
-    private void assertVerify(ConfigDefinition def, String id, String val, int expectedNumWarnings) {
-        List<String> issuedWarnings = new ArrayList<>();
-        def.verify(id, val, issuedWarnings);
-        assertThat(issuedWarnings.size(), is(expectedNumWarnings));
+    private void assertVerify(ConfigDefinition def, String id, String val) {
+        def.verify(id, val);
     }
 
     private void assertVerify(ConfigDefinition def, String id, String val, Class<?> expectedException) {
         try {
-            def.verify(id, val, new ArrayList<String>());
+            def.verify(id, val);
         } catch (Exception e) {
             if (!(e.getClass().isAssignableFrom(expectedException))) {
                 throw e;
@@ -226,9 +222,8 @@ public class ConfigDefinitionTest {
         }
     }
 
-    private void assertVerifyComplex(ConfigDefinition def, String id, int expectedNumWarnings) {
-        List<String> issuedWarnings = new ArrayList<>();
-        def.verify(id, issuedWarnings);
-        assertThat(issuedWarnings.size(), is(expectedNumWarnings));
+    private void assertVerifyComplex(ConfigDefinition def, String id) {
+        def.verify(id);
     }
+
 }
diff --git a/config/src/test/java/com/yahoo/vespa/config/ConfigPayloadBuilderTest.java b/config/src/test/java/com/yahoo/vespa/config/ConfigPayloadBuilderTest.java
index 24ade0f83c2..35ceebe393c 100644
--- a/config/src/test/java/com/yahoo/vespa/config/ConfigPayloadBuilderTest.java
+++ b/config/src/test/java/com/yahoo/vespa/config/ConfigPayloadBuilderTest.java
@@ -40,7 +40,7 @@ public class ConfigPayloadBuilderTest {
         def.arrayDef("myarray").setTypeSpec(new ConfigDefinition.TypeSpec("myarray", "int", null, null, null, null));
         ConfigDefinition myinnerarray = def.innerArrayDef("myinnerarray");
         myinnerarray.addIntDef("foo");
-        builderWithDef = new ConfigPayloadBuilder(def, new ArrayList<String>());
+        builderWithDef = new ConfigPayloadBuilder(def);
     }
 
     @Test
@@ -274,90 +274,71 @@ public class ConfigPayloadBuilderTest {
     @Test(expected=IllegalArgumentException.class)
     public void require_that_values_are_verified_against_def() {
         builderWithDef.setField("boolval", "true");
-        assertThat(builderWithDef.warnings().size(), is(0));
         builderWithDef.setField("boolval", "invalid");
-        //assertThat(builderWithDef.warnings().size(), is(1));
     }
 
     @Test(expected=IllegalArgumentException.class)
     public void require_that_arrays_must_exist() {
         builderWithDef.getArray("arraydoesnotexist");
-        //assertThat(builderWithDef.warnings().size(), is(1));
     }
 
     @Test(expected=IllegalArgumentException.class)
     public void require_that_structs_must_exist() {
         builderWithDef.getObject("structdoesnotexist");
-        //assertThat(builderWithDef.warnings().size(), is(1));
     }
 
     @Test(expected=IllegalArgumentException.class)
     public void require_that_definition_is_passed_to_childstruct() {
         ConfigPayloadBuilder nestedStruct = builderWithDef.getObject("mystruct");
-        assertThat(builderWithDef.warnings().size(), is(0));
         nestedStruct.setField("doesnotexit", "foo");
-        //assertThat(builderWithDef.warnings().size(), is(1));
     }
 
     @Test(expected=IllegalArgumentException.class)
     public void require_that_definition_is_passed_to_childstruct_but_invalid_field_will_throw() {
         ConfigPayloadBuilder nestedStruct = builderWithDef.getObject("mystruct");
         nestedStruct.setField("foofield", "invalid");
-        //assertThat(builderWithDef.warnings().size(), is(2));
     }
 
     @Test
     public void require_that_definition_is_passed_to_childarray() {
         ConfigPayloadBuilder.Array nestedArray = builderWithDef.getArray("myarray");
-        assertThat(builderWithDef.warnings().size(), is(0));
         nestedArray.append("1337");
-        assertThat(builderWithDef.warnings().size(), is(0));
     }
 
     @Test(expected=IllegalArgumentException.class)
     public void require_that_definition_is_passed_to_childarray_but_invalid_field_will_throw() {
         ConfigPayloadBuilder.Array nestedArray = builderWithDef.getArray("myarray");
         nestedArray.append("invalid");
-        //assertThat(builderWithDef.warnings().size(), is(1));
     }
 
     @Test
     public void require_that_definition_is_passed_to_inner_array_with_append() {
         ConfigPayloadBuilder.Array innerArray = builderWithDef.getArray("myinnerarray");
-        assertThat(builderWithDef.warnings().size(), is(0));
         ConfigPayloadBuilder innerStruct = innerArray.append();
         assertNotNull(innerStruct.getConfigDefinition());
-        assertThat(builderWithDef.warnings().size(), is(0));
         innerStruct.setField("foo", "1337");
-        assertThat(builderWithDef.warnings().size(), is(0));
     }
 
     @Test(expected=IllegalArgumentException.class)
     public void require_that_definition_is_passed_to_inner_array_with_append_but_invalid_field_will_throw() {
         ConfigPayloadBuilder.Array innerArray = builderWithDef.getArray("myinnerarray");
-        assertThat(builderWithDef.warnings().size(), is(0));
         ConfigPayloadBuilder innerStruct = innerArray.append();
         innerStruct.setField("foo", "invalid");
-        //assertThat(builderWithDef.warnings().size(), is(1));
     }
 
     @Test
     public void require_that_definition_is_passed_to_inner_array_with_index() {
         ConfigPayloadBuilder.Array innerArray = builderWithDef.getArray("myinnerarray");
-        assertThat(builderWithDef.warnings().size(), is(0));
         ConfigPayloadBuilder innerStruct = innerArray.set(1);
         assertNotNull(innerStruct.getConfigDefinition());
-        assertThat(builderWithDef.warnings().size(), is(0));
         innerStruct.setField("foo", "1337");
-        assertThat(builderWithDef.warnings().size(), is(0));
     }
 
     @Test(expected=IllegalArgumentException.class)
     public void require_that_definition_is_passed_to_inner_array_with_index_but_invalid_field_will_throw() {
         ConfigPayloadBuilder.Array innerArray = builderWithDef.getArray("myinnerarray");
-        assertThat(builderWithDef.warnings().size(), is(0));
         ConfigPayloadBuilder innerStruct = innerArray.set(1);
         innerStruct.setField("foo", "invalid");
-        //assertThat(builderWithDef.warnings().size(), is(1));
     }
+
 }
diff --git a/config/src/test/java/com/yahoo/vespa/config/util/ConfigUtilsTest.java b/config/src/test/java/com/yahoo/vespa/config/util/ConfigUtilsTest.java
index d080d04b29d..d5ddd5d4156 100644
--- a/config/src/test/java/com/yahoo/vespa/config/util/ConfigUtilsTest.java
+++ b/config/src/test/java/com/yahoo/vespa/config/util/ConfigUtilsTest.java
@@ -206,13 +206,8 @@ public class ConfigUtilsTest {
 
     @Test
     public void testGetConfigDefinitionKey() {
-        String input = "foo";
+        String input = "foo.bar";
         ConfigDefinitionKey def = ConfigUtils.getConfigDefinitionKeyFromString(input);
-        assertThat(def.getName(), is("foo"));
-        assertThat(def.getNamespace(), is(""));
-
-        input = "foo.bar";
-        def = ConfigUtils.getConfigDefinitionKeyFromString(input);
         assertThat(def.getName(), is("bar"));
         assertThat(def.getNamespace(), is("foo"));
 
@@ -225,23 +220,13 @@ public class ConfigUtilsTest {
         def = ConfigUtils.getConfigDefinitionKeyFromString(input);
         assertThat(def.getName(), is("qux"));
         assertThat(def.getNamespace(), is("foo.bar"));
-
-        input = "foo.2";
-        def = ConfigUtils.getConfigDefinitionKeyFromString(input);
-        assertThat(def.getName(), is("foo"));
-        assertThat(def.getNamespace(), is(""));
     }
 
     @Test
     public void testCreateConfigDefinitionKeyFromZKString() {
-        String input = "foo,1";
+        String input = "bar.foo,1";
         ConfigDefinitionKey def = ConfigUtils.createConfigDefinitionKeyFromZKString(input);
         assertThat(def.getName(), is("foo"));
-        assertThat(def.getNamespace(), is(""));
-
-        input = "bar.foo,1";
-        def = ConfigUtils.createConfigDefinitionKeyFromZKString(input);
-        assertThat(def.getName(), is("foo"));
         assertThat(def.getNamespace(), is("bar"));
     }