Use ValidationResult for models v2.0

Policy models uses PfValidationXxx classes which are totally unrelated
to ValidationResult in policy common.  This precludes the use of various
utility methods and annotations for doing validation.  Modified policy
models to use ValidationResult instead.
This approach uses function calls, though a future approach could make
use of annotations instead.

Issue-ID: POLICY-2648
Change-Id: I9760f1dc46902ab6bef7f440f3caf5e951660a5d
Signed-off-by: Jim Hahn <jrh3@att.com>

10 files changed, 403 insertions, 565 deletions

diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfConceptContainerTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfConceptContainerTest.java
index 062f6f953..8c74850d2 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/PfConceptContainerTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/PfConceptContainerTest.java
@@ -21,6 +21,7 @@
 
 package org.onap.policy.models.base;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -111,9 +112,7 @@ public class PfConceptContainerTest {
         container.clean();
         assertEquals(clonedContainer, container);
 
-        PfValidationResult result = new PfValidationResult();
-        result = container.validate(result);
-        assertTrue(result.isOk());
+        assertThat(container.validate("").getResult()).isNull();
 
         assertEquals(0, container.compareTo(clonedContainer));
 
@@ -136,30 +135,30 @@ public class PfConceptContainerTest {
 
         final DummyPfConceptContainer container3 = container;
         assertThatThrownBy(() -> container3.validate(null))
-            .hasMessageMatching("^resultIn is marked .*on.*ull but is null$");
+            .hasMessageMatching("^fieldName is marked .*on.*ull but is null$");
 
         DummyPfConceptContainer validateContainer = new DummyPfConceptContainer();
-        assertFalse(validateContainer.validate(new PfValidationResult()).isOk());
+        assertFalse(validateContainer.validate("").isValid());
         validateContainer.setKey(new PfConceptKey("VCKey", VERSION0_0_1));
-        assertTrue(validateContainer.validate(new PfValidationResult()).isOk());
+        assertTrue(validateContainer.validate("").isValid());
 
         validateContainer.getConceptMap().put(testConceptKey, new DummyPfConcept(testConceptKey));
-        assertTrue(validateContainer.validate(new PfValidationResult()).isOk());
+        assertTrue(validateContainer.validate("").isValid());
 
         validateContainer.getConceptMap().put(PfConceptKey.getNullKey(), new DummyPfConcept(PfConceptKey.getNullKey()));
-        assertFalse(validateContainer.validate(new PfValidationResult()).isOk());
+        assertFalse(validateContainer.validate("").isValid());
         validateContainer.getConceptMap().remove(PfConceptKey.getNullKey());
-        assertTrue(validateContainer.validate(new PfValidationResult()).isOk());
+        assertTrue(validateContainer.validate("").isValid());
 
         validateContainer.getConceptMap().put(testConceptKey, null);
-        assertFalse(validateContainer.validate(new PfValidationResult()).isOk());
+        assertFalse(validateContainer.validate("").isValid());
         validateContainer.getConceptMap().put(testConceptKey, new DummyPfConcept(testConceptKey));
-        assertTrue(validateContainer.validate(new PfValidationResult()).isOk());
+        assertTrue(validateContainer.validate("").isValid());
 
         validateContainer.getConceptMap().put(testConceptKey, new DummyPfConcept(conceptKey));
-        assertFalse(validateContainer.validate(new PfValidationResult()).isOk());
+        assertFalse(validateContainer.validate("").isValid());
         validateContainer.getConceptMap().put(testConceptKey, new DummyPfConcept(testConceptKey));
-        assertTrue(validateContainer.validate(new PfValidationResult()).isOk());
+        assertTrue(validateContainer.validate("").isValid());
 
         assertEquals(conceptKey, container.get(conceptKey).getKey());
         assertEquals(conceptKey, container.get(conceptKey.getName()).getKey());
diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfKeyImplTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfKeyImplTest.java
index 8b94a48c3..8d6b1b9f4 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/PfKeyImplTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/PfKeyImplTest.java
@@ -21,6 +21,7 @@
 
 package org.onap.policy.models.base;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
@@ -35,6 +36,7 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import org.junit.Test;
+import org.onap.policy.common.parameters.ValidationResult;
 import org.onap.policy.models.base.PfKey.Compatibility;
 import org.onap.policy.models.base.testconcepts.DummyPfKey;
 
@@ -109,20 +111,13 @@ public class PfKeyImplTest {
         assertFalse(someKey1.isCompatible(someKey5));
         assertFalse(someKey1.isCompatible(new DummyPfKey()));
 
-        assertEquals(PfValidationResult.ValidationResult.VALID,
-            someKey0.validate(new PfValidationResult()).getValidationResult());
-        assertEquals(PfValidationResult.ValidationResult.VALID,
-            someKey1.validate(new PfValidationResult()).getValidationResult());
-        assertEquals(PfValidationResult.ValidationResult.VALID,
-            someKey2.validate(new PfValidationResult()).getValidationResult());
-        assertEquals(PfValidationResult.ValidationResult.VALID,
-            someKey3.validate(new PfValidationResult()).getValidationResult());
-        assertEquals(PfValidationResult.ValidationResult.VALID,
-            someKey4.validate(new PfValidationResult()).getValidationResult());
-        assertEquals(PfValidationResult.ValidationResult.VALID,
-            someKey5.validate(new PfValidationResult()).getValidationResult());
-        assertEquals(PfValidationResult.ValidationResult.VALID,
-            someKey6.validate(new PfValidationResult()).getValidationResult());
+        assertTrue(someKey0.validate("").isValid());
+        assertTrue(someKey1.validate("").isValid());
+        assertTrue(someKey2.validate("").isValid());
+        assertTrue(someKey3.validate("").isValid());
+        assertTrue(someKey4.validate("").isValid());
+        assertTrue(someKey5.validate("").isValid());
+        assertTrue(someKey6.validate("").isValid());
 
         someKey0.clean();
         assertNotNull(someKey0.toString());
@@ -179,22 +174,20 @@ public class PfKeyImplTest {
         Field nameField = testKey.getClass().getDeclaredField("name");
         nameField.setAccessible(true);
         nameField.set(testKey, "Key Name");
-        PfValidationResult validationResult = new PfValidationResult();
-        testKey.validate(validationResult);
+        ValidationResult validationResult = testKey.validate("");
         nameField.set(testKey, "TheKey");
         nameField.setAccessible(false);
-        assertEquals("name invalid-parameter name with value Key Name " + "does not match regular expression "
-            + PfKey.NAME_REGEXP, validationResult.getMessageList().get(0).getMessage());
+        assertThat(validationResult.getResult()).contains("\"name\"").doesNotContain("\"version\"")
+            .contains("does not match regular expression " + PfKey.NAME_REGEXP);
 
         Field versionField = testKey.getClass().getDeclaredField("version");
         versionField.setAccessible(true);
         versionField.set(testKey, "Key Version");
-        PfValidationResult validationResult2 = new PfValidationResult();
-        testKey.validate(validationResult2);
+        ValidationResult validationResult2 = testKey.validate("");
         versionField.set(testKey, VERSION001);
         versionField.setAccessible(false);
-        assertEquals("version invalid-parameter version with value Key Version " + "does not match regular expression "
-            + PfKey.VERSION_REGEXP, validationResult2.getMessageList().get(0).getMessage());
+        assertThat(validationResult2.getResult()).doesNotContain("\"name\"").contains("\"version\"")
+            .contains("does not match regular expression " + PfKey.VERSION_REGEXP);
     }
 
     @Test
diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java
index f9ad889c7..d2aebdc43 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java
@@ -62,9 +62,7 @@ public class PfKeyUseTest {
         keyUse.clean();
         assertNotNull(keyUse);
 
-        PfValidationResult result = new PfValidationResult();
-        result = keyUse.validate(result);
-        assertNotNull(result);
+        assertNotNull(keyUse.validate(""));
 
         assertNotEquals(0, keyUse.hashCode());
 
@@ -84,8 +82,7 @@ public class PfKeyUseTest {
         assertEquals(0, keyUse.compareTo(new PfKeyUse(key)));
 
         PfKeyUse keyUseNull = new PfKeyUse(PfConceptKey.getNullKey());
-        PfValidationResult resultNull = new PfValidationResult();
-        assertEquals(false, keyUseNull.validate(resultNull).isValid());
+        assertEquals(false, keyUseNull.validate("").isValid());
 
         assertThatThrownBy(() -> keyUse.setKey(null)).hasMessageMatching("^key is marked .*on.*ull but is null$");
 
@@ -93,7 +90,8 @@ public class PfKeyUseTest {
 
         assertThatThrownBy(() -> keyUse.isCompatible(null)).hasMessageMatching(OTHER_KEY_IS_NULL);
 
-        assertThatThrownBy(() -> keyUse.validate(null)).hasMessageMatching("^result is marked .*on.*ull but is null$");
+        assertThatThrownBy(() -> keyUse.validate(null))
+                        .hasMessageMatching("^fieldName is marked .*on.*ull but is null$");
 
         PfKeyUse testKeyUse = new PfKeyUse(new DummyPfConceptKeySub(new PfConceptKey()));
         assertEquals(testKeyUse, new PfKeyUse(testKeyUse));
diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfModelTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfModelTest.java
index 9e4e350a1..760231a7c 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/PfModelTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/PfModelTest.java
@@ -73,59 +73,59 @@ public class PfModelTest {
     public void testPfModelValidation() {
         PfConceptKey dpmKey = new PfConceptKey("modelKey", VERSION001);
         DummyPfModel dpm = new DummyPfModel(dpmKey);
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
 
-        assertThatThrownBy(() -> dpm.validate(null)).hasMessageMatching("^resultIn is marked .*on.*ull but is null$");
+        assertThatThrownBy(() -> dpm.validate(null)).hasMessageMatching("^fieldName is marked .*on.*ull but is null$");
 
         dpm.setKey(PfConceptKey.getNullKey());
-        assertFalse(dpm.validate(new PfValidationResult()).isValid());
+        assertFalse(dpm.validate("").isValid());
         dpm.setKey(dpmKey);
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
 
         dpm.getKeyList().add(PfReferenceKey.getNullKey());
         dpm.getKeyList().add(new PfKeyUse(PfReferenceKey.getNullKey()));
-        assertFalse(dpm.validate(new PfValidationResult()).isValid());
+        assertFalse(dpm.validate("").isValid());
         dpm.getKeyList().clear();
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
 
         PfConceptKey goodCKey = new PfConceptKey("goodCKey", VERSION001);
         PfReferenceKey goodRKey = new PfReferenceKey(goodCKey, "goodLocalName");
 
         dpm.getKeyList().add(goodCKey);
         dpm.getKeyList().add(goodRKey);
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
 
         PfConceptKey goodCKeyDup = new PfConceptKey(goodCKey);
         dpm.getKeyList().add(goodCKeyDup);
-        assertFalse(dpm.validate(new PfValidationResult()).isValid());
+        assertFalse(dpm.validate("").isValid());
         dpm.getKeyList().remove(goodCKeyDup);
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
 
         PfReferenceKey goodRKeyDup = new PfReferenceKey(goodRKey);
         dpm.getKeyList().add(goodRKeyDup);
-        assertFalse(dpm.validate(new PfValidationResult()).isValid());
+        assertFalse(dpm.validate("").isValid());
         dpm.getKeyList().remove(goodRKeyDup);
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
 
         PfKeyUse goodCKeyUse = new PfKeyUse(goodCKey);
         dpm.getKeyList().add(goodCKeyUse);
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
 
         PfKeyUse goodRKeyUse = new PfKeyUse(goodRKey);
         dpm.getKeyList().add(goodRKeyUse);
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
 
         PfConceptKey badCKey = new PfConceptKey("badCKey", VERSION001);
         PfKeyUse badCKeyUse = new PfKeyUse(badCKey);
         dpm.getKeyList().add(badCKeyUse);
-        assertFalse(dpm.validate(new PfValidationResult()).isValid());
+        assertFalse(dpm.validate("").isValid());
         dpm.getKeyList().remove(badCKeyUse);
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
 
         PfKeyUse badRKeyUse = new PfKeyUse(new PfReferenceKey(badCKey, "badLocalName"));
         dpm.getKeyList().add(badRKeyUse);
-        assertFalse(dpm.validate(new PfValidationResult()).isValid());
+        assertFalse(dpm.validate("").isValid());
         dpm.getKeyList().remove(badRKeyUse);
-        assertTrue(dpm.validate(new PfValidationResult()).isValid());
+        assertTrue(dpm.validate("").isValid());
     }
 }
diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java
index a27a5ddea..de328e9f2 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java
@@ -21,6 +21,7 @@
 
 package org.onap.policy.models.base;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -30,6 +31,7 @@ import static org.junit.Assert.assertTrue;
 
 import java.lang.reflect.Field;
 import org.junit.Test;
+import org.onap.policy.common.parameters.ValidationResult;
 
 public class PfReferenceKeyTest {
 
@@ -93,9 +95,7 @@ public class PfReferenceKeyTest {
         assertEquals(PfKey.Compatibility.DIFFERENT, testReferenceKey.getCompatibility(PfReferenceKey.getNullKey()));
         assertEquals(PfKey.Compatibility.IDENTICAL, testReferenceKey.getCompatibility(testReferenceKey));
 
-        PfValidationResult result = new PfValidationResult();
-        result = testReferenceKey.validate(result);
-        assertEquals(PfValidationResult.ValidationResult.VALID, result.getValidationResult());
+        assertTrue(testReferenceKey.validate("").isValid());
 
         testReferenceKey.clean();
 
@@ -139,49 +139,37 @@ public class PfReferenceKeyTest {
         Field parentNameField = testReferenceKey.getClass().getDeclaredField("parentKeyName");
         parentNameField.setAccessible(true);
         parentNameField.set(testReferenceKey, "Parent Name");
-        PfValidationResult validationResult = new PfValidationResult();
-        testReferenceKey.validate(validationResult);
+        ValidationResult validationResult = testReferenceKey.validate("");
         parentNameField.set(testReferenceKey, "ParentName");
         parentNameField.setAccessible(false);
-        assertEquals(
-            "parentKeyName invalid-parameter parentKeyName with value Parent Name "
-                + "does not match regular expression " + PfKey.NAME_REGEXP,
-            validationResult.getMessageList().get(0).getMessage());
+        assertThat(validationResult.getResult()).contains("\"parentKeyName\"")
+                        .contains("does not match regular expression " + PfKey.NAME_REGEXP);
 
         Field parentVersionField = testReferenceKey.getClass().getDeclaredField("parentKeyVersion");
         parentVersionField.setAccessible(true);
         parentVersionField.set(testReferenceKey, "Parent Version");
-        PfValidationResult validationResult2 = new PfValidationResult();
-        testReferenceKey.validate(validationResult2);
+        ValidationResult validationResult2 = testReferenceKey.validate("");
         parentVersionField.set(testReferenceKey, VERSION001);
         parentVersionField.setAccessible(false);
-        assertEquals(
-            "parentKeyVersion invalid-parameter parentKeyVersion with value Parent Version "
-                + "does not match regular expression " + PfKey.VERSION_REGEXP,
-            validationResult2.getMessageList().get(0).getMessage());
+        assertThat(validationResult2.getResult()).contains("\"parentKeyVersion\"")
+            .contains("does not match regular expression " + PfKey.VERSION_REGEXP);
 
         Field parentLocalNameField = testReferenceKey.getClass().getDeclaredField("parentLocalName");
         parentLocalNameField.setAccessible(true);
         parentLocalNameField.set(testReferenceKey, "Parent Local Name");
-        PfValidationResult validationResult3 = new PfValidationResult();
-        testReferenceKey.validate(validationResult3);
+        ValidationResult validationResult3 = testReferenceKey.validate("");
         parentLocalNameField.set(testReferenceKey, PARENT_LOCAL_NAME);
         parentLocalNameField.setAccessible(false);
-        assertEquals(
-            "parentLocalName invalid-parameter parentLocalName with value "
-                + "Parent Local Name does not match regular expression [A-Za-z0-9\\-_\\.]+|^$",
-            validationResult3.getMessageList().get(0).getMessage());
+        assertThat(validationResult3.getResult()).contains("\"parentLocalName\"")
+            .contains("does not match regular expression [A-Za-z0-9\\-_\\.]+|^$");
 
         Field localNameField = testReferenceKey.getClass().getDeclaredField("localName");
         localNameField.setAccessible(true);
         localNameField.set(testReferenceKey, "Local Name");
-        PfValidationResult validationResult4 = new PfValidationResult();
-        testReferenceKey.validate(validationResult4);
+        ValidationResult validationResult4 = testReferenceKey.validate("");
         localNameField.set(testReferenceKey, LOCAL_NAME);
         localNameField.setAccessible(false);
-        assertEquals(
-            "localName invalid-parameter localName with value Local Name "
-                + "does not match regular expression [A-Za-z0-9\\-_\\.]+|^$",
-            validationResult4.getMessageList().get(0).getMessage());
+        assertThat(validationResult4.getResult()).contains("\"localName\"")
+        .contains("does not match regular expression [A-Za-z0-9\\-_\\.]+|^$");
     }
 }
diff --git a/models-base/src/test/java/org/onap/policy/models/base/ValidatedTest.java b/models-base/src/test/java/org/onap/policy/models/base/ValidatedTest.java
index 5d1367028..8534d82a6 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/ValidatedTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/ValidatedTest.java
@@ -1,9 +1,8 @@
-/*
+/*-
  * ============LICENSE_START=======================================================
- * ONAP Policy Models
+ * ONAP
  * ================================================================================
- * Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
- * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
  * ================================================================================
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,424 +20,426 @@
 
 package org.onap.policy.models.base;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.junit.Before;
+import java.util.function.BiFunction;
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
 import org.junit.Test;
+import org.onap.policy.common.parameters.BeanValidationResult;
+import org.onap.policy.common.parameters.ObjectValidationResult;
+import org.onap.policy.common.parameters.ValidationResult;
+import org.onap.policy.common.parameters.ValidationStatus;
+import org.onap.policy.common.utils.coder.CoderException;
+import org.onap.policy.common.utils.coder.StandardCoder;
 
 public class ValidatedTest {
-    private static final String COLLECTION_TEXT = "collection";
-    private static final String ERROR_MESSAGE = "error message";
-    private static final String COLLECTION_FIELD = "coll";
-    private static final String VALID_VALUE = "abc123";
-    private static final String PROPS_FIELD = "props";
-    private static final String MY_NAME = "my.name";
-    private static final String VALID_FIELD = "validField";
-    private static final String INVALID_FIELD = "invalidField";
-    private static final String NULL_FIELD = "nullField";
-    private static final String WORD_PAT = "\\w*";
-    private static final String MY_TO_STRING = "[some text]";
-    private static final String VERSION = "1.2.3";
-
-    private Validated validated;
-
-    @Before
-    public void setUp() {
-        validated = new Validated();
+    private static final @NonNull String MY_FIELD = "myField";
+    private static final @NonNull String Q_KEY = "\"" + Validated.KEY_TOKEN + "\"";
+    private static final @NonNull String Q_VALUE = "\"" + Validated.VALUE_TOKEN + "\"";
+    private static final String NOT_SAME = "not same";
+    private static final String TEXT = "some text";
+    private static final String OTHER = "other text";
+    private static final String NAME = "myKey";
+    private static final String VERSION = "1.0.0";
+    private static final String BLANKS = "\t \n";
+
+    @Test
+    public void testAddResult() {
+        BeanValidationResult result = new BeanValidationResult("", this);
+        Validated.addResult(result, MY_FIELD, TEXT, "some message");
+        assertThat(result.getResult()).contains(MY_FIELD).contains(TEXT).contains("some message");
+
+        assertThatThrownBy(() -> Validated.addResult(null, MY_FIELD, TEXT, OTHER))
+                        .isInstanceOf(NullPointerException.class);
+
+        assertThatThrownBy(() -> Validated.addResult(result, null, TEXT, OTHER))
+                        .isInstanceOf(NullPointerException.class);
+
+        assertThatCode(() -> Validated.addResult(result, MY_FIELD, null, OTHER)).doesNotThrowAnyException();
+
+        assertThatThrownBy(() -> Validated.addResult(result, MY_FIELD, TEXT, null))
+                        .isInstanceOf(NullPointerException.class);
     }
 
     @Test
-    public void testValidate() {
-        assertThatThrownBy(() -> validated.validate(null)).isInstanceOf(NullPointerException.class);
+    public void testMakeNullResult() {
+        ValidationResult rnull = Validated.makeNullResult(MY_FIELD, TEXT);
+        assertEquals(MY_FIELD, rnull.getName());
+        assertThat(rnull.getResult()).contains(MY_FIELD).contains(TEXT).contains(Validated.IS_NULL);
+        assertFalse(rnull.isValid());
+
+        assertThatThrownBy(() -> Validated.makeNullResult(null, TEXT)).isInstanceOf(NullPointerException.class);
 
-        PfValidationResult result = new PfValidationResult();
-        assertSame(result, validated.validate(result));
-        assertTrue(result.isValid());
-        assertEquals(0, result.getMessageList().size());
+        assertThatCode(() -> Validated.makeNullResult(MY_FIELD, null)).doesNotThrowAnyException();
     }
 
     @Test
-    public void testValidateNotNull() {
-        PfValidationResult result = new PfValidationResult();
+    public void testValidateOptional() {
+        BeanValidationResult result = new BeanValidationResult("", this);
+        Validated.validateOptional(result, MY_FIELD, null);
+        assertTrue(result.isClean());
 
-        final PfValidationResult result2 = result;
-        assertThatThrownBy(() -> validated.validateNotNull(null, VALID_FIELD, VALID_VALUE, result2))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateNotNull(this, null, VALID_VALUE, result2))
+        Validated.validateOptional(result, MY_FIELD, new MyString(TEXT));
+        assertTrue(result.isClean());
+
+        Validated.validateOptional(result, MY_FIELD, new MyString(OTHER));
+        assertThat(result.getResult()).contains(MY_FIELD).contains(OTHER).contains(NOT_SAME);
+
+        assertThatThrownBy(() -> Validated.validateOptional(null, MY_FIELD, new MyString(TEXT)))
                         .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateNotNull(this, VALID_FIELD, VALID_VALUE, null))
+
+        assertThatThrownBy(() -> Validated.validateOptional(result, null, new MyString(TEXT)))
                         .isInstanceOf(NullPointerException.class);
 
-        // null text
-        result = validated.validateNotNull(this, NULL_FIELD, null, result);
+        assertThatCode(() -> Validated.validateOptional(result, MY_FIELD, null)).doesNotThrowAnyException();
+    }
+
+    @Test
+    public void testValidateNotNull() {
+        assertThat(Validated.validateNotNull(MY_FIELD, TEXT)).isNull();
 
-        // invalid text
-        result = validated.validateNotNull(this, INVALID_FIELD, "!!!", result);
+        assertThat(Validated.validateNotNull(MY_FIELD, null).getResult()).contains(MY_FIELD)
+                        .contains(Validated.IS_NULL);
 
-        // valid text
-        result = validated.validateNotNull(this, VALID_FIELD, VALID_VALUE, result);
+        // should invoke the value's validate() method, which should return success
+        assertThat(Validated.validateNotNull(MY_FIELD, new MyString(TEXT))).isNull();
 
-        // different value
-        result = validated.validateNotNull(this, VALID_FIELD, Integer.valueOf(10), result);
+        // should invoke the value's validate() method, which should return failure
+        assertThat(Validated.validateNotNull(MY_FIELD, new MyString(OTHER)).getResult()).contains(MY_FIELD)
+                        .contains(NOT_SAME);
 
-        assertFalse(result.isValid());
-        assertEquals(1, result.getMessageList().size());
+        assertThatThrownBy(() -> Validated.validateNotNull(null, TEXT)).isInstanceOf(NullPointerException.class);
 
-        // check result for null text
-        PfValidationMessage msg = result.getMessageList().get(0);
-        assertEquals(ValidatedTest.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("nullField invalid-null"));
+        assertThatCode(() -> Validated.validateNotNull(MY_FIELD, null)).doesNotThrowAnyException();
     }
 
     @Test
-    public void testValidateNotNullConceptKey() {
-        PfValidationResult result = new PfValidationResult();
-
-        // null key
-        PfConceptKey key = new PfConceptKey();
-        key.setVersion(VERSION);
-        result = validated.validateNotNull(key, result);
-
-        // null value
-        key = new PfConceptKey();
-        key.setName(MY_NAME);
-        result = validated.validateNotNull(key, result);
-
-        // both null
-        key = new PfConceptKey();
-        result = validated.validateNotNull(key, result);
-
-        assertFalse(result.isValid());
-        assertEquals(4, result.getMessageList().size());
-
-        // valid key & value
-        key = new PfConceptKey();
-        key.setName(MY_NAME);
-        key.setVersion(VERSION);
-        result = validated.validateNotNull(key, result);
-
-        // no change
-        assertFalse(result.isValid());
-        assertEquals(4, result.getMessageList().size());
-
-        Iterator<PfValidationMessage> it = result.getMessageList().iterator();
-
-        // check null key
-        PfValidationMessage msg = it.next();
-        assertEquals(PfConceptKey.class.getName(), msg.getObservedClass());
-        assertTrue(msg.getMessage().contains("name invalid-null"));
-
-        // check null value
-        msg = it.next();
-        assertEquals(PfConceptKey.class.getName(), msg.getObservedClass());
-        assertTrue(msg.getMessage().contains("version invalid-null"));
-
-        // check both null
-        msg = it.next();
-        assertEquals(PfConceptKey.class.getName(), msg.getObservedClass());
-        assertTrue(msg.getMessage().contains("name invalid-null"));
-        assertTrue(it.next().getMessage().contains("version invalid-null"));
-
-        PfValidationResult pfValidationResult = new PfValidationResult();
-        final PfConceptKey key2 = key;
-        assertThatThrownBy(() -> validated.validateNotNull(key2, null)).isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateNotNull(null, pfValidationResult))
+    public void testValidateNotBlank() {
+        assertThat(Validated.validateNotBlank(MY_FIELD, TEXT, false)).isNull();
+        assertThat(Validated.validateNotBlank(MY_FIELD, TEXT, true)).isNull();
+
+        assertThat(Validated.validateNotBlank(MY_FIELD, null, false)).isNull();
+        assertThat(Validated.validateNotBlank(MY_FIELD, null, true).getResult()).contains(MY_FIELD)
+                        .contains(Validated.IS_BLANK);
+
+        assertThat(Validated.validateNotBlank(MY_FIELD, "", false).getResult()).contains(MY_FIELD)
+                        .contains(Validated.IS_BLANK);
+        assertThat(Validated.validateNotBlank(MY_FIELD, "", true).getResult()).contains(MY_FIELD)
+                        .contains(Validated.IS_BLANK);
+
+        assertThatThrownBy(() -> Validated.validateNotBlank(null, TEXT, false))
                         .isInstanceOf(NullPointerException.class);
+
+        assertThatCode(() -> Validated.validateNotBlank(MY_FIELD, null, false)).doesNotThrowAnyException();
     }
 
     @Test
-    public void testValidateText() {
-        PfValidationResult result = new PfValidationResult();
+    public void testValidateRegex() {
+        assertThat(Validated.validateRegex(MY_FIELD, "hello", ".*ll.*")).isNull();
 
-        final PfValidationResult result2 = result;
-        assertThatThrownBy(() -> validated.validateText(null, VALID_FIELD, VALID_VALUE, WORD_PAT, result2))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateText(this, null, VALID_VALUE, WORD_PAT, result2))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateText(this, VALID_FIELD, VALID_VALUE, null, result2))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateText(this, VALID_FIELD, VALID_VALUE, WORD_PAT, null))
-                        .isInstanceOf(NullPointerException.class);
+        assertThat(Validated.validateRegex(MY_FIELD, "hello", "[x-z]").getResult()).contains(MY_FIELD).contains("hello")
+                        .contains("does not match regular expression [x-z]");
 
-        // null text
-        result = validated.validateText(this, NULL_FIELD, null, WORD_PAT, result);
+        assertThatThrownBy(() -> Validated.validateRegex(null, "hello", "ll")).isInstanceOf(NullPointerException.class);
 
-        // invalid text
-        result = validated.validateText(this, INVALID_FIELD, "!!!", WORD_PAT, result);
+        assertThatCode(() -> Validated.validateRegex(MY_FIELD, null, "ll")).doesNotThrowAnyException();
 
-        // valid text
-        result = validated.validateText(this, VALID_FIELD, VALID_VALUE, WORD_PAT, result);
+        assertThatThrownBy(() -> Validated.validateRegex(MY_FIELD, "hello", null))
+                        .isInstanceOf(NullPointerException.class);
+    }
 
-        assertFalse(result.isValid());
-        assertEquals(1, result.getMessageList().size());
+    @Test
+    public void testValidateKeyNotNull() throws CoderException {
+        assertThat(Validated.validateKeyNotNull(MY_FIELD, new PfConceptKey(NAME, VERSION)).getResult()).isNull();
+        assertThat(Validated.validateKeyNotNull(MY_FIELD, new PfConceptKey(NAME, PfConceptKey.NULL_KEY_VERSION))
+                        .getResult()).isNull();
+        assertThat(Validated.validateKeyNotNull(MY_FIELD, new PfConceptKey(PfConceptKey.NULL_KEY_NAME, VERSION))
+                        .getResult()).isNull();
+
+        // key is null
+        assertThat(Validated.validateKeyNotNull(MY_FIELD, new PfConceptKey()).getResult()).contains(MY_FIELD)
+                        .doesNotContain("\"name\"").doesNotContain("\"version\"").contains(Validated.IS_A_NULL_KEY);
+
+        /*
+         * Key is not null, but key.validate() should fail due to an invalid version.
+         * Note: have to create the key by decoding from json, as the class will prevent
+         * an invalid version from being assigned.
+         */
+        PfConceptKey key = new StandardCoder().decode("{'name':'myKey','version':'bogus'}".replace('\'', '"'),
+                        PfConceptKey.class);
+        assertThat(Validated.validateKeyNotNull(MY_FIELD, key).getResult()).contains(MY_FIELD).contains("version")
+                        .contains("does not match regular expression");
+
+        // null parameter tests
+        assertThatThrownBy(() -> Validated.validateKeyNotNull(null, new PfConceptKey()))
+                        .isInstanceOf(NullPointerException.class);
 
-        // check result for invalid text
-        PfValidationMessage msg = result.getMessageList().get(0);
-        assertEquals(ValidatedTest.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("invalidField invalid-parameter invalidField"));
+        assertThatCode(() -> Validated.validateKeyNotNull(MY_FIELD, null)).doesNotThrowAnyException();
     }
 
     @Test
-    public void testValidatePropertiesNotNull() {
-        PfValidationResult result = new PfValidationResult();
-        result = validated.validatePropertiesNotNull(this, "properties", null, result);
-        assertTrue(result.isValid());
-        assertEquals(0, result.getMessageList().size());
+    public void testValidateKeyVersionNotNull() {
+        assertThat(Validated.validateKeyVersionNotNull(MY_FIELD, null)).isNull();
 
-        Map<String, Integer> map = new LinkedHashMap<>();
+        assertThat(Validated.validateKeyVersionNotNull(MY_FIELD, new PfConceptKey(NAME, VERSION))).isNull();
 
-        // null key
-        map.put(null, 10);
+        assertThat(Validated.validateKeyVersionNotNull(MY_FIELD, new PfConceptKey(NAME, PfConceptKey.NULL_KEY_VERSION))
+                        .getResult()).contains(MY_FIELD).contains("version").contains(Validated.IS_NULL);
 
-        // null value
-        map.put("abc", null);
+        assertThatThrownBy(() -> Validated.validateKeyVersionNotNull(null, new PfConceptKey()))
+                        .isInstanceOf(NullPointerException.class);
 
-        // valid key & value
-        map.put("def", 11);
+        assertThatCode(() -> Validated.validateKeyVersionNotNull(MY_FIELD, null)).doesNotThrowAnyException();
+    }
 
+    @Test
+    public void testValidateMinIntIntegerBoolean_testValidateMinStringIntegerIntIntegerBoolean() {
+        /*
+         * No "special" value, don't check the reference.
+         */
+        BiFunction<String, Integer, ValidationResult> func = Validated.validateMin(10, null, false);
+        assertThat(func.apply(MY_FIELD, null)).isNull();
 
-        result = validated.validatePropertiesNotNull(this, PROPS_FIELD, map, result);
+        // exact match
+        assertThat(func.apply(MY_FIELD, 10)).isNull();
 
-        assertFalse(result.isValid());
-        assertEquals(2, result.getMessageList().size());
+        assertThat(func.apply(MY_FIELD, 20)).isNull();
 
-        Iterator<PfValidationMessage> it = result.getMessageList().iterator();
+        assertThat(func.apply(MY_FIELD, 9).getResult()).contains(MY_FIELD).contains("9")
+                        .contains("is below the minimum value: 10");
 
-        // check null key
-        PfValidationMessage msg = it.next();
-        assertEquals(ValidatedTest.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("props.null invalid-null"));
+        /*
+         * "special" value, don't check the reference.
+         */
+        func = Validated.validateMin(10, 7, false);
+        assertThat(func.apply(MY_FIELD, null)).isNull();
 
-        // check null value
-        msg = it.next();
-        assertEquals(ValidatedTest.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("props.abc invalid-null"));
+        // exact match
+        assertThat(func.apply(MY_FIELD, 10)).isNull();
 
-        final PfValidationResult result2 = result;
-        assertThatThrownBy(() -> validated.validatePropertiesNotNull(null, PROPS_FIELD, map, result2))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validatePropertiesNotNull(this, null, map, result2))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validatePropertiesNotNull(this, PROPS_FIELD, map, null))
-                        .isInstanceOf(NullPointerException.class);
-    }
+        assertThat(func.apply(MY_FIELD, 20)).isNull();
 
-    @Test
-    public void testValidateCollectionNotNull() {
-        PfValidationResult result = new PfValidationResult();
-        result = validated.validateCollectionNotNull(this, COLLECTION_TEXT, null, result);
-        assertTrue(result.isValid());
-        assertEquals(0, result.getMessageList().size());
+        // special value - should be ok
+        assertThat(func.apply(MY_FIELD, 7)).isNull();
 
-        final List<String> lst = Arrays.asList("abc", null, "def", null);
+        assertThat(func.apply(MY_FIELD, 9).getResult()).contains(MY_FIELD).contains("9")
+                        .contains("is below the minimum value: 10");
 
-        result = validated.validateCollectionNotNull(this, COLLECTION_FIELD, lst, result);
+        /*
+         * Check the reference (i.e., generate an error if the value is null).
+         */
+        func = Validated.validateMin(10, null, true);
+        assertThat(func.apply(MY_FIELD, null).getResult()).contains(MY_FIELD).contains(Validated.IS_NULL);
 
-        assertFalse(result.isValid());
-        assertEquals(2, result.getMessageList().size());
+        // exact match
+        assertThat(func.apply(MY_FIELD, 10)).isNull();
 
-        Iterator<PfValidationMessage> it = result.getMessageList().iterator();
+        assertThat(func.apply(MY_FIELD, 20)).isNull();
 
-        // check first item
-        PfValidationMessage msg = it.next();
-        assertEquals(ValidatedTest.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("coll.1 invalid-null"));
+        assertThat(func.apply(MY_FIELD, 9).getResult()).contains(MY_FIELD).contains("9")
+                        .contains("is below the minimum value: 10");
 
-        // check null value
-        msg = it.next();
-        assertEquals(ValidatedTest.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("coll.3 invalid-null"));
 
-        final PfValidationResult result2 = result;
-        assertThatThrownBy(() -> validated.validateCollectionNotNull(null, COLLECTION_FIELD, lst, result2))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateCollectionNotNull(this, null, lst, result2))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateCollectionNotNull(this, COLLECTION_FIELD, lst, null))
-                        .isInstanceOf(NullPointerException.class);
+        BiFunction<String, Integer, ValidationResult> func2 = func;
+        assertThatThrownBy(() -> func2.apply(null, 30)).isInstanceOf(NullPointerException.class);
+
+        assertThatCode(() -> func2.apply(MY_FIELD, null)).doesNotThrowAnyException();
     }
 
     @Test
-    public void testValidateCollection() {
-        PfValidationResult result = new PfValidationResult();
-        result = validated.validateCollection(this, COLLECTION_TEXT, null, result);
-        assertTrue(result.isValid());
-        assertEquals(0, result.getMessageList().size());
-
-        List<MyValid> lst = Arrays.asList(new MyValid(0, false), new MyValid(1, true), null, new MyValid(2, false),
-                        new MyValid(3, true));
-        result = validated.validateCollection(this, COLLECTION_FIELD, lst, result);
-
-        assertFalse(result.isValid());
-        assertEquals(2, result.getMessageList().size());
-
-        Iterator<PfValidationMessage> it = result.getMessageList().iterator();
-
-        // check first item
-        PfValidationMessage msg = it.next();
-        assertEquals(MyValid.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("index.0 invalid-wrong value"));
-
-        // check null value
-        msg = it.next();
-        assertEquals(MyValid.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("index.2 invalid-wrong value"));
-
-        final PfValidationResult result2 = result;
-        assertThatThrownBy(() -> validated.validateCollection(null, COLLECTION_FIELD, lst, result2))
+    public void testValidateList() {
+        BeanValidationResult result = new BeanValidationResult("", this);
+        Validated.validateList(result, MY_FIELD, null, Validated::validateNotNull);
+        assertThat(result.getResult()).isNull();
+
+        result = new BeanValidationResult("", this);
+        Validated.validateList(result, MY_FIELD, List.of(TEXT, OTHER), Validated::validateNotNull);
+        assertThat(result.getResult()).isNull();
+
+        List<String> list = new ArrayList<>();
+        list.add(TEXT);
+        list.add(null);
+        list.add(OTHER);
+        list.add(null);
+        result = new BeanValidationResult("", this);
+        Validated.validateList(result, MY_FIELD, list, Validated::validateNotNull);
+        assertThat(result.getResult()).doesNotContain("0").contains("1").doesNotContain("2").contains("3")
+                        .contains(Validated.IS_NULL);
+
+        BeanValidationResult result2 = result;
+        assertThatThrownBy(() -> Validated.validateList(null, MY_FIELD, List.of(), Validated::validateNotNull))
                         .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateCollection(this, null, lst, result2))
+
+        assertThatThrownBy(() -> Validated.validateList(result2, null, List.of(), Validated::validateNotNull))
                         .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateCollection(this, COLLECTION_FIELD, lst, null))
+
+        assertThatCode(() -> Validated.validateList(result2, MY_FIELD, null, Validated::validateNotNull))
+                        .doesNotThrowAnyException();
+
+        assertThatThrownBy(() -> Validated.validateList(result2, MY_FIELD, List.of(), null))
                         .isInstanceOf(NullPointerException.class);
     }
 
     @Test
-    public void testValidateConceptCollection() {
-        PfValidationResult result = new PfValidationResult();
-        result = validated.validateConceptCollection(this, COLLECTION_TEXT, null, result);
-        assertTrue(result.isValid());
-        assertEquals(0, result.getMessageList().size());
-
-        List<MyConcept> lst = Arrays.asList(new MyConcept(0, false), new MyConcept(1, true), null,
-                        new MyConcept(2, false), new MyConcept(3, true));
-        result = validated.validateConceptCollection(this, COLLECTION_FIELD, lst, result);
-
-        assertFalse(result.isValid());
-        assertEquals(2, result.getMessageList().size());
-
-        Iterator<PfValidationMessage> it = result.getMessageList().iterator();
-
-        // check first item
-        PfValidationMessage msg = it.next();
-        assertEquals(MyConcept.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("index.0 invalid-wrong value"));
-
-        // check null value
-        msg = it.next();
-        assertEquals(MyConcept.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("index.2 invalid-wrong value"));
-
-        final PfValidationResult result2 = result;
-        assertThatThrownBy(() -> validated.validateConceptCollection(null, COLLECTION_FIELD, lst, result2))
+    public void testValidateMap() {
+        BeanValidationResult result = new BeanValidationResult("", this);
+        Validated.validateMap(result, MY_FIELD, null, Validated::validateEntryNotBlankNotBlank);
+        assertThat(result.getResult()).isNull();
+
+        result = new BeanValidationResult("", this);
+        Validated.validateMap(result, MY_FIELD, Map.of("abc", TEXT, "def", OTHER),
+                        Validated::validateEntryNotBlankNotBlank);
+        assertThat(result.getResult()).isNull();
+
+        // invalid values
+        Map<String, String> map = new HashMap<>();
+        map.put("ghi", TEXT);
+        map.put("jkl", "");
+        map.put("mno", OTHER);
+        map.put("pqr", "");
+        result = new BeanValidationResult("", this);
+        Validated.validateMap(result, MY_FIELD, map, Validated::validateEntryNotBlankNotBlank);
+        assertThat(result.getResult()).doesNotContain("abc").contains("jkl").doesNotContain("mno").contains("pqr")
+                        .contains(Q_VALUE).doesNotContain(Q_KEY).contains(Validated.IS_BLANK);
+
+        // invalid keys
+        map = new HashMap<>();
+        map.put("stu", TEXT);
+        map.put("", TEXT);
+        map.put("vwx", OTHER);
+        map.put(null, OTHER);
+        result = new BeanValidationResult("", this);
+        Validated.validateMap(result, MY_FIELD, map, Validated::validateEntryNotBlankNotBlank);
+        assertThat(result.getResult()).doesNotContain("stu").contains("\"\"").doesNotContain("vwx").contains("null")
+                        .contains(Q_KEY).doesNotContain(Q_VALUE).contains(Validated.IS_BLANK);
+
+        BeanValidationResult result2 = result;
+        Map<String, String> map2 = map;
+        assertThatThrownBy(() -> Validated.validateMap(null, MY_FIELD, map2, Validated::validateEntryNotBlankNotBlank))
                         .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateConceptCollection(this, null, lst, result2))
+
+        assertThatThrownBy(() -> Validated.validateMap(result2, null, map2, Validated::validateEntryNotBlankNotBlank))
                         .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.validateConceptCollection(this, COLLECTION_FIELD, lst, null))
+
+        assertThatCode(() -> Validated.validateMap(result2, MY_FIELD, null, Validated::validateEntryNotBlankNotBlank))
+                        .doesNotThrowAnyException();
+
+        assertThatThrownBy(() -> Validated.validateMap(result2, MY_FIELD, map2, null))
                         .isInstanceOf(NullPointerException.class);
     }
 
     @Test
-    public void testAddError() {
-        final PfValidationResult result = new PfValidationResult();
-        final PfValidationResult result2 = result;
+    public void testValidateEntryNotBlankNotBlank() {
+        assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(TEXT, OTHER))).isNull();
 
-        assertThatThrownBy(() -> validated.addError(null, VALID_FIELD, result2, ERROR_MESSAGE))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.addError(this, null, result2, ERROR_MESSAGE))
-                        .isInstanceOf(NullPointerException.class);
-        assertThatThrownBy(() -> validated.addError(this, VALID_FIELD, null, ERROR_MESSAGE))
-                        .isInstanceOf(NullPointerException.class);
-
-        validated.addError(this, VALID_FIELD, result, "error-A");
-        validated.addError(this, VALID_FIELD, result, null);
-        validated.addError(this, VALID_FIELD, result, "error-B");
+        // try invalid values for the key
+        assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(null, OTHER)).getResult()).contains(Q_KEY)
+                        .contains(Validated.IS_BLANK).doesNotContain(Q_VALUE);
 
