<dependencies>
         <dependency>
             <groupId>org.onap.policy.distribution</groupId>
-            <artifactId>reception-plugins</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.onap.policy.distribution</groupId>
-            <artifactId>forwarding-plugins</artifactId>
+            <artifactId>reception</artifactId>
             <version>${project.version}</version>
         </dependency>
         <dependency>
 
     private static final int REST_SERVER_PORT = 6969;
     private static final String REST_SERVER_HOST = "0.0.0.0";
     public static final String DISTRIBUTION_GROUP_NAME = "SDCDistributionGroup";
-    public static final String DECODER_TYPE = "TOSCA";
-    public static final String DECODER_CLASS_NAME =
-            "org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx";
-    public static final String FORWARDER_TYPE = "PAPEngine";
+    public static final String DECODER_TYPE = "DummyDecoder";
+    public static final String DECODER_CLASS_NAME = "org.onap.policy.distribution.main.testclasses.DummyDecoder";
+    public static final String FORWARDER_TYPE = "DummyForwarder";
     public static final String FORWARDER_CLASS_NAME =
-            "org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder";
-    public static final String RECEPTION_HANDLER_TYPE = "SDC";
+            "org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder";
+    public static final String RECEPTION_HANDLER_TYPE = "DummyReceptionHandler";
     public static final String RECEPTION_HANDLER_CLASS_NAME =
