Merge "Unit test improvement - Fixed dealy replaced with waiting function in one...
[ric-plt/submgr.git] / pkg / control / ut_messaging_test.go
index 891437f..2c90513 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 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()
+
+}
+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(0)
+}
+
+//-----------------------------------------------------------------------------
+// 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)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTSubReqAndDeleteOkWithE2apUtWrapper
+//
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|  // The order of these events may vary
+//     |                 |              |             |
+//     |     RESTSubResp |              |             |  // The order of these events may vary
+//     |<----------------|              |             |
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|  // The order of these events may vary
+//     |                 |              |             |
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |  // The order of these events may vary
+//     |                 |              |             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     |                 |              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |              |             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 |              |             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 |              |             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
+
+       deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTSubReqAndE1apDeleteReqPackingError
+//
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|  // The order of these events may vary
+//     |                 |              |             |
+//     |     RESTSubResp |              |             |  // The order of these events may vary
+//     |<----------------|              |             |
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|  // The order of these events may vary
+//     |                 |              |             |
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |  // The order of these events may vary
+//     |                 |              |             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     |                 |              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |                 |              |             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 |              |             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
+
+       e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, false)
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTSubReqAndE1apDeleteRespUnpackingError
+//
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|  // The order of these events may vary
+//     |                 |              |             |
+//     |     RESTSubResp |              |             |  // The order of these events may vary
+//     |<----------------|              |             |
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|  // The order of these events may vary
+//     |                 |              |             |
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |  // The order of these events may vary
+//     |                 |              |             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     |                 |              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |              |             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             | // The order of these events may vary
+//     |                 |              |             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             | // 1.st NOK
+//     |                 |              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |              |             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             | // 2.nd NOK
+//
+//-----------------------------------------------------------------------------
+
+func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, nil)
+
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, false)
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyAllClean(t)
+}
+
 //-----------------------------------------------------------------------------
 // TestSubReqAndRouteNok
 //
@@ -224,7 +675,6 @@ func TestSubDelReqAndRouteDeleteNok(t *testing.T) {
        xappConn2.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
-
        mainCtrl.VerifyCounterValues(t)
 }
 
@@ -284,6 +734,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},
@@ -292,6 +743,7 @@ func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
                Counter{cSubDelRespToXapp, 2},
+               Counter{cUnmergedSubscriptions, 1},
        })
 
        //Req1
@@ -818,6 +1270,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},
@@ -1004,12 +1457,6 @@ func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 //     |              |      SubFail |
 //     |              |<-------------|
 //     |              |              |
-//     |              | SubDelReq    |
-//     |              |------------->|
-//     |              |              |
-//     |              |   SubDelResp |
-//     |              |<-------------|
-//     |              |              |
 //     |      SubFail |              |
 //     |<-------------|              |
 //     |              |              |
@@ -1035,10 +1482,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)
 
@@ -1313,8 +1756,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()
@@ -1324,11 +1765,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)
@@ -1450,11 +1887,6 @@ func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
 //     |             |              |    SubFail1  |
 //     |             |              |<-------------|
 //     |             |              |              |
-//     |             |              | SubDelReq    |
-//     |             |              |------------->|
-//     |             |              |   SubDelResp |
-//     |             |              |<-------------|
-//     |             |              |              |
 //     |             |    SubFail1  |              |
 //     |             |<-------------|              |
 //     |             |              |              |
@@ -1485,10 +1917,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
@@ -1946,9 +2374,6 @@ func TestSubReqRetransmissionWithSameSubIdDiffXid(t *testing.T) {
 func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
        CaseBegin("TestSubReqNokAndSubDelOkWithRestartInMiddle")
 
-       // Remove possible existing subscrition
-       mainCtrl.removeExistingSubscriptions(t)
-
        mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
        xappConn1.SendSubsReq(t, nil, nil)
        e2termConn1.RecvSubsReq(t)
@@ -1963,6 +2388,7 @@ func TestSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
        mainCtrl.SimulateRestart(t)
        xapp.Logger.Debug("mainCtrl.SimulateRestart done")
 
+       // Submgr send delete for uncompleted subscription
        delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
        e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 
@@ -2029,6 +2455,10 @@ func TestSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
        mainCtrl.SimulateRestart(t)
        xapp.Logger.Debug("mainCtrl.SimulateRestart done")
 
+       // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+       // That needs to be completed before successful subscription query is possible
+       <-time.After(time.Second * 1)
+
        // Check that subscription is restored correctly after restart
        resp, _ = xapp.Subscription.QuerySubscriptions()
        assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId))
@@ -2123,7 +2553,7 @@ func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
        e2SubsId2 := xappConn2.RecvSubsResp(t, cretrans2)
 
        // Check subscription
-       resp, _ := xapp.Subscription.QuerySubscriptions() ////////////////////////////////
+       resp, _ := xapp.Subscription.QuerySubscriptions()
        assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
        assert.Equal(t, resp[0].Meid, "RAN_NAME_1")
        assert.Equal(t, resp[0].ClientEndpoint, []string{"localhost:13560", "localhost:13660"})
@@ -2131,6 +2561,10 @@ func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
        mainCtrl.SimulateRestart(t)
        xapp.Logger.Debug("mainCtrl.SimulateRestart done")
 
+       // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+       // That needs to be completed before successful subscription query is possible
+       <-time.After(time.Second * 1)
+
        // Check that subscription is restored correctly after restart
        resp, _ = xapp.Subscription.QuerySubscriptions()
        assert.Equal(t, resp[0].SubscriptionID, int64(e2SubsId1))
@@ -2146,6 +2580,10 @@ func TestSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
        mainCtrl.SimulateRestart(t)
        xapp.Logger.Debug("mainCtrl.SimulateRestart done")
 
+       // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+       // Submgr need be ready before successful subscription deletion is possible
+       <-time.After(time.Second * 1)
+
        //Del2
        deltrans2 := xappConn2.SendSubsDelReq(t, nil, e2SubsId2)
        delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
@@ -2199,6 +2637,11 @@ func TestPostEmptyDb(t *testing.T) {
        mainCtrl.sendPostRequest(t, "localhost:8080", "/ric/v1/test/emptydb")
 }
 
+func TestGetRestSubscriptions(t *testing.T) {
+
+       mainCtrl.sendGetRequest(t, "localhost:8080", "/ric/v1/restsubscriptions")
+}
+
 //-----------------------------------------------------------------------------
 // TestRESTSubReqAndRouteNok
 //
@@ -2234,29 +2677,28 @@ func TestRESTSubReqAndRouteNok(t *testing.T) {
        CaseBegin("TestRESTSubReqAndRouteNok")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cRouteCreateFail, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
+
        // Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
        waiter := rtmgrHttp.AllocNextSleep(50, false)
        newSubsId := mainCtrl.get_registry_next_subid(t)
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "failAll")
        waiter.WaitResult(t)
 
        e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
-       xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
+       xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
 
        // Del
        xappConn1.SendRESTSubsDelReq(t, &restSubId)
