remove dependency of drool-application/yaml in actors

Issue-ID: POLICY-1264
Change-Id: Ie89749cf25d6880fd2884eb6935f36f046114b23
Signed-off-by: ning.xi <ning.xi@est.tech>

12 files changed, 2895 insertions, 0 deletions

diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/compiler/CompilerExceptionTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/compiler/CompilerExceptionTest.java
new file mode 100644
index 000000000..ef3a68233
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/compiler/CompilerExceptionTest.java
@@ -0,0 +1,32 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.compiler;
+
+import org.junit.Test;
+import org.onap.policy.common.utils.test.ExceptionsTester;
+
+public class CompilerExceptionTest extends ExceptionsTester {
+
+    @Test
+    public void test() throws Exception {
+        test(CompilerException.class);
+    }
+
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/compiler/ControlLoopCompilerTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/compiler/ControlLoopCompilerTest.java
new file mode 100644
index 000000000..1028bde0f
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/compiler/ControlLoopCompilerTest.java
@@ -0,0 +1,221 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * policy-yaml unit test
+ * ================================================================================
+ * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.compiler;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.onap.policy.controlloop.policy.ControlLoopPolicy;
+import org.onap.policy.controlloop.policy.FinalResult;
+
+public class ControlLoopCompilerTest {
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test 
+    public void testTest() throws Exception {
+        List<String> expectedOnErrorMessages = new ArrayList<>();
+        expectedOnErrorMessages.add("Operational Policy has an bad ID");
+        expectedOnErrorMessages.add("Policy id is set to a PolicyResult SUCCESS");
+        expectedOnErrorMessages.add("Policy id is set to a FinalResult FINAL_SUCCESS");
+        expectedOnErrorMessages.add("Policy actor is null");
+        expectedOnErrorMessages.add("Policy actor is invalid");
+        expectedOnErrorMessages.add("Policy recipe is null");
+        expectedOnErrorMessages.add("Policy recipe is invalid");
+        expectedOnErrorMessages.add("Policy recipe is invalid");
+        expectedOnErrorMessages.add("Policy recipe is invalid");
+        expectedOnErrorMessages.add("Policy target is null");
+        expectedOnErrorMessages.add("Policy target is invalid");
+        expectedOnErrorMessages.add("Policy success is neither another policy nor FINAL_SUCCESS");
+        expectedOnErrorMessages.add("Policy failure is neither another policy nor FINAL_FAILURE");
+        expectedOnErrorMessages.add("Policy failure retries is neither another policy nor FINAL_FAILURE_RETRIES");
+        expectedOnErrorMessages.add("Policy failure timeout is neither another policy nor FINAL_FAILURE_TIMEOUT");
+        expectedOnErrorMessages.add("Policy failure exception is neither another policy nor FINAL_FAILURE_EXCEPTION");
+        expectedOnErrorMessages.add("Policy failure guard is neither another policy nor FINAL_FAILURE_GUARD");
+        expectedOnErrorMessages.add("Unsupported version for this compiler");
+        expectedOnErrorMessages.add("controlLoop overall timeout is less than the sum of operational policy timeouts.");
+
+        TestControlLoopCompilerCallback testControlLoopCompilerCallback = 
+                        new TestControlLoopCompilerCallback(expectedOnErrorMessages);
+        ControlLoopPolicy controlLoopPolicy = this.test("src/test/resources/v1.0.0/test.yaml", 
+                        testControlLoopCompilerCallback);
+        assertEquals(22, controlLoopPolicy.getPolicies().size());
+        assertTrue(testControlLoopCompilerCallback.areAllExpectedOnErrorsReceived());
+    }
+
+    @Test
+    public void testSuccessConnectedToUnknownPolicy() throws Exception {
+        expectedException.expect(CompilerException.class);
+        expectedException.expectMessage(
+                        "Operation Policy unique-policy-id-1-restart is connected to unknown policy unknown-policy");
+        this.test("src/test/resources/v1.0.0/bad_policy_success_connected_to_unknown_policy.yaml");
+    }
+
+    @Test
+    public void testFailureConnectedToUnknownPolicy() throws Exception {
+        expectedException.expect(CompilerException.class);
+        expectedException.expectMessage(
+                        "Operation Policy unique-policy-id-1-restart is connected to unknown policy unknown-policy");
+        this.test("src/test/resources/v1.0.0/bad_policy_failure_connected_to_unknown_policy.yaml");
+    }
+
+    @Test
+    public void testFailureTimeoutToUnknownPolicy() throws Exception {
+        expectedException.expect(CompilerException.class);
+        expectedException.expectMessage(
+                        "Operation Policy unique-policy-id-1-restart is connected to unknown policy unknown-policy");
+        this.test("src/test/resources/v1.0.0/bad_policy_failure_timeout_connected_to_unknown_policy.yaml");
+    }
+
+    @Test
+    public void testFailureRetriesToUnknownPolicy() throws Exception {
+        expectedException.expect(CompilerException.class);
+        expectedException.expectMessage(
+                        "Operation Policy unique-policy-id-1-restart is connected to unknown policy unknown-policy");
+        this.test("src/test/resources/v1.0.0/bad_policy_failure_retries_connected_to_unknown_policy.yaml");
+    }
+
+    @Test
+    public void testFailureExceptionToUnknownPolicy() throws Exception {
+        expectedException.expect(CompilerException.class);
+        expectedException.expectMessage(
+                        "Operation Policy unique-policy-id-1-restart is connected to unknown policy unknown-policy");
+        this.test("src/test/resources/v1.0.0/bad_policy_failure_exception_connected_to_unknown_policy.yaml");
+    }
+
+    @Test
+    public void testFailureGuardToUnknownPolicy() throws Exception {
+        expectedException.expect(CompilerException.class);
+        expectedException.expectMessage(
+                        "Operation Policy unique-policy-id-1-restart is connected to unknown policy unknown-policy");
+        this.test("src/test/resources/v1.0.0/bad_policy_failure_guard_connected_to_unknown_policy.yaml");
+    }
+
+    @Test 
+    public void testInvalidTriggerPolicyId() throws Exception {
+        expectedException.expect(CompilerException.class);
+        expectedException.expectMessage(
+                        "Unexpected value for trigger_policy, should only be " 
+                        + FinalResult.FINAL_OPENLOOP.toString() + " or a valid Policy ID");
+        this.test("src/test/resources/v1.0.0/bad_trigger_1.yaml");
+    }
+
+    @Test 
+    public void testNoTriggerPolicyId() throws Exception {
+        expectedException.expect(CompilerException.class);
+        this.test("src/test/resources/v1.0.0/bad_trigger_no_trigger_id.yaml");
+    }
+
+    @Test 
+    public void testNoControlLoopName() throws Exception {
+        List<String> expectedOnErrorMessages = new ArrayList<>();
+        expectedOnErrorMessages.add("Missing controlLoopName");
+        expectedOnErrorMessages.add("Unsupported version for this compiler");
+        TestControlLoopCompilerCallback testControlLoopCompilerCallback = 
+                        new TestControlLoopCompilerCallback(expectedOnErrorMessages);
+        this.test("src/test/resources/v1.0.0/bad_control_loop_no_control_loop_name.yaml", 
+                        testControlLoopCompilerCallback);
+        assertTrue(testControlLoopCompilerCallback.areAllExpectedOnErrorsReceived());
+    }
+
+    @Test 
+    public void testInvalidFinalResult() throws Exception {
+        expectedException.expect(CompilerException.class);
+        expectedException.expectMessage(
+                     "Unexpected Final Result for trigger_policy, should only be FINAL_OPENLOOP or a valid Policy ID");
+        this.test("src/test/resources/v1.0.0/bad_trigger_2.yaml");
+    }
+
+    @Test 
+    public void testCompileEmptyFile() throws Exception {
+        expectedException.expect(CompilerException.class);
+        expectedException.expectMessage("Could not parse yaml specification.");
+        this.test("src/test/resources/v1.0.0/empty.yaml");
+    }
+
+    public ControlLoopPolicy test(String testFile) throws Exception {
+        return test(testFile, null);
+    }
+
+    /**
+     * Does the actual test.
+     * 
+     * @param testFile test file
+     * @param controlLoopCompilerCallback callback method
+     * @return the policy object
+     * @throws Exception exception
+     */
+    public ControlLoopPolicy test(String testFile, 
+                    ControlLoopCompilerCallback controlLoopCompilerCallback) throws Exception {
+        try (InputStream is = new FileInputStream(new File(testFile))) {
+            return ControlLoopCompiler.compile(is, controlLoopCompilerCallback);
+        } catch (FileNotFoundException e) {
+            fail(e.getMessage());
+        } catch (IOException e) {
+            fail(e.getMessage());
+        } catch (Exception e) {
+            throw e;
+        }
+        return null;
+    }
+
+    class TestControlLoopCompilerCallback implements ControlLoopCompilerCallback {
+
+        private List<String> expectedOnErrorMessages;
+
+        public TestControlLoopCompilerCallback(List<String> expectedOnErrorMessages) {
+            this.expectedOnErrorMessages = expectedOnErrorMessages;
+        }
+
+        @Override
+        public boolean onWarning(String message) {
+            return true;
+        }
+
+        @Override
+        public boolean onError(String message) {
+            if (!expectedOnErrorMessages.remove(message)) {
+                fail("Unexpected onError message: " + message);
+            }
+            return true;
+        }
+
+        public boolean areAllExpectedOnErrorsReceived() {
+            return expectedOnErrorMessages.size() == 0;
+        }
+
+    }
+
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/compiler/ControlLoopGuardCompilerTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/compiler/ControlLoopGuardCompilerTest.java
new file mode 100644
index 000000000..850a4a374
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/compiler/ControlLoopGuardCompilerTest.java
@@ -0,0 +1,110 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * policy-yaml unit test
+ * ================================================================================
+ * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.compiler;
+
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.junit.Test;
+
+import org.onap.policy.controlloop.guard.compiler.ControlLoopGuardCompiler;
+
+public class ControlLoopGuardCompilerTest {
+
+    @Test 
+    public void testTest1() {
+        try {
+            this.test("src/test/resources/v2.0.0-guard/policy_guard_ONAP_demo_vDNS.yaml");
+        } catch (Exception e) {
+            fail(e.getMessage());
+        }
+    }
+
+    @Test 
+    public void testTest2() {
+        try {
+            this.test("src/test/resources/v2.0.0-guard/policy_guard_appc_restart.yaml");
+        } catch (Exception e) {
+            fail(e.getMessage());
+        }
+    }
+
+    @Test 
+    public void testBad1() {
+        try {
+            this.test("src/test/resources/v2.0.0-guard/no_guard_policy.yaml");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test 
+    public void testBad2() {
+        try {
+            this.test("src/test/resources/v2.0.0-guard/duplicate_guard_policy.yaml");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test 
+    public void testBad3() {
+        try {
+            this.test("src/test/resources/v2.0.0-guard/no_guard_constraint.yaml");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test 
+    public void testBad4() {
+        try {
+            this.test("src/test/resources/v2.0.0-guard/duplicate_guard_constraint.yaml");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Does the actual test.
+     * 
+     * @param testFile input test file
+     * @throws Exception exception thrown
+     */
+    public void test(String testFile) throws Exception {
+        try (InputStream is = new FileInputStream(new File(testFile))) {
+            ControlLoopGuardCompiler.compile(is, null);
+        } catch (FileNotFoundException e) {
+            fail(e.getMessage());
+        } catch (IOException e) {
+            fail(e.getMessage());
+        } catch (Exception e) {
+            throw e;
+        }
+    }
+
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopPolicyBuilderTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopPolicyBuilderTest.java
new file mode 100644
index 000000000..b95d0e007
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopPolicyBuilderTest.java
@@ -0,0 +1,947 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * policy-yaml unit test
+ * ================================================================================
+ * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.policy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.UUID;
+
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.onap.policy.aai.Pnf;
+import org.onap.policy.aai.PnfType;
+import org.onap.policy.controlloop.policy.builder.BuilderException;
+import org.onap.policy.controlloop.policy.builder.ControlLoopPolicyBuilder;
+import org.onap.policy.controlloop.policy.builder.Message;
+import org.onap.policy.controlloop.policy.builder.MessageLevel;
+import org.onap.policy.controlloop.policy.builder.Results;
+import org.onap.policy.sdc.Resource;
+import org.onap.policy.sdc.ResourceType;
+import org.onap.policy.sdc.Service;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+import org.yaml.snakeyaml.error.YAMLException;
+
+
+public class ControlLoopPolicyBuilderTest {
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testControlLoop() {
+        try {
+            //
+            // Create a builder for our policy
+            //
+            ControlLoopPolicyBuilder builder =
+                    ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+            //
+            // Test add services
+            //
+            Service scp = new Service("vSCP");
+            Service usp = new Service("vUSP");
+            Service trinity = new Service("Trinity");
+            builder = builder.addService(scp, usp, trinity);
+            assertTrue(builder.getControlLoop().getServices().size() == 3);
+            //
+            // Test remove services
+            //
+            builder = builder.removeService(scp);
+            assertTrue(builder.getControlLoop().getServices().size() == 2);
+            builder = builder.removeAllServices();
+            assertTrue(builder.getControlLoop().getServices().size() == 0);
+            //
+            // Test add resources
+            //
+            Resource cts = new Resource("vCTS", ResourceType.VF);
+            Resource com = new Resource("vCTS", ResourceType.VF);
+            Resource rar = new Resource("vCTS", ResourceType.VF);
+            builder = builder.addResource(cts, com, rar);
+            assertTrue(builder.getControlLoop().getResources().size() == 3);
+            //
+            // Test remove resources
+            //
+            builder = builder.removeResource(cts);
+            assertTrue(builder.getControlLoop().getResources().size() == 2);
+            builder = builder.removeAllResources();
+            assertTrue(builder.getControlLoop().getResources().size() == 0);
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void testAddNullService() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Service must not be null");
+        builder.addService((Service) null);
+    }
+
+    @Test
+    public void testAddInvalidService() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Invalid service - need either a serviceUUID or serviceName");
+        builder.addService(new Service());
+    }
+
+    @Test
+    public void testAddServiceWithUuid() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        UUID uuid = UUID.randomUUID();
+        Service serviceWithUuid = new Service(uuid);
+        builder.addService(serviceWithUuid);
+        assertTrue(builder.getControlLoop().getServices().size() == 1);
+    }
+
+    @Test
+    public void testAddNullResource() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Resource must not be null");
+        builder.addResource((Resource) null);
+    }
+
+
+    @Test
+    public void testAddInvalidResource() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Invalid resource - need either resourceUUID or resourceName");
+        builder.addResource(new Resource());
+    }
+
+    @Test
+    public void testAddAndRemoveResourceWithUuid() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        UUID uuid = UUID.randomUUID();
+        Resource resourceWithUuid = new Resource(uuid);
+        builder.addResource(resourceWithUuid);
+        assertTrue(builder.getControlLoop().getResources().size() == 1);
+
+        builder.removeResource(resourceWithUuid);
+        assertTrue(builder.getControlLoop().getResources().size() == 0);
+    }
+
+    @Test
+    public void testRemoveNullResource() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        Resource resource = new Resource("resource1", ResourceType.VF);
+        builder.addResource(resource);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Resource must not be null");
+        builder.removeResource((Resource) null);
+    }
+
+    @Test
+    public void testRemoveResourceNoExistingResources() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("No existing resources to remove");
+        builder.removeResource(new Resource("resource1", ResourceType.VF));
+    }
+
+    @Test
+    public void testRemoveInvalidResource() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        Resource resource = new Resource("resource1", ResourceType.VF);
+        builder.addResource(resource);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Invalid resource - need either a resourceUUID or resourceName");
+        builder.removeResource(new Resource());
+    }
+
+    @Test
+    public void testRemoveUnknownResource() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        Resource resource = new Resource("resource1", ResourceType.VF);
+        builder.addResource(resource);
+        final String unknownResourceName = "reource2";
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Unknown resource " + unknownResourceName);
+        builder.removeResource(new Resource(unknownResourceName, ResourceType.VF));
+    }
+
+    @Test
+    public void testControlLoopWithInitialResourceAndServices() {
+        try {
+            Resource cts = new Resource("vCTS", ResourceType.VF);
+            Service scp = new Service("vSCP");
+            Service usp = new Service("vUSP");
+            ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory
+                    .buildControlLoop(UUID.randomUUID().toString(), 2400, cts, scp, usp);
+            assertTrue(builder.getControlLoop().getResources().size() == 1);
+            assertTrue(builder.getControlLoop().getServices().size() == 2);
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void testControlLoopWithInitialResourcesAndService() {
+        try {
+            Resource cts = new Resource("vCTS", ResourceType.VF);
+            Resource com = new Resource("vCTS", ResourceType.VF);
+            Service scp = new Service("vSCP");
+            ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory
+                    .buildControlLoop(UUID.randomUUID().toString(), 2400, scp, cts, com);
+            assertTrue(builder.getControlLoop().getServices().size() == 1);
+            assertTrue(builder.getControlLoop().getResources().size() == 2);
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+
+    @Test
+    @Ignore
+    // I'VE MARKED THIS TEST CASE AS IGNORE BECAUSE THE TEST CASE FAILS
+    // This test case fails because builder.getControlLoop() returns an instance of ControlLoop
+    // copied using
+    // the ControlLoop(ControlLoop controlLoop) constructor.
+    // This constructor does not copy the value of pnf into the newly created object
+    // On the face of it, this looks like a bug, but perhaps there is a reason for this
+    // PLEASE ADVISE IF THE BEHAVIOUR IS INCORRECT OR THE TEST CASE IS INVALID
+    public void testControlLoopForPnf() {
+        try {
+            Pnf pnf = new Pnf();
+            pnf.setPnfType(PnfType.ENODEB);
+            ControlLoopPolicyBuilder builder =
+                    ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400, pnf);
+            assertEquals(pnf, builder.getControlLoop().getPnf());
+
+            builder.removePNF();
+            assertNull(builder.getControlLoop().getPnf());
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+
+    @Test
+    @Ignore
+    // Fails for the same reason as the above test case
+    public void testSetAndRemovePnf() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        assertNull(builder.getControlLoop().getPnf());
+
+        Pnf pnf = new Pnf();
+        pnf.setPnfType(PnfType.ENODEB);
+        builder.setPNF(pnf);
+        assertEquals(pnf, builder.getControlLoop().getPnf());
+
+        builder.removePNF();
+        assertNull(builder.getControlLoop().getPnf());
+    }
+
+    @Test
+    public void testSetNullPnf() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("PNF must not be null");
+        builder.setPNF(null);
+    }
+
+    @Test
+    public void testSetInvalidPnf() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Invalid PNF - need either pnfName or pnfType");
+        builder.setPNF(new Pnf());
+    }
+
+    @Test
+    public void testSetAbatement() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        assertFalse(builder.getControlLoop().getAbatement());
+        builder = builder.setAbatement(true);
+        assertTrue(builder.getControlLoop().getAbatement());
+    }
+
+    @Test
+    public void testSetNullAbatement() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("abatement must not be null");
+        builder = builder.setAbatement(null);
+    }
+
+    @Test
+    public void testTimeout() {
+        try {
+            //
+            // Create a builder for our policy
+            //
+            ControlLoopPolicyBuilder builder =
+                    ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+            //
+            // Test setTimeout
+            //
+            assertTrue(builder.getControlLoop().getTimeout() == 2400);
+            builder = builder.setTimeout(800);
+            assertTrue(builder.getControlLoop().getTimeout() == 800);
+            //
+            // Test calculateTimeout
+            //
+            Policy trigger =
+                    builder.setTriggerPolicy(PolicyParam.builder().id(UUID.randomUUID().toString())
+                            .name("Restart the VM")
+                            .description("Upon getting the trigger event, restart the VM")
+                            .actor("APPC")
+                            .target(new Target(TargetType.VM))
+                            .recipe("Restart")
+                            .payload(null)
+                            .retries(2)
+                            .timeout(300).build());
+            @SuppressWarnings("unused")
+            Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
+                    PolicyParam.builder()
+                            .name("Rebuild VM")
+                            .description("If the restart fails, rebuild it")
+                            .actor("APPC")
+                            .target(new Target(TargetType.VM))
+                            .recipe("Rebuild")
+                            .payload(null)
+                            .retries(1)
+                            .timeout(600)
+                            .id(trigger.getId()).build(),
+                            PolicyResult.FAILURE,
+                            PolicyResult.FAILURE_RETRIES,
+                            PolicyResult.FAILURE_TIMEOUT);
+            assertTrue(builder.calculateTimeout().equals(new Integer(300 + 600)));
+            //
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void testTriggerPolicyMethods() {
+        try {
+            ControlLoopPolicyBuilder builder =
+                    ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+            //
+            // Test isOpenLoop
+            //
+            assertTrue(builder.isOpenLoop());
+            //
+            // Test set initial trigger policy
+            //
+            Policy triggerPolicy1 =
+                    builder.setTriggerPolicy(
+                            PolicyParam.builder().id(UUID.randomUUID().toString())
+                            .name("Restart the VM")
+                            .description("Upon getting the trigger event, restart the VM")
+                            .actor("APPC")
+                            .target(new Target(TargetType.VM))
+                            .recipe("Restart")
+                            .payload(null)
+                            .retries(2)
+                            .timeout(300).build());
+            assertTrue(builder.isOpenLoop() == false);
+            assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
+            //
+            // Set trigger policy to a new policy
+            //
+            @SuppressWarnings("unused")
+            Policy triggerPolicy2 =
+                    builder.setTriggerPolicy(
+                            PolicyParam.builder()
+                            .id(UUID.randomUUID().toString())
+                            .name("Rebuild the VM")
+                            .description("Upon getting the trigger event, rebuild the VM")
+                            .actor("APPC")
+                            .target(new Target(TargetType.VM))
+                            .recipe("Rebuild")
+                            .payload(null)
+                            .retries(2)
+                            .timeout(300).build());
+            //
+            // Test set trigger policy to another existing policy
+            //
+            @SuppressWarnings("unused")
+            ControlLoop cl = builder.setExistingTriggerPolicy(triggerPolicy1.getId());
+            assertTrue(builder.getControlLoop().getTrigger_policy().equals(triggerPolicy1.getId()));
+            //
+            // Test get trigger policy
+            //
+            assertTrue(builder.getTriggerPolicy().equals(triggerPolicy1));
+            //
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void testSetTriggerPolicyNullPolicyId() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Id must not be null");
+        builder.setExistingTriggerPolicy(null);
+    }
+
+    @Test
+    public void testSetTriggerPolicyNoPoliciesExist() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        final String unknownPolicyId = "100";
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Unknown policy " + unknownPolicyId);
+        builder.setExistingTriggerPolicy(unknownPolicyId);
+    }
+
+    @Test
+    public void testSetTriggerPolicyUnknownPolicy() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        builder.setTriggerPolicy(
+                PolicyParam.builder()
+                .id(UUID.randomUUID().toString())
+                .name("Restart the VM")
+                .description("Upon getting the trigger event, restart the VM")
+                .actor("APPC")
+                .target(new Target(TargetType.VM))
+                .recipe("Restart")
+                .payload(null)
+                .retries(2)
+                .timeout(300).build());
+        final String unknownPolicyId = "100";
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Unknown policy " + unknownPolicyId);
+        builder.setExistingTriggerPolicy(unknownPolicyId);
+    }
+
+    @Test
+    public void testAddRemovePolicies() {
+        try {
+            ControlLoopPolicyBuilder builder =
+                    ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+            Policy triggerPolicy =
+                    builder.setTriggerPolicy(
+                            PolicyParam.builder()
+                            .id(UUID.randomUUID().toString())
+                            .name("Restart the VM")
+                            .description("Upon getting the trigger event, restart the VM")
+                            .actor("APPC")
+                            .target(new Target(TargetType.VM))
+                            .recipe("Restart")
+                            .payload(null)
+                            .retries(2)
+                            .timeout(300).build());
+            //
+            // Test create a policy and chain it to the results of trigger policy
+            //
+            Policy onRestartFailurePolicy1 = builder.setPolicyForPolicyResult(
+                    PolicyParam.builder()
+                    .name("Rebuild VM")
+                    .description("If the restart fails, rebuild it.")
+                    .actor("APPC")
+                    .target(new Target(TargetType.VM))
+                    .recipe("Rebuild")
+                    .payload(null)
+                    .retries(1)
+                    .timeout(600)
+                    .id(triggerPolicy.getId()).build(),
+                    PolicyResult.FAILURE,
+                    PolicyResult.FAILURE_EXCEPTION,
+                    PolicyResult.FAILURE_RETRIES,
+                    PolicyResult.FAILURE_TIMEOUT,
+                    PolicyResult.FAILURE_GUARD);
+            //
+            assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy1.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy1.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy1.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy1.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy1.getId()));
+
+            //
+            // Test create a policy and chain it to the results of trigger policy success
+            //
+            Policy onSuccessPolicy1 = builder.setPolicyForPolicyResult(
+                    PolicyParam.builder()
+                    .name("Do something")
+                    .description("If the restart succeeds, do something else.")
+                    .actor("APPC")
+                    .target(new Target(TargetType.VM))
+                    .recipe("SomethingElse")
+                    .payload(null)
+                    .retries(1)
+                    .timeout(600)
+                    .id(triggerPolicy.getId()).build(),
+                    PolicyResult.SUCCESS);
+            //
+            assertTrue(builder.getTriggerPolicy().getSuccess().equals(onSuccessPolicy1.getId()));
+
+            //
+            // Test remove policy
+            //
+            boolean removed = builder.removePolicy(onRestartFailurePolicy1.getId());
+            assertTrue(removed);
+            assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
+            assertTrue(builder.getTriggerPolicy().getFailure_retries()
+                    .equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
+            assertTrue(builder.getTriggerPolicy().getFailure_timeout()
+                    .equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
+            assertTrue(
+                    builder.getTriggerPolicy().getFailure_guard().equals(FinalResult.FINAL_FAILURE_GUARD.toString()));
+            //
+            // Create another policy and chain it to the results of trigger policy
+            //
+            final Policy onRestartFailurePolicy2 =
+                    builder.setPolicyForPolicyResult(
+                            PolicyParam.builder()
+                            .name("Rebuild VM")
+                            .description("If the restart fails, rebuild it.")
+                            .actor("APPC")
+                            .target(new Target(TargetType.VM))
+                            .recipe("Rebuild")
+                            .payload(null)
+                            .retries(2)
+                            .timeout(600)
+                            .id(triggerPolicy.getId()).build(),
+                            PolicyResult.FAILURE,
+                            PolicyResult.FAILURE_RETRIES,
+                            PolicyResult.FAILURE_TIMEOUT);
+            //
+            // Test reset policy results
+            //
+            triggerPolicy = builder.resetPolicyResults(triggerPolicy.getId());
+            assertTrue(builder.getTriggerPolicy().getFailure().equals(FinalResult.FINAL_FAILURE.toString()));
+            assertTrue(builder.getTriggerPolicy().getFailure_retries()
+                    .equals(FinalResult.FINAL_FAILURE_RETRIES.toString()));
+            assertTrue(builder.getTriggerPolicy().getFailure_timeout()
+                    .equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString()));
+            //
+            // Test set the policy results to an existing operational policy
+            //
+            Policy onRestartFailurePolicy3 =
+                    builder.setPolicyForPolicyResult(onRestartFailurePolicy2.getId(), triggerPolicy.getId(),
+                            PolicyResult.FAILURE, PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
+            assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy3.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy3.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy3.getId()));
+            //
+            // Test set the policy result for success to an existing operational policy
+            //
+            Policy onRestartFailurePolicy4 =
+                    builder.setPolicyForPolicyResult(onRestartFailurePolicy2.getId(), triggerPolicy.getId(),
+                            PolicyResult.FAILURE, PolicyResult.FAILURE_EXCEPTION, PolicyResult.FAILURE_GUARD,
+                            PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT, PolicyResult.SUCCESS);
+            assertTrue(builder.getTriggerPolicy().getFailure().equals(onRestartFailurePolicy4.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_exception().equals(onRestartFailurePolicy4.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_guard().equals(onRestartFailurePolicy4.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_retries().equals(onRestartFailurePolicy4.getId()));
+            assertTrue(builder.getTriggerPolicy().getFailure_timeout().equals(onRestartFailurePolicy4.getId()));
+            assertTrue(builder.getTriggerPolicy().getSuccess().equals(onRestartFailurePolicy4.getId()));
+
+            //
+            // Test remove all existing operational policies
+            //
+            builder = builder.removeAllPolicies();
+            assertTrue(builder.getControlLoop().getTrigger_policy().equals(FinalResult.FINAL_OPENLOOP.toString()));
+            //
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void testAddToUnknownPolicy() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        final String policyId = "100";
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Unknown policy " + policyId);
+
+        builder.setPolicyForPolicyResult(
+                PolicyParam.builder()
+                .name("Rebuild VM")
+                .description("If the restart fails, rebuild it.")
+                .actor("APPC")
+                .target(new Target(TargetType.VM))
+                .recipe("Rebuild")
+                .payload(null)
+                .retries(1)
+                .timeout(600)
+                .id(policyId).build(),
+                PolicyResult.FAILURE,
+                PolicyResult.FAILURE_RETRIES,
+                PolicyResult.FAILURE_TIMEOUT,
+                PolicyResult.FAILURE_GUARD);
+    }
+
+    @Test
+    public void testAddExistingPolicyToUnknownPolicy() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        Policy triggerPolicy =
+                builder.setTriggerPolicy(
+                        PolicyParam.builder()
+                        .id(UUID.randomUUID().toString())
+                        .name("Restart the VM")
+                        .description("Upon getting the trigger event, restart the VM")
+                        .actor("APPC")
+                        .target(new Target(TargetType.VM))
+                        .recipe("Restart")
+                        .payload(null)
+                        .retries(2)
+                        .timeout(300).build());
+
+
+        Policy onRestartFailurePolicy = builder.setPolicyForPolicyResult(
+                PolicyParam.builder()
+                .name("Rebuild VM")
+                .description("If the restart fails, rebuild it.")
+                .actor("APPC")
+                .target(new Target(TargetType.VM))
+                .recipe("Rebuild")
+                .payload(null)
+                .retries(1)
+                .timeout(600)
+                .id(triggerPolicy.getId()).build(),
+                PolicyResult.FAILURE);
+
+        final String unknownPolicyId = "100";
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage(unknownPolicyId + " does not exist");
+
+        builder.setPolicyForPolicyResult(onRestartFailurePolicy.getId(), unknownPolicyId, PolicyResult.FAILURE);
+    }
+
+    @Test
+    public void testAddUnknownExistingPolicyToPolicy() throws BuilderException {
+        ControlLoopPolicyBuilder builder =
+                ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+        Policy triggerPolicy =
+                builder.setTriggerPolicy(
+                        PolicyParam.builder()
+                        .id(UUID.randomUUID().toString())
+                        .name("Restart the VM")
+                        .description("Upon getting the trigger event, restart the VM")
+                        .actor("APPC")
+                        .target(new Target(TargetType.VM))
+                        .recipe("Restart")
+                        .payload(null)
+                        .retries(2)
+                        .timeout(300).build());
+
+        final String unknownPolicyId = "100";
+        expectedException.expect(BuilderException.class);
+        expectedException.expectMessage("Operational policy " + unknownPolicyId + " does not exist");
+
+        builder.setPolicyForPolicyResult(unknownPolicyId, triggerPolicy.getId(), PolicyResult.FAILURE);
+    }
+
+    @Test
+    public void testAddOperationsAccumulateParams() {
+        try {
+            ControlLoopPolicyBuilder builder =
+                    ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 2400);
+            Policy triggerPolicy =
+                    builder.setTriggerPolicy(
+                            PolicyParam.builder()
+                            .id(UUID.randomUUID().toString())
+                            .name("Restart the eNodeB")
+                            .description("Upon getting the trigger event, restart the eNodeB")
+                            .actor("RANController")
+                            .target(new Target(TargetType.PNF))
+                            .recipe("Restart")
+                            .payload(null)
+                            .retries(2)
+                            .timeout(300).build());
+            //
+            // Add the operationsAccumulateParams
+            //
+            triggerPolicy = builder.addOperationsAccumulateParams(triggerPolicy.getId(),
+                    new OperationsAccumulateParams("15m", 5));
+            assertNotNull(builder.getTriggerPolicy().getOperationsAccumulateParams());
+            assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getPeriod().equals("15m"));
+            assertTrue(builder.getTriggerPolicy().getOperationsAccumulateParams().getLimit() == 5);
+            //
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+
+
+    @Test
+    public void testBuildSpecification() {
+        try {
+            //
+            // Create the builder
+            //
+            ControlLoopPolicyBuilder builder =
+                    ControlLoopPolicyBuilder.Factory.buildControlLoop(UUID.randomUUID().toString(), 800);
+            //
+            // Set the first invalid trigger policy
+            //
+            final Policy policy1 = builder.setTriggerPolicy(
+                    PolicyParam.builder()
+                    .id(UUID.randomUUID().toString())
+                    .name("Restart the VM")
+                    .description("Upon getting the trigger event, restart the VM")
+                    .actor(null)
+                    .target(null)
+                    .recipe("Instantiate")
+                    .payload(null)
+                    .retries(2)
+                    .timeout(300).build());
+            Results results = builder.buildSpecification();
+            //
+            // Check that ERRORs are in results for invalid policy arguments
+            //
+            boolean invalidActor = false;
+            boolean invalidRecipe = false;
+            boolean invalidTarget = false;
+            for (Message m : results.getMessages()) {
+                if (m.getMessage().equals("Policy actor is null") && m.getLevel() == MessageLevel.ERROR) {
+                    invalidActor = true;
+                }
+                if (m.getMessage().equals("Policy recipe is invalid") && m.getLevel() == MessageLevel.ERROR) {
+                    invalidRecipe = true;
+                }
+                if (m.getMessage().equals("Policy target is null") && m.getLevel() == MessageLevel.ERROR) {
+                    invalidTarget = true;
+                }
+            }
+            //
+            assertTrue(invalidActor);
+            assertTrue(invalidRecipe);
+            assertTrue(invalidTarget);
+            //
+            // Remove the invalid policy
+            //
+            // @SuppressWarnings("unused")
+            boolean removed = builder.removePolicy(policy1.getId());
+            assertTrue(removed);
+            assertTrue(builder.getTriggerPolicy() == null);
+            //
+            // Set a valid trigger policy
+            //
+            Policy policy1a = builder.setTriggerPolicy(
+                    PolicyParam.builder()
+                    .id(UUID.randomUUID().toString())
+                    .name("Rebuild VM")
+                    .description("If the restart fails, rebuild it.")
+                    .actor("APPC")
+                    .target(new Target(TargetType.VM))
+                    .recipe("Rebuild")
+                    .payload(null)
+                    .retries(1)
+                    .timeout(600).build());
+            //
+            // Set a second valid trigger policy
+            //
+            final Policy policy2 =
+                    builder.setTriggerPolicy(
+                            PolicyParam.builder()
+                            .id(UUID.randomUUID().toString())
+                            .name("Restart the VM")
+                            .description("Upon getting the trigger event, restart the VM")
+                            .actor("APPC")
+                            .target(new Target(TargetType.VM))
+                            .recipe("Restart")
+                            .payload(null)
+                            .retries(2)
+                            .timeout(300).build());
+            //
+            // Now, we have policy1 unreachable
+            //
+            results = builder.buildSpecification();
+            boolean unreachable = false;
+            for (Message m : results.getMessages()) {
+                if (m.getMessage().equals("Policy " + policy1a.getId() + " is not reachable.")
+                        && m.getLevel() == MessageLevel.WARNING) {
+                    unreachable = true;
+                    break;
+                }
+            }
+            assertTrue(unreachable);
+            //
+            // Set policy1a for the failure results of policy2
+            //
+            policy1a = builder.setPolicyForPolicyResult(policy1a.getId(), policy2.getId(), PolicyResult.FAILURE,
+                    PolicyResult.FAILURE_RETRIES, PolicyResult.FAILURE_TIMEOUT);
+            results = builder.buildSpecification();
+            boolean invalidTimeout = false;
+            for (Message m : results.getMessages()) {
+                if (m.getMessage()
+                        .equals("controlLoop overall timeout is less than the sum of operational policy timeouts.")
+                        && m.getLevel() == MessageLevel.ERROR) {
+                    invalidTimeout = true;
+                    break;
+                }
+            }
+            assertTrue(invalidTimeout);
+            //
+            // Remove policy2 (revert controlLoop back to open loop)
+            //
+            removed = builder.removePolicy(policy2.getId());
+            //
+            // ControlLoop is open loop now, but it still has policies (policy1)
+            //
+            results = builder.buildSpecification();
+            unreachable = false;
+            for (Message m : results.getMessages()) {
+                if (m.getMessage().equals("Open Loop policy contains policies. The policies will never be invoked.")
+                        && m.getLevel() == MessageLevel.WARNING) {
+                    unreachable = true;
+                    break;
+                }
+            }
+            assertTrue(unreachable);
+            //
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+
+
+    @Test
+    public void test1() {
+        this.test("src/test/resources/v1.0.0/policy_Test.yaml");
+    }
+
+    @Test
+    public void testEvilYaml() {
+        try (InputStream is = new FileInputStream(new File("src/test/resources/v1.0.0/test_evil.yaml"))) {
+            //
+            // Read the yaml into our Java Object
+            //
+            Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
+            yaml.load(is);
+        } catch (FileNotFoundException e) {
+            fail(e.getLocalizedMessage());
+        } catch (IOException e) {
+            fail(e.getLocalizedMessage());
+        } catch (YAMLException e) {
+            //
+            // Should have this
+            //
+        }
+    }
+
+    /**
+     * Does the actual test.
+     * 
+     * @param testFile input file
+     */
+    public void test(String testFile) {
+        try (InputStream is = new FileInputStream(new File(testFile))) {
+            //
+            // Read the yaml into our Java Object
+            //
+            Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
+            Object obj = yaml.load(is);
+            assertNotNull(obj);
+            assertTrue(obj instanceof ControlLoopPolicy);
+            ControlLoopPolicy policyTobuild = (ControlLoopPolicy) obj;
+            //
+            // Now we're going to try to use the builder to build this.
+            //
+            ControlLoopPolicyBuilder builder = ControlLoopPolicyBuilder.Factory.buildControlLoop(
+                    policyTobuild.getControlLoop().getControlLoopName(), policyTobuild.getControlLoop().getTimeout());
+            //
+            // Add services
+            //
+            if (policyTobuild.getControlLoop().getServices() != null) {
+                builder = builder.addService(policyTobuild.getControlLoop().getServices()
+                        .toArray(new Service[policyTobuild.getControlLoop().getServices().size()]));
+            }
+            //
+            // Add resources
+            //
+            if (policyTobuild.getControlLoop().getResources() != null) {
+                builder = builder.addResource(policyTobuild.getControlLoop().getResources()
+                        .toArray(new Resource[policyTobuild.getControlLoop().getResources().size()]));
+            }
+            //
+            // Set pnf
+            //
+            if (policyTobuild.getControlLoop().getPnf() != null) {
+                builder = builder.setPNF(policyTobuild.getControlLoop().getPnf());
+            }
+            //
+            // Add the policies and be sure to set the trigger policy
+            //
+            if (policyTobuild.getPolicies() != null) {
+                for (Policy policy : policyTobuild.getPolicies()) {
+                    if (policy.getId() == policyTobuild.getControlLoop().getTrigger_policy()) {
+                        builder.setTriggerPolicy(
+                                PolicyParam.builder()
+                                .id(UUID.randomUUID().toString())
+                                .name(policy.getName())
+                                .description(policy.getDescription())
+                                .actor(policy.getActor())
+                                .target(policy.getTarget())
+                                .recipe(policy.getRecipe())
+                                .payload(null)
+                                .retries(policy.getRetry())
+                                .timeout(policy.getTimeout()).build());
+                    }
+                }
+            }
+
+            // Question : how to change policy ID and results by using builder ??
+
+            @SuppressWarnings("unused")
+            Results results = builder.buildSpecification();
+
+        } catch (FileNotFoundException e) {
+            fail(e.getLocalizedMessage());
+        } catch (IOException e) {
+            fail(e.getLocalizedMessage());
+        } catch (BuilderException e) {
+            fail(e.getLocalizedMessage());
+        }
+
+    }
+
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopPolicyTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopPolicyTest.java
new file mode 100644
index 000000000..9c92b7573
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopPolicyTest.java
@@ -0,0 +1,141 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * policy-yaml unit test
+ * ================================================================================
+ * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.policy;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.junit.Test;
+import org.onap.policy.common.utils.io.Serializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.DumperOptions.FlowStyle;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+
+
+public class ControlLoopPolicyTest {
+    private static final Logger logger = LoggerFactory.getLogger(ControlLoopPolicyTest.class);
+    
+    @Test 
+    public void test1() {
+        this.test("src/test/resources/v1.0.0/policy_Test.yaml");
+    }
+
+    @Test 
+    public void testvService1() {
+        this.test("src/test/resources/v1.0.0/policy_vService.yaml");
+    }
+
+    @Test 
+    public void testOpenLoop() {
+        this.test("src/test/resources/v1.0.0/policy_OpenLoop.yaml");
+    }
+
+    @Test 
+    public void testvdns() {
+        this.test("src/test/resources/v2.0.0/policy_ONAP_demo_vDNS.yaml");
+    }
+
+    @Test 
+    public void testvFirewall() {
+        // Chenfei to fix this.
+        // this.test("src/test/resources/v2.0.0/policy_ONAP_demo_vFirewall.yaml");
+    }
+
+    @Test 
+    public void testvcpe() {
+        this.test("src/test/resources/v2.0.0/policy_ONAP_UseCase_vCPE.yaml");
+    }
+
+    @Test 
+    public void testvpci() {
+        this.test("src/test/resources/v2.0.0/policy_ONAP_UseCase_vPCI.yaml");
+    }
+
+    @Test 
+    public void testvolte() {
+        this.test("src/test/resources/v2.0.0/policy_ONAP_UseCase_VOLTE.yaml");
+    }
+
+    /**
+     * Does the actual test.
+     * 
+     * @param testFile input file
+     */
+    public void test(String testFile) {
+        try (InputStream is = new FileInputStream(new File(testFile))) {
+            //
+            // Read the yaml into our Java Object
+            //
+            Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
+            Object obj = yaml.load(is);
+            assertNotNull(obj);
+            assertTrue(obj instanceof ControlLoopPolicy);
+            dump(obj);
+            //
+            // Now dump it to a yaml string
+            //
+            DumperOptions options = new DumperOptions();
+            options.setDefaultFlowStyle(FlowStyle.BLOCK);
+            options.setPrettyFlow(true);
+            yaml = new Yaml(options);
+            String dumpedYaml = yaml.dump(obj);
+            logger.debug(dumpedYaml);
+            //
+            // Read that string back into our java object
+            //
+            Object newObject = yaml.load(dumpedYaml);
+            dump(newObject);
+            assertNotNull(newObject);
+            assertTrue(newObject instanceof ControlLoopPolicy);
+            //
+            // Have to comment it out tentatively since it causes junit to fail. 
+            // Seems we cannot use assertEquals here. Need advice.
+            //
+            //assertEquals(newObject, obj);
+            
+            // test serialization
+            ControlLoopPolicy policy = (ControlLoopPolicy) obj;
+            ControlLoopPolicy policy2 = Serializer.roundTrip(policy);
+            assertTrue(policy.equals(policy2));
+            
+        } catch (FileNotFoundException e) {
+            fail(e.getLocalizedMessage());
+        } catch (IOException e) {
+            fail(e.getLocalizedMessage());
+        }
+    }
+
+    public void dump(Object obj) {
+        logger.debug("Dumping ", obj.getClass().getCanonicalName());
+        logger.debug("{}", obj);
+    }
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopTest.java
new file mode 100644
index 000000000..142b51b18
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/ControlLoopTest.java
@@ -0,0 +1,183 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. All rights reserved.
+ * Modifications Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.policy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import org.onap.policy.aai.Pnf;
+import org.onap.policy.common.utils.io.Serializer;
+import org.onap.policy.sdc.Resource;
+import org.onap.policy.sdc.ResourceType;
+import org.onap.policy.sdc.Service;
+
+public class ControlLoopTest {
+
+    private String controlLoopName = "control loop 1";
+    private String version = "1.0.1";
+    private String triggerPolicy = FinalResult.FINAL_OPENLOOP.toString();
+    private Integer timeout = 100;
+    private Boolean abatement = false;
+
+    @Test
+    public void testEqualsSameInstance() {
+        ControlLoop controlLoop1 = new ControlLoop();
+        assertTrue(controlLoop1.equals(controlLoop1));
+    }
+
+    @Test
+    public void testEqualsNull() {
+        ControlLoop controlLoop1 = new ControlLoop();
+        assertFalse(controlLoop1.equals(null));
+    }
+
+    @Test
+    public void testEqualsInstanceOfDiffClass() {
+        ControlLoop controlLoop1 = new ControlLoop();
+        assertFalse(controlLoop1.equals(""));
+    }
+
+    @Test
+    public void testEqualsNoServicesAndResourcesOrTimeout() {
+        final Pnf pnf = new Pnf();
+        pnf.setPnfName("pnf 1");
+
+        ControlLoop controlLoop1 = new ControlLoop();
+        controlLoop1.setControlLoopName(controlLoopName);
+        controlLoop1.setVersion(version);
+        controlLoop1.setPnf(pnf);
+        controlLoop1.setTrigger_policy(triggerPolicy);
+        controlLoop1.setAbatement(abatement);
+
+        ControlLoop controlLoop2 = new ControlLoop();
+        controlLoop2.setControlLoopName(controlLoopName);
+        controlLoop2.setVersion(version);
+        controlLoop2.setPnf(pnf);
+        controlLoop2.setTrigger_policy(triggerPolicy);
+        controlLoop2.setAbatement(abatement);
+
+        assertTrue(controlLoop1.equals(controlLoop2));
+    }
+
+    @Test
+    public void testEquals() throws IOException {
+        final Pnf pnf = new Pnf();
+        pnf.setPnfName("pnf 1");
+
+        ControlLoop controlLoop1 = new ControlLoop();
+        controlLoop1.setControlLoopName(controlLoopName);
+        controlLoop1.setVersion(version);
+        Service service1 = new Service("service1");
+        Service service2 = new Service("service2");
+        List<Service> services = new ArrayList<>();
+        services.add(service1);
+        services.add(service2);
+        controlLoop1.setServices(services);
+        Resource resource1 = new Resource("resource1", ResourceType.VF);
+        Resource resource2 = new Resource("resource2", ResourceType.VFC);
+        List<Resource> resources = new ArrayList<>();
+        resources.add(resource1);
+        resources.add(resource2);
+        controlLoop1.setResources(resources);
+        controlLoop1.setPnf(pnf);
+        controlLoop1.setTrigger_policy(triggerPolicy);
+        controlLoop1.setTimeout(timeout);
+        controlLoop1.setAbatement(abatement);
+
+        ControlLoop controlLoop2 = new ControlLoop();
+        controlLoop2.setControlLoopName(controlLoopName);
+        controlLoop2.setVersion(version);
+        Service controlLoop2Service1 = new Service("service1");
+        Service controlLoop2Service2 = new Service("service2");
+        List<Service> controlLoop2Services = new ArrayList<>();
+        controlLoop2Services.add(controlLoop2Service1);
+        controlLoop2Services.add(controlLoop2Service2);
+        controlLoop2.setServices(controlLoop2Services);
+        Resource controlLoop2Resource1 = new Resource("resource1", ResourceType.VF);
+        Resource controlLoop2Resource2 = new Resource("resource2", ResourceType.VFC);
+        List<Resource> controlLoop2Resources = new ArrayList<>();
+        controlLoop2Resources.add(controlLoop2Resource1);
+        controlLoop2Resources.add(controlLoop2Resource2);
+        controlLoop2.setResources(controlLoop2Resources);
+        controlLoop2.setPnf(pnf);
+        controlLoop2.setTrigger_policy(triggerPolicy);
+        controlLoop2.setTimeout(timeout);
+        controlLoop1.setAbatement(abatement);
+
+        assertTrue(controlLoop1.equals(controlLoop2));
+        assertEquals(controlLoop1.hashCode(), controlLoop2.hashCode());
+
+        controlLoop2 = Serializer.roundTrip(controlLoop1);
+        assertTrue(controlLoop1.equals(controlLoop2));
+        assertEquals(controlLoop1.hashCode(), controlLoop2.hashCode());
+    }
+
+    @Test
+    @Ignore
+    // I'VE MARKED THIS TEST CASE AS IGNORE BECAUSE THE TEST CASE FAILS
+    // This test case fails because the ControlLoop(ControlLoop controlLoop) constructor.
+    // does not copy the value of pnf and version into the newly created object
+    // PLEASE ADVISE IF THE EXISTING BEHAVIOUR IS CORRECT
+    public void testControlLoop() {
+        final Pnf pnf = new Pnf();
+        pnf.setPnfName("pnf 1");
+
+        ControlLoop controlLoop1 = new ControlLoop();
+        controlLoop1.setControlLoopName(controlLoopName);
+        controlLoop1.setVersion(version);
+        Service service1 = new Service("service1");
+        Service service2 = new Service("service2");
+        List<Service> services = new ArrayList<>();
+        services.add(service1);
+        services.add(service2);
+        controlLoop1.setServices(services);
+        Resource resource1 = new Resource("resource1", ResourceType.VF);
+        Resource resource2 = new Resource("resource2", ResourceType.VFC);
+        List<Resource> resources = new ArrayList<>();
+        resources.add(resource1);
+        resources.add(resource2);
+        controlLoop1.setResources(resources);
+        controlLoop1.setPnf(pnf);
+        controlLoop1.setTrigger_policy(triggerPolicy);
+        controlLoop1.setAbatement(abatement);
+
+        ControlLoop controlLoop2 = new ControlLoop(controlLoop1);
+
+        assertEquals(controlLoop1.getControlLoopName(), controlLoop2.getControlLoopName());
+        assertEquals(controlLoop1.getVersion(), controlLoop2.getVersion());
+        assertEquals(controlLoop1.getServices(), controlLoop2.getServices());
+        assertEquals(controlLoop1.getResources(), controlLoop2.getResources());
+        assertEquals(controlLoop1.getPnf(), controlLoop2.getPnf());
+        assertEquals(controlLoop1.getTrigger_policy(), controlLoop2.getTrigger_policy());
+        assertEquals(controlLoop1.getAbatement(), controlLoop2.getAbatement());
+
+        assertTrue(controlLoop1.equals(controlLoop2));
+    }
+
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/OperationsAccumulateParamsTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/OperationsAccumulateParamsTest.java
new file mode 100644
index 000000000..d06f3c010
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/OperationsAccumulateParamsTest.java
@@ -0,0 +1,125 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. All rights reserved.
+ * Modifications Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.policy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class OperationsAccumulateParamsTest {
+
+    @Test
+    public void testConstructor() {
+        OperationsAccumulateParams operationsAccumulateParams = new OperationsAccumulateParams();
+        assertNull(operationsAccumulateParams.getPeriod());
+        assertNull(operationsAccumulateParams.getLimit());
+    }
+
+    @Test
+    public void testConstructorOperationsAccumulateParams() {
+        String period = "15m";
+        Integer limit = 10;
+        OperationsAccumulateParams operationsAccumulateParams1 = 
+                        new OperationsAccumulateParams(period, limit);
+        OperationsAccumulateParams operationsAccumulateParams2 = 
+                        new OperationsAccumulateParams(operationsAccumulateParams1);
+        assertEquals(period, operationsAccumulateParams1.getPeriod());
+        assertEquals(limit, operationsAccumulateParams2.getLimit());
+    }
+
+    @Test
+    public void testOperationsAccumulateParamsStringInteger() {
+        String period = "15m";
+        Integer limit = 10;
+        OperationsAccumulateParams operationsAccumulateParams = new OperationsAccumulateParams(period, limit);
+        assertEquals(period, operationsAccumulateParams.getPeriod());
+        assertEquals(limit, operationsAccumulateParams.getLimit());
+    }
+
+    @Test
+    public void testSetAndGetPeriod() {
+        String period = "15m";
+        OperationsAccumulateParams operationsAccumulateParams = new OperationsAccumulateParams();
+        operationsAccumulateParams.setPeriod(period);
+        assertEquals(period, operationsAccumulateParams.getPeriod());
+    }
+
+    @Test
+    public void testSetLimit() {
+        Integer limit = 10;
+        OperationsAccumulateParams operationsAccumulateParams = new OperationsAccumulateParams();
+        operationsAccumulateParams.setLimit(limit);
+        assertEquals(limit, operationsAccumulateParams.getLimit());
+    }
+
+    @Test
+    public void testToString() {
+        String period = "15m";
+        Integer limit = 10;
+        OperationsAccumulateParams operationsAccumulateParams = new OperationsAccumulateParams(period, limit);
+        assertEquals("OperationsAccumulateParams [period=15m, limit=10]", operationsAccumulateParams.toString());
+    }
+
+    @Test
+    public void testEqualsAndHashCode() {
+        final String period = "15m";
+        final Integer limit = 10;
+        OperationsAccumulateParams operationsAccumulateParams1 = new OperationsAccumulateParams();
+        OperationsAccumulateParams operationsAccumulateParams2 = new OperationsAccumulateParams();
+
+        assertTrue(operationsAccumulateParams1.equals(operationsAccumulateParams2));
+
+        operationsAccumulateParams1.setPeriod(period);
+        assertFalse(operationsAccumulateParams1.equals(operationsAccumulateParams2));
+        operationsAccumulateParams2.setPeriod(period);
+        assertTrue(operationsAccumulateParams1.equals(operationsAccumulateParams2));
+        assertEquals(operationsAccumulateParams1.hashCode(), operationsAccumulateParams2.hashCode());
+
+        operationsAccumulateParams1.setLimit(limit);;
+        assertFalse(operationsAccumulateParams1.equals(operationsAccumulateParams2));
+        operationsAccumulateParams2.setLimit(limit);
+        assertTrue(operationsAccumulateParams1.equals(operationsAccumulateParams2));
+        assertEquals(operationsAccumulateParams1.hashCode(), operationsAccumulateParams2.hashCode());
+    }
+
+
+    @Test
+    public void testEqualsSameObject() {
+        OperationsAccumulateParams operationsAccumulateParams = new OperationsAccumulateParams();
+        assertTrue(operationsAccumulateParams.equals(operationsAccumulateParams));
+    }
+
+    @Test
+    public void testEqualsNull() {
+        OperationsAccumulateParams operationsAccumulateParams = new OperationsAccumulateParams();
+        assertFalse(operationsAccumulateParams.equals(null));
+    }
+
+    @Test
+    public void testEqualsInstanceOfDiffClass() {
+        OperationsAccumulateParams operationsAccumulateParams = new OperationsAccumulateParams();
+        assertFalse(operationsAccumulateParams.equals(""));
+    }
+
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/PolicyTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/PolicyTest.java
new file mode 100644
index 000000000..e87a421c4
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/PolicyTest.java
@@ -0,0 +1,221 @@
+/*
+ * ============LICENSE_START=======================================================
+ * policy-yaml unit test
+ * ================================================================================
+ * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.policy;
+
+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 java.io.IOException;
+import java.util.Map;
+import java.util.TreeMap;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.policy.common.utils.io.Serializer;
+
+public class PolicyTest {
+    private Policy policy;
+
+    @Before
+    public void setUp() {
+        policy = new Policy();
+    }
+
+    @Test
+    public void testHashCode() {
+        assertTrue(policy.hashCode() != 0);
+
+        policy.setActor("a");
+        int hc1 = policy.hashCode();
+
+        policy.setActor("b");
+        assertTrue(hc1 != policy.hashCode());
+    }
+
+    @Test
+    public void test() throws IOException {
+        OperationsAccumulateParams operationsAccumulateParams = new OperationsAccumulateParams();
+        operationsAccumulateParams.setLimit(10);
+
+        Map<String, String> payload = new TreeMap<>();
+        payload.put("mykey", "myvalue");
+
+        Target target = new Target();
+        target.setResourceID("myresource");
+
+        policy.setActor("act");
+        policy.setDescription("desc");
+        policy.setFailure("fail");
+        policy.setFailure_exception("failex");
+        policy.setFailure_guard("failguard");
+        policy.setFailure_retries("failretry");
+        policy.setFailure_timeout("failtimeout");
+        policy.setId("myid");
+        policy.setName("myname");
+        policy.setOperationsAccumulateParams(operationsAccumulateParams);
+        policy.setPayload(payload);
+        policy.setRecipe("myrecipe");
+        policy.setRetry(20);
+        policy.setSuccess("succ");
+        policy.setTarget(target);
+        policy.setTimeout(30);
+
+        assertEquals("act", policy.getActor());
+        assertEquals("desc", policy.getDescription());
+        assertEquals("fail", policy.getFailure());
+        assertEquals("failex", policy.getFailure_exception());
+        assertEquals("failguard", policy.getFailure_guard());
+        assertEquals("failretry", policy.getFailure_retries());
+        assertEquals("failtimeout", policy.getFailure_timeout());
+        assertEquals("myid", policy.getId());
+        assertEquals("myname", policy.getName());
+        assertEquals(operationsAccumulateParams, policy.getOperationsAccumulateParams());
+        assertEquals(payload, policy.getPayload());
+        assertEquals("myrecipe", policy.getRecipe());
+        assertEquals(20, policy.getRetry().intValue());
+        assertEquals("succ", policy.getSuccess());
+        assertEquals(target, policy.getTarget());
+        assertEquals(30, policy.getTimeout().intValue());
+
+        assertTrue(policy.equals(policy));
+        assertTrue(policy.hashCode() != new Policy().hashCode());
+        assertFalse(policy.equals(new Policy()));
+
+        Policy policy2 = Serializer.roundTrip(policy);
+        assertTrue(policy.equals(policy2));
+        assertEquals(policy.hashCode(), policy2.hashCode());
+
+        policy2 = new Policy(policy);
+        assertTrue(policy.equals(policy2));
+        assertEquals(policy.hashCode(), policy2.hashCode());
+    }
+
+    @Test
+    public void testPolicyString() {
+        policy = new Policy("justId");
+        assertEquals("justId", policy.getId());
+    }
+
+    @Test
+    public void testPolicyStringStringStringMapOfStringStringTarget() {
+        Map<String, String> payload = new TreeMap<>();
+        payload.put("mykeyB", "myvalueB");
+
+        Target target = new Target();
+        target.setResourceID("myresourceB");
+
+        policy = new Policy("nameB", "actorB", "recipeB", payload, target);
+        assertEquals("nameB", policy.getName());
+        assertEquals("actorB", policy.getActor());
+        assertEquals("recipeB", policy.getRecipe());
+        assertEquals(payload, policy.getPayload());
+        assertEquals(target, policy.getTarget());
+
+        assertTrue(policy.hashCode() != new Policy().hashCode());
+    }
+
+    @Test
+    public void testPolicyStringStringStringMapOfStringStringTargetIntegerInteger() {
+        Map<String, String> payload = new TreeMap<>();
+        payload.put("mykeyC", "myvalueC");
+
+        Target target = new Target();
+        target.setResourceID("myresourceC");
+
+        policy = new Policy("nameC", "actorC", "recipeC", payload, target, 201, 202);
+        assertEquals("nameC", policy.getName());
+        assertEquals("actorC", policy.getActor());
+        assertEquals("recipeC", policy.getRecipe());
+        assertEquals(payload, policy.getPayload());
+        assertEquals(target, policy.getTarget());
+        assertEquals(201, policy.getRetry().intValue());
+        assertEquals(202, policy.getTimeout().intValue());
+
+        assertTrue(policy.hashCode() != new Policy().hashCode());
+    }
+
+    @Test
+    public void testPolicyStringStringStringStringMapOfStringStringTargetStringIntegerInteger() {
+        Map<String, String> payload = new TreeMap<>();
+        payload.put("mykeyD", "myvalueD");
+
+        Target target = new Target();
+        target.setResourceID("myresourceD");
+
+        policy = new Policy(
+                PolicyParam.builder().id("idD")
+                .name("nameD")
+                .description("descD")
+                .actor("actorD")
+                .payload(payload)
+                .target(target)
+                .recipe("recipeD")
+                .retries(301)
+                .timeout(302)
+                .build());
+        assertEquals("idD", policy.getId());
+        assertEquals("nameD", policy.getName());
+        assertEquals("descD", policy.getDescription());
+        assertEquals("actorD", policy.getActor());
+        assertEquals(payload, policy.getPayload());
+        assertEquals(target, policy.getTarget());
+        assertEquals("recipeD", policy.getRecipe());
+        assertEquals(301, policy.getRetry().intValue());
+        assertEquals(302, policy.getTimeout().intValue());
+
+        assertTrue(policy.hashCode() != new Policy().hashCode());
+    }
+
+    @Test
+    public void testIsValid() {
+        assertFalse(policy.isValid());
+
+        Target target = new Target();
+        target.setResourceID("myresourceV");
+
+        policy = new Policy("nameV", "actorV", "recipeV", null, target);
+        assertEquals(null, policy.getPayload());
+        assertTrue(policy.isValid());
+    }
+
+    @Test
+    public void testToString() {
+        assertNotNull(policy.toString());
+    }
+
+    @Test
+    public void testEqualsObject() {
+        assertTrue(policy.equals(policy));
+
+        policy.setId("idE");
+        assertFalse(policy.equals(new Policy()));
+
+        Policy policy2 = new Policy();
+        policy2.setId(policy.getId());
+        assertTrue(policy.equals(policy2));
+
+        policy2.setId("idX");
+        assertFalse(policy.equals(policy2));
+    }
+
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ConstraintTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ConstraintTest.java
new file mode 100644
index 000000000..0c8901ffb
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ConstraintTest.java
@@ -0,0 +1,256 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. All rights reserved.
+ * Modifications Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.policy.guard;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+
+public class ConstraintTest {
+
+    @Test
+    public void testConstraint() {
+        Constraint constraint = new Constraint();
+
+        assertNull(constraint.getFreq_limit_per_target());
+        assertNull(constraint.getTime_window());
+        assertNull(constraint.getActive_time_range());
+        assertNull(constraint.getBlacklist());
+    }
+
+    @Test
+    public void testGetAndSetFreq_limit_per_target() {
+        Integer freqLimitPerTarget = 10;
+        Constraint constraint = new Constraint();
+        constraint.setFreq_limit_per_target(freqLimitPerTarget);
+        assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
+    }
+
+    @Test
+    public void testGetAndSetTime_window() {
+        Map<String, String> timeWindow = new HashMap<>();
+        timeWindow.put("timeWindowKey", "timeWindowValue");
+        Constraint constraint = new Constraint();
+        constraint.setTime_window(timeWindow);
+        assertEquals(timeWindow, constraint.getTime_window());
+    }
+
+    @Test
+    public void testGetAndSetActive_time_range() {
+        Map<String, String> activeTimeRange = new HashMap<>();
+        activeTimeRange.put("timeWindowKey", "timeWindowValue");
+        Constraint constraint = new Constraint();
+        constraint.setActive_time_range(activeTimeRange);;
+        assertEquals(activeTimeRange, constraint.getActive_time_range());
+    }
+
+    @Test
+    public void testGetAndSetBlacklist() {
+        List<String> blacklist = new ArrayList<>();
+        blacklist.add("blacklist item");
+        Constraint constraint = new Constraint();
+        constraint.setBlacklist(blacklist);
+        assertEquals(blacklist, constraint.getBlacklist());
+    }
+
+    @Test
+    public void testConstraintIntegerMapOfStringString() {
+        Integer freqLimitPerTarget = 10;
+        Map<String, String> timeWindow = new HashMap<>();
+
+        Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow);
+
+        assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
+        assertEquals(timeWindow, constraint.getTime_window());
+        assertNull(constraint.getActive_time_range());
+        assertNull(constraint.getBlacklist());
+    }
+
+    @Test
+    public void testConstraintListOfString() {
+        List<String> blacklist = new ArrayList<>();
+        blacklist.add("blacklist item");
+        Constraint constraint = new Constraint(blacklist);
+
+        assertNull(constraint.getFreq_limit_per_target());
+        assertNull(constraint.getTime_window());
+        assertNull(constraint.getActive_time_range());
+        assertEquals(blacklist, constraint.getBlacklist());
+    }
+
+    @Test
+    public void testConstraintIntegerMapOfStringStringListOfString() {
+        Integer freqLimitPerTarget = 10;
+        Map<String, String> timeWindow = new HashMap<>();
+        List<String> blacklist = new ArrayList<>();
+        blacklist.add("blacklist item");
+        Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, blacklist);
+
+        assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
+        assertEquals(timeWindow, constraint.getTime_window());
+        assertNull(constraint.getActive_time_range());
+        assertEquals(blacklist, constraint.getBlacklist());
+    }
+
+    @Test
+    public void testConstraintIntegerMapOfStringStringMapOfStringString() {
+        Integer freqLimitPerTarget = 10;
+        Map<String, String> timeWindow = new HashMap<>();
+        Map<String, String> activeTimeRange = new HashMap<>();
+        activeTimeRange.put("timeWindowKey", "timeWindowValue");
+        Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange);
+
+        assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
+        assertEquals(timeWindow, constraint.getTime_window());
+        assertEquals(activeTimeRange, constraint.getActive_time_range());
+        assertNull(constraint.getBlacklist());
+
+    }
+
+    @Test
+    public void testConstraintIntegerMapOfStringStringMapOfStringStringListOfString() {
+        Integer freqLimitPerTarget = 10;
+        Map<String, String> timeWindow = new HashMap<>();
+        Map<String, String> activeTimeRange = new HashMap<>();
+        activeTimeRange.put("timeWindowKey", "timeWindowValue");
+        List<String> blacklist = new ArrayList<>();
+        blacklist.add("blacklist item");
+        Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
+
+        assertEquals(freqLimitPerTarget, constraint.getFreq_limit_per_target());
+        assertEquals(timeWindow, constraint.getTime_window());
+        assertEquals(activeTimeRange, constraint.getActive_time_range());
+        assertEquals(blacklist, constraint.getBlacklist());
+    }
+
+    @Test
+    public void testConstraintConstraint() {
+        Integer freqLimitPerTarget = 10;
+        Map<String, String> timeWindow = new HashMap<>();
+        Map<String, String> activeTimeRange = new HashMap<>();
+        activeTimeRange.put("timeWindowKey", "timeWindowValue");
+        List<String> blacklist = new ArrayList<>();
+        blacklist.add("blacklist item");
+        Constraint constraint1 = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
+        Constraint constraint2 = new Constraint(constraint1);
+
+        assertEquals(freqLimitPerTarget, constraint2.getFreq_limit_per_target());
+        assertEquals(timeWindow, constraint2.getTime_window());
+        assertEquals(activeTimeRange, constraint2.getActive_time_range());
+        assertEquals(blacklist, constraint2.getBlacklist());
+    }
+
+    @Test
+    public void testIsValid() {
+        Integer freqLimitPerTarget = 10;
+        final Map<String, String> timeWindow = new HashMap<>();
+
+        Constraint constraint = new Constraint();
+        assertTrue(constraint.isValid());
+
+        constraint.setFreq_limit_per_target(freqLimitPerTarget);
+        assertFalse(constraint.isValid());
+
+        constraint.setTime_window(timeWindow);
+        assertTrue(constraint.isValid());
+
+        constraint.setFreq_limit_per_target(null);
+        assertFalse(constraint.isValid());
+    }
+
+    @Test
+    public void testToString() {
+        Integer freqLimitPerTarget = 10;
+        Map<String, String> timeWindow = new HashMap<>();
+        Map<String, String> activeTimeRange = new HashMap<>();
+        activeTimeRange.put("timeWindowKey", "timeWindowValue");
+        List<String> blacklist = new ArrayList<>();
+        blacklist.add("blacklist item");
+        Constraint constraint = new Constraint(freqLimitPerTarget, timeWindow, activeTimeRange, blacklist);
+
+        assertEquals(constraint.toString(), "Constraint [freq_limit_per_target=" + freqLimitPerTarget + ", time_window="
+                + timeWindow + ", active_time_range=" + activeTimeRange + ", blacklist=" + blacklist + "]");
+    }
+
+    @Test
+    public void testEquals() {
+        Integer freqLimitPerTarget = 10;
+        final Map<String, String> timeWindow = new HashMap<>();
+        final Map<String, String> activeTimeRange = new HashMap<>();
+        List<String> blacklist = new ArrayList<>();
+        blacklist.add("blacklist item");
+
+        Constraint constraint1 = new Constraint();
+        Constraint constraint2 = new Constraint();
+        assertTrue(constraint1.equals(constraint2));
+
+        constraint1.setFreq_limit_per_target(freqLimitPerTarget);
+        assertFalse(constraint1.equals(constraint2));
+        constraint2.setFreq_limit_per_target(freqLimitPerTarget);
+        assertTrue(constraint1.equals(constraint2));
+        assertEquals(constraint1.hashCode(), constraint2.hashCode());
+
+        constraint1.setTime_window(timeWindow);
+        assertFalse(constraint1.equals(constraint2));
+        constraint2.setTime_window(timeWindow);
+        assertTrue(constraint1.equals(constraint2));
+        assertEquals(constraint1.hashCode(), constraint2.hashCode());
+
+        constraint1.setActive_time_range(activeTimeRange);
+        assertFalse(constraint1.equals(constraint2));
+        constraint2.setActive_time_range(activeTimeRange);
+        assertTrue(constraint1.equals(constraint2));
+        assertEquals(constraint1.hashCode(), constraint2.hashCode());
+
+        constraint1.setBlacklist(blacklist);
+        assertFalse(constraint1.equals(constraint2));
+        constraint2.setBlacklist(blacklist);
+        assertTrue(constraint1.equals(constraint2));
+        assertEquals(constraint1.hashCode(), constraint2.hashCode());
+    }
+
+    @Test
+    public void testEqualsSameObject() {
+        Constraint constraint = new Constraint();
+        assertTrue(constraint.equals(constraint));
+    }
+
+    @Test
+    public void testEqualsNull() {
+        Constraint constraint = new Constraint();
+        assertFalse(constraint.equals(null));
+    }
+
+    @Test
+    public void testEqualsInstanceOfDiffClass() {
+        Constraint constraint = new Constraint();
+        assertFalse(constraint.equals(""));
+    }
+
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ControlLoopGuardBuilderTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ControlLoopGuardBuilderTest.java
new file mode 100644
index 000000000..f289d931f
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ControlLoopGuardBuilderTest.java
@@ -0,0 +1,218 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * policy-yaml unit test
+ * ================================================================================
+ * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.policy.guard;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+import org.onap.policy.controlloop.policy.builder.BuilderException;
+import org.onap.policy.controlloop.policy.builder.Message;
+import org.onap.policy.controlloop.policy.builder.MessageLevel;
+import org.onap.policy.controlloop.policy.builder.Results;
+import org.onap.policy.controlloop.policy.guard.builder.ControlLoopGuardBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+
+public class ControlLoopGuardBuilderTest {
+    private static final Logger logger = LoggerFactory.getLogger(ControlLoopGuardBuilderTest.class);
+    
+    @Test
+    public void testControlLoopGuard() {
+        try {
+            //
+            // Create a builder
+            //
+            ControlLoopGuardBuilder builder = ControlLoopGuardBuilder.Factory.buildControlLoopGuard(new Guard());
+            //
+            // Assert there is no guard policies yet
+            //
+            Results results = builder.buildSpecification();
+            boolean noGuardPolicies = false;
+            for (Message m : results.getMessages()) {
+                if (m.getMessage().equals("ControlLoop Guard should have at least one guard policies") 
+                                && m.getLevel() == MessageLevel.ERROR) {
+                    noGuardPolicies = true;
+                    break;
+                }
+            }
+            assertTrue(noGuardPolicies);
+            //
+            // Add a guard policy without limit constraint
+            //
+            String clname = "CL_vUSP123";
+            LinkedList<String> targets = new LinkedList<String>();
+            targets.add("s1");
+            targets.add("s2");
+            targets.add("s3");
+            MatchParameters matchParameters = new MatchParameters(clname, "APPC", "Restart", targets);
+            GuardPolicy policy1 = new GuardPolicy("id123", "guardpolicy1", "description aaa", matchParameters);
+            builder = builder.addGuardPolicy(policy1);
+            //
+            // Assert there is no limit constraint associated with the only guard policy
+            //
+            results = builder.buildSpecification();
+            boolean noConstraint = false;
+            for (Message m : results.getMessages()) {
+                if (m.getMessage().equals("Guard policy guardpolicy1 does not have any limit constraint") 
+                                && m.getLevel() == MessageLevel.ERROR) {
+                    noConstraint = true;
+                    break;
+                }
+            }
+            assertTrue(noConstraint);
+            //
+            // Add a constraint to policy1
+            //
+            Map<String, String> activeTimeRange = new HashMap<String, String>();
+            activeTimeRange.put("start", "00:00:00-05:00");
+            activeTimeRange.put("end", "23:59:59-05:00");
+            List<String> blacklist = new LinkedList<String>();
+            blacklist.add("eNodeB_common_id1");
+            blacklist.add("eNodeB_common_id2");
+            Map<String, String> timeWindow = new HashMap<String, String>();
+            timeWindow.put("value", "10");
+            timeWindow.put("units", "minute");
+            Constraint cons = new Constraint(5, timeWindow, activeTimeRange, blacklist);
+            builder = builder.addLimitConstraint(policy1.getId(), cons);
+            //
+            // Add a duplicate constraint to policy1
+            //
+            builder = builder.addLimitConstraint(policy1.getId(), cons);
+            //
+            // Assert there are duplicate constraints associated with the only guard policy
+            //
+            results = builder.buildSpecification();
+            boolean duplicateConstraint = false;
+            for (Message m : results.getMessages()) {
+                if (m.getMessage().equals("Guard policy guardpolicy1 has duplicate limit constraints") 
+                                && m.getLevel() == MessageLevel.WARNING) {
+                    duplicateConstraint = true;
+                    break;
+                }
+            }
+            assertTrue(duplicateConstraint);
+            //
+            // Remove the duplicate constraint
+            //
+            builder = builder.removeLimitConstraint(policy1.getId(), cons);
+            //
+            // Add a duplicate guard policy 
+            //
+            builder = builder.addGuardPolicy(policy1);
+            builder = builder.addLimitConstraint(policy1.getId(), cons);
+            //
+            // Assert there are duplicate guard policies
+            //
+            results = builder.buildSpecification();
+            boolean duplicateGuardPolicy = false;
+            for (Message m : results.getMessages()) {
+                if (m.getMessage().equals("There are duplicate guard policies") 
+                                && m.getLevel() == MessageLevel.WARNING) {
+                    duplicateGuardPolicy = true;
+                    break;
+                }
+            }
+            assertTrue(duplicateGuardPolicy);
+            //
+            // Remove the duplicate guard policy
+            //
+            builder = builder.removeGuardPolicy(policy1);
+            //
+            // Assert there are no Error/Warning message
+            //
+            results = builder.buildSpecification();
+            assertTrue(results.getMessages().size() == 1);
+            //
+        } catch (BuilderException e) {
+            fail(e.getMessage());
+        }
+    }
+    
+    @Test
+    public void test1() {
+        this.test("src/test/resources/v2.0.0-guard/policy_guard_ONAP_demo_vDNS.yaml");
+    }
+    
+    @Test
+    public void test2() {
+        this.test("src/test/resources/v2.0.0-guard/policy_guard_appc_restart.yaml");
+    }
+    
+    /**
+     * Do the actual test.
+     * 
+     * @param testFile input test file
+     */
+    public void test(String testFile) {
+        try (InputStream is = new FileInputStream(new File(testFile))) {
+            //
+            // Read the yaml into our Java Object
+            //
+            Yaml yaml = new Yaml(new Constructor(ControlLoopGuard.class));
+            Object obj = yaml.load(is);
+            assertNotNull(obj);
+            assertTrue(obj instanceof ControlLoopGuard);
+            ControlLoopGuard guardTobuild = (ControlLoopGuard) obj;
+            //
+            // Now we're going to try to use the builder to build this.
+            //
+            ControlLoopGuardBuilder builder = 
+                            ControlLoopGuardBuilder.Factory.buildControlLoopGuard(guardTobuild.getGuard());
+            //
+            // Add guard policy
+            //
+            if (guardTobuild.getGuards() != null) {
+                builder = builder.addGuardPolicy(guardTobuild.getGuards().toArray(
+                                new GuardPolicy[guardTobuild.getGuards().size()]));
+            }
+            //
+            // Build the specification
+            //
+            Results results = builder.buildSpecification();
+            //
+            // Print out the specification
+            //
+            logger.debug(results.getSpecification());
+            //
+        } catch (FileNotFoundException e) {
+            fail(e.getLocalizedMessage());
+        } catch (IOException e) {
+            fail(e.getLocalizedMessage());
+        } catch (BuilderException e) {
+            fail(e.getLocalizedMessage());
+        }
+    }
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ControlLoopGuardTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ControlLoopGuardTest.java
new file mode 100644
index 000000000..01d6eb1fe
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/ControlLoopGuardTest.java
@@ -0,0 +1,170 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * policy-yaml unit test
+ * ================================================================================
+ * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.policy.guard;
+
+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 static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedList;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.DumperOptions.FlowStyle;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+
+
+public class ControlLoopGuardTest {
+    private static final Logger logger = LoggerFactory.getLogger(ControlLoopGuardTest.class);
+    
+    @Test 
+    public void testGuardvdns() {
+        this.test("src/test/resources/v2.0.0-guard/policy_guard_ONAP_demo_vDNS.yaml");
+    }
+
+    @Test 
+    public void testGuardvusp() {
+        this.test("src/test/resources/v2.0.0-guard/policy_guard_appc_restart.yaml");
+    }
+
+    @Test
+    public void testConstructorControlLoopGuard() {
+        Guard guard1 = new Guard();
+        GuardPolicy guardPolicy1 = new GuardPolicy();
+        GuardPolicy guardPolicy2 = new GuardPolicy();
+        LinkedList<GuardPolicy> guardPolicies = new LinkedList<>();
+        guardPolicies.add(guardPolicy1);
+        guardPolicies.add(guardPolicy2);
+
+        ControlLoopGuard controlLoopGuard1 = new ControlLoopGuard();
+        controlLoopGuard1.setGuard(guard1);
+        controlLoopGuard1.setGuards(guardPolicies);
+        ControlLoopGuard controlLoopGuard2 = new ControlLoopGuard(controlLoopGuard1);
+
+        assertEquals(guard1, controlLoopGuard2.getGuard());
+        assertEquals(guardPolicies, controlLoopGuard2.getGuards());
+    }
+
+    @Test
+    public void testEqualsAndHashCode() {
+        final Guard guard1 = new Guard();
+        GuardPolicy guardPolicy1 = new GuardPolicy();
+        GuardPolicy guardPolicy2 = new GuardPolicy();
+        LinkedList<GuardPolicy> guardPolicies = new LinkedList<>();
+        guardPolicies.add(guardPolicy1);
+        guardPolicies.add(guardPolicy2);
+
+        ControlLoopGuard controlLoopGuard1 = new ControlLoopGuard();
+        ControlLoopGuard controlLoopGuard2 = new ControlLoopGuard();
+
+        assertTrue(controlLoopGuard1.equals(controlLoopGuard2));
+        assertEquals(controlLoopGuard1.hashCode(), controlLoopGuard2.hashCode());
+
+        controlLoopGuard1.setGuard(guard1);
+        assertFalse(controlLoopGuard1.equals(controlLoopGuard2));
+        controlLoopGuard2.setGuard(guard1);
+        assertTrue(controlLoopGuard1.equals(controlLoopGuard2));
+        assertEquals(controlLoopGuard1.hashCode(), controlLoopGuard2.hashCode());
+
+        controlLoopGuard1.setGuards(guardPolicies);
+        assertFalse(controlLoopGuard1.equals(controlLoopGuard2));
+        controlLoopGuard2.setGuards(guardPolicies);
+        assertTrue(controlLoopGuard1.equals(controlLoopGuard2));
+        assertEquals(controlLoopGuard1.hashCode(), controlLoopGuard2.hashCode());
+    }
+
+    @Test
+    public void testEqualsSameObject() {
+        ControlLoopGuard controlLoopGuard = new ControlLoopGuard();
+        assertTrue(controlLoopGuard.equals(controlLoopGuard));
+    }
+
+    @Test
+    public void testEqualsNull() {
+        ControlLoopGuard controlLoopGuard = new ControlLoopGuard();
+        assertFalse(controlLoopGuard.equals(null));
+    }
+
+    @Test
+    public void testEqualsInstanceOfDiffClass() {
+        ControlLoopGuard controlLoopGuard = new ControlLoopGuard();
+        assertFalse(controlLoopGuard.equals(""));
+    }
+
+    /**
+     * Does the actual test.
+     * 
+     * @param testFile input file
+     */
+    public void test(String testFile) {
+        try (InputStream is = new FileInputStream(new File(testFile))) {
+            //
+            // Read the yaml into our Java Object
+            //
+            Yaml yaml = new Yaml(new Constructor(ControlLoopGuard.class));
+            Object obj = yaml.load(is);
+            assertNotNull(obj);
+            assertTrue(obj instanceof ControlLoopGuard);
+            dump(obj);
+            //
+            // Now dump it to a yaml string
+            //
+            DumperOptions options = new DumperOptions();
+            options.setDefaultFlowStyle(FlowStyle.BLOCK);
+            options.setPrettyFlow(true);
+            yaml = new Yaml(options);
+            String dumpedYaml = yaml.dump(obj);
+            logger.debug(dumpedYaml);
+            //
+            // Read that string back into our java object
+            //
+            Object newObject = yaml.load(dumpedYaml);
+            dump(newObject);
+            assertNotNull(newObject);
+            assertTrue(newObject instanceof ControlLoopGuard);
+            //
+            // Have to comment it out tentatively since it causes junit to fail. 
+            // Seems we cannot use assertEquals here. Need advice.
+            //
+            //assertEquals(newObject, obj);
+        } catch (FileNotFoundException e) {
+            fail(e.getLocalizedMessage());
+        } catch (IOException e) {
+            fail(e.getLocalizedMessage());
+        }
+    }
+
+    public void dump(Object obj) {
+        logger.debug("Dumping {}", obj.getClass().getCanonicalName());
+        logger.debug("{}", obj);
+    }
+}
diff --git a/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/GuardPolicyTest.java b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/GuardPolicyTest.java
new file mode 100644
index 000000000..a8d183c8c
--- /dev/null
+++ b/models-interactions/model-yaml/src/test/java/org/onap/policy/controlloop/policy/guard/GuardPolicyTest.java
@@ -0,0 +1,271 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. All rights reserved.
+ * Modifications Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2019 Nordix Foundation.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.policy.guard;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+
+public class GuardPolicyTest {
+
+    @Test
+    public void testConstructor() {
+        GuardPolicy guardPolicy = new GuardPolicy();
+
+        assertNotNull(guardPolicy.getId());
+        assertNull(guardPolicy.getName());
+        assertNull(guardPolicy.getDescription());
+        assertNull(guardPolicy.getMatch_parameters());
+        assertNull(guardPolicy.getLimit_constraints());
+    }
+
+    @Test
+    public void testConstructorString() {
+        String id = "guard id";
+        GuardPolicy guardPolicy = new GuardPolicy(id);
+
+        assertEquals(id, guardPolicy.getId());
+        assertNull(guardPolicy.getName());
+        assertNull(guardPolicy.getDescription());
+        assertNull(guardPolicy.getMatch_parameters());
+        assertNull(guardPolicy.getLimit_constraints());
+    }
+
+    @Test
+    public void testConstructorStringStringStringMatchParameters() {
+        String id = "guard id";
+        String name = "guard name";
+        String description = "guard description";
+        MatchParameters matchParameters = new MatchParameters();
+        List<Constraint> limitConstraints = new LinkedList<>();
+        limitConstraints.add(new Constraint());
+        GuardPolicy guardPolicy = new GuardPolicy(id, name, description, matchParameters);
+
+        assertNotNull(guardPolicy.getId());
+        assertEquals(name, guardPolicy.getName());
+        assertEquals(description, guardPolicy.getDescription());
+        assertEquals(matchParameters, guardPolicy.getMatch_parameters());
+        assertNull(guardPolicy.getLimit_constraints());
+    }
+
+    @Test
+    public void testConstructorStringMatchParametersList() {
+        String name = "guard name";
+        MatchParameters matchParameters = new MatchParameters();
+        List<Constraint> limitConstraints = new LinkedList<>();
+        limitConstraints.add(new Constraint());
+        GuardPolicy guardPolicy = new GuardPolicy(name, matchParameters, limitConstraints);
+
+        assertNotNull(guardPolicy.getId());
+        assertEquals(name, guardPolicy.getName());
+        assertNull(guardPolicy.getDescription());
+        assertEquals(matchParameters, guardPolicy.getMatch_parameters());
+        assertEquals(limitConstraints, guardPolicy.getLimit_constraints());
+    }
+
+    @Test
+    public void testConstructorStringStringMatchParametersList() {
+        String name = "guard name";
+        String description = "guard description";
+        MatchParameters matchParameters = new MatchParameters();
+        List<Constraint> limitConstraints = new LinkedList<>();
+        limitConstraints.add(new Constraint());
+        GuardPolicy guardPolicy = new GuardPolicy(name, description, matchParameters, limitConstraints);
+
+        assertNotNull(guardPolicy.getId());
+        assertEquals(name, guardPolicy.getName());
+        assertEquals(description, guardPolicy.getDescription());
+        assertEquals(matchParameters, guardPolicy.getMatch_parameters());
+        assertEquals(limitConstraints, guardPolicy.getLimit_constraints());
+    }
+
+    @Test
+    public void testConstructorStringStringStringMatchParametersList() {
+        String id = "guard id";
+        String name = "guard name";
+        String description = "guard description";
+        MatchParameters matchParameters = new MatchParameters();
+        List<Constraint> limitConstraints = new LinkedList<>();
+        limitConstraints.add(new Constraint());
+        GuardPolicy guardPolicy = new GuardPolicy(id, name, description, matchParameters, limitConstraints);
+
+        assertEquals(id, guardPolicy.getId());
+        assertEquals(name, guardPolicy.getName());
+        assertEquals(description, guardPolicy.getDescription());
+        assertEquals(matchParameters, guardPolicy.getMatch_parameters());
+        assertEquals(limitConstraints, guardPolicy.getLimit_constraints());
+    }
+
+    @Test
+    public void testConstructorGuardPolicy() {
+        String id = "guard id";
+        String name = "guard name";
+        String description = "guard description";
+        MatchParameters matchParameters = new MatchParameters();
+        List<Constraint> limitConstraints = new LinkedList<>();
+        limitConstraints.add(new Constraint());
+        GuardPolicy guardPolicy1 = new GuardPolicy(id, name, description, matchParameters, limitConstraints);
+
+        GuardPolicy guardPolicy2 = new GuardPolicy(guardPolicy1);
+
+
+        assertEquals(id, guardPolicy2.getId());
+        assertEquals(name, guardPolicy2.getName());
+        assertEquals(description, guardPolicy2.getDescription());
+        assertEquals(matchParameters, guardPolicy2.getMatch_parameters());
+        assertEquals(limitConstraints, guardPolicy2.getLimit_constraints());
+    }
+
+    @Test
+    public void testSetAndGetId() {
+        String id = "guard id";
+        GuardPolicy guardPolicy = new GuardPolicy();
+        guardPolicy.setId(id);
+        assertEquals(id, guardPolicy.getId());
+    }
+
+    @Test
+    public void testSetAndGetName() {
+        String name = "guard name";
+        GuardPolicy guardPolicy = new GuardPolicy();
+        guardPolicy.setName(name);
+        assertEquals(name, guardPolicy.getName());
+    }
+
+    @Test
+    public void testSetAndGetDescription() {
+        String description = "guard description";
+        GuardPolicy guardPolicy = new GuardPolicy();
+        guardPolicy.setDescription(description);
+        assertEquals(description, guardPolicy.getDescription());
+    }
+
+    @Test
+    public void testSetAndGetMatchParameters() {
+        MatchParameters matchParameters = new MatchParameters();
+        GuardPolicy guardPolicy = new GuardPolicy();
+        guardPolicy.setMatch_parameters(matchParameters);
+        assertEquals(matchParameters, guardPolicy.getMatch_parameters());
+    }
+
+    @Test
+    public void testSetAndGetLimitConstraints() {
+        LinkedList<Constraint> limitConstraints = new LinkedList<>();
+        limitConstraints.add(new Constraint());
+        GuardPolicy guardPolicy = new GuardPolicy();
+        guardPolicy.setLimit_constraints(limitConstraints);
+        assertEquals(limitConstraints, guardPolicy.getLimit_constraints());
+    }
+
+    @Test
+    public void testIsValid() {
+        GuardPolicy guardPolicy = new GuardPolicy();
+        assertFalse(guardPolicy.isValid());
+
+        guardPolicy.setName("guard name");
+        assertTrue(guardPolicy.isValid());
+
+        guardPolicy.setId(null);
+        assertFalse(guardPolicy.isValid());
+    }
+
+    @Test
+    public void testToString() {
+        String id = "guard id";
+        String name = "guard name";
+        String description = "guard description";
+        MatchParameters matchParameters = new MatchParameters();
+        List<Constraint> limitConstraints = new LinkedList<>();
+        limitConstraints.add(new Constraint());
+        GuardPolicy guardPolicy = new GuardPolicy(id, name, description, matchParameters, limitConstraints);
+
+        assertEquals(guardPolicy.toString(), "Policy [id=guard id, name=guard name, description=guard description, "
+                + "match_parameters=MatchParameters [controlLoopName=null, actor=null, recipe=null, targets=null], "
+                + "limitConstraints=[Constraint [freq_limit_per_target=null, time_window=null, active_time_range=null,"
+                + " blacklist=null]]]", guardPolicy.toString());
+    }
+
+    @Test
+    public void testEquals() {
+        final String id = "guard id";
+        final String name = "guard name";
+        final String description = "guard description";
+        GuardPolicy guardPolicy1 = new GuardPolicy(id);
+        GuardPolicy guardPolicy2 = new GuardPolicy();
+        assertFalse(guardPolicy1.equals(guardPolicy2));
+
+        guardPolicy2.setId(id);
+        assertTrue(guardPolicy1.equals(guardPolicy2));
+        assertEquals(guardPolicy1.hashCode(), guardPolicy2.hashCode());
+
+        guardPolicy1.setName(name);
+        assertFalse(guardPolicy1.equals(guardPolicy2));
+        guardPolicy2.setName(name);
+        assertTrue(guardPolicy1.equals(guardPolicy2));
+        assertEquals(guardPolicy1.hashCode(), guardPolicy2.hashCode());
+
+        guardPolicy1.setDescription(description);
+        assertFalse(guardPolicy1.equals(guardPolicy2));
+        guardPolicy2.setDescription(description);
+        assertTrue(guardPolicy1.equals(guardPolicy2));
+        assertEquals(guardPolicy1.hashCode(), guardPolicy2.hashCode());
+
+        MatchParameters matchParameters = new MatchParameters();
+        guardPolicy1.setMatch_parameters(matchParameters);
+        assertFalse(guardPolicy1.equals(guardPolicy2));
+        guardPolicy2.setMatch_parameters(matchParameters);
+        assertTrue(guardPolicy1.equals(guardPolicy2));
+        assertEquals(guardPolicy1.hashCode(), guardPolicy2.hashCode());
+
+        LinkedList<Constraint> limitConstraints = new LinkedList<>();
+        limitConstraints.add(new Constraint());
+        guardPolicy1.setLimit_constraints(limitConstraints);
+        assertFalse(guardPolicy1.equals(guardPolicy2));
+        guardPolicy2.setLimit_constraints(limitConstraints);
+        assertTrue(guardPolicy1.equals(guardPolicy2));
+        assertEquals(guardPolicy1.hashCode(), guardPolicy2.hashCode());
+    }
+
+    @Test
+    public void testEqualsSameObject() {
+        GuardPolicy guardPolicy = new GuardPolicy();
+        assertTrue(guardPolicy.equals(guardPolicy));
+    }
+
+    @Test
+    public void testEqualsNull() {
+        GuardPolicy guardPolicy = new GuardPolicy();
+        assertFalse(guardPolicy.equals(null));
+    }
+
+    @Test
+    public void testEqualsInstanceOfDiffClass() {
+        GuardPolicy guardPolicy = new GuardPolicy();
+        assertFalse(guardPolicy.equals(""));
+    }
+}