diff --git a/app/src/test/java/org/opencord/aaa/impl/AaaManagerTest.java b/app/src/test/java/org/opencord/aaa/impl/AaaManagerTest.java
index 110ebec..83d5c42 100644
--- a/app/src/test/java/org/opencord/aaa/impl/AaaManagerTest.java
+++ b/app/src/test/java/org/opencord/aaa/impl/AaaManagerTest.java
@@ -204,45 +204,58 @@
 
         Ethernet startPacket = constructSupplicantStartPacket();
         sendPacket(startPacket);
-
-        Ethernet responsePacket = (Ethernet) fetchPacket(0);
-        checkRadiusPacket(aaaManager, responsePacket, EAP.ATTR_IDENTITY);
-
-        //  (2) Supplicant identify
-
-        Ethernet identifyPacket = constructSupplicantIdentifyPacket(null,
-                EAP.ATTR_IDENTITY, (byte) 3, null);
-        sendPacket(identifyPacket);
-
-        RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
-        AtomicReference<Byte> reqId = new AtomicReference<>(radiusIdentifyPacket.getIdentifier());
-
-        checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
-
-        assertThat(radiusIdentifyPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
-        assertThat(new String(radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_USERNAME).getValue()),
-                   is("testuser"));
-
-        IpAddress nasIp =
-                IpAddress.valueOf(IpAddress.Version.INET,
-                                  radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_NAS_IP)
-                                          .getValue());
-        assertThat(nasIp.toString(), is(aaaManager.nasIpAddress.getHostAddress()));
-
-        //  State machine should have been created by now
-
-        StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
-        assertThat(stateMachine, notNullValue());
-        assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
-
-        // (3) RADIUS MD5 challenge
-
-        RADIUS radiusCodeAccessChallengePacket =
-                constructRadiusCodeAccessChallengePacket(RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_MD5,
-                                                         reqId.get(), aaaManager.radiusSecret.getBytes());
-        aaaManager.handleRadiusPacket(radiusCodeAccessChallengePacket);
-
         assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            Ethernet responsePacket = (Ethernet) fetchPacket(0);
+            checkRadiusPacket(aaaManager, responsePacket, EAP.ATTR_IDENTITY);
+
+            //  (2) Supplicant identify
+
+            Ethernet identifyPacket = null;
+            try {
+                identifyPacket = constructSupplicantIdentifyPacket(null,
+                                                                   EAP.ATTR_IDENTITY, (byte) 3, null);
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
+            sendPacket(identifyPacket);
+        });
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
+            AtomicReference<Byte> reqId = new AtomicReference<>(radiusIdentifyPacket.getIdentifier());
+
+            try {
+                checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
+            } catch (DeserializationException e) {
+                log.error(e.getMessage());
+                fail();
+            }
+
+            assertThat(radiusIdentifyPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
+            assertThat(new String(radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_USERNAME).getValue()),
+                       is("testuser"));
+
+            IpAddress nasIp =
+                    IpAddress.valueOf(IpAddress.Version.INET,
+                                      radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_NAS_IP)
+                                              .getValue());
+            assertThat(nasIp.toString(), is(aaaManager.nasIpAddress.getHostAddress()));
+
+            // (3) RADIUS MD5 challenge
+
+            RADIUS radiusCodeAccessChallengePacket =
+                    constructRadiusCodeAccessChallengePacket(RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_MD5,
+                                                             reqId.get(), aaaManager.radiusSecret.getBytes());
+            aaaManager.handleRadiusPacket(radiusCodeAccessChallengePacket);
+        });
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+
+            //  State machine should have been created by now
+
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
+            assertThat(stateMachine, notNullValue());
+            assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
+
             Ethernet radiusChallengeMD5Packet = (Ethernet) fetchPacket(2);
             checkRadiusPacket(aaaManager, radiusChallengeMD5Packet, EAP.ATTR_MD5);
 
@@ -259,7 +272,14 @@
                 fail();
             }
         });
