Code Review / ric-plt / submgr.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
xapp-frame v0.8.3 integration to submgr
[ric-plt/submgr.git] / pkg / control / ut_messaging_test.go
diff --git a/pkg/control/ut_messaging_test.go b/pkg/control/ut_messaging_test.go
index e3d6655..4f93f20 100644 (file)
--- a/pkg/control/ut_messaging_test.go
+++ b/pkg/control/ut_messaging_test.go
@@ -20,6 +20,7 @@
 package control
 
 import (
+       "strings"
        "testing"
        "time"
 
@@ -30,14 +31,56 @@ import (
        "github.com/stretchr/testify/assert"
 )
 
-func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
-
+func TestSuiteSetup(t *testing.T) {
        // The effect of this call shall endure thgough the UT suite!
        // If this causes any issues, the previout interface can be restored
-       // like this:
+       // like this:git log
        // SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
 
        SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
+}
+
+//-----------------------------------------------------------------------------
+// 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)
 
@@ -46,6 +89,114 @@ func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
        waitSubsCleanup(t, e2SubsId, 10)
 }
 
+//-----------------------------------------------------------------------------
+// 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)
+}
+
+//-----------------------------------------------------------------------------
+// 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)
+}
+
 //-----------------------------------------------------------------------------
 // TestSubReqAndRouteNok
 //
@@ -2251,23 +2402,21 @@ 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)
        waiter.WaitResult(t)
@@ -2289,15 +2438,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, 1},
                Counter{cSubDelReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2310,7 +2461,7 @@ 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)
@@ -2335,15 +2486,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
@@ -2368,15 +2520,16 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
        CaseBegin("TestRESTSubMergeDelAndRouteUpdateNok")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               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},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2446,14 +2599,15 @@ func TestRESTSubReqRetransmission(t *testing.T) {
        CaseBegin("TestRESTSubReqRetransmission")
 
        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},
        })
        // Retry/duplicate will get the same way as the first request.  Submgr cannot detect duplicate RESTRequests
        // Contianed duplicate messages from same xapp will not be merged. Here we use xappConn2 to simulate sending
@@ -2461,14 +2615,11 @@ func TestRESTSubReqRetransmission(t *testing.T) {
 
        // 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)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId1 := xappConn1.SendRESTSubsReq(t, params)
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
 
@@ -2509,14 +2660,15 @@ 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, 1},
        })
 
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -2574,23 +2726,21 @@ 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{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
@@ -2622,23 +2772,24 @@ 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)
 
        //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)
 
@@ -2675,21 +2826,22 @@ 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)
 
-       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)
@@ -2712,18 +2864,19 @@ 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{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)
@@ -2793,7 +2946,8 @@ func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(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},
@@ -2801,7 +2955,7 @@ func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
                Counter{cSubDelRespFromE2, 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)
 
@@ -2828,7 +2982,8 @@ 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},
@@ -2836,7 +2991,7 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
                Counter{cSubDelReqTimerExpiry, 2},
        })
 
-       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)
 
@@ -2904,7 +3059,8 @@ 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},
@@ -2913,7 +3069,7 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
                Counter{cSubDelReqTimerExpiry, 2},
        })
 
-       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)
 
@@ -2974,19 +3130,17 @@ 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},
        })
 
        const subReqCount int = 1
-       const parameterSet = 1
-       const actionDefinitionPresent bool = true
-       const actionParamCount int = 1
 
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
@@ -3041,15 +3195,16 @@ 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{cSubDelReReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
        // Req
        var params *teststube2ap.RESTSubsReqParams = nil
@@ -3100,15 +3255,16 @@ 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{cSubDelReReqToE2, 1},
                Counter{cSubDelRespFromE2, 1},
-               Counter{cSubDelRespToXapp, 1},
+               Counter{cRestSubDelRespToXapp, 1},
        })
 
        // Req
@@ -3159,14 +3315,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
@@ -3240,16 +3397,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
@@ -3260,7 +3418,7 @@ 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)
@@ -3337,21 +3495,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)
@@ -3434,28 +3593,26 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelNoAnswerSameActionParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubFailNotifToXapp, 2},
+               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)
@@ -3540,29 +3697,27 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
        CaseBegin("TestRESTSubReqAndSubDelNokSameActionParallel")
 
        mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
-               Counter{cSubReqFromXapp, 2},
+               Counter{cRestSubReqFromXapp, 2},
+               Counter{cRestSubRespToXapp, 2},
                Counter{cSubReqToE2, 1},
                Counter{cSubFailFromE2, 1},