@@ -2265,6 +2707,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) {
@@ -2272,15 +2715,17 @@ func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
 
        //Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 2},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
                Counter{cRouteCreateUpdateFail, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2293,24 +2738,25 @@ func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
        // xapp2 ROUTE creation shall fail with  400 from rtmgr -> submgr
        waiter := rtmgrHttp.AllocNextEvent(false)
        newSubsId := mainCtrl.get_registry_next_subid(t)
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
-       xappConn2.ExpectRESTNotification(t, restSubId2)
+       xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
+       xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
        waiter.WaitResult(t)
-       // e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
        xappConn2.WaitRESTNotification(t, restSubId2)
 
        queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
 
        deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
+       xappConn2.SendRESTSubsDelReq(t, &restSubId2)
 
        mainCtrl.wait_subs_clean(t, newSubsId, 10)
        //Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
@@ -2318,15 +2764,16 @@ func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cRouteDeleteFail, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2343,23 +2790,26 @@ func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
        waiter.WaitResult(t)
 
        waitSubsCleanup(t, e2SubsId, 10)
-
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
        CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cMergedSubscriptions, 1},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cRouteDeleteUpdateFail, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
+               Counter{cUnmergedSubscriptions, 1},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2383,8 +2833,8 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
        deleteXapp2Subscription(t, &restSubId2)
 
        waitSubsCleanup(t, e2SubsId2, 10)
-
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2406,19 +2856,13 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
 //     | RESTSubReq2     |              |
 //     | (retrans)       |              |
 //     |---------------->|              |
-//     |                 |              |
-//     |                 | SubReq2      |
-//     |                 |------------->|
-//     |    RESTSubResp2 |              |
+//     | RESTSubResp(201)|              |
 //     |<----------------|              |
+//     |                 |              |
 //     |                 |     SubResp1 |
 //     |                 |<-------------|
 //     |      RESTNotif1 |              |
 //     |<----------------|              |
-//     |                 |     SubResp1 |
-//     |                 |<-------------|
-//     |      RESTNotif2 |              |
-//     |<----------------|              |
 //     |                 |              |
 //     |            [SUBS DELETE]       |
 //     |                 |              |
@@ -2429,77 +2873,617 @@ func TestRESTSubReqRetransmission(t *testing.T) {
        CaseBegin("TestRESTSubReqRetransmission")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
-               Counter{cSubReqToE2, 2},
-               Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
-               Counter{cSubDelReqToE2, 2},
-               Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
-       // Retry/duplicate will get the same way as the first request.  Submgr cannot detect duplicate RESTRequests
+       // Retry/duplicate will get the same way as the first request.
        // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
        // second request from same xapp as doing it from xappConn1 would not work as notification would not be received
 
        // Subs Create
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
 
-       // In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
-       // gets into execution before the rtmgrg responds for the first one.
-       waiter := rtmgrHttp.AllocNextSleep(10, true)
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
-       restSubId1 := xappConn1.SendRESTSubsReq(t, params)
-       restSubId2 := xappConn2.SendRESTSubsReq(t, params)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
 
-       waiter.WaitResult(t)
+       xappConn1.SendRESTSubsReq(t, params)
+       <-time.After(time.Second * 1)
 
-       xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
+       xappConn1.WaitListedRestNotifications(t, []string{restSubId})
 
        // Depending one goroutine scheduling order, we cannot say for sure which xapp reaches e2term first. Thus
-       // the order is not significant he6re.
+       // the order is not significant here.
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
        e2termConn1.SendSubsResp(t, crereq, cremsg)
-       crereq, cremsg = e2termConn1.RecvSubsReq(t)
-       e2termConn1.SendSubsResp(t, crereq, cremsg)
 
-       e2SubsIdA := <-xappConn1.ListedRESTNotifications
-       xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
-       e2SubsIdB := <-xappConn1.ListedRESTNotifications
-       xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
+       e2SubsId := <-xappConn1.ListedRESTNotifications
+
+       xapp.Logger.Debug("TEST: XAPP notification received e2SubsId=%v", e2SubsId)
 
        // Del1
-       xappConn1.SendRESTSubsDelReq(t, &restSubId1)
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
        delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
        e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 
-       // Del2
-       xappConn2.SendRESTSubsDelReq(t, &restSubId2)
-       delreq2, delmsg2 := e2termConn1.RecvSubsDelReq(t)
-       e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
+       mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
 
-       mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId, e2SubsIdB.E2SubsId}, 10)
+       mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
+}
 
-       waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|  // The order of these events may vary
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |  // The order of these events may vary
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [RETRANS1]      |              |             |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [RETRANS2]      |              |             |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+
+func TestRESTSubReqRetransmissionV2(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV2")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 2},
+               Counter{cRestSubRespToXapp, 3},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 3},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       //1.st resend
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
+
+       assert.Equal(t, restSubId_resend, restSubId)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       //2.nd resend
+       restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
+
+       assert.Equal(t, restSubId_resend2, restSubId)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|  // The order of these events may vary
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |  // The order of these events may vary
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [RETRANS, with RESTsubsId]     |             |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [RETRANS, without RESTsubsId]  |             |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubReqRetransmissionV3(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV3")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 2},
+               Counter{cRestSubRespToXapp, 3},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 3},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       //1.st resend with subscription ID
+       params.SetSubscriptionID(&restSubId)
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params)
+
+       assert.Equal(t, restSubId_resend, restSubId)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       //2.nd resend without subscription ID (faking app restart)
+       params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
+
+       assert.Equal(t, restSubId_resend2, restSubId)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [with RestSUbsId + one additional e2 subDetail]
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     | [for initial e2 subDetail]     |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [with RESTsubsId initial request]            |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+
+func TestRESTSubReqRetransmissionV4(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV4")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 2},
+               Counter{cRestSubRespToXapp, 3},
+               Counter{cSubReqToE2, 2},
+               Counter{cSubRespFromE2, 2},
+               Counter{cRestSubNotifToXapp, 4},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 2},
+               Counter{cSubDelRespFromE2, 2},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       // Send modified  requst, this time with e2 subscriptions.
+       params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
+       params2.SetSubscriptionID(&restSubId)
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
+       e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
+
+       crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
 
