Verify all clean function added for unit tests
[ric-plt/submgr.git] / pkg / control / ut_messaging_test.go
index 9c2874b..99ceafc 100644 (file)
 package control
 
 import (
+       //"os"
        "strings"
        "testing"
        "time"
 
        "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
        "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
+       "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
        "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststube2ap"
        "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
        "github.com/stretchr/testify/assert"
 )
 
 func TestSuiteSetup(t *testing.T) {
-       // The effect of this call shall endure thgough the UT suite!
-       // If this causes any issues, the previout interface can be restored
+       // The effect of this call shall endure though the UT suite!
+       // If this causes any issues, the previous interface can be restored
        // like this:git log
        // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
 
+       mainCtrl.InitAllCounterMap()
        SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
+       mainCtrl.c.restDuplicateCtrl.Init()
 
-       restDuplicateCtrl.Init()
+}
+func TestRanStatusChangeViaSDLNotification(t *testing.T) {
+
+       // Current UT test cases use these ran names
+       xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
+       xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
+       xappRnibMock.CreateGnb("RAN_NAME_2", entities.ConnectionStatus_DISCONNECTED)
+
+       mainCtrl.c.e2IfState.ReadE2ConfigurationFromRnib()
+       mainCtrl.c.e2IfState.SubscribeChannels()
+
+       mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
+       mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
+       mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTSubReqAfterE2ConnBreak
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     |         [E2 Conn. DOWN]        |
+//     |                 |              |
+//     | RESTSubReq      |              |
+//     |---------------->|              |
+//     |     RESTSubFail |              |
+//     |<----------------|              |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+
+func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
+       CaseBegin("TestRESTSubReqAfterE2ConnBreak")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestReqRejDueE2Down, 1},
+       })
+
+       // E2 disconnect after E2term has received response
+       mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
+       // Req
+       const subReqCount int = 1
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       xappConn1.SendRESTSubsReq(t, params)
+
+       // Restore E2 connection for following test cases
+       mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
 
