diff --git a/app/src/main/java/org/onosproject/segmentrouting/pwaas/PwaasUtil.java b/app/src/main/java/org/onosproject/segmentrouting/pwaas/PwaasUtil.java
index ada38f4..7cb60a6 100644
--- a/app/src/main/java/org/onosproject/segmentrouting/pwaas/PwaasUtil.java
+++ b/app/src/main/java/org/onosproject/segmentrouting/pwaas/PwaasUtil.java
@@ -16,6 +16,7 @@
 
 package org.onosproject.segmentrouting.pwaas;
 
+import org.onlab.osgi.ServiceNotFoundException;
 import org.onlab.packet.MplsLabel;
 import org.onlab.packet.VlanId;
 import org.onosproject.cli.AbstractShellCommand;
@@ -43,12 +44,46 @@
 
     private static final Logger log = LoggerFactory.getLogger(PwaasUtil.class);
 
-    private static DeviceService deviceService = AbstractShellCommand.get(DeviceService.class);
+    private static DeviceService deviceService;
+    private static InterfaceService intfService;
 
-    private static InterfaceService intfService = AbstractShellCommand.get(InterfaceService.class);
+    // Suppress ExceptionInInitializerError and simply set the value to null,
+    // such that unit tests have a chance to replace the variable with mocked service
+    static {
+        try {
+            deviceService = AbstractShellCommand.get(DeviceService.class);
+        } catch (NullPointerException | ServiceNotFoundException e) {
+            deviceService = null;
+        }
+        try {
+            intfService = AbstractShellCommand.get(InterfaceService.class);
+        } catch (NullPointerException | ServiceNotFoundException e) {
+            intfService = null;
+        }
+    }
+
+    static final String ERR_SERVICE_UNAVAIL = "Service %s not available";
+    static final String ERR_SAME_DEV =
+            "Pseudowire connection points can not reside in the same node, in pseudowire %d.";
+    static final String ERR_EMPTY_INNER_WHEN_OUTER_PRESENT =
+            "Inner tag should not be empty when outer tag is set for pseudowire %d for %s.";
+    static final String ERR_WILDCARD_VLAN =
+            "Wildcard VLAN matching not yet supported for pseudowire %d.";
+    static final String ERR_DOUBLE_TO_UNTAGGED =
+            "Support for double tag <-> untag is not supported for pseudowire %d.";
+    static final String ERR_DOUBLE_TO_SINGLE =
+            "Support for double-tag<-> single-tag is not supported for pseudowire %d.";
+    static final String ERR_SINGLE_TO_UNTAGGED =
+            "single-tag <-> untag is not supported for pseudowire %d.";
+    static final String ERR_VLAN_TRANSLATION =
+            "We do not support VLAN translation for pseudowire %d.";
+    static final String ERR_DEV_NOT_FOUND =
+            "Device %s does not exist for pseudowire %d.";
+    static final String ERR_PORT_NOT_FOUND =
+            "Port %s of device %s does not exist for pseudowire %d.";
 
     private PwaasUtil() {
-        return;
+
     }
 
     /**
@@ -129,12 +164,15 @@
      * supported and if policy will be successfully instantiated in the
      * network.
      *
+     * @param cP1 pseudo wire endpoint 1
+     * @param cP2 pseudo wire endpoint 2
      * @param ingressInner the ingress inner tag
      * @param ingressOuter the ingress outer tag
      * @param egressInner the egress inner tag
      * @param egressOuter the egress outer tag
+     * @param tunnelId tunnel ID
      */