+       xappConn1.DecrementRequestCount()
+       xappConn1.ExpectRESTNotification(t, restSubId_resend)
+       e2termConn1.SendSubsResp(t, crereq2, cremsg2)
+       e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
+       assert.NotEqual(t, e2SubsId2, 0)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       params.SetSubscriptionID(&restSubId)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request again with only one e2 subscription (detail), this time with restsubsid
+       restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
+       assert.Equal(t, restSubId_resend, restSubId_resend2)
+
+       e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       // Delete both e2 subscriptions
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       e2SubsIds := []uint32{e2SubsId, e2SubsId2}
+       sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [with RestSUbsId + one additional e2 subDetail]
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     | [for initial e2 subDetail]     |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [without RESTsubsId initial request]         |
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+
+func TestRESTSubReqRetransmissionV5(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV5")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 2},
+               Counter{cRestSubRespToXapp, 3},
+               Counter{cSubReqToE2, 2},
+               Counter{cSubRespFromE2, 2},
+               Counter{cRestSubNotifToXapp, 4},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 2},
+               Counter{cSubDelRespFromE2, 2},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       // Send modified  request, this time with e2 subscriptions.
+       params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
+       params2.SetSubscriptionID(&restSubId)
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
+
+       e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
+       // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
+       xappConn1.DecrementRequestCount()
+
+       crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
+
+       xappConn1.ExpectRESTNotification(t, restSubId_resend)
+       e2termConn1.SendSubsResp(t, crereq2, cremsg2)
+       e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
+       assert.NotEqual(t, e2SubsId2, 0)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
+       // md5sum shall find the original request
+       restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
+       assert.Equal(t, restSubId_resend, restSubId_resend2)
+
+       e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       // Delete both e2 subscriptions
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       e2SubsIds := []uint32{e2SubsId, e2SubsId2}
+       sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+//   stub                             stub          stub
+// +-------+        +---------+    +---------+   +---------+
+// | xapp  |        | submgr  |    | e2term  |   |  rtmgr  |
+// +-------+        +---------+    +---------+   +---------+
+//     |                 |              |             |
+//     | RESTSubReq      |              |             |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubReq      |              |             |
+//     | [with RestSUbsId + one additional e2 subDetail]
+//     |---------------->|              |             |
+//     |      RESTNotif1 |              |             |
+//     | [for initial e2 subDetail]     |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     | RESTSubDelReq   |              |             |
+//     |---------------->|              |             |
+//     |   RESTSubDelResp|              |             |
+//     |<----------------|              |             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     |                 | SubDelReq    |             |
+//     |                 |------------->|             |
+//     |                 |   SubDelResp |             |
+//     |                 |<-------------|             |
+//     | RESTSubReq      |              |             |
+//     | [with RESTsubsId initial request]            |
+//     |---------------->|              |             |
+//     |     RESTSubResp |              |             |
+//     |<----------------|              |             |
+//     |                 | RouteCreate  |             |
+//     |                 |--------------------------->|
+//     |                 | RouteResponse|             |
+//     |                 |<---------------------------|
+//     |                 | SubReq       |             |
+//     |                 |------------->|             |
+//     |                 |      SubResp |             |
+//     |                 |<-------------|             |
+//     |      RESTNotif1 |              |             |
+//     |<----------------|              |             |
+//     |                 |              |             |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubReqRetransmissionV6(t *testing.T) {
+       CaseBegin("TestRESTSubReqRetransmissionV6")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 3},
+               Counter{cDuplicateE2SubReq, 1},
+               Counter{cRestSubRespToXapp, 3},
+               Counter{cSubReqToE2, 3},
+               Counter{cSubRespFromE2, 3},
+               Counter{cRestSubNotifToXapp, 4},
+               Counter{cRestSubDelReqFromXapp, 2},
+               Counter{cSubDelReqToE2, 3},
+               Counter{cSubDelRespFromE2, 3},
+               Counter{cRestSubDelRespToXapp, 2},
+       })
+
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       // Send modified  requst, this time with e2 subscriptions.
+       params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
+       params2.SetSubscriptionID(&restSubId)
+
+       xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
+       xappConn1.ExpectAnyNotification(t)
+       // Resend the original request with an additional e2 subscription (detail), this time with restsubsid
+       restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
+
+       e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
+       assert.Equal(t, e2SubsId, e2SubsId1)
+
+       crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
+
+       xappConn1.ExpectRESTNotification(t, restSubId_resend)
+       e2termConn1.SendSubsResp(t, crereq2, cremsg2)
+       e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
+       assert.NotEqual(t, e2SubsId2, 0)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       // Delete both e2 subscriptions
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       e2SubsIds := []uint32{e2SubsId, e2SubsId2}
+       sendAndReceiveMultipleE2DelReqs(t, e2SubsIds, e2termConn1)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+
+       // Resend the original request, we shall find it's previous md5sum/restsubs
+       // but the restsubscription has been already removed. This shall trigger a
+       // fresh create.
+       restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
+
+       mainCtrl.WaitOngoingRequestMapEmpty()
+
+       deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
+
+       waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubDelReqRetransmission(t *testing.T) {
        CaseBegin("TestRESTSubDelReqRetransmission")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2520,8 +3504,8 @@ func TestRESTSubDelReqRetransmission(t *testing.T) {
        e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 
        waitSubsCleanup(t, e2SubsId, 10)
-
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2557,23 +3541,22 @@ func TestRESTSubReqDelReq(t *testing.T) {
        CaseBegin("TestRESTSubReqDelReq")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 2},
+               Counter{cRestSubDelFailToXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        // Del. This will fail as processing of the subscription
@@ -2594,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) {
@@ -2605,25 +3588,26 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkTwoParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        //Req1
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId1 := xappConn1.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
 
        //Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
 
        crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
        crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
@@ -2637,9 +3621,9 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
        e2termConn1.SendSubsResp(t, crereq2, cremsg2)
 
        e2SubsIdA := <-xappConn1.ListedRESTNotifications
-       xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+       xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
        e2SubsIdB := <-xappConn1.ListedRESTNotifications
-       xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
+       xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
 
        //Del1
        deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
@@ -2651,31 +3635,32 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
        waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSameSubsDiffRan(t *testing.T) {
        CaseBegin("TestRESTSameSubsDiffRan")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
 
-       params = xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_2")
        restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
 
        //Del1
        deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
@@ -2687,7 +3672,7 @@ func TestRESTSameSubsDiffRan(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
@@ -2695,25 +3680,27 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
-       xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
 
        // Catch the first message and ignore it
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
-       xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
 
        // The second request is being handled normally
        crereq, cremsg = e2termConn1.RecvSubsReq(t)
@@ -2730,7 +3717,7 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2771,39 +3758,45 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) {
 //     |                 |              |
 //
 //-----------------------------------------------------------------------------
+
 func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubReqTwoRetriesNoRespSubDelRespInSubmgr start")
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubReqTimerExpiry, 2},
+               Counter{cRestSubFailNotifToXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
 
        e2termConn1.RecvSubsReq(t)
-       xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
 
        e2termConn1.RecvSubsReq(t)
-       xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
 
        delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
        e2termConn1.SendSubsDelResp(t, delreq, delmsg)
-       // e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)     - TODO:  Should we delete this?
        xappConn1.WaitRESTNotification(t, restSubId)
 
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
        // Wait that subs is cleaned
        waitSubsCleanup(t, delreq.RequestId.InstanceId, 10)
-
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
@@ -2811,37 +3804,43 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubReqTimerExpiry, 2},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelReqTimerExpiry, 2},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
 
        e2termConn1.RecvSubsReq(t)
-       xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
 
        e2termConn1.RecvSubsReq(t)
-       xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
 
        e2termConn1.RecvSubsDelReq(t)
-       xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
        e2termConn1.RecvSubsDelReq(t)
-       xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
 
        e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
 
-       waitSubsCleanup(t, e2SubsId, 10)
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
 
+       waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2887,37 +3886,43 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubReReqToE2, 1},
                Counter{cSubReqTimerExpiry, 2},
+               Counter{cRestSubFailNotifToXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelReReqToE2, 1},
                Counter{cSubDelReqTimerExpiry, 2},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
 
        e2termConn1.RecvSubsReq(t)
-       xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
 
        e2termConn1.RecvSubsReq(t)
-       xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
 
        e2termConn1.RecvSubsDelReq(t)
-       xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
 
-       xappConn1.ExpectRESTNotification(t, restSubId)
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
        e2termConn1.RecvSubsDelReq(t)
-       xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
 
        e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
 
-       waitSubsCleanup(t, e2SubsId, 10)
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
 
+       waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2939,12 +3944,6 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 //     |                 |      SubFail |
 //     |                 |<-------------|
 //     |                 |              |
-//     |                 | SubDelReq    |
-//     |                 |------------->|
-//     |                 |              |
-//     |                 |   SubDelResp |
-//     |                 |<-------------|
-//     |                 |              |
 //     |       RESTNotif |              |
 //     |       unsuccess |              |
 //     |<----------------|              |
@@ -2957,31 +3956,32 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubReqSubFailRespInSubmgr")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubFailFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
+       const e2Timeout int64 = 2
+       const e2RetryCount int64 = 1
+       const routingNeeded bool = true
 
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        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.ExpectRESTNotification(t, restSubId)
-       e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
        e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
-       xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
+       xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
 
        // REST subscription sill there to be deleted
        xappConn1.SendRESTSubsDelReq(t, &restSubId)
@@ -2990,7 +3990,7 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3024,15 +4024,17 @@ func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubDelReqRetryInSubmgr")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 1},
                Counter{cSubDelReReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
        // Req
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -3052,6 +4054,7 @@ func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3083,15 +4086,17 @@ func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubDelReTwoRetriesNoRespInSubmgr")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 1},
                Counter{cSubDelReReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -3112,6 +4117,7 @@ func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3142,14 +4148,15 @@ func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
        CaseBegin("TestRESTSubDelReqSubDelFailRespInSubmgr")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelFailFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -3167,6 +4174,7 @@ func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3223,16 +4231,17 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkSameAction")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
                Counter{cMergedSubscriptions, 1},
                Counter{cUnmergedSubscriptions, 1},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -3243,17 +4252,17 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
 
        xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
-       xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
+       xappConn2.ExpectAnyNotification(t)
        waiter := rtmgrHttp.AllocNextSleep(10, true)
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
        waiter.WaitResult(t)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
-       e2SubsId2 := <-xappConn2.RESTNotification
-       xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
+       e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
+       xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
 
@@ -3265,8 +4274,8 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
 
        //Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId2, 10)
-
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3320,21 +4329,22 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkSameActionParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId1 := xappConn1.SendRESTSubsReq(t, params)
        crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 
-       params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
        restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
 
        xappConn1.ExpectRESTNotification(t, restSubId1)
@@ -3358,8 +4368,8 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
        e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 
        waitSubsCleanup(t, e2SubsId2, 10)
-
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3382,7 +4392,7 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
 //     | RESTSubReq2                   |              |
 //     |------------------------------>|              |
 //     |             |                 |              |
-//     |               RESTSubDelResp2 |              |
+//     |               RESTSubResp2    |              |
 //     |<------------------------------|              |
 //     |             |                 | SubReq1      |
 //     |             |                 |------------->|
@@ -3417,28 +4427,29 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cMergedSubscriptions, 1},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cSubReqTimerExpiry, 2},
+               Counter{cSubReReqToE2, 1},
+               Counter{cRestSubFailNotifToXapp, 2},
+               Counter{cUnmergedSubscriptions, 1},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
-
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
 
        // Req1
-       params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params1 := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId1 := xappConn1.SendRESTSubsReq(t, params1)
        crereq1, _ := e2termConn1.RecvSubsReq(t)
 
        // Req2
        subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
-       params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params2.SetMeid("RAN_NAME_1")
        restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
        mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
@@ -3452,9 +4463,9 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
        e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 
        e2SubsIdA := <-xappConn1.ListedRESTNotifications
-       xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+       xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
        e2SubsIdB := <-xappConn1.ListedRESTNotifications
-       xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
+       xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
 
        // Del1
        xappConn1.SendRESTSubsDelReq(t, &restSubId1)
@@ -3466,8 +4477,8 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
 
        //Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
-
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3501,12 +4512,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 |              |
@@ -3523,29 +4530,27 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cMergedSubscriptions, 1},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubFailFromE2, 1},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
-               Counter{cSubDelReqToE2, 1},
-               Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubFailNotifToXapp, 2},
+               Counter{cUnmergedSubscriptions, 1},
+               Counter{cRestSubDelReqFromXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
 
        // Req1
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId1 := xappConn1.SendRESTSubsReq(t, params)
        crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 
        // Req2
        subepcnt2 := mainCtrl.get_subs_entrypoint_cnt(t, crereq1.RequestId.InstanceId)
-       params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params2 := xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params2.SetMeid("RAN_NAME_1")
        restSubId2 := xappConn2.SendRESTSubsReq(t, params2)
        mainCtrl.wait_subs_entrypoint_cnt_change(t, crereq1.RequestId.InstanceId, subepcnt2, 10)
@@ -3555,15 +4560,11 @@ 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.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+       xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
        e2SubsIdB := <-xappConn1.ListedRESTNotifications
-       xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
+       xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
 
        // Del1
        xappConn1.SendRESTSubsDelReq(t, &restSubId1)
@@ -3574,8 +4575,8 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
        //Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
        waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
-
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
@@ -3583,30 +4584,26 @@ func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
-       const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
-
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
+       xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
 
        crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
        xappConn1.ExpectRESTNotification(t, restSubId)
        e2termConn1.SendSubsResp(t, crereq1, cremsg1)
        e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
-       xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
+       xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
 
        xappConn1.SendRESTSubsDelReq(t, &restSubId)
        delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
@@ -3615,6 +4612,7 @@ func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
        // Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3670,30 +4668,33 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
        CaseBegin("TestRESTSubReqPolicyAndSubDelOk")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const policyParamCount int = 1
+       const e2Timeout int64 = 1
+       const e2RetryCount int64 = 0
+       const routingNeeded bool = true
 
        // Req
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
        restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
 
        // Policy change
-       instanceId := int64(e2SubsId)
-       // GetRESTSubsReqPolicyParams sets some coutners on tc side.
-       params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
-       params.SubsReqParams.SubscriptionDetails[0].InstanceID = &instanceId
+       // GetRESTSubsReqPolicyParams sets some counters on tc side.
+
+       params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
+       params.SetSubscriptionID(&restSubId)
        params.SetTimeToWait("w200ms")
        restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
 
@@ -3706,6 +4707,89 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
        // Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTSubReqPolicyChangeNOk
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RESTSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubResp |
+//     |                 |<-------------|
+//     |                 |              |
+//     |       RESTNotif |              |
+//     |<----------------|              |
+//     |                 |              |
+//     | RESTSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |         RESTSubUpdateFail(400 Bad request)
+//     |                 |              |
+//     | RESTSubDelReq   |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp |
+//     |                 |<-------------|
+//     |                 |              |
+//     |  RESTSubDelResp |              |
+//     |<----------------|              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
+       CaseBegin("TestRESTSubReqPolicyChangeNOk")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubFailToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       // Req
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       // Policy change
+       params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+
+       restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
+       params.SetSubscriptionID(&restSubIdUpd)
+       params.SetTimeToWait("w200ms")
+
+       restSubId2 := xappConn1.SendRESTSubsReq(t, params)
+       assert.Equal(t, restSubId2, "")
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       // Wait that subs is cleaned
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3754,28 +4838,26 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
 
        // Init counter check
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
 
        // Req1
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId1 := xappConn1.SendRESTSubsReq(t, params)
        crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 
        // Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_11")
        // Here we use xappConn2 to simulate sending second request from same xapp as doing it from xappConn1
        // would not work as notification would not be received
@@ -3786,13 +4868,13 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
        xappConn1.ExpectRESTNotification(t, restSubId1)
        e2termConn1.SendSubsResp(t, crereq1, cremsg1)
        e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
-       xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
+       xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
 
        // Resp2
        xappConn2.ExpectRESTNotification(t, restSubId2)
        e2termConn2.SendSubsResp(t, crereq2, cremsg2)
        e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
-       xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
+       xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
 
        // Delete1
        xappConn1.SendRESTSubsDelReq(t, &restSubId1)
@@ -3811,6 +4893,7 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3838,7 +4921,7 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
 func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
        CaseBegin("TestRESTSubReqAsn1EncodeFail")
 
-       xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
+       xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
 
 }
 