+       mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
+       //os.Exit(1)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTSubReqE2ConnBreak
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RESTSubReq      |              |
+//     |---------------->|              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |      SubResp |
+//     |                 |<-------------|
+//     |                 |              |
+//     |         [E2 Conn. DOWN]        |
+//     |        [Int. SUBS DELETE]      |
+//     |                 |              |
+//     |      RESTNotif(unsuccessful)   |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubReqE2ConnBreak(t *testing.T) {
+       CaseBegin("TestRESTSubReqE2ConnBreak")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+       })
+
+       // Req
+       const subReqCount int = 1
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+
+       crereq, cremsg := e2termConn1.RecvSubsReq(t)
+       xappConn1.ExpectRESTNotification(t, restSubId)
+
+       // E2 disconnect after E2term has received response
+       mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
+
+       e2termConn1.SendSubsResp(t, crereq, cremsg)
+       e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
+
+       <-time.After(time.Second * 1)
+       assert.Equal(t, 0, len(mainCtrl.c.registry.register))
+       assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
+
+       subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
+       if err != nil {
+               xapp.Logger.Error("%v", err)
+       } else {
+               assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
+               assert.Equal(t, 0, len(register))
+       }
+
+       restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
+       if err != nil {
+               xapp.Logger.Error("%v", err)
+       } else {
+               assert.Equal(t, 0, len(restSubscriptions))
+       }
+
+       // Restore E2 connection for following test cases
+       mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
+
+       // Wait that subs is cleaned
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTSubscriptionDeleteAfterE2ConnectionBreak
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     |            [SUBS CREATE]       |
+//     |                 |              |
+//     |           [E2 Conn. DOWN]      |
+//     |                 |              |
+//     | RESTSubDelReq   |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |  RESTSubDelResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |  [No valid subscription found] |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTSubscriptionDeleteAfterE2ConnectionBreak")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       // Req
+       var params *teststube2ap.RESTSubsReqParams = nil
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       // E2 disconnect after E2term has received response
+       mainCtrl.SetE2State(t, "RAN_NAME_1_DISCONNECTED")
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       <-time.After(time.Second * 1)
+       assert.Equal(t, 0, len(mainCtrl.c.registry.register))
+       assert.Equal(t, 0, len(mainCtrl.c.registry.restSubscriptions))
+
+       subIds, register, err := mainCtrl.c.ReadAllSubscriptionsFromSdl()
+       if err != nil {
+               xapp.Logger.Error("%v", err)
+       } else {
+               assert.Equal(t, 65534, len(subIds)) // range 1-65535 , FFFF = 65535
+               assert.Equal(t, 0, len(register))
+       }
+
+       restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
+       if err != nil {
+               xapp.Logger.Error("%v", err)
+       } else {
+               assert.Equal(t, 0, len(restSubscriptions))
+       }
+
+       // Restore E2 connection for following test cases
+       mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
+
+       // Wait that subs is cleaned
+       mainCtrl.wait_subs_clean(t, e2SubsId, 10)
+
+       xappConn1.TestMsgChanEmpty(t)
+       e2termConn1.TestMsgChanEmpty(t)
+       mainCtrl.wait_registry_empty(t, 10)
+       mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTOtherE2ConnectionChanges
+//
+
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     |            [SUBS CREATE]       |
+//     |                 |              |
+//     |  [E2 CONNECTED_SETUP_FAILED]   |
+//     |         [E2 CONNECTING]        |
+//     |        [E2 SHUTTING_DOWN]      |
+//     |          [E2 SHUT_DOWN]        |
+//     |                 |              |
+//     |            [SUBS DELETE]       |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTOtherE2ConnectionChanges(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTOtherE2ConnectionChanges")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       // Req
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+
+       crereq, cremsg := e2termConn1.RecvSubsReq(t)
+       xappConn1.ExpectRESTNotification(t, restSubId)
+       e2termConn1.SendSubsResp(t, crereq, cremsg)
+       e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
+
+       // Submgr should not react any other connection state changes than CONNECTED and DISCONNECTED
+       mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED_SETUP_FAILED")
+       mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTING")
+       mainCtrl.SetE2State(t, "RAN_NAME_1_SHUTTING_DOWN")
+       mainCtrl.SetE2State(t, "RAN_NAME_1_SHUT_DOWN")
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       // Restore E2 connection for following test cases
+       mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
+
+       // Wait that subs is cleaned
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -90,6 +367,7 @@ func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
        deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
 
        waitSubsCleanup(t, e2SubsId, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -136,6 +414,7 @@ func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
        defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
 
        waitSubsCleanup(t, e2SubsId, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -198,6 +477,7 @@ func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
        defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
 
        waitSubsCleanup(t, e2SubsId, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -455,6 +735,7 @@ func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cSubReqFromXapp, 2},
+               Counter{cMergedSubscriptions, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
                Counter{cSubRespToXapp, 2},
@@ -463,6 +744,7 @@ func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
                Counter{cSubDelRespToXapp, 2},
+               Counter{cUnmergedSubscriptions, 1},
        })
 
        //Req1
@@ -989,6 +1271,7 @@ func TestSubReqRetryInSubmgr(t *testing.T) {
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cSubReqFromXapp, 1},
                Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubRespFromE2, 1},
                Counter{cSubRespToXapp, 1},
@@ -1175,12 +1458,6 @@ func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 //     |              |      SubFail |
 //     |              |<-------------|
 //     |              |              |
-//     |              | SubDelReq    |
-//     |              |------------->|
-//     |              |              |
-//     |              |   SubDelResp |
-//     |              |<-------------|
-//     |              |              |
 //     |      SubFail |              |
 //     |<-------------|              |
 //     |              |              |