-        assertFalse(result.isValid());
-        assertEquals(2, result.getMessageList().size());
+        assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(BLANKS, OTHER)).getResult()).contains(Q_KEY)
+                        .contains(Validated.IS_BLANK).doesNotContain(Q_VALUE);
 
-        Iterator<PfValidationMessage> it = result.getMessageList().iterator();
+        // try invalid values for the value
+        assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(TEXT, null)).getResult()).contains(Q_VALUE)
+                        .contains(Validated.IS_BLANK).doesNotContain(Q_KEY);
 
-        PfValidationMessage msg = it.next();
-        assertEquals(ValidatedTest.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("validField invalid-error-A"));
+        assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(TEXT, BLANKS)).getResult()).contains(Q_VALUE)
+                        .contains(Validated.IS_BLANK).doesNotContain(Q_KEY);
 
-        msg = it.next();
-        assertEquals(ValidatedTest.class.getName(), msg.getObservedClass());
-        assertEquals(MY_TO_STRING, msg.getObservedKey().toString());
-        assertTrue(msg.getMessage().contains("validField invalid-error-B"));
+        // both invalid
+        assertThat(Validated.validateEntryNotBlankNotBlank(makeEntry(BLANKS, BLANKS)).getResult()).contains(Q_KEY)
+                        .contains(Q_VALUE);
     }
 
     @Test