@@ -3882,22 +4965,20 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
        CaseBegin("TestRESTInsertSubReqAndSubDelOk")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
-       const parameterSet int = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
 
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        params.SetSubActionTypes("insert")
 
        // Req
@@ -3912,6 +4993,7 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
        // Wait that subs is cleaned
        waitSubsCleanup(t, e2SubsId, 10)
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3925,6 +5007,8 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
 //     | RESTSubReq   |              |
 //     |------------->|              |
 //     |              |              |
+//     |  RESTSubResp |              |
+//     |<-------------|              |
 //     |              | SubReq       |
 //     |              |------------->|
 //     |              |              |
@@ -3940,33 +5024,39 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
 //     |              |   SubDelResp |
 //     |              |<-------------|
 //     |              |              |
+//     |    RESTNotif |              |
+//     |    unsuccess |              |
+//     |<-------------|              |
+//     |              |              |
+//     | RESTSubDelReq|              |
+//     |------------->|              |
+//     |              |              |
+//     |RESTSubDelResp|              |
+//     |<-------------|              |
 //
 //-----------------------------------------------------------------------------
 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
        CaseBegin("TestRESTSubReqNokAndSubDelOkWithRestartInMiddle")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
 
-       // Remove possible existing subscription
-       mainCtrl.removeExistingSubscriptions(t)
-
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
 
        //Req
        mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
 
        e2termConn1.RecvSubsReq(t)
 
@@ -3975,16 +5065,19 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
        mainCtrl.SimulateRestart(t)
        xapp.Logger.Debug("mainCtrl.SimulateRestart done")
 
-       //Del
+       // Deleletion of uncompleted subscription
        delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
        e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 
+       //Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
        xappConn1.TestMsgChanEmpty(t)
-       xappConn2.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4025,37 +5118,36 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
 //     |<----------------|              |
 //
 //-----------------------------------------------------------------------------
+
 func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkWithRestartInMiddle")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 1},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
-       // Remove possible existing subscription
-       mainCtrl.removeExistingSubscriptions(t)
-
-       var params *teststube2ap.RESTSubsReqParams = nil
-
        // Create subscription
+       var params *teststube2ap.RESTSubsReqParams = nil
        restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+       xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
 
        // Check subscription
        queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
 
-       // When SDL support for the REST Interface is added
-       // the submgr restart statement below should be removed
-       // from the comment.
+       mainCtrl.SimulateRestart(t)
+       xapp.Logger.Debug("mainCtrl.SimulateRestart done")
 
-       //      mainCtrl.SimulateRestart(t)
-       //      xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+       // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+       // That needs to be completed before successful subscription query is possible
+       <-time.After(time.Second * 1)
 
        // Check subscription
        queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