@@ -1206,10 +1483,6 @@ func TestSubReqSubFailRespInSubmgr(t *testing.T) {
        fparams1.Set(crereq1)
        e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 
-       // E2t: Receive SubsDelReq and send SubsDelResp (internal first)
-       delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
-       e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
-
        // Xapp: Receive SubsFail
        e2SubsId := xappConn1.RecvSubsFail(t, cretrans)
 
@@ -1484,8 +1757,6 @@ func TestSubReqAndSubDelOkSameAction(t *testing.T) {
        rparams2 := &teststube2ap.E2StubSubsReqParams{}
        rparams2.Init()
        cretrans2 := xappConn2.SendSubsReq(t, rparams2, nil)
-       //crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
-       //e2termConn1.SendSubsResp(t, crereq2, cremsg2)
        e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
 
        resp, _ := xapp.Subscription.QuerySubscriptions()
@@ -1495,11 +1766,7 @@ func TestSubReqAndSubDelOkSameAction(t *testing.T) {
 
        //Del1
        deltrans1 := xappConn1.SendSubsDelReq(t, nil, e2SubsId1)
-       //e2termConn1.RecvSubsDelReq(t)
-       //e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
        xappConn1.RecvSubsDelResp(t, deltrans1)
-       //Wait that subs is cleaned
-       //mainCtrl.wait_subs_clean(t, e2SubsId1, 10)
 
        //Del2
        deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
@@ -1621,11 +1888,6 @@ func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
 //     |             |              |    SubFail1  |
 //     |             |              |<-------------|
 //     |             |              |              |
-//     |             |              | SubDelReq    |
-//     |             |              |------------->|
-//     |             |              |   SubDelResp |
-//     |             |              |<-------------|
-//     |             |              |              |
 //     |             |    SubFail1  |              |
 //     |             |<-------------|              |
 //     |             |              |              |
@@ -1656,10 +1918,6 @@ func TestSubReqAndSubDelNokSameActionParallel(t *testing.T) {
        fparams1.Set(crereq1)
        e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 
-       // E2t: internal delete
-       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
-       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
-
        //Fail1
        e2SubsId1 := xappConn1.RecvSubsFail(t, cretrans1)
        //Fail2
@@ -2441,6 +2699,7 @@ func TestRESTSubReqAndRouteNok(t *testing.T) {
        mainCtrl.wait_subs_clean(t, newSubsId, 10)
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
@@ -2489,6 +2748,7 @@ func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)    //This test case is not working correctly
 }
 
 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
@@ -2524,6 +2784,7 @@ func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       ////mainCtrl.VerifyAllClean(t)  This test case is not working correctly
 }
 
 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
@@ -2531,6 +2792,7 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cRestSubReqFromXapp, 2},
+               Counter{cMergedSubscriptions, 1},
                Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
@@ -2540,6 +2802,7 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
                Counter{cRestSubDelRespToXapp, 2},
+               Counter{cUnmergedSubscriptions, 1},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2563,8 +2826,8 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
        deleteXapp2Subscription(t, &restSubId2)
 
        waitSubsCleanup(t, e2SubsId2, 10)
-
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2647,6 +2910,7 @@ func TestRESTSubReqRetransmission(t *testing.T) {
        mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2696,6 +2960,7 @@ func TestRESTSubReqRetransmissionV2(t *testing.T) {
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 2},
                Counter{cRestSubRespToXapp, 3},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
@@ -2732,6 +2997,7 @@ func TestRESTSubReqRetransmissionV2(t *testing.T) {
 
        //Wait that subs is cleaned
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2780,6 +3046,7 @@ func TestRESTSubReqRetransmissionV3(t *testing.T) {
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 2},
                Counter{cRestSubRespToXapp, 3},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
@@ -2820,6 +3087,7 @@ func TestRESTSubReqRetransmissionV3(t *testing.T) {
 
        //Wait that subs is cleaned
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2884,6 +3152,7 @@ func TestRESTSubReqRetransmissionV4(t *testing.T) {
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 2},
                Counter{cRestSubRespToXapp, 3},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
@@ -2941,6 +3210,7 @@ func TestRESTSubReqRetransmissionV4(t *testing.T) {
 
        //Wait that subs is cleaned
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3005,6 +3275,7 @@ func TestRESTSubReqRetransmissionV5(t *testing.T) {
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 2},
                Counter{cRestSubRespToXapp, 3},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
@@ -3064,6 +3335,7 @@ func TestRESTSubReqRetransmissionV5(t *testing.T) {
 
        //Wait that subs is cleaned
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3137,6 +3409,7 @@ func TestRESTSubReqRetransmissionV6(t *testing.T) {
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 1},
                Counter{cRestSubRespToXapp, 3},
                Counter{cSubReqToE2, 3},
                Counter{cSubRespFromE2, 3},
@@ -3194,6 +3467,7 @@ func TestRESTSubReqRetransmissionV6(t *testing.T) {
 
        //Wait that subs is cleaned
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubDelReqRetransmission(t *testing.T) {
@@ -3208,7 +3482,7 @@ func TestRESTSubDelReqRetransmission(t *testing.T) {
                Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cRestSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -3231,6 +3505,7 @@ func TestRESTSubDelReqRetransmission(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3272,6 +3547,7 @@ func TestRESTSubReqDelReq(t *testing.T) {
                Counter{cSubRespFromE2, 1},
                Counter{cRestSubNotifToXapp, 1},
                Counter{cRestSubDelReqFromXapp, 2},
+               Counter{cRestSubDelFailToXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
                Counter{cRestSubDelRespToXapp, 1},
@@ -3301,7 +3577,7 @@ func TestRESTSubReqDelReq(t *testing.T) {
        // Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubDelReqCollision(t *testing.T) {
@@ -3359,7 +3635,7 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
        waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSameSubsDiffRan(t *testing.T) {
@@ -3396,7 +3672,7 @@ func TestRESTSameSubsDiffRan(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
@@ -3407,6 +3683,7 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) {
                Counter{cRestSubReqFromXapp, 1},
                Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubRespFromE2, 1},
                Counter{cRestSubNotifToXapp, 1},
@@ -3440,7 +3717,7 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3492,10 +3769,10 @@ func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubReqTimerExpiry, 2},
+               Counter{cRestSubFailNotifToXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
        })
-
        params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
        xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
@@ -3515,6 +3792,7 @@ func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
        waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
@@ -3527,10 +3805,11 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubReqTimerExpiry, 2},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelReqTimerExpiry, 2},
        })
-
        params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
        xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
@@ -3553,7 +3832,7 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3604,6 +3883,7 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubReqTimerExpiry, 2},
+               Counter{cRestSubFailNotifToXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelReReqToE2, 1},
                Counter{cSubDelReqTimerExpiry, 2},
@@ -3631,6 +3911,7 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3652,12 +3933,6 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 //     |                 |      SubFail |
 //     |                 |<-------------|
 //     |                 |              |
-//     |                 | SubDelReq    |
-//     |                 |------------->|
-//     |                 |              |
-//     |                 |   SubDelResp |
-//     |                 |<-------------|
-//     |                 |              |
 //     |       RESTNotif |              |
 //     |       unsuccess |              |
 //     |<----------------|              |
@@ -3676,6 +3951,7 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
                Counter{cSubFailFromE2, 1},
                Counter{cRestSubFailNotifToXapp, 1},
                Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
@@ -3690,11 +3966,9 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
        crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
        fparams1 := &teststube2ap.E2StubSubsFailParams{}
        fparams1.Set(crereq1)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
        e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 
-       delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
-       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
-       e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
        e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
        xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
 
@@ -3705,7 +3979,7 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3746,6 +4020,7 @@ func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
                Counter{cRestSubNotifToXapp, 1},
                Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 1},
                Counter{cSubDelReReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
                Counter{cRestSubDelRespToXapp, 1},
@@ -3768,6 +4043,7 @@ func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3806,6 +4082,7 @@ func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
                Counter{cRestSubNotifToXapp, 1},
                Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 1},
                Counter{cSubDelReReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
                Counter{cRestSubDelRespToXapp, 1},
@@ -3829,6 +4106,7 @@ func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3885,6 +4163,7 @@ func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3986,6 +4265,7 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4080,6 +4360,7 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4102,7 +4383,7 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
 //     | RESTSubReq2                   |              |
 //     |------------------------------>|              |
 //     |             |                 |              |
-//     |               RESTSubDelResp2 |              |
+//     |               RESTSubResp2    |              |
 //     |<------------------------------|              |
 //     |             |                 | SubReq1      |
 //     |             |                 |------------->|
@@ -4138,15 +4419,17 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cRestSubReqFromXapp, 2},
+               Counter{cMergedSubscriptions, 1},
                Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 2},
+               Counter{cSubReReqToE2, 1},
                Counter{cRestSubFailNotifToXapp, 2},
                Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
                Counter{cRestSubDelRespToXapp, 2},
        })
-
        const subReqCount int = 1
 
        // Req1
@@ -4186,6 +4469,7 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
        waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4219,12 +4503,8 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
 //     |                    RESTNotif2 |              |
 //     |             |       unsuccess |              |
 //     |<------------------------------|              |
-//     |             |                 | SubDelReq    |
-//     |             |                 |------------->|
-//     |             |                 |   SubDelResp |
-//     |             |                 |<-------------|
 //     |             |                 |              |
-//     |             | RESTSubDelReq1  |              |
+//     |             | RESTSubDelReq1  |              |   There is no need for xApp to send delete for failed subscriptions but some xApp might do so.
 //     |             |---------------->|              |
 //     |             |                 |              |
 //     |             | RESTSubDelResp1 |              |
@@ -4242,13 +4522,12 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
                Counter{cRestSubReqFromXapp, 2},
+               Counter{cMergedSubscriptions, 1},
                Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubFailFromE2, 1},
                Counter{cRestSubFailNotifToXapp, 2},
                Counter{cRestSubDelReqFromXapp, 2},
-               Counter{cSubDelReqToE2, 1},
-               Counter{cSubDelRespFromE2, 1},
                Counter{cRestSubDelRespToXapp, 2},
        })
 