+
+        //  State machine should have been created by now
+
+        StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
+
         assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+
+
             RADIUS responseMd5RadiusPacket = (RADIUS) fetchPacket(3);
             try {
                 checkRadiusPacketFromSupplicant(responseMd5RadiusPacket);
@@ -268,7 +288,7 @@
                 fail();
             }
             //assertThat(responseMd5RadiusPacket.getIdentifier(), is((byte) 9));
-            reqId.set(responseMd5RadiusPacket.getIdentifier());
+            AtomicReference<Byte> reqId = new AtomicReference<>(responseMd5RadiusPacket.getIdentifier());
             assertThat(responseMd5RadiusPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
 
             //  State machine should be in pending state
@@ -300,15 +320,16 @@
     public void testRemoveAuthentication() {
         Ethernet startPacket = constructSupplicantStartPacket();
         sendPacket(startPacket);
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
 
-        StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
+            assertThat(stateMachine, notNullValue());
+            assertThat(stateMachine.state(), is(StateMachine.STATE_STARTED));
 
-        assertThat(stateMachine, notNullValue());
-        assertThat(stateMachine.state(), is(StateMachine.STATE_STARTED));
+            aaaManager.removeAuthenticationStateByMac(stateMachine.supplicantAddress());
 
-        aaaManager.removeAuthenticationStateByMac(stateMachine.supplicantAddress());
-
-        assertThat(aaaManager.getStateMachine(SESSION_ID), nullValue());
+            assertThat(aaaManager.getStateMachine(SESSION_ID), nullValue());
+        });
     }
 
     /**
diff --git a/app/src/test/java/org/opencord/aaa/impl/AaaStatisticsTest.java b/app/src/test/java/org/opencord/aaa/impl/AaaStatisticsTest.java
index c4f390c..0c11292 100644
--- a/app/src/test/java/org/opencord/aaa/impl/AaaStatisticsTest.java
+++ b/app/src/test/java/org/opencord/aaa/impl/AaaStatisticsTest.java
@@ -149,6 +149,7 @@
         aaaManager.sadisService = new MockSadisService();
         aaaManager.cfgService = new MockCfgService();
         aaaManager.storageService = new TestStorageService();
+        aaaManager.mastershipService = new MockMastershipService();
         aaaStatisticsManager = new AaaStatisticsManager();
         aaaStatisticsManager.storageService = new TestStorageService();
         aaaStatisticsManager.clusterService = new ClusterServiceAdapter();
@@ -211,39 +212,56 @@
         // (1) Supplicant start up
         Ethernet startPacket = constructSupplicantStartPacket();
         sendPacket(startPacket);
-
-        Ethernet responsePacket = (Ethernet) fetchPacket(0);
-        checkRadiusPacket(aaaManager, responsePacket, EAP.ATTR_IDENTITY);
-
-        // (2) Supplicant identify
-
-        Ethernet identifyPacket = constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
-        sendPacket(identifyPacket);
-
-        RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
-        checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
-
-        assertThat(radiusIdentifyPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
-        assertThat(new String(radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_USERNAME).getValue()),
-                is("testuser"));
-        IpAddress nasIp = IpAddress.valueOf(IpAddress.Version.INET,
-                radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_NAS_IP).getValue());
-        assertThat(nasIp.toString(), is(aaaManager.nasIpAddress.getHostAddress()));
-
-        // State machine should have been created by now
-
-        StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
-        assertThat(stateMachine, notNullValue());
-        assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
-
-        // (3) RADIUS MD5 challenge
-
-        RADIUS radiusCodeAccessChallengePacket = constructRadiusCodeAccessChallengePacket(
-                RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_MD5, radiusIdentifyPacket.getIdentifier(),
-                aaaManager.radiusSecret.getBytes());
-        aaaManager.handleRadiusPacket(radiusCodeAccessChallengePacket);
-
         assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            Ethernet responsePacket = (Ethernet) fetchPacket(0);
+            checkRadiusPacket(aaaManager, responsePacket, EAP.ATTR_IDENTITY);
+
+            // (2) Supplicant identify
+
+            Ethernet identifyPacket = null;
+            try {
+                identifyPacket = constructSupplicantIdentifyPacket(null,
+                                                                   EAP.ATTR_IDENTITY, (byte) 1, null);
+                sendPacket(identifyPacket);
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
+            });
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            try {
+                RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
+                checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
+
+                assertThat(radiusIdentifyPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
+                assertThat(new String(radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_USERNAME)
+                .getValue()),
+                           is("testuser"));
+                IpAddress nasIp = IpAddress.valueOf(IpAddress.Version.INET,
+                                                    radiusIdentifyPacket
+                                                    .getAttribute(RADIUSAttribute.RADIUS_ATTR_NAS_IP)
+                                                            .getValue());
+                assertThat(nasIp.toString(), is(aaaManager.nasIpAddress.getHostAddress()));
+
+                // State machine should have been created by now
+
+                StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
+                assertThat(stateMachine, notNullValue());
+                assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
+
+                // (3) RADIUS MD5 challenge
+
+                RADIUS radiusCodeAccessChallengePacket = constructRadiusCodeAccessChallengePacket(
+                        RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_MD5, radiusIdentifyPacket.getIdentifier(),
+                        aaaManager.radiusSecret.getBytes());
+                aaaManager.handleRadiusPacket(radiusCodeAccessChallengePacket);
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
+        });
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
             Ethernet radiusChallengeMD5Packet = (Ethernet) fetchPacket(2);
             checkRadiusPacket(aaaManager, radiusChallengeMD5Packet, EAP.ATTR_MD5);
             // (4) Supplicant MD5 response
@@ -261,6 +279,7 @@
 
 
         assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
             RADIUS responseMd5RadiusPacket = (RADIUS) fetchPacket(3);
 
             try {
@@ -286,6 +305,7 @@
             aaaManager.handleRadiusPacket((successPacket));
         });
         assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
             Ethernet supplicantSuccessPacket = (Ethernet) fetchPacket(4);
 
             checkRadiusPacket(aaaManager, supplicantSuccessPacket, EAP.SUCCESS);
@@ -419,26 +439,39 @@
         sendPacket(startPacket);
 
         // (2) Supplicant identify
-
-        Ethernet identifyPacket = constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
-        sendPacket(identifyPacket);
-
-        RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
-
-        checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
-
-        // State machine should have been created by now
-
-        StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
-
-        // (3) RADIUS MD5 challenge
-
-        RADIUS radiusCodeAccessChallengePacket = constructRadiusCodeAccessChallengePacket(
-                RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_MD5, radiusIdentifyPacket.getIdentifier(),
-                aaaManager.radiusSecret.getBytes());
-        aaaManager.handleRadiusPacket(radiusCodeAccessChallengePacket);
-
         assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            Ethernet identifyPacket = null;
+            try {
+                identifyPacket = constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
+                sendPacket(identifyPacket);
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
+        });
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            try {
+                RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
+
+                checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
+
+                // State machine should have been created by now
+
+                StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
+
+                // (3) RADIUS MD5 challenge
+
+                RADIUS radiusCodeAccessChallengePacket = constructRadiusCodeAccessChallengePacket(
+                        RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_MD5, radiusIdentifyPacket.getIdentifier(),
+                        aaaManager.radiusSecret.getBytes());
+                aaaManager.handleRadiusPacket(radiusCodeAccessChallengePacket);
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
+        });
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
             Ethernet radiusChallengeMD5Packet = (Ethernet) fetchPacket(2);
 
             // (4) Supplicant MD5 response
@@ -470,6 +503,7 @@
         });
 
         assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
             Ethernet supplicantRejectedPacket = (Ethernet) fetchPacket(4);
 
             checkRadiusPacket(aaaManager, supplicantRejectedPacket, EAP.FAILURE);
@@ -511,42 +545,51 @@
         // (1) Supplicant start up
         Ethernet startPacket = constructSupplicantStartPacket();
         sendPacket(startPacket);
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            // (2) Supplicant identify
 
-        // (2) Supplicant identify
+            Ethernet identifyPacket = null;
+            try {
+                identifyPacket = constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
+                sendPacket(identifyPacket);
 
-        Ethernet identifyPacket = constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
-        sendPacket(identifyPacket);
+                RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
+                checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
 
-        RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
-        checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
+                // again creating pending state for same packet
+                constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
+                sendPacket(identifyPacket);
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
+        });
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            aaaManager.impl.handlePacketFromServer(null);
+            aaaManager.aaaStatisticsManager.calculatePacketRoundtripTime();
 
-        // again creating pending state for same packet
-        constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
-        sendPacket(identifyPacket);
-        aaaManager.impl.handlePacketFromServer(null);
-        aaaManager.aaaStatisticsManager.calculatePacketRoundtripTime();
+            // creating malformed packet
+            final ByteBuffer byteBuffer = ByteBuffer.wrap(startPacket.serialize());
+            InboundPacket inPacket = new DefaultInboundPacket(connectPoint("1", 1),
+                                                              startPacket, byteBuffer);
 
-        // creating malformed packet
-        final ByteBuffer byteBuffer = ByteBuffer.wrap(startPacket.serialize());
-        InboundPacket inPacket = new DefaultInboundPacket(connectPoint("1", 1),
-                startPacket, byteBuffer);
+            PacketContext context = new TestPacketContext(127L, inPacket, null, false);
+            aaaManager.impl.handlePacketFromServer(context);
 
-        PacketContext context = new TestPacketContext(127L, inPacket, null, false);
-        aaaManager.impl.handlePacketFromServer(context);
+            // Check for increase of Stats
+            assertNotEquals(aaaStatisticsManager.getAaaStats().getEapolResIdentityMsgTrans(), ZERO);
+            assertNotEquals(aaaStatisticsManager.getAaaStats().getEapolStartReqTrans(), ZERO);
 
-        // Check for increase of Stats
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getEapolResIdentityMsgTrans(), ZERO);
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getEapolStartReqTrans(), ZERO);
+            assertNotEquals(aaaStatisticsManager.getAaaStats().getAccessRequestsTx(), ZERO);
+            assertNotEquals(aaaStatisticsManager.getAaaStats().getDroppedResponsesRx(), ZERO);
+            assertNotEquals(aaaStatisticsManager.getAaaStats().getPendingRequests(), ZERO);
+            assertNotEquals(aaaStatisticsManager.getAaaStats().getMalformedResponsesRx(), ZERO);
+            assertNotEquals(aaaStatisticsManager.getAaaStats().getRequestReTx(), ZERO);
+            assertNotEquals(aaaStatisticsManager.getAaaStats().getUnknownTypeRx(), ZERO);
+            assertNotEquals(aaaStatisticsManager.getAaaStats().getUnknownServerRx(), ZERO);
 
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getAccessRequestsTx(), ZERO);
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getDroppedResponsesRx(), ZERO);
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getPendingRequests(), ZERO);
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getMalformedResponsesRx(), ZERO);
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getRequestReTx(), ZERO);
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getUnknownTypeRx(), ZERO);
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getUnknownServerRx(), ZERO);
-
-        countAaaStatistics();
+            countAaaStatistics();
+        });
     }
 
     /**
@@ -561,38 +604,55 @@
         // (1) Supplicant start up
         Ethernet startPacket = constructSupplicantStartPacket();
         sendPacket(startPacket);
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+                        Ethernet responsePacket = (Ethernet) fetchPacket(0);
+                        checkRadiusPacket(aaaManager, responsePacket, EAP.ATTR_IDENTITY);
 
-        Ethernet responsePacket = (Ethernet) fetchPacket(0);
-        checkRadiusPacket(aaaManager, responsePacket, EAP.ATTR_IDENTITY);
+                        // (2) Supplicant identify
 
-        // (2) Supplicant identify
+            Ethernet identifyPacket = null;
+            try {
+                identifyPacket = constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
+            sendPacket(identifyPacket);
+                    });
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+                        RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
+            try {
+                checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
 
-        Ethernet identifyPacket = constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
-        sendPacket(identifyPacket);
+            assertThat(radiusIdentifyPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
+                        assertThat(new String(radiusIdentifyPacket
+                                                      .getAttribute(RADIUSAttribute.RADIUS_ATTR_USERNAME)
+                                                      .getValue()),
+                                   is("testuser"));
+                        IpAddress nasIp = IpAddress.valueOf(IpAddress.Version.INET,
+                                                            radiusIdentifyPacket
+                                                                    .getAttribute(RADIUSAttribute.RADIUS_ATTR_NAS_IP)
+                                                                    .getValue());
+                        assertThat(nasIp.toString(), is(aaaManager.nasIpAddress.getHostAddress()));
 
-        RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
-        checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
+                        // State machine should have been created by now
 
-        assertThat(radiusIdentifyPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
-        assertThat(new String(radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_USERNAME).getValue()),
-                is("testuser"));
-        IpAddress nasIp = IpAddress.valueOf(IpAddress.Version.INET,
-                radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_NAS_IP).getValue());
-        assertThat(nasIp.toString(), is(aaaManager.nasIpAddress.getHostAddress()));
+                        //StateMachine stateMachine = StateMachine.lookupStateMachineBySessionId(SESSION_ID);
+                        StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
+                        assertThat(stateMachine, notNullValue());
+                        assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
 
-        // State machine should have been created by now
+                        // (3) RADIUS MD5 challenge
 
-        //StateMachine stateMachine = StateMachine.lookupStateMachineBySessionId(SESSION_ID);
-        StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
-        assertThat(stateMachine, notNullValue());
-        assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
-
-        // (3) RADIUS MD5 challenge
-
-        RADIUS radiusCodeAccessChallengePacket = constructRadiusCodeAccessChallengePacket(
-                RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_MD5,
-                radiusIdentifyPacket.getIdentifier(), aaaManager.radiusSecret.getBytes());
-        aaaManager.handleRadiusPacket(radiusCodeAccessChallengePacket);
+                        RADIUS radiusCodeAccessChallengePacket = constructRadiusCodeAccessChallengePacket(
+                                RADIUS.RADIUS_CODE_ACCESS_CHALLENGE, EAP.ATTR_MD5,
+                                radiusIdentifyPacket.getIdentifier(), aaaManager.radiusSecret.getBytes());
+                        aaaManager.handleRadiusPacket(radiusCodeAccessChallengePacket);
+                    });
         assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
             Ethernet radiusChallengeMD5Packet = (Ethernet) fetchPacket(2);
             checkRadiusPacket(aaaManager, radiusChallengeMD5Packet, EAP.ATTR_MD5);
@@ -600,6 +660,8 @@
             // (4) Supplicant MD5 response
 
             Ethernet md5RadiusPacket = null;
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
+
             try {
                 md5RadiusPacket = constructSupplicantIdentifyPacket(stateMachine, EAP.ATTR_MD5,
                                                                     stateMachine.challengeIdentifier(),
@@ -623,7 +685,7 @@
             assertThat(responseMd5RadiusPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
 
             // State machine should be in pending state
-
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
             assertThat(stateMachine, notNullValue());
             assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
 
@@ -642,6 +704,7 @@
             checkRadiusPacket(aaaManager, supplicantSuccessPacket, EAP.SUCCESS);
 
             // State machine should be in authorized state
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
 
             assertThat(stateMachine, notNullValue());
             assertThat(stateMachine.state(), is(StateMachine.STATE_AUTHORIZED));
@@ -652,6 +715,8 @@
         });
         assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
             // State machine should be in logoff state
+            StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
+
             assertThat(stateMachine, notNullValue());
             assertThat(stateMachine.state(), is(StateMachine.STATE_IDLE));
 
@@ -681,40 +746,58 @@
         // (1) Supplicant start up
         Ethernet startPacket = constructSupplicantStartPacket();
         sendPacket(startPacket);
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            Ethernet responsePacket = (Ethernet) fetchPacket(0);
+            checkRadiusPacket(aaaManager, responsePacket, EAP.ATTR_IDENTITY);
 
-        Ethernet responsePacket = (Ethernet) fetchPacket(0);
-        checkRadiusPacket(aaaManager, responsePacket, EAP.ATTR_IDENTITY);
+            // (2) Supplicant identify
 
-        // (2) Supplicant identify
+            Ethernet identifyPacket = null;
+            try {
+                identifyPacket = constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
+            sendPacket(identifyPacket);
+        });
+        assertAfter(ASSERTION_DELAY, ASSERTION_LENGTH, () -> {
+            RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
+            try {
+                checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
 
-        Ethernet identifyPacket = constructSupplicantIdentifyPacket(null, EAP.ATTR_IDENTITY, (byte) 1, null);
-        sendPacket(identifyPacket);
 
-        RADIUS radiusIdentifyPacket = (RADIUS) fetchPacket(1);
-        checkRadiusPacketFromSupplicant(radiusIdentifyPacket);
+                assertThat(radiusIdentifyPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
+                assertThat(new String(radiusIdentifyPacket
+                                              .getAttribute(RADIUSAttribute.RADIUS_ATTR_USERNAME)
+                                              .getValue()),
+                           is("testuser"));
+                IpAddress nasIp = IpAddress.valueOf(IpAddress.Version.INET,
+                                                    radiusIdentifyPacket
+                                                            .getAttribute(RADIUSAttribute.RADIUS_ATTR_NAS_IP)
+                                                            .getValue());
+                assertThat(nasIp.toString(), is(aaaManager.nasIpAddress.getHostAddress()));
 
-        assertThat(radiusIdentifyPacket.getCode(), is(RADIUS.RADIUS_CODE_ACCESS_REQUEST));
-        assertThat(new String(radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_USERNAME).getValue()),
-                is("testuser"));
-        IpAddress nasIp = IpAddress.valueOf(IpAddress.Version.INET,
-                  radiusIdentifyPacket.getAttribute(RADIUSAttribute.RADIUS_ATTR_NAS_IP).getValue());
-        assertThat(nasIp.toString(), is(aaaManager.nasIpAddress.getHostAddress()));
+                // State machine should have been created by now
 
-        // State machine should have been created by now
+                StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
+                assertThat(stateMachine, notNullValue());
+                assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
+                Thread.sleep((aaaManager.cleanupTimerTimeOutInMins / 2) + 1);
 
-        StateMachine stateMachine = aaaManager.getStateMachine(SESSION_ID);
-        assertThat(stateMachine, notNullValue());
-        assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
-        Thread.sleep((aaaManager.cleanupTimerTimeOutInMins / 2) + 1);
+                // State machine should be in timeout state
+                assertThat(stateMachine, notNullValue());
+                assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
 
-        // State machine should be in timeout state
-        assertThat(stateMachine, notNullValue());
-        assertThat(stateMachine.state(), is(StateMachine.STATE_PENDING));
-
-        //Check for increase in stats
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getEapolResIdentityMsgTrans(), ZERO);
-        assertNotEquals(aaaStatisticsManager.getAaaStats().getEapolStartReqTrans(), ZERO);
-       countAaaStatistics();
+                //Check for increase in stats
+                assertNotEquals(aaaStatisticsManager.getAaaStats().getEapolResIdentityMsgTrans(), ZERO);
+                assertNotEquals(aaaStatisticsManager.getAaaStats().getEapolStartReqTrans(), ZERO);
+                countAaaStatistics();
+            } catch (Exception e) {
+                log.error(e.getMessage());
+                fail();
+            }
+        });
 
     }
 
diff --git a/app/src/test/java/org/opencord/aaa/impl/AaaTestBase.java b/app/src/test/java/org/opencord/aaa/impl/AaaTestBase.java
index fdd23e9..09f5e97 100644
--- a/app/src/test/java/org/opencord/aaa/impl/AaaTestBase.java
+++ b/app/src/test/java/org/opencord/aaa/impl/AaaTestBase.java
@@ -29,8 +29,10 @@
 import org.onlab.packet.VlanId;
 import org.onosproject.cfg.ComponentConfigService;
 import org.onosproject.cfg.ConfigProperty;
+import org.onosproject.mastership.MastershipServiceAdapter;
 import org.onosproject.net.Annotations;
 import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.DeviceId;
 import org.onosproject.net.Element;
 import org.onosproject.net.Port;
 import org.onosproject.net.PortNumber;
@@ -117,66 +119,67 @@
             }
         }
     }
+
     class MockComponentContext implements ComponentContext {
 
-                @Override
-                public Dictionary<String, Object> getProperties() {
-                        Dictionary<String, Object> cfgDict = new Hashtable<String, Object>();
-                        cfgDict.put("statisticsGenerationEvent", 20);
-                        return cfgDict;
-                }
+        @Override
+        public Dictionary<String, Object> getProperties() {
+            Dictionary<String, Object> cfgDict = new Hashtable<String, Object>();
+            cfgDict.put("statisticsGenerationEvent", 20);
+            return cfgDict;
+        }
 
-                @Override
-                public Object locateService(String name) {
-                        // TODO Auto-generated method stub
-                        return null;
-                }
+        @Override
+        public Object locateService(String name) {
+            // TODO Auto-generated method stub
+            return null;
+        }
 
-                @Override
-                public Object locateService(String name, ServiceReference reference) {
-                        // TODO Auto-generated method stub
-                        return null;
-                }
+        @Override
+        public Object locateService(String name, ServiceReference reference) {
+            // TODO Auto-generated method stub
+            return null;
+        }
 
-                @Override
-                public Object[] locateServices(String name) {
-                        // TODO Auto-generated method stub
-                        return null;
-                }
+        @Override
+        public Object[] locateServices(String name) {
+            // TODO Auto-generated method stub
+            return null;
+        }
 
-                @Override
-                public BundleContext getBundleContext() {
-                        // TODO Auto-generated method stub
-                        return null;
-                }
+        @Override
+        public BundleContext getBundleContext() {
+            // TODO Auto-generated method stub
+            return null;
+        }
 
-                @Override
-                public Bundle getUsingBundle() {
-                        // TODO Auto-generated method stub
-                        return null;
-                }
+        @Override
+        public Bundle getUsingBundle() {
+            // TODO Auto-generated method stub
+            return null;
+        }
 
-                @Override
-                public ComponentInstance getComponentInstance() {
-                        // TODO Auto-generated method stub
-                        return null;
-                }
+        @Override
+        public ComponentInstance getComponentInstance() {
+            // TODO Auto-generated method stub
+            return null;
+        }
 
-                @Override
-                public void enableComponent(String name) {
-                        // TODO Auto-generated method stub
-                }
+        @Override
+        public void enableComponent(String name) {
+            // TODO Auto-generated method stub
+        }
 
-                @Override
-                public void disableComponent(String name) {
-                       // TODO Auto-generated method stub
-                }
+        @Override
+        public void disableComponent(String name) {
+            // TODO Auto-generated method stub
+        }
 
-                @Override
-                public ServiceReference getServiceReference() {
-                       // TODO Auto-generated method stub
-                       return null;
-                }
+        @Override
+        public ServiceReference getServiceReference() {
+            // TODO Auto-generated method stub
+            return null;
+        }
     }
 
     /**
@@ -188,24 +191,30 @@
             return new MockPort();
         }
     }
-    private class  MockPort implements Port {
+
+    private class MockPort implements Port {
 
         @Override
         public boolean isEnabled() {
             return true;
         }
+
         public long portSpeed() {
             return 1000;
         }
+
         public Element element() {
             return null;
         }
+
         public PortNumber number() {
             return null;
         }
+
         public Annotations annotations() {
             return new MockAnnotations();
         }
+
         public Type type() {
             return Port.Type.FIBER;
         }
@@ -216,6 +225,7 @@
             public String value(String val) {
                 return "PON 1/1";
             }
+
             public Set<String> keys() {
                 return null;
             }
@@ -282,7 +292,7 @@
 
         @Override
         public Set<ConfigProperty> getProperties(String componentName) {
-           return null;
+            return null;
         }
 
         @Override
@@ -307,10 +317,17 @@
 
         @Override
         public ConfigProperty getProperty(String componentName, String attribute) {
-           return null;
+            return null;
         }
 
-}
+    }
+
+    final class MockMastershipService extends MastershipServiceAdapter {
+        @Override
+        public boolean isLocalMaster(DeviceId deviceId) {
+            return true;
+        }
+    }
 
     final class MockSubService implements BaseInformationService<SubscriberAndDeviceInformation> {
         private final VlanId uniTagMatch = VlanId.vlanId((short) 35);
@@ -331,27 +348,33 @@
                                                        techProfileId, dsBpId, usBpId,
                                                        clientNasPortId, clientCircuitId, null,
                                                        null);
+
         @Override
         public SubscriberAndDeviceInformation get(String id) {
 
-                return  sub;
+            return sub;
 
         }
 
         @Override
-        public void invalidateAll() {}
-        public void invalidateId(String id) {}
+        public void invalidateAll() {
+        }
+
+        public void invalidateId(String id) {
+        }
+
         public SubscriberAndDeviceInformation getfromCache(String id) {
             return null;
         }
     }
+
     /**
      * Mocks the DefaultPacketContext.
      */
     final class TestPacketContext extends DefaultPacketContext {
 
         TestPacketContext(long time, InboundPacket inPkt,
-                                  OutboundPacket outPkt, boolean block) {
+                          OutboundPacket outPkt, boolean block) {
             super(time, inPkt, outPkt, block);
         }
 
@@ -382,9 +405,9 @@
      * @return Ethernet packet
      */
     Ethernet constructSupplicantIdentifyPacket(StateMachine stateMachine,
-                                                       byte type,
-                                                       byte id,
-                                                       Ethernet radiusChallenge)
+                                               byte type,
+                                               byte id,
+                                               Ethernet radiusChallenge)
             throws Exception {
         Ethernet eth = new Ethernet();
         eth.setDestinationMACAddress(clientMac.toBytes());
@@ -488,7 +511,7 @@
      * Checks the contents of a RADIUS packet being sent to the RADIUS server.
      *
      * @param radiusPacket packet to check
-     * @param code expected code
+     * @param code         expected code
      */
     void checkRadiusPacket(AaaManager aaaManager, Ethernet radiusPacket, byte code) {
 
@@ -544,12 +567,12 @@
      * @return Ethernet packet
      */
     RADIUS constructRadiusCodeAccessChallengePacket(byte challengeCode, byte challengeType,
-            byte identifier, byte[] messageAuth) {
+                                                    byte identifier, byte[] messageAuth) {
 
         String challenge = "12345678901234567";
 
         EAP eap = new EAP(challengeType, (byte) 4, challengeType,
-                challenge.getBytes(Charsets.US_ASCII));
+                          challenge.getBytes(Charsets.US_ASCII));
         //eap.setIdentifier((byte) 4);
         eap.setIdentifier(identifier);
 
@@ -558,7 +581,7 @@
         //radius.setIdentifier((byte) 4);
         radius.setIdentifier(identifier);
         radius.setAttribute(RADIUSAttribute.RADIUS_ATTR_STATE,
-                challenge.getBytes(Charsets.US_ASCII));
+                            challenge.getBytes(Charsets.US_ASCII));
 
         radius.setPayload(eap);
         radius.setAttribute(RADIUSAttribute.RADIUS_ATTR_EAP_MESSAGE, eap.serialize());