@@ -4067,6 +5159,7 @@ func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4127,55 +5220,54 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubRespFromE2, 1},
-               Counter{cSubRespToXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
                Counter{cMergedSubscriptions, 1},
                Counter{cUnmergedSubscriptions, 1},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
-       // Remove possible existing subscription
-       mainCtrl.removeExistingSubscriptions(t)
-
-       var params *teststube2ap.RESTSubsReqParams = nil
-
        // Create subscription 1
+       var params *teststube2ap.RESTSubsReqParams = nil
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
+       xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
 
        // Create subscription 2 with same action
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
        xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
-       xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
+       xappConn2.ExpectAnyNotification(t)
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
-       e2SubsId2 := <-xappConn2.RESTNotification
-       xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
+       e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
+       xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
 
-       // When SDL support for the REST Interface is added
-       // the submgr restart statement below should be removed
-       // from the comment.
+       mainCtrl.SimulateRestart(t)
+       xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
 
-       //      mainCtrl.SimulateRestart(t)
-       //      xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+       // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+       // That needs to be completed before successful subscription delete is possible
+       <-time.After(time.Second * 1)
 
-       // Delete subscription 1
+       // Delete subscription 1, and wait until it has removed the first endpoint
        xappConn1.SendRESTSubsDelReq(t, &restSubId1)
+       mainCtrl.WaitRESTSubscriptionDelete(restSubId1)
+       // Above wait does not work correctly anymore as this delay makes this test case work
 
-       // When SDL support for the REST Interface is added
-       // the submgr restart statement below should be removed
-       // from the comment.
+       mainCtrl.SimulateRestart(t)
+       xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
 
-       //      mainCtrl.SimulateRestart(t)
-       //      xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+       // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+       // That needs to be completed before successful subscription query is possible
+       <-time.After(time.Second * 1)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
 
@@ -4186,6 +5278,7 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4222,31 +5315,41 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
 //     | RESTSubDelReq   |              |
 //     |---------------->|              |
 //     |                 |              |
+//     |   RESTSubDelResp|              |
+//     |<----------------|              |
 //     |                 | SubDelReq    |
 //     |                 |------------->|
 //     |                 |              |
 //     |                 |   SubDelResp |
 //     |                 |<-------------|
 //     |                 |              |
-//     |   RESTSubDelResp|              |
-//     |<----------------|              |
 //
 //-----------------------------------------------------------------------------
+
 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
        CaseBegin("TestRESTReportSubReqAndSubDelOk")
-       subReqCount := 1
-       parameterSet := 1 // E2SM-gNB-X2
-       actionDefinitionPresent := true
-       actionParamCount := 1
+       const subReqCount int = 1
        testIndex := 1
-       RESTReportSubReqAndSubDelOk(t, subReqCount, parameterSet, actionDefinitionPresent, actionParamCount, testIndex)
+       RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
 }
 
-func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, parameterSet int, actionDefinitionPresent bool, actionParamCount int, testIndex int) {
-       xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with parameter set %v", testIndex)
+func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
+       xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, uint64(subReqCount)},
+               Counter{cSubRespFromE2, uint64(subReqCount)},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+               Counter{cSubDelReqToE2, uint64(subReqCount)},
+               Counter{cSubDelRespFromE2, uint64(subReqCount)},
+       })
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        var e2SubsId []uint32
@@ -4256,7 +5359,7 @@ func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, parameterSet int
 
                e2termConn1.SendSubsResp(t, crereq, cremsg)
                instanceId := xappConn1.WaitRESTNotification(t, restSubId)
-               xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+               xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
                e2SubsId = append(e2SubsId, instanceId)
                resp, _ := xapp.Subscription.QuerySubscriptions()
                assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
@@ -4281,33 +5384,41 @@ func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, parameterSet int
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
 }
 
 /*
-func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
+func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {  //Was in comments already. Next case is not run!
        CaseBegin("TestRESTPolicySubReqAndSubDelOk")
 
        subReqCount := 2
-       actionDefinitionPresent := true
-       policyParamCount := 1
        testIndex := 1
-       RESTPolicySubReqAndSubDelOk(t, subReqCount, actionDefinitionPresent, policyParamCount, testIndex)
+       RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
 
        subReqCount = 19
-       actionDefinitionPresent = false
-       policyParamCount = 0
        testIndex = 2
-       RESTPolicySubReqAndSubDelOk(t, subReqCount, actionDefinitionPresent, policyParamCount, testIndex)
+       RESTPolicySubReqAndSubDelOk(t, subReqCount, testIndex)
 }
 */
-func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, actionDefinitionPresent bool, policyParamCount int, testIndex int) {
-       xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with parameter set %v", testIndex)
+func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
+       xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, uint64(subReqCount)},
+               Counter{cSubRespFromE2, uint64(subReqCount)},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+               Counter{cSubDelReqToE2, uint64(subReqCount)},
+               Counter{cSubDelRespFromE2, uint64(subReqCount)},
+       })
 
        // Req
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount, actionDefinitionPresent, policyParamCount)
-       //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
 
        var e2SubsId []uint32
        for i := 0; i < subReqCount; i++ {
@@ -4315,7 +5426,7 @@ func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, actionDefinition
                xappConn1.ExpectRESTNotification(t, restSubId)
                e2termConn1.SendSubsResp(t, crereq, cremsg)
                instanceId := xappConn1.WaitRESTNotification(t, restSubId)
-               xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+               xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
                e2SubsId = append(e2SubsId, instanceId)
        }
 
@@ -4334,25 +5445,28 @@ func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, actionDefinition
        xappConn1.TestMsgChanEmpty(t)
        e2termConn1.TestMsgChanEmpty(t)
        mainCtrl.wait_registry_empty(t, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
 }
 
 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
 
-       subReqCount := 2
-
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
+       const subReqCount int = 2
+
        // Req
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
        e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
 
@@ -4367,24 +5481,25 @@ func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
 
-       subReqCount := 19
-
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, 19},
                Counter{cSubRespFromE2, 19},
-               Counter{cSubRespToXapp, 19},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, 19},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, 19},
                Counter{cSubDelRespFromE2, 19},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
+       const subReqCount int = 19
        // Req
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
        e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
 
@@ -4398,27 +5513,27 @@ func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
+
 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
 
        subReqCount := 2
-       parameterSet := 1
-       actionDefinitionPresent := true
-       actionParamCount := 1
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, uint64(subReqCount)},
                Counter{cSubRespFromE2, uint64(subReqCount)},
-               Counter{cSubRespToXapp, uint64(subReqCount)},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, uint64(subReqCount)},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, uint64(subReqCount)},
                Counter{cSubDelRespFromE2, uint64(subReqCount)},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
        e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
 
@@ -4433,29 +5548,27 @@ func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
 
-/*
 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
 
        subReqCount := 2
-       parameterSet := 1
-       actionDefinitionPresent := false
-       actionParamCount := 0
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, uint64(subReqCount)},
                Counter{cSubRespFromE2, uint64(subReqCount)},
-               Counter{cSubRespToXapp, uint64(subReqCount)},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, uint64(subReqCount)},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, uint64(subReqCount)},
                Counter{cSubDelRespFromE2, uint64(subReqCount)},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
        e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
 
@@ -4470,29 +5583,27 @@ func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
-*/
-/*
+
 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
 
        subReqCount := 19
-       parameterSet := 1
-       actionDefinitionPresent := false
-       actionParamCount := 0
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 1},
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
                Counter{cSubReqToE2, uint64(subReqCount)},
                Counter{cSubRespFromE2, uint64(subReqCount)},
-               Counter{cSubRespToXapp, uint64(subReqCount)},
-               Counter{cSubDelReqFromXapp, 1},
+               Counter{cRestSubNotifToXapp, uint64(subReqCount)},
+               Counter{cRestSubDelReqFromXapp, 1},
                Counter{cSubDelReqToE2, uint64(subReqCount)},
                Counter{cSubDelRespFromE2, uint64(subReqCount)},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
        e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
 
@@ -4507,21 +5618,22 @@ func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
 }
-*/
 
 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4529,18 +5641,18 @@ func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
-       eventTriggerDefinition := "1234"
+       eventTriggerDefinition := []int64{1234, 1}
        params.SetSubEventTriggerDefinition(eventTriggerDefinition)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
        xappConn2.ExpectRESTNotification(t, restSubId2)
        e2termConn1.SendSubsResp(t, crereq, cremsg)
@@ -4553,21 +5665,22 @@ func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffActionListLen")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4575,23 +5688,23 @@ func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
 
        actionId := int64(1)
        actionType := "report"
-       actionDefinition := "56781"
+       actionDefinition := []int64{5678, 1}
        subsequestActionType := "continue"
        timeToWait := "w10ms"
        params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
        xappConn2.ExpectRESTNotification(t, restSubId2)
        e2termConn1.SendSubsResp(t, crereq, cremsg)
@@ -4604,21 +5717,22 @@ func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffActionID")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4626,17 +5740,17 @@ func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
        params.SetSubActionIDs(int64(2))
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
        xappConn2.ExpectRESTNotification(t, restSubId2)
        e2termConn1.SendSubsResp(t, crereq, cremsg)
