diff --git a/app/src/test/java/org/opencord/dhcpl2relay/impl/DhcpL2RelayTest.java b/app/src/test/java/org/opencord/dhcpl2relay/impl/DhcpL2RelayTest.java
index 4106ef1..e37470b 100755
--- a/app/src/test/java/org/opencord/dhcpl2relay/impl/DhcpL2RelayTest.java
+++ b/app/src/test/java/org/opencord/dhcpl2relay/impl/DhcpL2RelayTest.java
@@ -15,7 +15,14 @@
  */
 package org.opencord.dhcpl2relay.impl;
 
-import com.google.common.collect.Lists;
+import static org.easymock.EasyMock.createMock;
+import static org.junit.Assert.assertEquals;
+import static org.slf4j.LoggerFactory.getLogger;
+
+import java.nio.ByteBuffer;
+import java.util.List;
+import java.util.Map;
+
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -23,7 +30,9 @@
 import org.onlab.packet.DHCP;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.IPv4;
+import org.onlab.packet.MacAddress;
 import org.onlab.packet.UDP;
+import org.onlab.packet.VlanId;
 import org.onlab.packet.dhcp.DhcpOption;
 import org.onosproject.cfg.ComponentConfigService;
 import org.onosproject.cluster.ClusterServiceAdapter;
@@ -32,21 +41,20 @@
 import org.onosproject.net.flowobjective.FlowObjectiveServiceAdapter;
 import org.onosproject.store.cluster.messaging.ClusterCommunicationServiceAdapter;
 import org.onosproject.store.service.TestStorageService;
+import org.opencord.dhcpl2relay.DhcpAllocationInfo;
 import org.opencord.dhcpl2relay.DhcpL2RelayEvent;
 import org.opencord.dhcpl2relay.DhcpL2RelayStoreDelegate;
 import org.opencord.dhcpl2relay.impl.packet.DhcpOption82;
+import org.slf4j.Logger;
 
-import java.nio.ByteBuffer;
-import java.util.List;
-import java.util.Map;
-
-import static org.easymock.EasyMock.createMock;
-import static org.junit.Assert.assertEquals;
+import com.google.common.collect.Lists;
 
 public class DhcpL2RelayTest extends DhcpL2RelayTestBase {
 
     private DhcpL2Relay dhcpL2Relay;
     private SimpleDhcpL2RelayCountersStore store;
+    private final Logger log = getLogger(getClass());
+    Map<String, DhcpAllocationInfo> allocs;
 
     ComponentConfigService mockConfigService =
             createMock(ComponentConfigService.class);
@@ -91,6 +99,76 @@
         dhcpL2Relay.deactivate();
     }
 