-    private static void verifyPolicy(ConnectPoint cP1,
+    static void verifyPolicy(ConnectPoint cP1,
                               ConnectPoint cP2,
                               VlanId ingressInner,
                               VlanId ingressOuter,
@@ -143,42 +181,34 @@
                               Long tunnelId) {
 
         if (cP1.deviceId().equals(cP2.deviceId())) {
-            throw new IllegalArgumentException(String.format("Pseudowire connection points can not reside in the " +
-                                                                     "same node, in pseudowire %d.", tunnelId));
+            throw new IllegalArgumentException(String.format(ERR_SAME_DEV, tunnelId));
         }
 
         // We can have multiple tags, all of them can be NONE,
         // indicating untagged traffic, however, the outer tag can
         // not have value if the inner tag is None
         if (ingressInner.equals(VlanId.NONE) && !ingressOuter.equals(VlanId.NONE)) {
-            throw new IllegalArgumentException(String.format("Inner tag should not be empty when " +
-                                                                     "outer tag is set for pseudowire %d for cP1.",
-                                                             tunnelId));
+            throw new IllegalArgumentException(String.format(ERR_EMPTY_INNER_WHEN_OUTER_PRESENT,
+                    tunnelId, "cp1"));
         }
 
         if (egressInner.equals(VlanId.NONE) && !egressOuter.equals(VlanId.NONE)) {
-            throw new IllegalArgumentException(String.valueOf(String.format("Inner tag should not be empty when" +
-                                                                                    " outer tag is set for " +
-                                                                                    "pseudowire %d " +
-                                                                                    "for cP2.", tunnelId)));
+            throw new IllegalArgumentException(String.format(ERR_EMPTY_INNER_WHEN_OUTER_PRESENT,
+                    tunnelId, "cp2"));
         }
 
         if (ingressInner.equals(VlanId.ANY) ||
                 ingressOuter.equals(VlanId.ANY) ||
                 egressInner.equals(VlanId.ANY) ||
                 egressOuter.equals(VlanId.ANY)) {
-            throw new IllegalArgumentException(String.valueOf(String.format("Wildcard VLAN matching not yet " +
-                                                                                    "supported for pseudowire %d.",
-                                                                            tunnelId)));
+            throw new IllegalArgumentException(String.format(ERR_WILDCARD_VLAN, tunnelId));
         }
 
         if (((!ingressOuter.equals(VlanId.NONE) && !ingressInner.equals(VlanId.NONE)) &&
                 (egressOuter.equals(VlanId.NONE) && egressInner.equals(VlanId.NONE)))
                 || ((ingressOuter.equals(VlanId.NONE) && ingressInner.equals(VlanId.NONE)) &&
                 (!egressOuter.equals(VlanId.NONE) && !egressInner.equals(VlanId.NONE)))) {
-            throw new IllegalArgumentException(String.valueOf(String.format("Support for double tag <-> untag is not" +
-                                                                                    "supported for pseudowire %d.",
-                                                                            tunnelId)));
+            throw new IllegalArgumentException(String.format(ERR_DOUBLE_TO_UNTAGGED, tunnelId));
         }
         if ((!ingressInner.equals(VlanId.NONE) &&
                 ingressOuter.equals(VlanId.NONE) &&
@@ -186,50 +216,42 @@
                 || (egressOuter.equals(VlanId.NONE) &&
                 !egressInner.equals(VlanId.NONE) &&
                 !ingressOuter.equals(VlanId.NONE))) {
-            throw new IllegalArgumentException(String.valueOf(String.format("Support for double-tag<->" +
-                                                                                    "single-tag is not supported" +
-                                                                                    " for pseudowire %d.", tunnelId)));
+            throw new IllegalArgumentException(String.format(ERR_DOUBLE_TO_SINGLE, tunnelId));
         }
 
         if ((ingressInner.equals(VlanId.NONE) && !egressInner.equals(VlanId.NONE))
                 || (!ingressInner.equals(VlanId.NONE) && egressInner.equals(VlanId.NONE))) {
-            throw new IllegalArgumentException(String.valueOf(String.format("single-tag <-> untag is not supported" +
-                                                                                    " for pseudowire %d.", tunnelId)));
+            throw new IllegalArgumentException(String.format(ERR_SINGLE_TO_UNTAGGED, tunnelId));
         }
 
+        // FIXME PW VLAN translation is not supported on Dune
+        //       Need to explore doing that in egress table later if there is a requirement
+        if (!ingressInner.equals(egressInner) || !ingressOuter.equals(egressOuter)) {
+            throw new IllegalArgumentException(String.format(ERR_VLAN_TRANSLATION, tunnelId));
+        }
 
-        if (!ingressInner.equals(egressInner) && !ingressOuter.equals(egressOuter)) {
-            throw new IllegalArgumentException(String.valueOf(String.format("We do not support changing both tags " +
-                                                                                    "in double tagged pws, only the " +
-                                                                                    "outer," +
-                                                                                    " for pseudowire %d.", tunnelId)));
+        if (deviceService == null) {
+            throw new IllegalStateException(String.format(ERR_SERVICE_UNAVAIL, "DeviceService"));
         }
 
         // check if cp1 and port of cp1 exist
         if (deviceService.getDevice(cP1.deviceId()) == null) {
-            throw new IllegalArgumentException(String.valueOf(String.format("cP1 device %s does not exist for" +
-                                                                                    " pseudowire %d.", cP1.deviceId(),
-                                                                            tunnelId)));
+            throw new IllegalArgumentException(String.format(ERR_DEV_NOT_FOUND, cP1.deviceId(), tunnelId));
         }
 
         if (deviceService.getPort(cP1) == null) {
-            throw new IllegalArgumentException(String.valueOf(String.format("Port %s for cP1 device %s does not" +
-                                                                                    " exist for pseudowire %d.",
-                                                                            cP1.port(),
-                                                                            cP1.deviceId(), tunnelId)));
+            throw new IllegalArgumentException(String.format(ERR_PORT_NOT_FOUND, cP1.port(),
+                    cP1.deviceId(), tunnelId));
         }
 
         // check if cp2 and port of cp2 exist
         if (deviceService.getDevice(cP2.deviceId()) == null) {
-            throw new IllegalArgumentException(String.valueOf(String.format("cP2 device %s does not exist for" +
-                                                                                    " pseudowire %d.", cP2.deviceId(),
-                                                                            tunnelId)));
+            throw new IllegalArgumentException(String.format(ERR_DEV_NOT_FOUND, cP2.deviceId(), tunnelId));
         }
 
         if (deviceService.getPort(cP2) == null) {
-            throw new IllegalArgumentException(String.valueOf(String.format("Port %s for cP2 device %s does " +
-                                                                                    "not exist for pseudowire %d.",
-                                                                            cP2.port(), cP2.deviceId(), tunnelId)));
+            throw new IllegalArgumentException(String.format(ERR_PORT_NOT_FOUND, cP2.port(),
+                    cP2.deviceId(), tunnelId));
         }
     }
 
@@ -312,6 +334,10 @@
         }
         vlanSet.get(cP2).add(vlanToCheckCP2);
 
+        if (intfService == null) {
+            throw new IllegalStateException(String.format(ERR_SERVICE_UNAVAIL, "InterfaceService"));
+        }
+
         // check that vlans for the connect points are not used
         intfService.getInterfacesByPort(cP1).stream()
                 .forEach(intf -> {
diff --git a/app/src/test/java/org/onosproject/segmentrouting/pwaas/PwaasUtilTest.java b/app/src/test/java/org/onosproject/segmentrouting/pwaas/PwaasUtilTest.java
new file mode 100644
index 0000000..1d9f07e
--- /dev/null
+++ b/app/src/test/java/org/onosproject/segmentrouting/pwaas/PwaasUtilTest.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright 2018-present Open Networking 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.
+ */
+package org.onosproject.segmentrouting.pwaas;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.onlab.junit.TestUtils;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DefaultPort;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.Port;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.intf.Interface;
+import org.onosproject.net.intf.InterfaceService;
+import org.onosproject.segmentrouting.MockDevice;
+
+import static org.easymock.EasyMock.createNiceMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+
+public class PwaasUtilTest {
+    private static final DeviceId DID1 = DeviceId.deviceId("of:1");
+    private static final DeviceId DID2 = DeviceId.deviceId("of:2");
+    private static final DeviceId DID99 = DeviceId.deviceId("of:99");
+    private static final PortNumber PN1 = PortNumber.portNumber(1);
+    private static final PortNumber PN2 = PortNumber.portNumber(2);
+    private static final PortNumber PN99 = PortNumber.portNumber(99);
+    private static final ConnectPoint CP11 = new ConnectPoint(DID1, PN1);
+    private static final ConnectPoint CP12 = new ConnectPoint(DID1, PN2);
+    private static final ConnectPoint CP21 = new ConnectPoint(DID2, PN1);
+    private static final ConnectPoint CP22 = new ConnectPoint(DID2, PN2);
+    private static final VlanId V1 = VlanId.vlanId((short) 1);
+    private static final VlanId V2 = VlanId.vlanId((short) 2);
+    private static final Device D1 = new MockDevice(DID1, null);
+    private static final Device D2 = new MockDevice(DID2, null);
+    private static final Port P11 = new DefaultPort(D1, PN1, true);
+    private static final Port P12 = new DefaultPort(D1, PN2, true);
+    private static final Port P21 = new DefaultPort(D2, PN1, true);
+    private static final Port P22 = new DefaultPort(D2, PN2, true);
+    private static final Interface I11 = new Interface("I11", CP11, Lists.newArrayList(), MacAddress.NONE,
+            VlanId.NONE, VlanId.NONE, Sets.newHashSet(VlanId.NONE), VlanId.NONE);
+    private static final Interface I12 = new Interface("I12", CP12, Lists.newArrayList(), MacAddress.NONE,
+            VlanId.NONE, VlanId.NONE, Sets.newHashSet(VlanId.NONE), VlanId.NONE);
+    private static final Interface I21 = new Interface("I21", CP21, Lists.newArrayList(), MacAddress.NONE,
+            VlanId.NONE, VlanId.NONE, Sets.newHashSet(VlanId.NONE), VlanId.NONE);
+    private static final Interface I22 = new Interface("I22", CP22, Lists.newArrayList(), MacAddress.NONE,
+            VlanId.NONE, VlanId.NONE, Sets.newHashSet(VlanId.NONE), VlanId.NONE);
+
+    private ConnectPoint cp1;
+    private ConnectPoint cp2;
+    private VlanId ingressInner;
+    private VlanId ingressOuter;
+    private VlanId egressInner;
+    private VlanId egressOuter;
+    private static final Long TUNNEL_ID = (long) 1234;
+
+    @Before
+    public void setUp() {
+        DeviceService deviceService = createNiceMock(DeviceService.class);
+        InterfaceService intfService = createNiceMock(InterfaceService.class);
+        TestUtils.setField(PwaasUtil.class, "deviceService", deviceService);
+        TestUtils.setField(PwaasUtil.class, "intfService", intfService);
+
+        expect(deviceService.getDevice(DID1)).andReturn(D1).anyTimes();
+        expect(deviceService.getDevice(DID2)).andReturn(D2).anyTimes();
+        expect(deviceService.getPort(CP11)).andReturn(P11).anyTimes();
+        expect(deviceService.getPort(CP12)).andReturn(P12).anyTimes();
+        expect(deviceService.getPort(CP21)).andReturn(P21).anyTimes();
+        expect(deviceService.getPort(CP22)).andReturn(P22).anyTimes();
+        expect(intfService.getInterfacesByPort(CP11)).andReturn(Sets.newHashSet(I11)).anyTimes();
+        expect(intfService.getInterfacesByPort(CP12)).andReturn(Sets.newHashSet(I12)).anyTimes();
+        expect(intfService.getInterfacesByPort(CP21)).andReturn(Sets.newHashSet(I21)).anyTimes();
+        expect(intfService.getInterfacesByPort(CP22)).andReturn(Sets.newHashSet(I22)).anyTimes();
+        replay(deviceService);
+        replay(intfService);
+    }
+
+    @Rule
+    public final ExpectedException exception = ExpectedException.none();
+
+    @Test
+    public void verifyPolicy() {
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = V1;
+        ingressOuter = V2;
+        egressInner = V1;
+        egressOuter = V2;
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+
+        ingressInner = VlanId.NONE;
+        ingressOuter = VlanId.NONE;
+        egressInner = VlanId.NONE;
+        egressOuter = VlanId.NONE;
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicyOnSameDevice() {
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID1, PN2);
+        ingressInner = VlanId.NONE;
+        ingressOuter = VlanId.NONE;
+        egressInner = VlanId.NONE;
+        egressOuter = VlanId.NONE;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_SAME_DEV, TUNNEL_ID));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicyEmptyInnerCp1() {
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = VlanId.NONE;
+        ingressOuter = V1;
+        egressInner = VlanId.NONE;
+        egressOuter = VlanId.NONE;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_EMPTY_INNER_WHEN_OUTER_PRESENT, TUNNEL_ID, "cp1"));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicyEmptyInnerCp2() {
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = VlanId.NONE;
+        ingressOuter = VlanId.NONE;
+        egressInner = VlanId.NONE;
+        egressOuter = V1;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_EMPTY_INNER_WHEN_OUTER_PRESENT, TUNNEL_ID, "cp2"));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicyVlanWildcard() {
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = VlanId.ANY;
+        ingressOuter = VlanId.NONE;
+        egressInner = VlanId.NONE;
+        egressOuter = VlanId.NONE;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_WILDCARD_VLAN, TUNNEL_ID));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+
+    @Test
+    public void verifyPolicyDeviceServiceNotAvailable() {
+        TestUtils.setField(PwaasUtil.class, "deviceService", null);
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = V1;
+        ingressOuter = V2;
+        egressInner = V1;
+        egressOuter = V2;
+        exception.expect(IllegalStateException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_SERVICE_UNAVAIL, "DeviceService"));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicyDoubleToUntagged() {
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = V1;
+        ingressOuter = V2;
+        egressInner = VlanId.NONE;
+        egressOuter = VlanId.NONE;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_DOUBLE_TO_UNTAGGED, TUNNEL_ID));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicyDoubleToSingle() {
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = V1;
+        ingressOuter = V2;
+        egressInner = V1;
+        egressOuter = VlanId.NONE;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_DOUBLE_TO_SINGLE, TUNNEL_ID));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicySingleToUntagged() {
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = V1;
+        ingressOuter = VlanId.NONE;
+        egressInner = VlanId.NONE;
+        egressOuter = VlanId.NONE;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_SINGLE_TO_UNTAGGED, TUNNEL_ID));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicyVlanTranslation() {
+        cp1 = new ConnectPoint(DID1, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = V1;
+        ingressOuter = VlanId.NONE;
+        egressInner = V2;
+        egressOuter = VlanId.NONE;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_VLAN_TRANSLATION, TUNNEL_ID));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicyDeviceNotFound() {
+        cp1 = new ConnectPoint(DID99, PN1);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = V1;
+        ingressOuter = V2;
+        egressInner = V1;
+        egressOuter = V2;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_DEV_NOT_FOUND, DID99, TUNNEL_ID));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+
+    @Test
+    public void verifyPolicyPortNotFound() {
+        cp1 = new ConnectPoint(DID1, PN99);
+        cp2 = new ConnectPoint(DID2, PN2);
+        ingressInner = V1;
+        ingressOuter = V2;
+        egressInner = V1;
+        egressOuter = V2;
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(String.format(PwaasUtil.ERR_PORT_NOT_FOUND, PN99, DID1, TUNNEL_ID));
+        PwaasUtil.verifyPolicy(cp1, cp2, ingressInner, ingressOuter, egressInner, egressOuter, TUNNEL_ID);
+    }
+}
\ No newline at end of file