@@ -4649,38 +5763,45 @@ func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqDiffActionType(t *testing.T) {
        CaseBegin("TestRESTSubReqDiffActionType")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
+       const e2Timeout int64 = 2
+       const e2RetryCount int64 = 2
+       const routingNeeded bool = true
+
        // Req1
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
        params.SetMeid("RAN_NAME_1")
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
        xappConn2.ExpectRESTNotification(t, restSubId2)
        e2termConn1.SendSubsResp(t, crereq, cremsg)
@@ -4693,38 +5814,45 @@ func TestRESTSubReqDiffActionType(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
        CaseBegin("TestRESTSubReqPolicyAndSubDelOkSameAction")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
+       const e2Timeout int64 = 2
+       const e2RetryCount int64 = 2
+       const routingNeeded bool = true
+
        // Req1
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
        params.SetMeid("RAN_NAME_1")
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
        xappConn2.ExpectRESTNotification(t, restSubId2)
        e2termConn1.SendSubsResp(t, crereq, cremsg)
@@ -4737,21 +5865,22 @@ func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionLen")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4759,18 +5888,18 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
-       actionDefinition := "5678"
+       actionDefinition := []int64{5678, 1}
        params.SetSubActionDefinition(actionDefinition)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
        xappConn2.ExpectRESTNotification(t, restSubId2)
        e2termConn1.SendSubsResp(t, crereq, cremsg)
@@ -4783,21 +5912,22 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffActionDefinitionContents")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4805,18 +5935,18 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
-       actionDefinition := "56782"
+       actionDefinition := []int64{56782}
        params.SetSubActionDefinition(actionDefinition)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
        xappConn2.ExpectRESTNotification(t, restSubId2)
        e2termConn1.SendSubsResp(t, crereq, cremsg)
@@ -4829,21 +5959,22 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
-
+       mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
        CaseBegin("TestRESTSubReqReportSameActionDiffSubsAction")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 2},
                Counter{cSubRespFromE2, 2},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubNotifToXapp, 2},
+               Counter{cRestSubDelReqFromXapp, 2},
                Counter{cSubDelReqToE2, 2},
                Counter{cSubDelRespFromE2, 2},
-               Counter{cSubDelRespToXapp, 2},
+               Counter{cRestSubDelRespToXapp, 2},
        })
 
        // Req1
@@ -4851,16 +5982,16 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
 
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
        params.SetTimeToWait("w200ms")
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
        xappConn2.ExpectRESTNotification(t, restSubId2)
        e2termConn1.SendSubsResp(t, crereq, cremsg)
@@ -4873,67 +6004,1354 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
        waitSubsCleanup(t, e2SubsId2, 10)
 
        mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionResponseDecodeFail
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RestSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubResp | ASN.1 decode fails
+//     |                 |<-------------| Decode failed. More data needed. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubFail | Duplicated action
+//     |                 |<-------------|
+//     | RESTNotif (fail)|              |
+//     |<----------------|              |
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+
+func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 1},
+               Counter{cSubReReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cSubFailFromE2, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       const subReqCount int = 1
+
+       // Req
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+
+       crereq, cremsg := e2termConn1.RecvSubsReq(t)
+       // Decode of this response fails which will result resending original request
+       e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_RESP)
+
+       _, cremsg = e2termConn1.RecvSubsReq(t)
+
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
+
+       // Subscription already created in E2 Node.
+       fparams := &teststube2ap.E2StubSubsFailParams{}
+       fparams.Set(crereq)
+       fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
+       e2termConn1.SendSubsFail(t, fparams, cremsg)
+
+       instanceId := xappConn1.WaitRESTNotification(t, restSubId)
+       xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
+
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // Wait that subs is cleaned
+       mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
 
+       xappConn1.TestMsgChanEmpty(t)
+       e2termConn1.TestMsgChanEmpty(t)
+       mainCtrl.wait_registry_empty(t, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
 }
 
-////////////////////////////////////////////////////////////////////////////////////
-//   Services for UT cases
-////////////////////////////////////////////////////////////////////////////////////
-const subReqCount int = 1
-const parameterSet = 1
-const actionDefinitionPresent bool = true
-const actionParamCount int = 1
-const policyParamCount int = 1
-const host string = "localhost"
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionResponseUnknownInstanceId
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RestSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubResp | Unknown instanceId
+//     |                 |<-------------| No valid subscription found with subIds [0]
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubFail | Duplicated action
+//     |                 |<-------------| No valid subscription found with subIds [0]
+//     | RESTNotif (fail)|              |
+//     |<----------------|              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp |
+//     |                 |<-------------|
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
 
-func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
-       if params == nil {
-               params = fromXappConn.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
-       }
-       restSubId := fromXappConn.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
+func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
 
-       crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
-       fromXappConn.ExpectRESTNotification(t, restSubId)
-       toE2termConn.SendSubsResp(t, crereq1, cremsg1)
-       e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
-       xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 2},
+               Counter{cSubReReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cSubFailFromE2, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+       })
 
-       return restSubId, e2SubsId
+       const subReqCount int = 1
+
+       // Req
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+
+       crereq, cremsg := e2termConn1.RecvSubsReq(t)
+
+       // Unknown instanceId 0 in this response which will result resending original request
+       orgInstanceId := crereq.RequestId.InstanceId
+       crereq.RequestId.InstanceId = 0
+       e2termConn1.SendSubsResp(t, crereq, cremsg)
+
+       _, cremsg = e2termConn1.RecvSubsReq(t)
+
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
+
+       // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
+       fparams := &teststube2ap.E2StubSubsFailParams{}
+       fparams.Set(crereq)
+       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)
+
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // Wait that subs is cleaned
+       mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
+
+       xappConn1.TestMsgChanEmpty(t)
+       e2termConn1.TestMsgChanEmpty(t)
+       mainCtrl.wait_registry_empty(t, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
 }
 
-func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionResponseNoTransaction
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RestSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubResp | No transaction for the response
+//     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubFail | Duplicated action
+//     |                 |<-------------|Ongoing transaction not found. This will result timer expiry and sending delete
+//     | RESTNotif (fail)|              |
+//     |<----------------|              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp |
+//     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp |
+//     |                 |<-------------| Ongoing transaction not found.
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
 
-       params := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
-       if meid != "" {
-               params.SetMeid(meid)
-       }
-       xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
-       restSubId := xappConn2.SendRESTSubsReq(t, params)
-       xappConn2.ExpectRESTNotification(t, restSubId)
-       xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
-       e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
-       xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 2},
+               Counter{cSubReReqToE2, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cSubFailFromE2, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 2},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cSubDelRespFromE2, 2},
+       })
 
-       return restSubId, e2SubsId
+       const subReqCount int = 1
+
+       // Req
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+
+       crereq, cremsg := e2termConn1.RecvSubsReq(t)
+
+       mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
+       // No transaction exist for this response which will result resending original request
+       e2termConn1.SendSubsResp(t, crereq, cremsg)
+
+       _, cremsg = e2termConn1.RecvSubsReq(t)
+
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
+
+       // Subscription already created in E2 Node.
+       fparams := &teststube2ap.E2StubSubsFailParams{}
+       fparams.Set(crereq)
+       fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
+       e2termConn1.SendSubsFail(t, fparams, cremsg)
+
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       // Resending happens because there no transaction
+       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)
+
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // Wait that subs is cleaned
+       mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
+
+       xappConn1.TestMsgChanEmpty(t)
+       e2termConn1.TestMsgChanEmpty(t)
+       mainCtrl.wait_registry_empty(t, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
 }
 