-               Counter{cSubRespToXapp, 2},
-               Counter{cSubDelReqFromXapp, 2},
+               Counter{cRestSubFailNotifToXapp, 2},
+               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
-       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)
@@ -3600,22 +3755,20 @@ 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)
 
@@ -3687,30 +3840,28 @@ 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
 
        // Req
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
        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
+
+       params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       params.SetSubscriptionID(&restSubId)
        params.SetTimeToWait("w200ms")
        restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
 
@@ -3725,6 +3876,90 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
        mainCtrl.VerifyCounterValues(t)
 }
 
+//-----------------------------------------------------------------------------
+// TestRESTSubReqPolicyChangeNOk
+//
+//   stub                             stub
+// +-------+        +---------+    +---------+
+// | xapp  |        | submgr  |    | e2term  |
+// +-------+        +---------+    +---------+
+//     |                 |              |
+//     | RESTSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |     RESTSubResp |              |
+//     |<----------------|              |
+//     |                 | SubReq       |
+//     |                 |------------->|
+//     |                 |              |
+//     |                 |      SubResp |
+//     |                 |<-------------|
+//     |                 |              |
+//     |       RESTNotif |              |
+//     |<----------------|              |
+//     |                 |              |
+//     | RESTSubReq      |              |
+//     |---------------->|              |
+//     |                 |              |
+//     |         RESTSubUpdateFail      |
+//     |                 |              |
+//     | 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},
+       })
+
+       const subReqCount int = 1
+
+       // Req
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+       restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
+
+       // Policy change
+
+       params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+
+       restSubIdUpd := strings.ToUpper(restSubId)
+       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)
+}
+
 //-----------------------------------------------------------------------------
 // TestRESTSubReqAndSubDelOkTwoE2termParallel
 //
@@ -3771,28 +4006,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
@@ -3899,22 +4132,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
@@ -3963,7 +4194,8 @@ 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},
@@ -3971,14 +4203,11 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
        })
 
        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
@@ -4046,13 +4275,14 @@ 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{cRestSubDelRespToXapp, 1},
        })
 
        // Remove possible existing subscription
@@ -4144,16 +4374,17 @@ 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
@@ -4166,7 +4397,7 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
        xapp.Logger.Info("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)
@@ -4253,18 +4484,15 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
 func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
        CaseBegin("TestRESTReportSubReqAndSubDelOk")
        subReqCount := 1
-       parameterSet := 1 // E2SM-gNB-X2
-       actionDefinitionPresent := true
-       actionParamCount := 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.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        var e2SubsId []uint32
@@ -4306,25 +4534,21 @@ func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
        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.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
 
        // Req
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
-       //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount, actionDefinitionPresent, policyParamCount)
+       //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount)
        //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
 
        var e2SubsId []uint32
@@ -4359,18 +4583,19 @@ 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},
        })
 
        // Req
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
        e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
 
@@ -4391,18 +4616,19 @@ 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},
        })
 
        // Req
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
        e2SubsIds := sendAndReceiveMultipleE2SubReqs(t, subReqCount, xappConn1, e2termConn1, restSubId)
 
@@ -4420,23 +4646,21 @@ func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.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)
 
@@ -4456,23 +4680,21 @@ func TestRESTTwoReportSubReqAndSubDelOk(t *testing.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)
 
@@ -4492,23 +4714,21 @@ func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.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)
 
@@ -4529,14 +4749,15 @@ 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
@@ -4549,9 +4770,9 @@ func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(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")
-       eventTriggerDefinition := "1234"
+       eventTriggerDefinition := []int64{1234, 1}
        params.SetSubEventTriggerDefinition(eventTriggerDefinition)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
@@ -4575,14 +4796,15 @@ 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
@@ -4595,12 +4817,12 @@ func TestRESTSubReqReportSameActionDiffActionListLen(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")
 
        actionId := int64(1)
        actionType := "report"
-       actionDefinition := "56781"
+       actionDefinition := []int64{5678, 1}
        subsequestActionType := "continue"
        timeToWait := "w10ms"
        params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
@@ -4626,14 +4848,15 @@ 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
@@ -4646,7 +4869,7 @@ func TestRESTSubReqReportSameActionDiffActionID(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")
        params.SetSubActionIDs(int64(2))
 
@@ -4671,18 +4894,19 @@ 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},
        })
 
        // Req1
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
@@ -4691,7 +4915,7 @@ func TestRESTSubReqDiffActionType(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")
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
@@ -4715,18 +4939,19 @@ 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},
        })
 
        // Req1