+    private void checkAllocation(DHCP.MsgType messageType) {
+        ConnectPoint clientCp = ConnectPoint.deviceConnectPoint(OLT_DEV_ID + "/"
+                + String.valueOf(CLIENT_PORT));
+        allocs = dhcpL2Relay.getAllocationInfo();
+        assert allocs.size() == 1;
+        allocs.forEach((k, v) -> {
+            log.info("Allocation {} : {}", k, v);
+            assertEquals(v.type(), messageType);
+            assertEquals(v.macAddress(), CLIENT_MAC);
+            assertEquals(v.location(), clientCp);
+        });
+    }
+
+    @Test
+    public void testMultipleAllocations() throws Exception {
+        dhcpL2Relay.clearAllocations();
+        // Trigger a discover from one RG on port 32
+        MacAddress mac32 = MacAddress.valueOf("b4:96:91:0c:4f:e4");
+        VlanId vlan32a = VlanId.vlanId((short) 801);
+        Ethernet discover32a = constructDhcpDiscoverPacket(
+                                  mac32, vlan32a, (short) 0);
+        ConnectPoint client32 = ConnectPoint.deviceConnectPoint(
+                                                "of:0000b86a974385f7/32");
+        sendPacket(discover32a, client32);
+        allocs = dhcpL2Relay.getAllocationInfo();
+        assert allocs.size() == 1;
+
+        //Trigger a discover from another RG on port 4112
+        MacAddress mac4112 = MacAddress.valueOf("b4:96:91:0c:4f:c9");
+        VlanId vlan4112 = VlanId.vlanId((short) 101);
+        Ethernet discover4112 = constructDhcpDiscoverPacket(
+                                                            mac4112, vlan4112,
+                                                            (short) 0);
+        ConnectPoint client4112 = ConnectPoint.deviceConnectPoint(
+                "of:0000b86a974385f7/4112");
+        sendPacket(discover4112, client4112);
+        allocs = dhcpL2Relay.getAllocationInfo();
+        assert allocs.size() == 2;
+
+        // Trigger a discover for another service with a different vlan
+        // from the same UNI port 32
+        VlanId vlan32b = VlanId.vlanId((short) 802);
+        Ethernet discover32b = constructDhcpDiscoverPacket(
+                                  mac32, vlan32b, (short) 0);
+        sendPacket(discover32b, client32);
+        allocs = dhcpL2Relay.getAllocationInfo();
+        assert allocs.size() == 3;
+
+        allocs.forEach((k, v) -> {
+            log.info("Allocation {} : {}", k, v);
+            assertEquals(v.type(), DHCP.MsgType.DHCPDISCOVER);
+            if (v.subscriberId().equals("ALPHe3d1cea3-1")) {
+                assertEquals(v.macAddress(), mac32);
+                assertEquals(v.location(), client32);
+                if (!(v.vlanId().equals(vlan32a) || v.vlanId().equals(vlan32b))) {
+                    assert false;
+                }
+            } else if (v.subscriberId().equals("ALPHe3d1ceb7-1")) {
+                assertEquals(v.macAddress(), mac4112);
+                assertEquals(v.location(), client4112);
+                assertEquals(v.vlanId(), vlan4112);
+            } else {
+                assert false;
+            }
+        });
+
+        dhcpL2Relay.clearAllocations();
+        assert dhcpL2Relay.getAllocationInfo().size() == 0;
+    }
+
     /**
      * Tests the DHCP relay app by sending DHCP discovery Packet.
      *
@@ -98,13 +176,16 @@
      */
     @Test
     public void testDhcpDiscover()  throws Exception {
-        //  (1) Sending DHCP discover packet
+        // Sending DHCP Discover packet
+        dhcpL2Relay.clearAllocations();
         Ethernet discoverPacket = constructDhcpDiscoverPacket(CLIENT_MAC);
-
-        sendPacket(discoverPacket, ConnectPoint.deviceConnectPoint(OLT_DEV_ID + "/" + 1));
+        ConnectPoint clientCp = ConnectPoint.deviceConnectPoint(OLT_DEV_ID + "/"
+                + String.valueOf(CLIENT_PORT));
+        sendPacket(discoverPacket, clientCp);
 
         Ethernet discoverRelayed = (Ethernet) getPacket();
         compareClientPackets(discoverPacket, discoverRelayed);
+        checkAllocation(DHCP.MsgType.DHCPDISCOVER);
     }
 
     /**
@@ -114,13 +195,15 @@
      */
     @Test
     public void testDhcpRequest()  throws Exception {
-        //  (1) Sending DHCP discover packet
+        // Sending DHCP Request packet
         Ethernet requestPacket = constructDhcpRequestPacket(CLIENT_MAC);
-
-        sendPacket(requestPacket, ConnectPoint.deviceConnectPoint(OLT_DEV_ID + "/" + 1));
+        ConnectPoint clientCp = ConnectPoint.deviceConnectPoint(OLT_DEV_ID + "/"
+                + String.valueOf(CLIENT_PORT));
+        sendPacket(requestPacket, clientCp);
 
         Ethernet requestRelayed = (Ethernet) getPacket();
         compareClientPackets(requestPacket, requestRelayed);
+        checkAllocation(DHCP.MsgType.DHCPREQUEST);
     }
 
     /**
@@ -130,14 +213,15 @@
      */
     @Test
     public void testDhcpOffer() {
-        //  (1) Sending DHCP discover packet
+        // Sending DHCP Offer packet
         Ethernet offerPacket = constructDhcpOfferPacket(SERVER_MAC,
                 CLIENT_MAC, DESTINATION_ADDRESS_IP, DHCP_CLIENT_IP_ADDRESS);
-
-        sendPacket(offerPacket, ConnectPoint.deviceConnectPoint(OLT_DEV_ID + "/" + 1));
+        sendPacket(offerPacket, ConnectPoint.deviceConnectPoint(OLT_DEV_ID + "/"
+                + String.valueOf(UPLINK_PORT)));
 
         Ethernet offerRelayed = (Ethernet) getPacket();
         compareServerPackets(offerPacket, offerRelayed);
+        checkAllocation(DHCP.MsgType.DHCPOFFER);
     }
 
     /**
@@ -151,10 +235,12 @@
         Ethernet ackPacket = constructDhcpAckPacket(SERVER_MAC,
                 CLIENT_MAC, DESTINATION_ADDRESS_IP, DHCP_CLIENT_IP_ADDRESS);
 
-        sendPacket(ackPacket, ConnectPoint.deviceConnectPoint(OLT_DEV_ID + "/" + 1));
+        sendPacket(ackPacket, ConnectPoint.deviceConnectPoint(OLT_DEV_ID + "/"
+                + String.valueOf(UPLINK_PORT)));
 
         Ethernet ackRelayed = (Ethernet) getPacket();
         compareServerPackets(ackPacket, ackRelayed);
+        checkAllocation(DHCP.MsgType.DHCPACK);
     }
 
     /**
@@ -172,6 +258,7 @@
 
         Ethernet nakRelayed = (Ethernet) getPacket();
         compareServerPackets(nakPacket, nakRelayed);
+        checkAllocation(DHCP.MsgType.DHCPNAK);
     }
 
     /**
@@ -188,6 +275,7 @@
 
         Ethernet declineRelayed = (Ethernet) getPacket();
         compareClientPackets(declinePacket, declineRelayed);
+        checkAllocation(DHCP.MsgType.DHCPDECLINE);
     }
 
     /**
diff --git a/app/src/test/java/org/opencord/dhcpl2relay/impl/DhcpL2RelayTestBase.java b/app/src/test/java/org/opencord/dhcpl2relay/impl/DhcpL2RelayTestBase.java
index 3d88b38..20ac9f5 100755
--- a/app/src/test/java/org/opencord/dhcpl2relay/impl/DhcpL2RelayTestBase.java
+++ b/app/src/test/java/org/opencord/dhcpl2relay/impl/DhcpL2RelayTestBase.java
@@ -32,19 +32,18 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
-import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeoutException;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
-import com.google.common.collect.ImmutableSet;
 import org.onlab.packet.BasePacket;
 import org.onlab.packet.ChassisId;
 import org.onlab.packet.DHCP;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.IPv4;
-import org.onlab.packet.IpAddress;
 import org.onlab.packet.Ip4Address;
+import org.onlab.packet.IpAddress;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.UDP;
 import org.onlab.packet.VlanId;
@@ -94,9 +93,11 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import com.google.common.collect.ImmutableSet;
+
 
 /**
- * Common methods for AAA app testing.
+ * Common methods for DHCP app testing.
  */
 public class DhcpL2RelayTestBase {
     private final Logger log = LoggerFactory.getLogger(getClass());
@@ -114,6 +115,7 @@
     static final String DESTINATION_ADDRESS_IP = "1.1.1.1";
     static final String DHCP_CLIENT_IP_ADDRESS = "2.2.2.2";
     static final int UPLINK_PORT = 5;
+    static final int CLIENT_PORT = 1;
 
     static final String EXPECTED_IP = "10.2.0.2";
     static final String OLT_DEV_ID = "of:00000000000000aa";
@@ -123,7 +125,8 @@
     static final MacAddress OLT_MAC_ADDRESS = MacAddress.valueOf("01:02:03:04:05:06");
 
     static final ConnectPoint SERVER_CONNECT_POINT =
-            ConnectPoint.deviceConnectPoint("of:00000000000000aa/5");
+            ConnectPoint.deviceConnectPoint("of:00000000000000aa/" +
+                                            String.valueOf(UPLINK_PORT));
 
     static final DefaultAnnotations DEVICE_ANNOTATIONS = DefaultAnnotations.builder()
             .set(AnnotationKeys.PROTOCOL, SCHEME_NAME.toUpperCase()).build();
@@ -162,21 +165,30 @@
         private final Device device1 = new DhcpL2RelayTestBase.MockDevice(providerId, DEVICE_ID_1, Device.Type.SWITCH,
                 "foo.inc", "0", "0", OLT_DEV_ID, new ChassisId(),
                 DEVICE_ANNOTATIONS);
-
+        private final Device otherDevice = new DhcpL2RelayTestBase.MockDevice(
+                                                providerId,
+                                                DeviceId.deviceId("of:0000b86a974385f7"),
+                                                Device.Type.SWITCH,
+                                                "foo.inc", "0", "0", "EC1838000853", new ChassisId(),
+                                                DEVICE_ANNOTATIONS);
         @Override
         public Device getDevice(DeviceId devId) {
-            return device1;
-
+            if (devId.equals(DEVICE_ID_1)) {
+                return device1;
+            } else {
+                return otherDevice;
+            }
         }
 
         @Override
         public Port getPort(ConnectPoint cp) {
-            return new DhcpL2RelayTestBase.MockPort();
+            return new DhcpL2RelayTestBase.MockPort(cp);
         }
 
         @Override
         public Port getPort(DeviceId deviceId, PortNumber portNumber) {
-            return new DhcpL2RelayTestBase.MockPort();
+            return new DhcpL2RelayTestBase.MockPort(new ConnectPoint(deviceId,
+                                                                     portNumber));
         }
 
         @Override
@@ -200,7 +212,8 @@
         @Override
         public Set<Host> getHostsByMac(MacAddress mac) {
 
-            HostLocation loc = new HostLocation(DEVICE_ID_1, PortNumber.portNumber(22), 0);
+            HostLocation loc = new HostLocation(DEVICE_ID_1, PortNumber
+                    .portNumber(CLIENT_PORT), 0);
 
             IpAddress ip = IpAddress.valueOf("10.100.200.10");
 
@@ -219,7 +232,11 @@
     }
 
     class  MockPort implements Port {
+        private ConnectPoint cp;
 
+        public MockPort(ConnectPoint cp) {
+            this.cp = cp;
+        }
         @Override
         public boolean isEnabled() {
             return true;
@@ -249,7 +266,13 @@
 
             @Override
             public String value(String val) {
-                return "PON 1/1";
+                if (cp.port().toLong() == 32) {
+                    return "ALPHe3d1cea3-1";
+                } else if (cp.port().toLong() == 4112) {
+                    return "ALPHe3d1ceb7-1";
+                } else {
+                    return "PON 1/1";
+                }
             }
             @Override
             public Set<String> keys() {
@@ -296,13 +319,30 @@
         DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation device =
                 new DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation(OLT_DEV_ID, VlanId.NONE, VlanId.NONE, null,
                         null, OLT_MAC_ADDRESS, Ip4Address.valueOf("10.10.10.10"), UPLINK_PORT);
+        DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation otherDevice =
+                new DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation(
+                        "EC1838000853", VlanId.NONE, VlanId.NONE, null,
+                        null, OLT_MAC_ADDRESS, Ip4Address.valueOf("10.10.10.10"), UPLINK_PORT);
+
         DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation sub =
                 new DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation(CLIENT_ID_1, CLIENT_C_TAG,
                         CLIENT_S_TAG, CLIENT_NAS_PORT_ID, CLIENT_CIRCUIT_ID, null, null, -1);
+        DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation sub32 =
+                new DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation("ALPHe3d1cea3-1", VlanId.vlanId((short) 801),
+                        VlanId.vlanId((short) 111), CLIENT_NAS_PORT_ID, CLIENT_CIRCUIT_ID, null, null, -1);
+        DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation sub4112 =
+                new DhcpL2RelayTestBase.MockSubscriberAndDeviceInformation("ALPHe3d1ceb7-1", VlanId.vlanId((short) 101),
+                        VlanId.vlanId((short) 222), CLIENT_NAS_PORT_ID, CLIENT_CIRCUIT_ID, null, null, -1);
         @Override
         public SubscriberAndDeviceInformation get(String id) {
             if (id.equals(OLT_DEV_ID)) {
                 return device;
+            } else if (id.equals("EC1838000853")) {
+                return otherDevice;
+            } else if (id.equals("ALPHe3d1cea3-1")) {
+                return sub32;
+            } else if (id.equals("ALPHe3d1ceb7-1")) {
+                return sub4112;
             } else {
                 return  sub;
             }
@@ -340,6 +380,18 @@
                     .setIsDhcpRequired(true)
                     .build();
             uniTagInformationList.add(uniTagInformation);
+
+            if (id.equals("ALPHe3d1cea3-1")) {
+                // a second service on the same UNI
+                uniTagInformation = new UniTagInformation.Builder()
+                        .setPonCTag(VlanId.vlanId(((short) (cTag.toShort() + 1))))
+                        .setPonSTag(sTag)
+                        .setUsPonCTagPriority(CLIENT_C_PBIT)
+                        .setIsDhcpRequired(true)
+                        .build();
+                uniTagInformationList.add(uniTagInformation);
+            }
+
             this.setUniTagList(uniTagInformationList);
         }
     }
@@ -587,22 +639,18 @@
         packetProcessor.process(context);
     }
 
-    /**
-     * Constructs an Ethernet packet with IP/UDP/DHCP payload.
-     *
-     * @return Ethernet packet
-     */
-    private Ethernet construcEthernetPacket(MacAddress srcMac, MacAddress dstMac,
+    private Ethernet constructEthernetPacket(MacAddress srcMac, MacAddress dstMac,
                                                 String dstIp, byte dhcpReqRsp,
                                                 MacAddress clientHwAddress,
-                                                Ip4Address dhcpClientIpAddress) {
+                                                Ip4Address dhcpClientIpAddress,
+                                                VlanId clientVlan, short clientPbit) {
         // Ethernet Frame.
         Ethernet ethPkt = new Ethernet();
         ethPkt.setSourceMACAddress(srcMac);
         ethPkt.setDestinationMACAddress(dstMac);
         ethPkt.setEtherType(Ethernet.TYPE_IPV4);
-        ethPkt.setVlanID(CLIENT_C_TAG.toShort());
-        ethPkt.setPriorityCode((byte) CLIENT_C_PBIT);
+        ethPkt.setVlanID(clientVlan.toShort());
+        ethPkt.setPriorityCode((byte) clientPbit);
 
         if (DHCP.OPCODE_REPLY == dhcpReqRsp) {
             ethPkt.setQinQPriorityCode((byte) 3);
@@ -646,6 +694,23 @@
         ethPkt.setPayload(ipv4Reply);
 
         return ethPkt;
+
+    }
+
+    /**
+     * Constructs an Ethernet packet with IP/UDP/DHCP payload and client
+     * VLAN information.
+     *
+     * @return Ethernet packet
+     */
+    private Ethernet construcEthernetPacket(MacAddress srcMac, MacAddress dstMac,
+                                            String dstIp, byte dhcpReqRsp,
+                                            MacAddress clientHwAddress,
+                                            Ip4Address dhcpClientIpAddress) {
+        return constructEthernetPacket(srcMac, dstMac, dstIp, dhcpReqRsp,
+                                       clientHwAddress, dhcpClientIpAddress,
+                                       CLIENT_C_TAG, CLIENT_C_PBIT);
+
     }
 
     /**
@@ -654,9 +719,8 @@
      * @return Ethernet packet
      */
     Ethernet constructDhcpDiscoverPacket(MacAddress clientMac) {
-
         Ethernet pkt = construcEthernetPacket(clientMac, MacAddress.BROADCAST,
-                "255.255.255.255", DHCP.OPCODE_REQUEST, MacAddress.NONE,
+                "255.255.255.255", DHCP.OPCODE_REQUEST, clientMac,
                 Ip4Address.valueOf("0.0.0.0"));
 
         IPv4 ipv4Packet = (IPv4) pkt.getPayload();
@@ -669,14 +733,33 @@
     }
 
     /**
+     * Constructs DHCP Discover Packet with client VLAN information.
+     *
+     * @return Ethernet packet
+     */
+    Ethernet constructDhcpDiscoverPacket(MacAddress clientMac, VlanId clientVlan,
+                                         short clientPbit) {
+        Ethernet pkt = constructEthernetPacket(clientMac, MacAddress.BROADCAST,
+                "255.255.255.255", DHCP.OPCODE_REQUEST, clientMac,
+                Ip4Address.valueOf("0.0.0.0"), clientVlan, clientPbit);
+
+        IPv4 ipv4Packet = (IPv4) pkt.getPayload();
+        UDP udpPacket = (UDP) ipv4Packet.getPayload();
+        DHCP dhcpPacket = (DHCP) udpPacket.getPayload();
+
+        dhcpPacket.setOptions(constructDhcpOptions(DHCP.MsgType.DHCPDISCOVER));
+
+        return pkt;
+    }
+
+    /**
      * Constructs DHCP Request Packet.
      *
      * @return Ethernet packet
      */
     Ethernet constructDhcpRequestPacket(MacAddress clientMac) {
-
         Ethernet pkt = construcEthernetPacket(clientMac, MacAddress.BROADCAST,
-                "255.255.255.255", DHCP.OPCODE_REQUEST, MacAddress.NONE,
+                "255.255.255.255", DHCP.OPCODE_REQUEST, clientMac,
                 Ip4Address.valueOf("0.0.0.0"));
 
         IPv4 ipv4Packet = (IPv4) pkt.getPayload();
@@ -695,7 +778,6 @@
      */
     Ethernet constructDhcpOfferPacket(MacAddress servMac, MacAddress clientMac,
                                            String ipAddress, String dhcpClientIpAddress) {
-
         Ethernet pkt = construcEthernetPacket(servMac, clientMac, ipAddress, DHCP.OPCODE_REPLY,
                 clientMac, Ip4Address.valueOf(dhcpClientIpAddress));
 
@@ -715,7 +797,6 @@
      */
     Ethernet constructDhcpAckPacket(MacAddress servMac, MacAddress clientMac,
                                            String ipAddress, String dhcpClientIpAddress) {
-
         Ethernet pkt = construcEthernetPacket(servMac, clientMac, ipAddress, DHCP.OPCODE_REPLY,
                 clientMac, Ip4Address.valueOf(dhcpClientIpAddress));
 
@@ -756,7 +837,7 @@
     Ethernet constructDhcpDeclinePacket(MacAddress clientMac) {
 
         Ethernet pkt = construcEthernetPacket(clientMac, MacAddress.BROADCAST,
-                "255.255.255.255", DHCP.OPCODE_REQUEST, MacAddress.NONE,
+                "255.255.255.255", DHCP.OPCODE_REQUEST, clientMac,
                 Ip4Address.valueOf("0.0.0.0"));
 
         IPv4 ipv4Packet = (IPv4) pkt.getPayload();