-func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionFailureDecodeFail
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RestSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubFail | ASN.1 decode fails
+//     |                 |<-------------| Decode failed. More data needed. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubFail | Duplicated action
+//     |                 |<-------------|
+//     | RESTNotif (fail)|              |
+//     |<----------------|              |
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 1},
+               Counter{cSubReReqToE2, 1},
+               Counter{cSubFailFromE2, 2},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       const subReqCount int = 1
+
+       // Req
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+
+       crereq, cremsg := e2termConn1.RecvSubsReq(t)
+
+       // Decode of this response fails which will result resending original request
+       e2termConn1.SendInvalidE2Asn1Resp(t, cremsg, xapp.RIC_SUB_FAILURE)
+
+       _, cremsg = e2termConn1.RecvSubsReq(t)
+
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
+
+       // Subscription already created in E2 Node.
+       fparams := &teststube2ap.E2StubSubsFailParams{}
+       fparams.Set(crereq)
+       fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
+       e2termConn1.SendSubsFail(t, fparams, cremsg)
+
+       instanceId := xappConn1.WaitRESTNotification(t, restSubId)
+       xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
+
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // Wait that subs is cleaned
+       mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
+
+       xappConn1.TestMsgChanEmpty(t)
+       e2termConn1.TestMsgChanEmpty(t)
+       mainCtrl.wait_registry_empty(t, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionResponseUnknownInstanceId
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RestSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubFail | Unknown instanceId
+//     |                 |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubFail | Duplicated action
+//     |                 |<-------------|No valid subscription found with subIds [0]. This will result timer expiry and sending delete
+//     | RESTNotif (fail)|              |
+//     |<----------------|              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp |
+//     |                 |<-------------|
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
+       const subReqCount int = 1
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 2},
+               Counter{cSubReReqToE2, 1},
+               Counter{cSubFailFromE2, 2},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+       })
+
+       // Req
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+
+       crereq, cremsg := e2termConn1.RecvSubsReq(t)
+
+       // Unknown instanceId 0 in this response which will result resending original request
+       fparams := &teststube2ap.E2StubSubsFailParams{}
+       fparams.Set(crereq)
+       fparams.Fail.RequestId.InstanceId = 0
+       e2termConn1.SendSubsFail(t, fparams, cremsg)
+
+       _, cremsg = e2termConn1.RecvSubsReq(t)
+
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
+
+       // Subscription already created in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
+       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)
+
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // Wait that subs is cleaned
+       mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
+
+       xappConn1.TestMsgChanEmpty(t)
+       e2termConn1.TestMsgChanEmpty(t)
+       mainCtrl.wait_registry_empty(t, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionFailureNoTransaction
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RestSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubFail | No transaction for the response
+//     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubFail | Duplicated action
+//     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and sending delete
+//     | RESTNotif (fail)|              |
+//     |<----------------|              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp |
+//     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp |
+//     |                 |<-------------| Ongoing transaction not found.
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
+       const subReqCount int = 1
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cSubReqToE2, 1},
+               Counter{cSubReqTimerExpiry, 2},
+               Counter{cSubReReqToE2, 1},
+               Counter{cSubFailFromE2, 2},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 2},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cSubDelRespFromE2, 2},
+       })
+
+       // Req
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+
+       crereq, cremsg := e2termConn1.RecvSubsReq(t)
+
+       mainCtrl.MakeTransactionNil(t, crereq.RequestId.InstanceId)
+
+       // No transaction exist for this response which will result resending original request
+       fparams := &teststube2ap.E2StubSubsFailParams{}
+       fparams.Set(crereq)
+       e2termConn1.SendSubsFail(t, fparams, cremsg)
+
+       _, cremsg = e2termConn1.RecvSubsReq(t)
+
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
+
+       // Subscription already created in E2 Node.
+       fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
+       e2termConn1.SendSubsFail(t, fparams, cremsg)
+
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       // Resending happens because there no transaction
+       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)
+
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // Wait that subs is cleaned
+       mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
+
+       xappConn1.TestMsgChanEmpty(t)
+       e2termConn1.TestMsgChanEmpty(t)
+       mainCtrl.wait_registry_empty(t, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionDeleteResponseDecodeFail
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     |            [SUBS CREATE]       |
+//     |                 |              |
+//     |                 |              |
+//     | RESTSubDelReq   |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |  RESTSubDelResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp | ASN.1 decode fails.
+//     |                 |<-------------| Decode failed. More data needed. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelFail | Subscription does exist any more in E2 node
+//     |                 |<-------------|
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
+
+       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},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 1},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cSubDelFailFromE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+       })
+
+       // Req
+       var params *teststube2ap.RESTSubsReqParams = nil
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // E2t: Receive 1st SubsDelReq
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+
+       // Decode of this response fails which will result resending original request
+       e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_RESP)
+
+       // E2t: Receive 2nd SubsDelReq and send SubsDelResp
+       delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
+
+       // Subscription does not exist in in E2 Node.
+       e2termConn1.SendSubsDelFail(t, delreq, delmsg)
+
+       // 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.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     |            [SUBS CREATE]       |
+//     |                 |              |
+//     |                 |              |
+//     | RESTSubDelReq   |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |  RESTSubDelResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp | Unknown instanceId
+//     |                 |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelFail | Subscription does exist any more in E2 node
+//     |                 |<-------------|
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
+
+       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},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 1},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cSubDelFailFromE2, 1},
+       })
+
+       // Req
+       var params *teststube2ap.RESTSubsReqParams = nil
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // E2t: Receive 1st SubsDelReq
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+
+       // Unknown instanceId in this response which will result resending original request
+       delreq.RequestId.InstanceId = 0
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       // E2t: Receive 2nd SubsDelReq
+       delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
+
+       // Subscription does not exist in in E2 Node.
+       e2termConn1.SendSubsDelFail(t, delreq, delmsg)
+
+       // 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.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionDeleteResponseNoTransaction
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     |            [SUBS CREATE]       |
+//     |                 |              |
+//     |                 |              |
+//     | RESTSubDelReq   |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |  RESTSubDelResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp | No transaction for the response
+//     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelFail | Subscription does exist any more in E2 node
+//     |                 |<-------------| Ongoing transaction not found. This will result timer expiry
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
+
+       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},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 2},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cSubDelFailFromE2, 1},
+       })
+
+       // Req
+       var params *teststube2ap.RESTSubsReqParams = nil
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // E2t: Receive 1st SubsDelReq
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+
+       mainCtrl.MakeTransactionNil(t, e2SubsId)
+
+       // No transaction exist for this response which will result resending original request
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       // E2t: Receive 2nd SubsDelReq
+       delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
+
+       // Subscription does not exist in in E2 Node.
+       e2termConn1.SendSubsDelFail(t, delreq, delmsg)
+
+       // 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.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionDeleteFailureDecodeFail
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     |            [SUBS CREATE]       |
+//     |                 |              |
+//     |                 |              |
+//     | RESTSubDelReq   |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |  RESTSubDelResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelFail | ASN.1 decode fails
+//     |                 |<-------------| Decode failed. More data needed. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelFail | Subscription does exist any more in E2 node
+//     |                 |<-------------|
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
+
+       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},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 1},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cSubDelFailFromE2, 2},
+       })
+
+       // Req
+       var params *teststube2ap.RESTSubsReqParams = nil
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // E2t: Receive 1st SubsDelReq
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+
+       // Decode of this response fails which will result resending original request
+       e2termConn1.SendInvalidE2Asn1Resp(t, delmsg, xapp.RIC_SUB_DEL_FAILURE)
+
+       // E2t: Receive 2nd SubsDelReq and send SubsDelResp
+       delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
+
+       // Subscription does not exist in in E2 Node.
+       e2termConn1.SendSubsDelFail(t, delreq, delmsg)
+
+       // 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.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     |            [SUBS CREATE]       |
+//     |                 |              |
+//     |                 |              |
+//     | RESTSubDelReq   |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |  RESTSubDelResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelFail | Unknown instanceId
+//     |                 |<-------------| No valid subscription found with subIds [0]. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelFail | Subscription does exist any more in E2 node
+//     |                 |<-------------| No valid subscription found with subIds [0].
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
+
+       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},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 1},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cSubDelFailFromE2, 2},
+       })
+
+       // Req
+       var params *teststube2ap.RESTSubsReqParams = nil
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // E2t: Receive 1st SubsDelReq
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+
+       // Unknown instanceId 0 in this response which will result resending original request
+       delreq.RequestId.InstanceId = 0
+       e2termConn1.SendSubsDelFail(t, delreq, delmsg)
+
+       // E2t: Receive 2nd SubsDelReq
+       delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
+
+       // Subscription does not exist in in E2 Node. E2 Node responds with failure but there is also same unknown instanceId 0
+       e2termConn1.SendSubsDelFail(t, delreq, delmsg)
+
+       // 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.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTUnpackSubscriptionDeleteFailureNoTransaction
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     |            [SUBS CREATE]       |
+//     |                 |              |
+//     |                 |              |
+//     | RESTSubDelReq   |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |  RESTSubDelResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelFail | No transaction for the response
+//     |                 |<-------------| Ongoing transaction not found. This will result timer expiry and resending
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelFail | Subscription does exist any more in E2 node
+//     |                 |<-------------| Ongoing transaction not found. This will result timer expiry
+//     |                 |              |
+//     |           [SUBS DELETE]        |
+//     |                 |              |
+//-----------------------------------------------------------------------------
+func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
+       xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
+
+       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},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelReqTimerExpiry, 2},
+               Counter{cSubDelReReqToE2, 1},
+               Counter{cSubDelFailFromE2, 2},
+       })
+
+       // Req
+       var params *teststube2ap.RESTSubsReqParams = nil
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // E2t: Receive 1st SubsDelReq
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+
+       mainCtrl.MakeTransactionNil(t, e2SubsId)
+
+       // No transaction exist for this response which will result resending original request
+       e2termConn1.SendSubsDelFail(t, delreq, delmsg)
+
+       // E2t: Receive 2nd SubsDelReq
+       delreq, delmsg = e2termConn1.RecvSubsDelReq(t)
+
+       // Subscription does not exist in in E2 Node.
+       e2termConn1.SendSubsDelFail(t, delreq, delmsg)
+
+       // 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.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestRESTSubReqFailAsn1PackSubReqError
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RESTSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |        ASN.1 encode fails      |
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |  SubDelFail  |
+//     |                 |<-------------|
+//     |                 |              |
+//     |       RESTNotif |              |
+//     |       unsuccess |              |
+//     |<----------------|              |
+//     |                 |              |
+//     |            [SUBS DELETE]       |
+//     |                 |              |
+//
+//-----------------------------------------------------------------------------
+func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 1},
+               Counter{cRestSubRespToXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       const subReqCount int = 1
+
+       var params *teststube2ap.RESTSubsReqParams = nil
+       params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
+       e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, false)
+
+       // Req
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
+
+       // E2t: Receive SubsDelReq
+       xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
+
+       e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
+       xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
+
+       e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
+
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+
+       // Wait that subs is cleaned
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
+       CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
+               Counter{cSubReqToE2, 2},
+               Counter{cSubReqTimerExpiry, 1},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       const e2Timeout int64 = 1
+       const e2RetryCount int64 = 0
+       const routingNeeded bool = false
+
+       // Req1
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
+
+       // Subs Create
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+       xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
+
+       crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
+       xappConn1.ExpectRESTNotification(t, restSubId)
+       e2termConn1.SendSubsResp(t, crereq1, cremsg1)
+       e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
+       xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
+
+       // Policy change
+       params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
+       params.SetSubscriptionID(&restSubId)
+       params.SetTimeToWait("w200ms")
+       restSubId = xappConn1.SendRESTSubsReq(t, params)
+       xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
+
+       crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
+       xappConn1.ExpectRESTNotification(t, restSubId)
+       // SubsResp is missing, e2SubsId will be 0
+       zeroE2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
+       xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", zeroE2SubsId)
+
+       // Del
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       waitSubsCleanup(t, e2SubsId, 10)
+       mainCtrl.VerifyAllClean(t)
+       mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RESTSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubResp |
+//     |                 |<-------------|
+//     |                 |              |
+//     |       RESTNotif |              |
+//     |<----------------|              |
+//     |                 |              |
+//     | RESTSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                                |
+//     |           Submgr restart       |
+//     |                 |              |
+//     | RESTSubDelReq   |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |                 | SubDelReq    |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |   SubDelResp |
+//     |                 |<-------------|
+//     |                 |              |
+//     |  RESTSubDelResp |              |
+//     |<----------------|              |
+//
+//-----------------------------------------------------------------------------
+
+func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
+       CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
+
+       mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
+               Counter{cSubReqToE2, 2},
+               Counter{cSubRespFromE2, 1},
+               Counter{cRestSubNotifToXapp, 1},
+               Counter{cRestSubDelReqFromXapp, 1},
+               Counter{cSubDelReqToE2, 1},
+               Counter{cSubDelRespFromE2, 1},
+               Counter{cRestSubDelRespToXapp, 1},
+       })
+
+       const e2Timeout int64 = 1
+       const e2RetryCount int64 = 0
+       const routingNeeded bool = false
+
+       // Req1
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
+       // Create subscription
+       restSubId := xappConn1.SendRESTSubsReq(t, params)
+       xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
+
+       crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
+       xappConn1.ExpectRESTNotification(t, restSubId)
+       e2termConn1.SendSubsResp(t, crereq1, cremsg1)
+       e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
+       xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
+
+       // Check subscription
+       queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
+
+       // Policy change
+       params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
+       params.SetSubscriptionID(&restSubId)
+       params.SetTimeToWait("w200ms")
+       mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
+       restSubId = xappConn1.SendRESTSubsReq(t, params)
+       xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
+
+       crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
+       mainCtrl.SetResetTestFlag(t, false)
+
+       // SubsResp is missing due to submgr restart
+
+       mainCtrl.SimulateRestart(t)
+       xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+
+       // ReadE2Subscriptions() for testing is running in own go routine (go mainCtrl.c.ReadE2Subscriptions())
+       // That needs to be completed before successful subscription query is possible
+       <-time.After(time.Second * 1)
+
+       // Check subscription
+       queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
+
+       // Delete subscription
+       xappConn1.SendRESTSubsDelReq(t, &restSubId)
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+       e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+       //Wait that subs is cleaned
+       waitSubsCleanup(t, e2SubsId, 10)
+
+       mainCtrl.VerifyCounterValues(t)
+       mainCtrl.VerifyAllClean(t)
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+//   Services for UT cases
+////////////////////////////////////////////////////////////////////////////////////
+const subReqCount int = 1
+const host string = "localhost"
+
+func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2termConn *teststube2ap.E2Stub, params *teststube2ap.RESTSubsReqParams) (string, uint32) {
+       if params == nil {
+               params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
+       }
+       restSubId := fromXappConn.SendRESTSubsReq(t, params)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
+
+       crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
+       fromXappConn.ExpectRESTNotification(t, restSubId)
+       toE2termConn.SendSubsResp(t, crereq1, cremsg1)
+       e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
+       xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
+
+       return restSubId, e2SubsId
+}
+
+func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
+
+       params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
+       if meid != "" {
+               params.SetMeid(meid)
+       }
+       xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
+       restSubId := xappConn2.SendRESTSubsReq(t, params)
+       xappConn2.ExpectRESTNotification(t, restSubId)
+       xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
+       e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
+       xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
+
+       return restSubId, e2SubsId
+}
+
+func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
+
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
+       xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
 
        crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
        xappConn1.ExpectRESTNotification(t, restSubId)
        e2termConn1.SendSubsResp(t, crereq1, cremsg1)
        e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