-       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
 
        //Subs Create
        restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
@@ -4735,7 +4960,7 @@ func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
        queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
 
        // Req2
-       params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount, actionDefinitionPresent, policyParamCount)
+       params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
        params.SetMeid("RAN_NAME_1")
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
@@ -4759,14 +4984,15 @@ 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
@@ -4779,9 +5005,9 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionLen(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")
-       actionDefinition := "5678"
+       actionDefinition := []int64{5678, 1}
        params.SetSubActionDefinition(actionDefinition)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
@@ -4805,14 +5031,15 @@ 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
@@ -4825,9 +5052,9 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionContents(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")
-       actionDefinition := "56782"
+       actionDefinition := []int64{56782}
        params.SetSubActionDefinition(actionDefinition)
 
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
@@ -4851,14 +5078,15 @@ 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
@@ -4871,7 +5099,7 @@ func TestRESTSubReqReportSameActionDiffSubsAction(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")
        params.SetTimeToWait("w200ms")
        restSubId2 := xappConn2.SendRESTSubsReq(t, params)
@@ -4928,12 +5156,9 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
 func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
        xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
        subReqCount := 1
-       parameterSet := 1 // E2SM-gNB-X2
-       actionDefinitionPresent := true
-       actionParamCount := 1
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
@@ -5001,12 +5226,9 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
 func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
        xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
        subReqCount := 1
-       parameterSet := 1 // E2SM-gNB-X2
-       actionDefinitionPresent := true
-       actionParamCount := 1
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
@@ -5083,12 +5305,9 @@ func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
 func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
        xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
        subReqCount := 1
-       parameterSet := 1 // E2SM-gNB-X2
-       actionDefinitionPresent := true
-       actionParamCount := 1
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
@@ -5163,12 +5382,9 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
        xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
        subReqCount := 1
-       parameterSet := 1 // E2SM-gNB-X2
-       actionDefinitionPresent := true
-       actionParamCount := 1
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
@@ -5237,12 +5453,9 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
 func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
        xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
        subReqCount := 1
-       parameterSet := 1 // E2SM-gNB-X2
-       actionDefinitionPresent := true
-       actionParamCount := 1
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
@@ -5312,12 +5525,9 @@ func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
 func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
        xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
        subReqCount := 1
-       parameterSet := 1 // E2SM-gNB-X2
-       actionDefinitionPresent := true
-       actionParamCount := 1
 
        // Req
-       params := xappConn1.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
        restSubId := xappConn1.SendRESTSubsReq(t, params)
 
        crereq, cremsg := e2termConn1.RecvSubsReq(t)
@@ -5722,19 +5932,81 @@ func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
        mainCtrl.wait_registry_empty(t, 10)
 }
 
+//-----------------------------------------------------------------------------
+// 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{cSubDelReqToE2, 1},
+               Counter{cSubDelFailFromE2, 1},
+               Counter{cRestSubFailNotifToXapp, 1},
+       })
+
+       subReqCount := 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.Info("Send REST subscriber request for subscriberId : %v", restSubId)
+
+       // E2t: Receive SubsDelReq
+       delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+       xappConn1.ExpectRESTNotification(t, restSubId)
+
+       // Subscription does not exist in in E2 Node.
+       e2termConn1.SendSubsDelFail(t, delreq, delmsg)
+
+       e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
+       xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
+
+       e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
+       // Wait that subs is cleaned
+       waitSubsCleanup(t, e2SubsId, 10)
+       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"
 
 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)
+               params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
        }
        restSubId := fromXappConn.SendRESTSubsReq(t, params)
        xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
@@ -5750,7 +6022,7 @@ func createSubscription(t *testing.T, fromXappConn *teststube2ap.E2Stub, toE2ter
 
 func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
 
-       params := xappConn2.GetRESTSubsReqReportParams(subReqCount, parameterSet, actionDefinitionPresent, actionParamCount)
+       params := xappConn2.GetRESTSubsReqReportParams(subReqCount)
        if meid != "" {
                params.SetMeid(meid)
        }
@@ -5765,7 +6037,7 @@ func createXapp2MergedSubscription(t *testing.T, meid string) (string, uint32) {
 }
 
 func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
-       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)
 
@@ -5779,7 +6051,7 @@ func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
 }
 
 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)
(near-realtime) RIC Platform Subscription Manager