@@ -4271,11 +4550,7 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
        fparams1.Set(crereq1)
        e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 
-       // E2t: internal delete
-       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
        xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
-       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
-
        e2SubsIdA := <-xappConn1.ListedRESTNotifications
        xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
        e2SubsIdB := <-xappConn1.ListedRESTNotifications
@@ -4292,6 +4567,7 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
        waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
@@ -4327,6 +4603,7 @@ func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
        // Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4421,6 +4698,7 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
        // Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4502,6 +4780,7 @@ func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
        // Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4605,6 +4884,7 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4704,6 +4984,7 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
        // Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4744,6 +5025,7 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
                Counter{cSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
        })
 
        const subReqCount int = 1
@@ -4775,6 +5057,7 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4827,9 +5110,9 @@ func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
                Counter{cRestSubNotifToXapp, 1},
                Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
                Counter{cRestSubDelRespToXapp, 1},
        })
-
        // Remove possible existing subscription
        mainCtrl.removeExistingSubscriptions(t)
 
@@ -4855,6 +5138,7 @@ func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4969,6 +5253,7 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -5062,6 +5347,7 @@ func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 /*
@@ -5109,6 +5395,7 @@ func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
@@ -5143,6 +5430,7 @@ func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
 
@@ -5174,6 +5462,7 @@ func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
@@ -5208,6 +5497,7 @@ func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
@@ -5242,6 +5532,7 @@ func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
@@ -5276,6 +5567,7 @@ func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
@@ -5322,7 +5614,7 @@ func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
@@ -5374,7 +5666,7 @@ func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
@@ -5420,7 +5712,7 @@ func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqDiffActionType(t *testing.T) {
@@ -5471,7 +5763,7 @@ func TestRESTSubReqDiffActionType(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
@@ -5522,7 +5814,7 @@ func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
@@ -5569,7 +5861,7 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
@@ -5616,7 +5908,7 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
@@ -5661,7 +5953,7 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -5691,11 +5983,7 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
 //     |                 |<-------------|
 //     | RESTNotif (fail)|              |
 //     |<----------------|              |
-//     |                 | SubDelReq    |
-//     |                 |------------->|
 //     |                 |              |
-//     |                 |   SubDelResp |
-//     |                 |<-------------|
 //
 //-----------------------------------------------------------------------------
 
@@ -5721,9 +6009,6 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
        fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
        e2termConn1.SendSubsFail(t, fparams, cremsg)
 
-       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
-       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
-
        instanceId := xappConn1.WaitRESTNotification(t, restSubId)
        xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
 
@@ -5733,6 +6018,7 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -5807,6 +6093,7 @@ func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -5889,7 +6176,7 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
-
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -5919,11 +6206,7 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
 //     |                 |<-------------|
 //     | RESTNotif (fail)|              |
 //     |<----------------|              |
-//     |                 | SubDelReq    |
-//     |                 |------------->|
 //     |                 |              |
-//     |                 |   SubDelResp |
-//     |                 |<-------------|
 //
 //-----------------------------------------------------------------------------
 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
@@ -5949,9 +6232,6 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
        fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
        e2termConn1.SendSubsFail(t, fparams, cremsg)
 
-       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
-       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
-
        instanceId := xappConn1.WaitRESTNotification(t, restSubId)
        xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
 
@@ -5961,6 +6241,7 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6033,6 +6314,7 @@ func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6110,6 +6392,7 @@ func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6171,6 +6454,7 @@ func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6232,6 +6516,7 @@ func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6294,6 +6579,7 @@ func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6354,6 +6640,7 @@ func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6415,6 +6702,7 @@ func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6477,6 +6765,7 @@ func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6537,6 +6826,7 @@ func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
        // Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
@@ -6546,6 +6836,7 @@ func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
                Counter{cRestSubReqFromXapp, 2},
                Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
+               Counter{cSubReqTimerExpiry, 1},
                Counter{cSubRespFromE2, 1},
                Counter{cRestSubNotifToXapp, 1},
                Counter{cRestSubFailNotifToXapp, 1},
@@ -6595,6 +6886,7 @@ func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6652,9 +6944,10 @@ func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 1},
                Counter{cRestSubNotifToXapp, 1},
-               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
                Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
                Counter{cRestSubDelRespToXapp, 1},
        })
 
@@ -6701,10 +6994,6 @@ func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
        // Check subscription
        queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
 
-       xapp.Logger.Debug("Here 1")
-       //<-time.After(3 * time.Second)
-       xapp.Logger.Debug("Here 2")
-
        // Delete subscription
        xappConn1.SendRESTSubsDelReq(t, &restSubId)
        delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
@@ -6714,6 +7003,7 @@ func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       //mainCtrl.VerifyAllClean(t)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////