-    public void testMakeKey() {
-        assertThatThrownBy(() -> validated.makeKey(null)).isInstanceOf(NullPointerException.class);
+    public void testValidateEntryNotBlankNotNull() {
+        assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(TEXT, OTHER))).isNull();
 
-        PfKey key = validated.makeKey(this);
-        assertEquals(MY_TO_STRING, key.toString());
-    }
+        // try invalid values for the key
+        assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(null, OTHER)).getResult()).contains(Q_KEY)
+                        .contains(Validated.IS_BLANK).doesNotContain(Q_VALUE);
+
+        assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(BLANKS, OTHER)).getResult()).contains(Q_KEY)
+                        .contains(Validated.IS_BLANK).doesNotContain(Q_VALUE);
 
-    @Override
-    public String toString() {
-        return MY_TO_STRING;
+        // try invalid values for the value
+        assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(TEXT, null)).getResult()).contains(Q_VALUE)
+                        .contains(Validated.IS_NULL).doesNotContain(Q_KEY);
+
+        // blanks should have no impact for the value
+        assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(TEXT, BLANKS))).isNull();
+
+        // both invalid
+        assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(BLANKS, null)).getResult()).contains(Q_KEY)
+                        .contains(Q_VALUE);
     }
 
-    private static class MyValid extends Validated {
-        private boolean valid;
-        private int index;
+    @Test
+    public void testValidateEntryValueNotNull() {
+        assertThat(Validated.validateEntryValueNotNull(makeEntry(TEXT, OTHER))).isNull();
 
-        public MyValid(int index, boolean valid) {
-            this.index = index;
-            this.valid = valid;
-        }
+        // blanks should have no impact
+        assertThat(Validated.validateEntryValueNotNull(makeEntry(BLANKS, OTHER))).isNull();
+        assertThat(Validated.validateEntryNotBlankNotNull(makeEntry(TEXT, BLANKS))).isNull();
 
-        @Override
-        public PfValidationResult validate(PfValidationResult result) {
-            if (!valid) {
-                this.addError(this, "index." + index, result, "wrong value");
-            }
+        assertThat(Validated.validateEntryValueNotNull(makeEntry(null, OTHER)).getResult()).contains(Q_KEY)
+                        .contains(Validated.IS_NULL).doesNotContain(Q_VALUE);
 
-            return result;
-        }
+        assertThat(Validated.validateEntryValueNotNull(makeEntry(TEXT, null)).getResult()).contains(Q_VALUE)
+                        .contains(Validated.IS_NULL).doesNotContain(Q_KEY);
 
-        @Override
-        public String toString() {
-            return MY_TO_STRING;
-        }
+        // should invoke the value's validate() method, which should return success
+        assertThat(Validated.validateEntryValueNotNull(makeEntry(TEXT, new MyString(TEXT)))).isNull();
+
+        // should invoke the value's validate() method, which should return failure
+        assertThat(Validated.validateEntryValueNotNull(makeEntry(TEXT, new MyString(OTHER))).getResult())
+                        .contains(Q_VALUE).contains(NOT_SAME).doesNotContain(Q_KEY);
+
+        // both invalid
+        assertThat(Validated.validateEntryValueNotNull(makeEntry(null, null)).getResult()).contains(Q_KEY)
+                        .contains(Q_VALUE);
     }
 
-    private static class MyConcept extends PfConceptKey {
-        private static final long serialVersionUID = 1L;
+    @Test
+    public void testGetKeyId() {
+        // not a key field - should just use the given value
+        BeanValidationResult result = new BeanValidationResult("", this);
+        Validated.addResult(result, MY_FIELD, TEXT, "some message");
+        assertThat(result.getResult()).contains(MY_FIELD).contains(TEXT).contains("some message");
+
+        // repeat with a key field - should use the key's ID
+        result = new BeanValidationResult("", this);
+        Validated.addResult(result, MY_FIELD, new PfConceptKey(NAME, VERSION), "some message");
+        assertThat(result.getResult()).contains(MY_FIELD).contains("myKey:1.0.0").contains("some message");
+    }
 
-        private boolean valid;
-        private int index;
+    private <V> Map.Entry<String, V> makeEntry(String key, V value) {
+        Map<String, V> map = new HashMap<>();
+        map.put(key, value);
+        return map.entrySet().iterator().next();
+    }
 
-        public MyConcept(int index, boolean valid) {
-            this.index = index;
-            this.valid = valid;
-        }
+    @AllArgsConstructor
+    private static class MyString extends Validated {
+        private final String text;
 
         @Override
-        public PfValidationResult validate(PfValidationResult result) {
-            if (!valid) {
-                new Validated().addError(this, "index." + index, result, "wrong value");
+        public ValidationResult validate(String fieldName) {
+            if (TEXT.equals(text)) {
+                return null;
             }
 
-            return result;
-        }
-
-        @Override
-        public String toString() {
-            return MY_TO_STRING;
+            return new ObjectValidationResult(fieldName, text, ValidationStatus.INVALID, NOT_SAME);
         }
     }
 }
diff --git a/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java b/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java
deleted file mode 100644
index 6030d2ab9..000000000
--- a/models-base/src/test/java/org/onap/policy/models/base/ValidationTest.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*-
- * ============LICENSE_START=======================================================
- *  Copyright (C) 2019-2020 Nordix Foundation.
- *  Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- * ============LICENSE_END=========================================================
- */
-
-package org.onap.policy.models.base;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-import org.onap.policy.models.base.PfValidationResult.ValidationResult;
-
-public class ValidationTest {
-
-    private static final String HELLO = "hello";
-    private static final String SOME_MESSAGE = "Some message";
-
-    @Test
-    public void testValidation1() {
-        PfValidationResult result = new PfValidationResult();
-        PfConceptKey pfKeyey = new PfConceptKey("PK", "0.0.1");
-        result = pfKeyey.validate(result);
-
-        assertNotNull(result);
-        assertTrue(result.isOk());
-        assertTrue(result.isValid());
-        assertEquals(PfValidationResult.ValidationResult.VALID, result.getValidationResult());
-        assertNotNull(result.getMessageList());
-
-        PfValidationMessage vmess0 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
-                ValidationResult.VALID, SOME_MESSAGE);
-        result.addValidationMessage(vmess0);
-
-        assertTrue(result.isOk());
-        assertTrue(result.isValid());
-        assertEquals(PfValidationResult.ValidationResult.VALID, result.getValidationResult());
-        assertNotNull(result.getMessageList());
-        assertNotNull(HELLO, result.toString());
-
-        PfValidationMessage vmess1 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
-                ValidationResult.OBSERVATION, SOME_MESSAGE);
-        result.addValidationMessage(vmess1);
-
-        assertTrue(result.isOk());
-        assertTrue(result.isValid());
-        assertEquals(PfValidationResult.ValidationResult.OBSERVATION, result.getValidationResult());
-        assertNotNull(result.getMessageList());
-        assertNotNull(HELLO, result.toString());
-    }
-
-
-    @Test
-    public void testValidation2() {
-        PfValidationResult result = new PfValidationResult();
-
-        PfValidationMessage vmess2 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
-                ValidationResult.WARNING, SOME_MESSAGE);
-        result.addValidationMessage(vmess2);
-
-        assertFalse(result.isOk());
-        assertTrue(result.isValid());
-        assertEquals(PfValidationResult.ValidationResult.WARNING, result.getValidationResult());
-        assertNotNull(result.getMessageList());
-        assertNotNull(HELLO, result.toString());
-
-        PfValidationMessage vmess3 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
-                ValidationResult.INVALID, SOME_MESSAGE);
-        result.addValidationMessage(vmess3);
-
-        assertFalse(result.isOk());
-        assertFalse(result.isValid());
-        assertEquals(PfValidationResult.ValidationResult.INVALID, result.getValidationResult());
-        assertNotNull(result.getMessageList());
-        assertNotNull(HELLO, result.toString());
-
-        assertEquals(PfValidationResult.ValidationResult.INVALID, result.getMessageList().get(1).getValidationResult());
-        assertEquals(SOME_MESSAGE, result.getMessageList().get(1).getMessage());
-        assertEquals(PfConceptKey.class.getName(), result.getMessageList().get(1).getObservedClass());
-        assertEquals(PfConceptKey.getNullKey(), result.getMessageList().get(1).getObservedKey());
-    }
-
-    @Test
-    public void testValidationAppend() {
-        PfValidationResult result = new PfValidationResult();
-
-        PfValidationResult result2 = new PfValidationResult();
-        PfValidationMessage vmess1 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
-                ValidationResult.OBSERVATION, "Message 1");
-        result2.addValidationMessage(vmess1);
-
-        result.append(result2);
-        assertEquals(1, result.getMessageList().size());
-        assertEquals(ValidationResult.OBSERVATION, result.getValidationResult());
-
-        PfValidationResult result3 = new PfValidationResult();
-        PfValidationMessage vmess2 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
-                ValidationResult.WARNING, "Message 2");
-        result3.addValidationMessage(vmess2);
-        result.append(result3);
-        assertEquals(2, result.getMessageList().size());
-        assertEquals(ValidationResult.WARNING, result.getValidationResult());
-
-        PfValidationResult result4 = new PfValidationResult();
-        PfValidationMessage vmess3 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
-                ValidationResult.INVALID, "Message 3");
-        PfValidationMessage vmess4 = new PfValidationMessage(PfConceptKey.getNullKey(), PfConceptKey.class,
-                ValidationResult.VALID, "Message 4");
-        result4.addValidationMessage(vmess3);
-        result4.addValidationMessage(vmess4);
-        result.append(result4);
-        assertEquals(4, result.getMessageList().size());
-        assertEquals(ValidationResult.INVALID, result.getValidationResult());
-    }
-}
diff --git a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfConcept.java b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfConcept.java
index be398b95f..67a450702 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfConcept.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfConcept.java
@@ -1,7 +1,7 @@
 /*-
  * ============LICENSE_START=======================================================
  *  Copyright (C) 2019 Nordix Foundation.
- *  Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ *  Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
  * ================================================================================
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,13 +27,12 @@ import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.NonNull;
 import org.apache.commons.lang3.ObjectUtils;
+import org.onap.policy.common.parameters.BeanValidationResult;
+import org.onap.policy.common.parameters.ValidationResult;
 import org.onap.policy.models.base.PfAuthorative;
 import org.onap.policy.models.base.PfConcept;
 import org.onap.policy.models.base.PfConceptKey;
 import org.onap.policy.models.base.PfKey;
-import org.onap.policy.models.base.PfValidationMessage;
-import org.onap.policy.models.base.PfValidationResult;
-import org.onap.policy.models.base.PfValidationResult.ValidationResult;
 
 @Data
 @EqualsAndHashCode(callSuper = false)
@@ -102,20 +101,11 @@ public class DummyPfConcept extends PfConcept implements PfAuthorative<DummyAuth
     }
 
     @Override
-    public PfValidationResult validate(PfValidationResult resultIn) {
-        PfValidationResult result = resultIn;
+    public ValidationResult validate(@NonNull String fieldName) {
+        BeanValidationResult result = new BeanValidationResult(fieldName, this);
 
-        if (key.isNullKey()) {
-            result.addValidationMessage(
-                    new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key"));
-        }
-
-        result = key.validate(result);
-
-        if (description != null && description.trim().length() == 0) {
-            result.addValidationMessage(new PfValidationMessage(key, this.getClass(), ValidationResult.INVALID,
-                    "property description may not be blank"));
-        }
+        result.addResult(validateKeyNotNull("key", key));
+        result.addResult(validateNotBlank("description", description, false));
 
         return result;
     }
diff --git a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java
index 81ebb6e59..5a5891ad6 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java
@@ -1,7 +1,7 @@
 /*-
  * ============LICENSE_START=======================================================
  *  Copyright (C) 2019 Nordix Foundation.
- *  Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ *  Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
  * ================================================================================
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,9 +24,9 @@ package org.onap.policy.models.base.testconcepts;
 import java.util.Arrays;
 import java.util.List;
 import lombok.NonNull;
+import org.onap.policy.common.parameters.ValidationResult;
 import org.onap.policy.models.base.PfConcept;
 import org.onap.policy.models.base.PfKey;
-import org.onap.policy.models.base.PfValidationResult;
 
 public class DummyPfKey extends PfKey {
     private static final long serialVersionUID = 1L;
@@ -75,7 +75,7 @@ public class DummyPfKey extends PfKey {
     }
 
     @Override
-    public PfValidationResult validate(PfValidationResult result) {
+    public ValidationResult validate(@NonNull String fieldName) {
         return null;
     }
 
diff --git a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfModel.java b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfModel.java
index 764b91b24..f828fba09 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfModel.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfModel.java
@@ -1,7 +1,7 @@
 /*-
  * ============LICENSE_START=======================================================
  *  Copyright (C) 2019 Nordix Foundation.
- *  Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ *  Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
  * ================================================================================
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,12 +25,13 @@ import java.util.ArrayList;
 import java.util.List;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
+import lombok.NonNull;
+import org.onap.policy.common.parameters.BeanValidationResult;
 import org.onap.policy.models.base.PfConcept;
 import org.onap.policy.models.base.PfConceptKey;
 import org.onap.policy.models.base.PfKey;
 import org.onap.policy.models.base.PfModel;
 import org.onap.policy.models.base.PfUtils;
-import org.onap.policy.models.base.PfValidationResult;
 
 @Data
 @EqualsAndHashCode(callSuper = true)
@@ -108,11 +109,12 @@ public class DummyPfModel extends PfModel {
     }
 
     @Override
-    public PfValidationResult validate(final PfValidationResult resultIn) {
-        PfValidationResult result = super.validate(resultIn);
+    public BeanValidationResult validate(@NonNull String fieldName) {
+        BeanValidationResult result = super.validate(fieldName);
 
+        int count = 0;
         for (PfKey pfKey : keyList) {
-            result = pfKey.validate(result);
+            result.addResult(pfKey.validate("keyList." + (count++)));
         }
 
         return result;