-            "org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler";
-    public static final String SDC_RECEPTION_HANDLER_KEY = "SDCReceptionHandler";
-    public static final String PAP_ENGINE_FORWARDER_KEY = "PAPEngineForwarder";
-    public static final String TOSCA_DECODER_KEY = "TOSCADecoder";
+            "org.onap.policy.distribution.main.testclasses.DummyReceptionHandler";
+    public static final String DUMMY_RECEPTION_HANDLER_KEY = "DummyReceptionHandler";
+    public static final String DUMMY_ENGINE_FORWARDER_KEY = "DummyForwarder";
+    public static final String DUMMY_DECODER_KEY = "DummyDecoder";
 
     /**
      * Returns an instance of ReceptionHandlerParameters for test cases.
             final PluginHandlerParameters pHParameters = new PluginHandlerParameters(policyDecoders, policyForwarders);
             final ReceptionHandlerParameters rhParameters = new ReceptionHandlerParameters(RECEPTION_HANDLER_TYPE,
                     RECEPTION_HANDLER_CLASS_NAME, pssdConfiguration, pHParameters);
-            receptionHandlerParameters.put(SDC_RECEPTION_HANDLER_KEY, rhParameters);
+            receptionHandlerParameters.put(DUMMY_RECEPTION_HANDLER_KEY, rhParameters);
         }
         return receptionHandlerParameters;
     }
         if (!isEmpty) {
             final PolicyForwarderParameters pFParameters =
                     new PolicyForwarderParameters(FORWARDER_TYPE, FORWARDER_CLASS_NAME);
-            policyForwarders.put(PAP_ENGINE_FORWARDER_KEY, pFParameters);
+            policyForwarders.put(DUMMY_ENGINE_FORWARDER_KEY, pFParameters);
         }
         return policyForwarders;
     }
         final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
         if (!isEmpty) {
             final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters(DECODER_TYPE, DECODER_CLASS_NAME);
-            policyDecoders.put(TOSCA_DECODER_KEY, pDParameters);
+            policyDecoders.put(DUMMY_DECODER_KEY, pDParameters);
         }
         return policyDecoders;
     }
 
         assertEquals(restServerParameters.getPassword(),
                 distributionParameters.getRestServerParameters().getPassword());
         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, distributionParameters.getName());
-        assertEquals(receptionHandlerParameters.get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getReceptionHandlerType(),
-                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
+        assertEquals(
+                receptionHandlerParameters.get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getReceptionHandlerType(),
+                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
                         .getReceptionHandlerType());
         assertEquals(
-                receptionHandlerParameters.get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getReceptionHandlerClassName(),
-                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
+                receptionHandlerParameters.get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
+                        .getReceptionHandlerClassName(),
+                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
                         .getReceptionHandlerClassName());
         assertEquals(
-                receptionHandlerParameters.get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getPluginHandlerParameters(),
-                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
+                receptionHandlerParameters.get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getPluginHandlerParameters(),
+                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
                         .getPluginHandlerParameters());
     }
 
         final GroupValidationResult validationResult = distributionParameters.validate();
         assertFalse(validationResult.isValid());
         assertEquals(null, distributionParameters.getName());
-        assertEquals(receptionHandlerParameters.get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getReceptionHandlerType(),
-                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
+        assertEquals(
+                receptionHandlerParameters.get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getReceptionHandlerType(),
+                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
                         .getReceptionHandlerType());
         assertEquals(
-                receptionHandlerParameters.get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getReceptionHandlerClassName(),
-                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
+                receptionHandlerParameters.get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
+                        .getReceptionHandlerClassName(),
+                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
                         .getReceptionHandlerClassName());
         assertEquals(
-                receptionHandlerParameters.get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getPluginHandlerParameters(),
-                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
+                receptionHandlerParameters.get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getPluginHandlerParameters(),
+                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
                         .getPluginHandlerParameters());
         assertTrue(validationResult.getResult().contains(
                 "field \"name\" type \"java.lang.String\" value \"null\" INVALID, " + "must be a non-blank string"));
         final GroupValidationResult validationResult = distributionParameters.validate();
         assertFalse(validationResult.isValid());
         assertEquals("", distributionParameters.getName());
-        assertEquals(receptionHandlerParameters.get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getReceptionHandlerType(),
-                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
+        assertEquals(
+                receptionHandlerParameters.get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getReceptionHandlerType(),
+                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
                         .getReceptionHandlerType());
         assertEquals(
-                receptionHandlerParameters.get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getReceptionHandlerClassName(),
-                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
+                receptionHandlerParameters.get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
+                        .getReceptionHandlerClassName(),
+                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
                         .getReceptionHandlerClassName());
         assertEquals(
-                receptionHandlerParameters.get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getPluginHandlerParameters(),
-                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
+                receptionHandlerParameters.get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getPluginHandlerParameters(),
+                distributionParameters.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
                         .getPluginHandlerParameters());
         assertTrue(validationResult.getResult().contains(
                 "field \"name\" type \"java.lang.String\" value \"\" INVALID, " + "must be a non-blank string"));
 
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
 import org.junit.Test;
 import org.onap.policy.distribution.main.PolicyDistributionException;
 import org.onap.policy.distribution.main.startstop.DistributionCommandLineArguments;
         arguments.parse(distributionConfigParameters);
 
         final DistributionParameterGroup parGroup = new DistributionParameterHandler().getParameters(arguments);
+        assertTrue(arguments.checkSetConfigurationFilePath());
         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, parGroup.getName());
         assertEquals(CommonTestData.RECEPTION_HANDLER_TYPE, parGroup.getReceptionHandlerParameters()
-                .get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getReceptionHandlerType());
+                .get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getReceptionHandlerType());
         assertEquals(CommonTestData.DECODER_TYPE,
-                parGroup.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
-                        .getPluginHandlerParameters().getPolicyDecoders().get(CommonTestData.TOSCA_DECODER_KEY)
+                parGroup.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
+                        .getPluginHandlerParameters().getPolicyDecoders().get(CommonTestData.DUMMY_DECODER_KEY)
                         .getDecoderType());
         assertEquals(CommonTestData.FORWARDER_TYPE,
-                parGroup.getReceptionHandlerParameters().get(CommonTestData.SDC_RECEPTION_HANDLER_KEY)
-                        .getPluginHandlerParameters().getPolicyForwarders().get(CommonTestData.PAP_ENGINE_FORWARDER_KEY)
-                        .getForwarderType());
+                parGroup.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
+                        .getPluginHandlerParameters().getPolicyForwarders()
+                        .get(CommonTestData.DUMMY_ENGINE_FORWARDER_KEY).getForwarderType());
     }
 
     @Test
         }
     }
 
-    @Test
-    public void testDistributionParameterGroup_InvalidReceptionHandlerType() throws PolicyDistributionException {
-        final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerType.json" };
-
-        final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
-        arguments.parse(distributionConfigParameters);
-
-        try {
-            new DistributionParameterHandler().getParameters(arguments);
-            fail("test should throw an exception here");
-        } catch (final Exception e) {
-            assertTrue(e.getMessage()
-                    .contains("field \"receptionHandlerType\" type \"java.lang.String\" value \" \" INVALID, "
-                            + "must be a non-blank string"));
-        }
-    }
-
-    @Test
-    public void testDistributionParameterGroup_InvalidPolicyDecoderType() throws PolicyDistributionException {
-        final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidPolicyDecoderType.json" };
-
-        final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
-        arguments.parse(distributionConfigParameters);
-
-        try {
-            new DistributionParameterHandler().getParameters(arguments);
-            fail("test should throw an exception here");
-        } catch (final Exception e) {
-            assertTrue(e.getMessage().contains(
-                    "field \"decoderType\" type \"java.lang.String\" value \" \" INVALID, must be a non-blank string"));
-        }
-    }
-
-    @Test
-    public void testDistributionParameterGroup_InvalidPolicyForwarderType() throws PolicyDistributionException {
-        final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidPolicyForwarderType.json" };
-
-        final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
-        arguments.parse(distributionConfigParameters);
-
-        try {
-            new DistributionParameterHandler().getParameters(arguments);
-            fail("test should throw an exception here");
-        } catch (final Exception e) {
-            assertTrue(e.getMessage().contains("field \"forwarderType\" type \"java.lang.String\" value \" \" INVALID, "
-                    + "must be a non-blank string"));
-        }
-    }
-
     @Test
     public void testDistributionParameterGroup_NoReceptionHandler() throws PolicyDistributionException {
         final String[] distributionConfigParameters =
     }
 
     @Test
-    public void testDistributionParameterGroup_InvalidReceptionHandlerClass() throws PolicyDistributionException {
+    public void testDistributionParameterGroup_InvalidReceptionHandlerParameters()
+            throws PolicyDistributionException, IOException {
         final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerClass.json" };
+        { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerParameters.json" };
 
         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
         arguments.parse(distributionConfigParameters);
             new DistributionParameterHandler().getParameters(arguments);
             fail("test should throw an exception here");
         } catch (final Exception e) {
-            assertTrue(e.getMessage().contains("reception handler class not found in classpath"));
+            final String expectedResult = new String(Files.readAllBytes(
+                    Paths.get("src/test/resources/expectedValidationResults/InvalidReceptionHandlerParameters.txt")))
+                            .replaceAll("\\s+", "");
+            assertEquals(expectedResult, e.getMessage().replaceAll("\\s+", ""));
         }
     }
 
     @Test
-    public void testDistributionParameterGroup_InvalidPolicyDecoderClass() throws PolicyDistributionException {
+    public void testDistributionParameterGroup_InvalidDecoderAndForwarderParameters()
+            throws PolicyDistributionException, IOException {
         final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidPolicyDecoderClass.json" };
+        { "-c", "parameters/DistributionConfigParameters_InvalidDecoderAndForwarderParameters.json" };
 
         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
         arguments.parse(distributionConfigParameters);
             new DistributionParameterHandler().getParameters(arguments);
             fail("test should throw an exception here");
         } catch (final Exception e) {
-            assertTrue(e.getMessage().contains("policy decoder class not found in classpath"));
+            final String expectedResult = new String(Files.readAllBytes(
+                    Paths.get("src/test/resources/expectedValidationResults/InvalidDecoderAndForwarderParameters.txt")))
+                            .replaceAll("\\s+", "");
+            assertEquals(expectedResult, e.getMessage().replaceAll("\\s+", ""));
         }
     }
 
     @Test
-    public void testDistributionParameterGroup_InvalidPolicyForwarderClass() throws PolicyDistributionException {
+    public void testDistributionParameterGroup_InvalidRestServerParameters()
+            throws PolicyDistributionException, IOException {
         final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidPolicyForwarderClass.json" };
+        { "-c", "parameters/DistributionConfigParameters_InvalidRestServerParameters.json" };
 
         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
         arguments.parse(distributionConfigParameters);
             new DistributionParameterHandler().getParameters(arguments);
             fail("test should throw an exception here");
         } catch (final Exception e) {
-            assertTrue(e.getMessage().contains("policy forwarder class not found in classpath"));
+            final String expectedResult = new String(Files.readAllBytes(
+                    Paths.get("src/test/resources/expectedValidationResults/InvalidRestServerParameters.txt")))
+                            .replaceAll("\\s+", "");
+            assertEquals(expectedResult, e.getMessage().replaceAll("\\s+", ""));
         }
     }
 
     @Test
-    public void testDistributionParameterGroup_InvalidRestServerHost() throws PolicyDistributionException {
+    public void testDistributionVersion() throws PolicyDistributionException {
         final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidRestServerHost.json" };
-
+        { "-v" };
         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
-        arguments.parse(distributionConfigParameters);
-
-        try {
-            new DistributionParameterHandler().getParameters(arguments);
-            fail("test should throw an exception here");
-        } catch (final Exception e) {
-            assertTrue(e.getMessage().contains(
-                    "must be a non-blank string containing hostname/ipaddress of the distribution rest server"));
-        }
+        final String version = arguments.parse(distributionConfigParameters);
+        assertTrue(version.startsWith("ONAP Policy Framework Distribution Service"));
     }
 
     @Test
-    public void testDistributionParameterGroup_InvalidRestServerPort() throws PolicyDistributionException {
+    public void testDistributionHelp() throws PolicyDistributionException {
         final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidRestServerPort.json" };
-
+        { "-h" };
         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
-        arguments.parse(distributionConfigParameters);
-
-        try {
-            new DistributionParameterHandler().getParameters(arguments);
-            fail("test should throw an exception here");
-        } catch (final Exception e) {
-            assertTrue(e.getMessage()
-                    .contains("must be a positive integer containing port of the distribution rest server"));
-        }
+        final String help = arguments.parse(distributionConfigParameters);
+        assertTrue(help.startsWith("usage:"));
     }
 
     @Test
-    public void testDistributionParameterGroup_InvalidRestServerUser() throws PolicyDistributionException {
+    public void testDistributionInvalidOption() throws PolicyDistributionException {
         final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidRestServerUser.json" };
-
+        { "-d" };
         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
-        arguments.parse(distributionConfigParameters);
-
         try {
-            new DistributionParameterHandler().getParameters(arguments);
-            fail("test should throw an exception here");
-        } catch (final Exception e) {
-            assertTrue(e.getMessage().contains(
-                    "must be a non-blank string containing userName for distribution rest server credentials"));
-        }
-    }
-
-    @Test
-    public void testDistributionParameterGroup_InvalidRestServerPassword() throws PolicyDistributionException {
-        final String[] distributionConfigParameters =
-        { "-c", "parameters/DistributionConfigParameters_InvalidRestServerPassword.json" };
-
-        final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
-        arguments.parse(distributionConfigParameters);
-
-        try {
-            new DistributionParameterHandler().getParameters(arguments);
-            fail("test should throw an exception here");
-        } catch (final Exception e) {
-            assertTrue(e.getMessage().contains(
-                    "must be a non-blank string containing password for distribution rest server credentials"));
+            arguments.parse(distributionConfigParameters);
+        } catch (final Exception exp) {
+            assertTrue(exp.getMessage().startsWith("invalid command line arguments specified"));
         }
     }
 }
 
         final Map<String, PolicyForwarderParameters> policyForwarders = commonTestData.getPolicyForwarders(false);
         final PluginHandlerParameters pHParameters = new PluginHandlerParameters(policyDecoders, policyForwarders);
         final GroupValidationResult validationResult = pHParameters.validate();
-        assertEquals(policyDecoders.get(CommonTestData.TOSCA_DECODER_KEY),
-                pHParameters.getPolicyDecoders().get(CommonTestData.TOSCA_DECODER_KEY));
-        assertEquals(policyForwarders.get(CommonTestData.PAP_ENGINE_FORWARDER_KEY),
-                pHParameters.getPolicyForwarders().get(CommonTestData.PAP_ENGINE_FORWARDER_KEY));
+        assertEquals(policyDecoders.get(CommonTestData.DUMMY_DECODER_KEY),
+                pHParameters.getPolicyDecoders().get(CommonTestData.DUMMY_DECODER_KEY));
+        assertEquals(policyForwarders.get(CommonTestData.DUMMY_ENGINE_FORWARDER_KEY),
+                pHParameters.getPolicyForwarders().get(CommonTestData.DUMMY_ENGINE_FORWARDER_KEY));
         assertTrue(validationResult.isValid());
     }
 
 
 
     @Test
     public void testDistributionActivator() throws PolicyDistributionException {
-        final String[] distributionConfigParameters = { "-c", "parameters/DistributionConfigParameters.json" };
+        final String[] distributionConfigParameters =
+        { "-c", "parameters/DistributionConfigParameters.json" };
 
         final DistributionCommandLineArguments arguments =
                 new DistributionCommandLineArguments(distributionConfigParameters);
         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, activator.getParameterGroup().getName());
         assertEquals(CommonTestData.RECEPTION_HANDLER_TYPE,
                 activator.getParameterGroup().getReceptionHandlerParameters()
-                        .get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getReceptionHandlerType());
+                        .get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getReceptionHandlerType());
         assertEquals(CommonTestData.DECODER_TYPE,
                 activator.getParameterGroup().getReceptionHandlerParameters()
-                        .get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getPluginHandlerParameters().getPolicyDecoders()
-                        .get(CommonTestData.TOSCA_DECODER_KEY).getDecoderType());
+                        .get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getPluginHandlerParameters()
+                        .getPolicyDecoders().get(CommonTestData.DUMMY_DECODER_KEY).getDecoderType());
         assertEquals(CommonTestData.FORWARDER_TYPE,
                 activator.getParameterGroup().getReceptionHandlerParameters()
-                        .get(CommonTestData.SDC_RECEPTION_HANDLER_KEY).getPluginHandlerParameters()
-                        .getPolicyForwarders().get(CommonTestData.PAP_ENGINE_FORWARDER_KEY).getForwarderType());
+                        .get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getPluginHandlerParameters()
+                        .getPolicyForwarders().get(CommonTestData.DUMMY_ENGINE_FORWARDER_KEY).getForwarderType());
         activator.terminate();
     }
 }
 
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2018 Ericsson. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.main.testclasses;
+
+import java.util.Collection;
+
+import org.onap.policy.distribution.model.Policy;
+import org.onap.policy.distribution.model.PolicyInput;
+import org.onap.policy.distribution.reception.decoding.PolicyDecoder;
+import org.onap.policy.distribution.reception.decoding.PolicyDecodingException;
+
+/**
+ * Class to create a dummy decoder for test cases.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+public class DummyDecoder implements PolicyDecoder<PolicyInput, Policy> {
+
+    private boolean canHandleValue;
+    private Collection<Policy> policesToReturn;
+
+    public DummyDecoder() {
+        this.canHandleValue = false;
+        this.policesToReturn = null;
+    }
+
+    public DummyDecoder(final boolean canHandleValue, final Collection<Policy> policesToReturn) {
+        this.canHandleValue = canHandleValue;
+        this.policesToReturn = policesToReturn;
+    }
+
+    @Override
+    public boolean canHandle(final PolicyInput policyInput) {
+        return canHandleValue;
+    }
+
+    @Override
+    public Collection<Policy> decode(final PolicyInput input) throws PolicyDecodingException {
+        return policesToReturn;
+    }
+}
 
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2018 Ericsson. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.main.testclasses;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.onap.policy.distribution.forwarding.PolicyForwarder;
+import org.onap.policy.distribution.forwarding.PolicyForwardingException;
+import org.onap.policy.distribution.model.Policy;
+
+/**
+ * Class to create a dummy forwarder for test cases.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+public class DummyPolicyForwarder implements PolicyForwarder {
+    private int numberOfPoliciesReceived = 0;
+    private Collection<Policy> policiesReceived = new ArrayList<>();
+
+    @Override
+    public void forward(final Collection<Policy> policies) throws PolicyForwardingException {
+        numberOfPoliciesReceived += policies.size();
+        policiesReceived.addAll(policies);
+    }
+
+    public int getNumberOfPoliciesReceived() {
+        return numberOfPoliciesReceived;
+    }
+
+    public boolean receivedPolicy(final Policy policy) {
+        return policiesReceived.contains(policy);
+    }
+}
 
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2018 Ericsson. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.main.testclasses;
+
+import org.onap.policy.distribution.reception.handling.AbstractReceptionHandler;
+
+/**
+ * Class to create a dummy reception handler for test cases.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+public class DummyReceptionHandler extends AbstractReceptionHandler {
+
+    @Override
+    public void initializeReception(final String parameterGroupName) {}
+
+    @Override
+    public void destroy() {}
+}
 
--- /dev/null
+validation error(s) on parameters from "parameters/DistributionConfigParameters_InvalidDecoderAndForwarderParameters.json"
+parameter group "SDCDistributionGroup" type "org.onap.policy.distribution.main.parameters.DistributionParameterGroup" INVALID, parameter group has status INVALID
+  parameter group map "receptionHandlerParameters" INVALID, parameter group has status INVALID
+    parameter group "null_DummyReceptionHandler" type "org.onap.policy.distribution.reception.parameters.ReceptionHandlerParameters" INVALID, parameter group has status INVALID
+      parameter group "null_PluginHandler" type "org.onap.policy.distribution.reception.parameters.PluginHandlerParameters" INVALID, parameter group has status INVALID
+        parameter group map "policyDecoders" INVALID, parameter group has status INVALID
+          parameter group "null" type "org.onap.policy.distribution.reception.parameters.PolicyDecoderParameters" INVALID, parameter group has status INVALID
+            field "decoderType" type "java.lang.String" value "" INVALID, must be a non-blank string
+            field "decoderClassName" type "java.lang.String" value "org.onap.policy.distribution.main.testclasses.PolicyDecoderApexPdpa" INVALID, policy decoder class not found in classpath
+          parameter group "null" type "org.onap.policy.distribution.reception.parameters.PolicyDecoderParameters" INVALID, parameter group has status INVALID
+            field "decoderClassName" type "java.lang.String" value "" INVALID, must be a non-blank string containing full class name of the decoder
+        parameter group map "policyForwarders" INVALID, parameter group has status INVALID
+          parameter group "null" type "org.onap.policy.distribution.forwarding.parameters.PolicyForwarderParameters" INVALID, parameter group has status INVALID
+            field "forwarderType" type "java.lang.String" value "" INVALID, must be a non-blank string
+            field "forwarderClassName" type "java.lang.String" value "org.onap.policy.distribution.main.testclasses.PapStandalonePolicyForwarder" INVALID, policy forwarder class not found in classpath
+          parameter group "null" type "org.onap.policy.distribution.forwarding.parameters.PolicyForwarderParameters" INVALID, parameter group has status INVALID
+            field "forwarderClassName" type "java.lang.String" value "" INVALID, must be a non-blank string containing full class name of the forwarder
 
--- /dev/null
+validation error(s) on parameters from "parameters/DistributionConfigParameters_InvalidReceptionHandlerParameters.json"
+parameter group "SDCDistributionGroup" type "org.onap.policy.distribution.main.parameters.DistributionParameterGroup" INVALID, parameter group has status INVALID
+  parameter group map "receptionHandlerParameters" INVALID, parameter group has status INVALID
+    parameter group "null_" type "org.onap.policy.distribution.reception.parameters.ReceptionHandlerParameters" INVALID, parameter group has status INVALID
+      field "receptionHandlerType" type "java.lang.String" value "" INVALID, must be a non-blank string
+      field "receptionHandlerClassName" type "java.lang.String" value "org.onap.policy.distribution.main.testclasses.InvalidSdcReceptionHandler" INVALID, reception handler class not found in classpath
 
--- /dev/null
+validation error(s) on parameters from "parameters/DistributionConfigParameters_InvalidRestServerParameters.json"
+parameter group "SDCDistributionGroup" type "org.onap.policy.distribution.main.parameters.DistributionParameterGroup" INVALID, parameter group has status INVALID
+  parameter group "null" type "org.onap.policy.distribution.main.parameters.RestServerParameters" INVALID, parameter group has status INVALID
+    field "host" type "java.lang.String" value "" INVALID, must be a non-blank string containing hostname/ipaddress of the distribution rest server
+    field "port" type "int" value "-1" INVALID, must be a positive integer containing port of the distribution rest server
+    field "userName" type "java.lang.String" value "" INVALID, must be a non-blank string containing userName for distribution rest server credentials
+    field "password" type "java.lang.String" value "" INVALID, must be a non-blank string containing password for distribution rest server credentials
 
         "password":"zb!XztG34"
     },
     "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{
+            "receptionHandlerType":"DummyReceptionHandler",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
             },
             "pluginHandlerParameters":{
                 "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
+                    "DummyDecoder":{
+                        "decoderType":"DummyDecoder",
+                        "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
                     }
                 },
                 "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
+                    "DummyForwarder":{
+                        "forwarderType":"DummyForwarder",
+                        "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder"
                     }
                 }
             }
 
         "password":"zb!XztG34"
     },
     "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{
+            "receptionHandlerType":"DummyReceptionHandler",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
                 "policyDecoders":{
                 },
                 "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
+                    "DummyForwarder":{
+                        "forwarderType":"DummyForwarder",
+                        "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder"
                     }
                 }
             }
 
         "password":"zb!XztG34"
     },
     "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{
+            "receptionHandlerType":"DummyReceptionHandler",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
             },
             "pluginHandlerParameters":{
                 "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
+                    "DummyDecoder":{
+                        "decoderType":"DummyDecoder",
+                        "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
                     }
                 },
                 "policyForwarders":{
 
         "password":"zb!XztG34"
     },
     "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{
+            "receptionHandlerType":"DummyReceptionHandler",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
             },
             "pluginHandlerParameters":{
                 "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
+                    "DummyDecoder":{
+                        "decoderType":"DummyDecoder",
+                        "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
                     },
                     "APEXDecoder":{
-                        "decoderType":"APEX",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderApexPdpa"
+                        "decoderType":"",
+                        "decoderClassName":"org.onap.policy.distribution.main.testclasses.PolicyDecoderApexPdpa"
                     },
                     "DROOLSDecoder":{
                         "decoderType":"DROOLS",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderDroolsPdpd"
+                        "decoderClassName":""
                     }
                 },
                 "policyForwarders":{
+                    "DummyForwarder":{
+                        "forwarderType":"DummyForwarder",
+                        "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder"
+                    },
+                    "PAPStandaloneForwarder":{
+                        "forwarderType":"",
+                        "forwarderClassName":"org.onap.policy.distribution.main.testclasses.PapStandalonePolicyForwarder"
+                    },
                     "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
+                        "forwarderType":"PAPEngineForwarder",
+                        "forwarderClassName":""
                     }
                 }
+                
             }
         }
     }
 
         "password":"zb!XztG34"
     },
     "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{
+            "receptionHandlerType":"DummyReceptionHandler",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
             },
             "pluginHandlerParameters":{
                 "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
+                    "DummyDecoder":{
+                        "decoderType":"DummyDecoder",
+                        "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
                     }
                 },
                 "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
+                    "DummyForwarder":{
+                        "forwarderType":"DummyForwarder",
+                        "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder"
                     }
                 }
             }
 
+++ /dev/null
-{
-    "name":"SDCDistributionGroup",
-    "restServerParameters":{
-        "host":"0.0.0.0",
-        "port":6969,
-        "userName":"healthcheck",
-        "password":"zb!XztG34"
-    },
-    "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
-            "pssdConfiguration":{
-                "asdcAddress": "localhost",
-                "messageBusAddress": [
-                    "a.com",
-                    "b.com",
-                    "c.com"
-                 ],
-                "user": "tbdsdc-1480",
-                "password": "tbdsdc-1480",
-                "pollingInterval":20,
-                "pollingTimeout":30,
-                "consumerId": "policy-id",
-                "artifactTypes": [
-                    "TOSCA_CSAR",
-                    "HEAT"
-                ],
-                "consumerGroup": "policy-group",
-                "environmentName": "environmentName",
-                "keystorePath": "null",
-                "keystorePassword": "null",
-                "activeserverTlsAuth": false,
-                "isFilterinEmptyResources": true,
-                "isUseHttpsWithDmaap": false
-            },
-            "pluginHandlerParameters":{
-                "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":" ",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
-                    }
-                },
-                "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
-                    }
-                }
-            }
-        }
-    }
-}
 
+++ /dev/null
-{
-    "name":"SDCDistributionGroup",
-    "restServerParameters":{
-        "host":"0.0.0.0",
-        "port":6969,
-        "userName":"healthcheck",
-        "password":"zb!XztG34"
-    },
-    "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
-            "pssdConfiguration":{
-                "asdcAddress": "localhost",
-                "messageBusAddress": [
-                    "a.com",
-                    "b.com",
-                    "c.com"
-                 ],
-                "user": "tbdsdc-1480",
-                "password": "tbdsdc-1480",
-                "pollingInterval":20,
-                "pollingTimeout":30,
-                "consumerId": "policy-id",
-                "artifactTypes": [
-                    "TOSCA_CSAR",
-                    "HEAT"
-                ],
-                "consumerGroup": "policy-group",
-                "environmentName": "environmentName",
-                "keystorePath": "null",
-                "keystorePassword": "null",
-                "activeserverTlsAuth": false,
-                "isFilterinEmptyResources": true,
-                "isUseHttpsWithDmaap": false
-            },
-            "pluginHandlerParameters":{
-                "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
-                    }
-                },
-                "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
-                    },
-                    "PAPStandaloneForwarder":{
-                        "forwarderType":"PAPStandalone",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.PapStandalonePolicyForwarder"
-                    }
-                }
-            }
-        }
-    }
-}
 
+++ /dev/null
-{
-    "name":"SDCDistributionGroup",
-    "restServerParameters":{
-        "host":"0.0.0.0",
-        "port":6969,
-        "userName":"healthcheck",
-        "password":"zb!XztG34"
-    },
-    "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.InvalidSdcReceptionHandler",
-            "pssdConfiguration":{
-                "asdcAddress": "localhost",
-                "messageBusAddress": [
-                    "a.com",
-                    "b.com",
-                    "c.com"
-                 ],
-                "user": "tbdsdc-1480",
-                "password": "tbdsdc-1480",
-                "pollingInterval":20,
-                "pollingTimeout":30,
-                "consumerId": "policy-id",
-                "artifactTypes": [
-                    "TOSCA_CSAR",
-                    "HEAT"
-                ],
-                "consumerGroup": "policy-group",
-                "environmentName": "environmentName",
-                "keystorePath": "null",
-                "keystorePassword": "null",
-                "activeserverTlsAuth": false,
-                "isFilterinEmptyResources": true,
-                "isUseHttpsWithDmaap": false
-            },
-            "pluginHandlerParameters":{
-                "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
-                    }
-                },
-                "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
-                    }
-                }
-            }
-        }
-    }
-}
 
         "password":"zb!XztG34"
     },
     "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{
+            "receptionHandlerType":"",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.InvalidSdcReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
             },
             "pluginHandlerParameters":{
                 "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
+                    "DummyDecoder":{
+                        "decoderType":"DummyDecoder",
+                        "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
                     }
                 },
                 "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":" ",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
+                    "DummyForwarder":{
+                        "forwarderType":"DummyForwarder",
+                        "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder"
                     }
                 }
             }
 
+++ /dev/null
-{
-    "name":"SDCDistributionGroup",
-    "restServerParameters":{
-        "host":"0.0.0.0",
-        "port":6969,
-        "userName":"healthcheck",
-        "password":"zb!XztG34"
-    },
-    "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":" ",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
-            "pssdConfiguration":{
-                "asdcAddress": "localhost",
-                "messageBusAddress": [
-                    "a.com",
-                    "b.com",
-                    "c.com"
-                 ],
-                "user": "tbdsdc-1480",
-                "password": "tbdsdc-1480",
-                "pollingInterval":20,
-                "pollingTimeout":30,
-                "consumerId": "policy-id",
-                "artifactTypes": [
-                    "TOSCA_CSAR",
-                    "HEAT"
-                ],
-                "consumerGroup": "policy-group",
-                "environmentName": "environmentName",
-                "keystorePath": "null",
-                "keystorePassword": "null",
-                "activeserverTlsAuth": false,
-                "isFilterinEmptyResources": true,
-                "isUseHttpsWithDmaap": false
-            },
-            "pluginHandlerParameters":{
-                "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
-                    }
-                },
-                "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
-                    }
-                }
-            }
-        }
-    }
-}
 
+++ /dev/null
-{
-    "name":"SDCDistributionGroup",
-    "restServerParameters":{
-        "host":"",
-        "port":6969,
-        "userName":"healthcheck",
-        "password":"zb!XztG34"
-    },
-    "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
-            "pssdConfiguration":{
-                "asdcAddress": "localhost",
-                "messageBusAddress": [
-                    "a.com",
-                    "b.com",
-                    "c.com"
-                 ],
-                "user": "tbdsdc-1480",
-                "password": "tbdsdc-1480",
-                "pollingInterval":20,
-                "pollingTimeout":30,
-                "consumerId": "policy-id",
-                "artifactTypes": [
-                    "TOSCA_CSAR",
-                    "HEAT"
-                ],
-                "consumerGroup": "policy-group",
-                "environmentName": "environmentName",
-                "keystorePath": "null",
-                "keystorePassword": "null",
-                "activeserverTlsAuth": false,
-                "isFilterinEmptyResources": true,
-                "isUseHttpsWithDmaap": false
-            },
-            "pluginHandlerParameters":{
-                "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
-                    }
-                },
-                "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
-                    }
-                }
-            }
-        }
-    }
-}
 
 {
     "name":"SDCDistributionGroup",
     "restServerParameters":{
-        "host":"0.0.0.0",
-        "port":6969,
+        "host":"",
+        "port":-1,
         "userName":"",
-        "password":"zb!XztG34"
+        "password":""
     },
     "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{
+            "receptionHandlerType":"DummyReceptionHandler",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
             },
             "pluginHandlerParameters":{
                 "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
+                    "DummyDecoder":{
+                        "decoderType":"DummyDecoder",
+                        "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
                     }
                 },
                 "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
+                    "DummyForwarder":{
+                        "forwarderType":"DummyForwarder",
+                        "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder"
                     }
                 }
             }
 
+++ /dev/null
-{
-    "name":"SDCDistributionGroup",
-    "restServerParameters":{
-        "host":"0.0.0.0",
-        "port":6969,
-        "userName":"healthcheck",
-        "password":""
-    },
-    "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
-            "pssdConfiguration":{
-                "asdcAddress": "localhost",
-                "messageBusAddress": [
-                    "a.com",
-                    "b.com",
-                    "c.com"
-                 ],
-                "user": "tbdsdc-1480",
-                "password": "tbdsdc-1480",
-                "pollingInterval":20,
-                "pollingTimeout":30,
-                "consumerId": "policy-id",
-                "artifactTypes": [
-                    "TOSCA_CSAR",
-                    "HEAT"
-                ],
-                "consumerGroup": "policy-group",
-                "environmentName": "environmentName",
-                "keystorePath": "null",
-                "keystorePassword": "null",
-                "activeserverTlsAuth": false,
-                "isFilterinEmptyResources": true,
-                "isUseHttpsWithDmaap": false
-            },
-            "pluginHandlerParameters":{
-                "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
-                    }
-                },
-                "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
-                    }
-                }
-            }
-        }
-    }
-}
 
+++ /dev/null
-{
-    "name":"SDCDistributionGroup",
-    "restServerParameters":{
-        "host":"0.0.0.0",
-        "port":-1,
-        "userName":"healthcheck",
-        "password":"zb!XztG34"
-    },
-    "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
-            "pssdConfiguration":{
-                "asdcAddress": "localhost",
-                "messageBusAddress": [
-                    "a.com",
-                    "b.com",
-                    "c.com"
-                 ],
-                "user": "tbdsdc-1480",
-                "password": "tbdsdc-1480",
-                "pollingInterval":20,
-                "pollingTimeout":30,
-                "consumerId": "policy-id",
-                "artifactTypes": [
-                    "TOSCA_CSAR",
-                    "HEAT"
-                ],
-                "consumerGroup": "policy-group",
-                "environmentName": "environmentName",
-                "keystorePath": "null",
-                "keystorePassword": "null",
-                "activeserverTlsAuth": false,
-                "isFilterinEmptyResources": true,
-                "isUseHttpsWithDmaap": false
-            },
-            "pluginHandlerParameters":{
-                "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
-                    }
-                },
-                "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
-                    }
-                }
-            }
-        }
-    }
-}
 
         "password":"zb!XztG34"
     },
     "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{
+            "receptionHandlerType":"DummyReceptionHandler",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
             },
             "pluginHandlerParameters":{
                 "policyForwarders":{
-                    "PAPEngineForwarder":{
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
+                    "DummyForwarder":{
+                        "forwarderType":"DummyForwarder",
+                        "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder"
                     }
                 }
             }
 
         "password":"zb!XztG34"
     },
     "receptionHandlerParameters":{
-        "SDCReceptionHandler":{
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{
+            "receptionHandlerType":"DummyReceptionHandler",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
             },
             "pluginHandlerParameters":{
                 "policyDecoders":{
-                    "TOSCADecoder":{
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
+                    "DummyDecoder":{
+                        "decoderType":"DummyDecoder",
+                        "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
                     }
                 }
             }
 
         "password":"zb!XztG34"
     },
     "receptionHandlerParameters":{  
-        "SDCReceptionHandler":{  
-            "receptionHandlerType":"SDC",
-            "receptionHandlerClassName":"org.onap.policy.distribution.reception.handling.sdc.SdcReceptionHandler",
+        "DummyReceptionHandler":{  
+            "receptionHandlerType":"DummyReceptionHandler",
+            "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
             "pssdConfiguration":{
                 "asdcAddress": "localhost",
                 "messageBusAddress": [
             },
             "pluginHandlerParameters":{  
                 "policyDecoders":{  
-                    "TOSCADecoder":{  
-                        "decoderType":"TOSCA",
-                        "decoderClassName":"org.onap.policy.distribution.reception.decoding.pdpx.PolicyDecoderToscaPdpx"
+                    "DummyDecoder":{  
+                        "decoderType":"DummyDecoder",
+                        "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
                     }
                 },
                 "policyForwarders":{  
-                    "PAPEngineForwarder":{  
-                        "forwarderType":"PAPEngine",
-                        "forwarderClassName":"org.onap.policy.distribution.forwarding.pap.engine.XacmlPapServletPolicyForwarder"
+                    "DummyForwarder":{  
+                        "forwarderType":"DummyForwarder",
+                        "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder"
                     }
                 }
             }