-       xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
+       xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
 
        return restSubId, e2SubsId
 }
 
 func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
@@ -4945,7 +7363,7 @@ func createXapp1ReportSubscriptionE2Fail(t *testing.T) (string, uint32) {
        xappConn1.ExpectRESTNotification(t, restSubId)
        e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
        e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
-       xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
+       xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
 
        return restSubId, e2SubsId
 }
@@ -4970,9 +7388,9 @@ func deleteXapp2Subscription(t *testing.T, restSubId *string) {
 
 func queryXappSubscription(t *testing.T, e2SubsId int64, meid string, endpoint []string) {
        resp, _ := xapp.Subscription.QuerySubscriptions()
-       assert.Equal(t, resp[0].SubscriptionID, e2SubsId)
-       assert.Equal(t, resp[0].Meid, meid)
-       assert.Equal(t, resp[0].ClientEndpoint, endpoint)
+       assert.Equal(t, e2SubsId, resp[0].SubscriptionID)
+       assert.Equal(t, meid, resp[0].Meid)
+       assert.Equal(t, endpoint, resp[0].ClientEndpoint)
 }
 
 func waitSubsCleanup(t *testing.T, e2SubsId uint32, timeout int) {
@@ -4990,14 +7408,14 @@ func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *test
        var e2SubsId []uint32
 
        for i := 0; i < count; i++ {
-               xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
+               xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
                crereq, cremsg := toE2termConn.RecvSubsReq(t)
                fromXappConn.ExpectRESTNotification(t, restSubId)
                toE2termConn.SendSubsResp(t, crereq, cremsg)
                instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
                e2SubsId = append(e2SubsId, instanceId)
-               xapp.Logger.Info("TEST: %v", e2SubsId)
-               xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
+               xapp.Logger.Debug("TEST: %v", e2SubsId)
+               xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
                <-time.After(100 * time.Millisecond)
        }
        return e2SubsId
@@ -5006,11 +7424,11 @@ func sendAndReceiveMultipleE2SubReqs(t *testing.T, count int, fromXappConn *test
 func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
 
        for i := 0; i < len(e2SubsIds); i++ {
-               xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
+               xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
                delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
                toE2termConn.SendSubsDelResp(t, delreq, delmsg)
                <-time.After(1 * time.Second)
-               xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
+               xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
                <-time.After(100 * time.Millisecond)
        }