X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fcontrol%2Fut_messaging_test.go;h=79eccd2efffea041626e16e3e379b5b692e0a44b;hb=4b1ff2caedf6814946263792275b027f824f9b69;hp=fd411bf9578845322eb1d4441907fdf4392fb590;hpb=c7da4ee19c2b2a96c1eeccd8da944902fcd9323f;p=ric-plt%2Fsubmgr.git

diff --git a/pkg/control/ut_messaging_test.go b/pkg/control/ut_messaging_test.go
index fd411bf..79eccd2 100644
--- a/pkg/control/ut_messaging_test.go
+++ b/pkg/control/ut_messaging_test.go
@@ -39,12 +39,17 @@ func TestSuiteSetup(t *testing.T) {
 	// like this:git log
 	// SetPackerIf(e2ap_wrapper.NewAsn1E2APPacker())
 
+	mainCtrl.InitAllCounterMap()
 	SetPackerIf(e2ap_wrapper.NewUtAsn1E2APPacker())
 	mainCtrl.c.restDuplicateCtrl.Init()
 
 }
 func TestRanStatusChangeViaSDLNotification(t *testing.T) {
 
+	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+		Counter{cE2StateChangedToUp, 3},
+	})
+
 	// Current UT test cases use these ran names
 	xappRnibMock.CreateGnb("RAN_NAME_1", entities.ConnectionStatus_DISCONNECTED)
 	xappRnibMock.CreateGnb("RAN_NAME_11", entities.ConnectionStatus_DISCONNECTED)
@@ -56,6 +61,8 @@ func TestRanStatusChangeViaSDLNotification(t *testing.T) {
 	mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
 	mainCtrl.SetE2State(t, "RAN_NAME_2_CONNECTED")
 	mainCtrl.SetE2State(t, "RAN_NAME_11_CONNECTED")
+
+	mainCtrl.VerifyCounterValues(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -82,6 +89,8 @@ func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
 	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 		Counter{cRestSubReqFromXapp, 1},
 		Counter{cRestReqRejDueE2Down, 1},
+		Counter{cE2StateChangedToDown, 1},
+		Counter{cE2StateChangedToUp, 1},
 	})
 
 	// E2 disconnect after E2term has received response
@@ -94,7 +103,9 @@ func TestRESTSubReqAfterE2ConnBreak(t *testing.T) {
 	// Restore E2 connection for following test cases
 	mainCtrl.SetE2State(t, "RAN_NAME_1_CONNECTED")
 
+	mainCtrl.VerifyAllClean(t)
 	mainCtrl.VerifyCounterValues(t)
+	//os.Exit(0)
 }
 
 //-----------------------------------------------------------------------------
@@ -132,6 +143,8 @@ func TestRESTSubReqE2ConnBreak(t *testing.T) {
 		Counter{cSubReqToE2, 1},
 		Counter{cSubRespFromE2, 1},
 		Counter{cRestSubFailNotifToXapp, 1},
+		Counter{cE2StateChangedToDown, 1},
+		Counter{cE2StateChangedToUp, 1},
 	})
 
 	// Req
@@ -173,6 +186,7 @@ func TestRESTSubReqE2ConnBreak(t *testing.T) {
 	// Wait that subs is cleaned
 	waitSubsCleanup(t, e2SubsId, 10)
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -208,6 +222,8 @@ func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
 		Counter{cRestSubNotifToXapp, 1},
 		Counter{cRestSubDelReqFromXapp, 1},
 		Counter{cRestSubDelRespToXapp, 1},
+		Counter{cE2StateChangedToDown, 1},
+		Counter{cE2StateChangedToUp, 1},
 	})
 
 	// Req
@@ -249,6 +265,7 @@ func TestRESTSubscriptionDeleteAfterE2ConnectionBreak(t *testing.T) {
 	e2termConn1.TestMsgChanEmpty(t)
 	mainCtrl.wait_registry_empty(t, 10)
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -284,6 +301,7 @@ func TestRESTOtherE2ConnectionChanges(t *testing.T) {
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
 		Counter{cRestSubDelRespToXapp, 1},
+		Counter{cE2StateChangedToUp, 1},
 	})
 
 	// Req
@@ -295,7 +313,7 @@ func TestRESTOtherE2ConnectionChanges(t *testing.T) {
 	e2termConn1.SendSubsResp(t, crereq, cremsg)
 	e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
 
-	// Submgr should not react any other connection state changes than CONNECTED and DISCONNECTED
+	// Submgr should not react to 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")
@@ -312,6 +330,7 @@ func TestRESTOtherE2ConnectionChanges(t *testing.T) {
 	// Wait that subs is cleaned
 	waitSubsCleanup(t, e2SubsId, 10)
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -361,6 +380,7 @@ func TestRESTSubReqAndDeleteOkWithE2apUtWrapper(t *testing.T) {
 	deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
 
 	waitSubsCleanup(t, e2SubsId, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -407,6 +427,7 @@ func TestRESTSubReqAndE1apDeleteReqPackingError(t *testing.T) {
 	defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_REQ, true)
 
 	waitSubsCleanup(t, e2SubsId, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -469,6 +490,7 @@ func TestRESTSubReqAndE1apDeleteRespUnpackingError(t *testing.T) {
 	defer e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_DEL_RESP, true)
 
 	waitSubsCleanup(t, e2SubsId, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -726,6 +748,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},
@@ -734,6 +757,7 @@ func TestSubMergeDelAndRouteUpdateNok(t *testing.T) {
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
 		Counter{cSubDelRespToXapp, 2},
+		Counter{cUnmergedSubscriptions, 1},
 	})
 
 	//Req1
@@ -1260,6 +1284,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},
@@ -1446,12 +1471,6 @@ func TestSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 //     |              |      SubFail |
 //     |              |<-------------|
 //     |              |              |
-//     |              | SubDelReq    |
-//     |              |------------->|
-//     |              |              |
-//     |              |   SubDelResp |
-//     |              |<-------------|
-//     |              |              |
 //     |      SubFail |              |
 //     |<-------------|              |
 //     |              |              |
@@ -1477,10 +1496,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)
 
@@ -1755,8 +1770,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()
@@ -1766,11 +1779,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)
@@ -1892,11 +1901,6 @@ func TestSubReqAndSubDelOkSameActionParallel(t *testing.T) {
 //     |             |              |    SubFail1  |
 //     |             |              |<-------------|
 //     |             |              |              |
-//     |             |              | SubDelReq    |
-//     |             |              |------------->|
-//     |             |              |   SubDelResp |
-//     |             |              |<-------------|
-//     |             |              |              |
 //     |             |    SubFail1  |              |
 //     |             |<-------------|              |
 //     |             |              |              |
@@ -1927,10 +1931,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
@@ -2388,9 +2388,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)
@@ -2472,6 +2469,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))
@@ -2566,7 +2567,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"})
@@ -2574,6 +2575,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))
@@ -2589,6 +2594,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)
@@ -2712,6 +2721,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) {
@@ -2726,10 +2736,10 @@ func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
 		Counter{cRestSubNotifToXapp, 1},
 		Counter{cRestSubFailNotifToXapp, 1},
 		Counter{cRouteCreateUpdateFail, 1},
-		Counter{cRestSubDelReqFromXapp, 1},
+		Counter{cRestSubDelReqFromXapp, 2},
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
-		Counter{cRestSubDelRespToXapp, 1},
+		Counter{cRestSubDelRespToXapp, 2},
 	})
 
 	var params *teststube2ap.RESTSubsReqParams = nil
@@ -2748,18 +2758,19 @@ func TestRESTSubReqAndRouteUpdateNok(t *testing.T) {
 	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) {
@@ -2793,8 +2804,8 @@ func TestRESTSubDelReqAndRouteDeleteNok(t *testing.T) {
 	waiter.WaitResult(t)
 
 	waitSubsCleanup(t, e2SubsId, 10)
-
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
@@ -2802,6 +2813,7 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
 
 	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 		Counter{cRestSubReqFromXapp, 2},
+		Counter{cMergedSubscriptions, 1},
 		Counter{cRestSubRespToXapp, 2},
 		Counter{cSubReqToE2, 1},
 		Counter{cSubRespFromE2, 1},
@@ -2811,6 +2823,7 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
 		Counter{cRestSubDelRespToXapp, 2},
+		Counter{cUnmergedSubscriptions, 1},
 	})
 
 	var params *teststube2ap.RESTSubsReqParams = nil
@@ -2834,8 +2847,8 @@ func TestRESTSubMergeDelAndRouteUpdateNok(t *testing.T) {
 	deleteXapp2Subscription(t, &restSubId2)
 
 	waitSubsCleanup(t, e2SubsId2, 10)
-
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2891,33 +2904,32 @@ func TestRESTSubReqRetransmission(t *testing.T) {
 	// Subs Create
 	const subReqCount 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)
-	restSubId1 := xappConn1.SendRESTSubsReq(t, params)
-	xappConn2.SendRESTSubsReq(t, params)
+	restSubId := xappConn1.SendRESTSubsReq(t, params)
 
-	waiter.WaitResult(t)
+	xappConn1.SendRESTSubsReq(t, params)
+	<-time.After(time.Second * 1)
 
-	xappConn1.WaitListedRestNotifications(t, []string{restSubId1})
+	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)
 
-	e2SubsIdA := <-xappConn1.ListedRESTNotifications
-	xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+	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)
 
-	mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsIdA.E2SubsId}, 10)
+	mainCtrl.wait_multi_subs_clean(t, []uint32{e2SubsId.E2SubsId}, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -2967,6 +2979,7 @@ func TestRESTSubReqRetransmissionV2(t *testing.T) {
 
 	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 		Counter{cRestSubReqFromXapp, 3},
+		Counter{cDuplicateE2SubReq, 2},
 		Counter{cRestSubRespToXapp, 3},
 		Counter{cSubReqToE2, 1},
 		Counter{cSubRespFromE2, 1},
@@ -2983,26 +2996,27 @@ func TestRESTSubReqRetransmissionV2(t *testing.T) {
 
 	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)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	//2.nd resend
 	restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
 
 	assert.Equal(t, restSubId_resend2, restSubId)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
 
 	waitSubsCleanup(t, e2SubsId, 10)
-
-	//Wait that subs is cleaned
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3051,6 +3065,7 @@ func TestRESTSubReqRetransmissionV3(t *testing.T) {
 
 	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 		Counter{cRestSubReqFromXapp, 3},
+		Counter{cDuplicateE2SubReq, 2},
 		Counter{cRestSubRespToXapp, 3},
 		Counter{cSubReqToE2, 1},
 		Counter{cSubRespFromE2, 1},
@@ -3067,7 +3082,7 @@ func TestRESTSubReqRetransmissionV3(t *testing.T) {
 
 	queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	//1.st resend with subscription ID
 	params.SetSubscriptionID(&restSubId)
@@ -3075,7 +3090,7 @@ func TestRESTSubReqRetransmissionV3(t *testing.T) {
 
 	assert.Equal(t, restSubId_resend, restSubId)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	//2.nd resend without subscription ID (faking app restart)
 	params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
@@ -3083,14 +3098,13 @@ func TestRESTSubReqRetransmissionV3(t *testing.T) {
 
 	assert.Equal(t, restSubId_resend2, restSubId)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
 
 	waitSubsCleanup(t, e2SubsId, 10)
-
-	//Wait that subs is cleaned
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3155,6 +3169,7 @@ func TestRESTSubReqRetransmissionV4(t *testing.T) {
 
 	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 		Counter{cRestSubReqFromXapp, 3},
+		Counter{cDuplicateE2SubReq, 2},
 		Counter{cRestSubRespToXapp, 3},
 		Counter{cSubReqToE2, 2},
 		Counter{cSubRespFromE2, 2},
@@ -3169,7 +3184,7 @@ func TestRESTSubReqRetransmissionV4(t *testing.T) {
 
 	restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	// Send modified  requst, this time with e2 subscriptions.
 	params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
@@ -3190,7 +3205,7 @@ func TestRESTSubReqRetransmissionV4(t *testing.T) {
 	e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
 	assert.NotEqual(t, e2SubsId2, 0)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
 	params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
@@ -3203,15 +3218,16 @@ func TestRESTSubReqRetransmissionV4(t *testing.T) {
 	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)
-
-	//Wait that subs is cleaned
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3276,6 +3292,7 @@ func TestRESTSubReqRetransmissionV5(t *testing.T) {
 
 	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 		Counter{cRestSubReqFromXapp, 3},
+		Counter{cDuplicateE2SubReq, 2},
 		Counter{cRestSubRespToXapp, 3},
 		Counter{cSubReqToE2, 2},
 		Counter{cSubRespFromE2, 2},
@@ -3290,7 +3307,7 @@ func TestRESTSubReqRetransmissionV5(t *testing.T) {
 
 	restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	// Send modified  requst, this time with e2 subscriptions.
 	params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
@@ -3313,7 +3330,7 @@ func TestRESTSubReqRetransmissionV5(t *testing.T) {
 	e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
 	assert.NotEqual(t, e2SubsId2, 0)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
 	params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
@@ -3326,15 +3343,16 @@ func TestRESTSubReqRetransmissionV5(t *testing.T) {
 	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)
-
-	//Wait that subs is cleaned
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3408,6 +3426,7 @@ func TestRESTSubReqRetransmissionV6(t *testing.T) {
 
 	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 		Counter{cRestSubReqFromXapp, 3},
+		Counter{cDuplicateE2SubReq, 1},
 		Counter{cRestSubRespToXapp, 3},
 		Counter{cSubReqToE2, 3},
 		Counter{cSubRespFromE2, 3},
@@ -3422,7 +3441,7 @@ func TestRESTSubReqRetransmissionV6(t *testing.T) {
 
 	restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	// Send modified  requst, this time with e2 subscriptions.
 	params2 := xappConn1.GetRESTSubsReqReportParams(subReqCount + 1)
@@ -3443,7 +3462,7 @@ func TestRESTSubReqRetransmissionV6(t *testing.T) {
 	e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
 	assert.NotEqual(t, e2SubsId2, 0)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	// Delete both e2 subscriptions
 	xappConn1.SendRESTSubsDelReq(t, &restSubId)
@@ -3457,14 +3476,13 @@ func TestRESTSubReqRetransmissionV6(t *testing.T) {
 	// fresh create.
 	restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
 
-	<-time.After(100 * time.Millisecond)
+	mainCtrl.WaitOngoingRequestMapEmpty()
 
 	deleteSubscription(t, xappConn1, e2termConn1, &restSubId)
 
 	waitSubsCleanup(t, e2SubsId, 10)
-
-	//Wait that subs is cleaned
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubDelReqRetransmission(t *testing.T) {
@@ -3479,7 +3497,7 @@ func TestRESTSubDelReqRetransmission(t *testing.T) {
 		Counter{cRestSubDelReqFromXapp, 2},
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
-		Counter{cRestSubDelRespToXapp, 1},
+		Counter{cRestSubDelRespToXapp, 2},
 	})
 
 	var params *teststube2ap.RESTSubsReqParams = nil
@@ -3500,8 +3518,8 @@ func TestRESTSubDelReqRetransmission(t *testing.T) {
 	e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 
 	waitSubsCleanup(t, e2SubsId, 10)
-
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3543,6 +3561,7 @@ func TestRESTSubReqDelReq(t *testing.T) {
 		Counter{cSubRespFromE2, 1},
 		Counter{cRestSubNotifToXapp, 1},
 		Counter{cRestSubDelReqFromXapp, 2},
+		Counter{cRestSubDelFailToXapp, 1},
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
 		Counter{cRestSubDelRespToXapp, 1},
@@ -3572,7 +3591,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) {
@@ -3630,7 +3649,7 @@ func TestRESTSubReqAndSubDelOkTwoParallel(t *testing.T) {
 	waitSubsCleanup(t, e2SubsIdB.E2SubsId, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSameSubsDiffRan(t *testing.T) {
@@ -3667,7 +3686,7 @@ func TestRESTSameSubsDiffRan(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqRetryInSubmgr(t *testing.T) {
@@ -3678,6 +3697,7 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) {
 		Counter{cRestSubReqFromXapp, 1},
 		Counter{cRestSubRespToXapp, 1},
 		Counter{cSubReqToE2, 1},
+		Counter{cSubReqTimerExpiry, 1},
 		Counter{cSubReReqToE2, 1},
 		Counter{cSubRespFromE2, 1},
 		Counter{cRestSubNotifToXapp, 1},
@@ -3711,7 +3731,7 @@ func TestRESTSubReqRetryInSubmgr(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3763,8 +3783,11 @@ func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
 		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)
@@ -3782,10 +3805,12 @@ func TestRESTSubReqRetryNoRespSubDelRespInSubmgr(t *testing.T) {
 	e2termConn1.SendSubsDelResp(t, delreq, delmsg)
 	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) {
@@ -3798,8 +3823,12 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
 		Counter{cSubReqToE2, 1},
 		Counter{cSubReReqToE2, 1},
 		Counter{cSubReqTimerExpiry, 2},
+		Counter{cSubDelReReqToE2, 1},
+		Counter{cRestSubFailNotifToXapp, 1},
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelReqTimerExpiry, 2},
+		Counter{cRestSubDelReqFromXapp, 1},
+		Counter{cRestSubDelRespToXapp, 1},
 	})
 
 	params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
@@ -3821,10 +3850,11 @@ func TestREST2eTermNotRespondingToSubReq(t *testing.T) {
 
 	e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
 
-	waitSubsCleanup(t, e2SubsId, 10)
+	xappConn1.SendRESTSubsDelReq(t, &restSubId)
 
+	waitSubsCleanup(t, e2SubsId, 10)
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3875,9 +3905,12 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 		Counter{cSubReqToE2, 1},
 		Counter{cSubReReqToE2, 1},
 		Counter{cSubReqTimerExpiry, 2},
+		Counter{cRestSubFailNotifToXapp, 1},
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelReReqToE2, 1},
 		Counter{cSubDelReqTimerExpiry, 2},
+		Counter{cRestSubDelReqFromXapp, 1},
+		Counter{cRestSubDelRespToXapp, 1},
 	})
 
 	params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
@@ -3899,9 +3932,11 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 
 	e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
 
-	waitSubsCleanup(t, e2SubsId, 10)
+	xappConn1.SendRESTSubsDelReq(t, &restSubId)
 
+	waitSubsCleanup(t, e2SubsId, 10)
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -3923,12 +3958,6 @@ func TestRESTSubReqTwoRetriesNoRespAtAllInSubmgr(t *testing.T) {
 //     |                 |      SubFail |
 //     |                 |<-------------|
 //     |                 |              |
-//     |                 | SubDelReq    |
-//     |                 |------------->|
-//     |                 |              |
-//     |                 |   SubDelResp |
-//     |                 |<-------------|
-//     |                 |              |
 //     |       RESTNotif |              |
 //     |       unsuccess |              |
 //     |<----------------|              |
@@ -3947,6 +3976,7 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
 		Counter{cSubFailFromE2, 1},
 		Counter{cRestSubFailNotifToXapp, 1},
 		Counter{cRestSubDelReqFromXapp, 1},
+		Counter{cRestSubDelRespToXapp, 1},
 	})
 
 	const subReqCount int = 1
@@ -3961,11 +3991,9 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
 	crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
 	fparams1 := &teststube2ap.E2StubSubsFailParams{}
 	fparams1.Set(crereq1)
+	xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
 	e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 
-	delreq1, delmsg1 := e2termConn1.RecvSubsDelReq(t)
-	xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
-	e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
 	e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
 	xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
 
@@ -3976,7 +4004,7 @@ func TestRESTSubReqSubFailRespInSubmgr(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4017,6 +4045,7 @@ func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
 		Counter{cRestSubNotifToXapp, 1},
 		Counter{cRestSubDelReqFromXapp, 1},
 		Counter{cSubDelReqToE2, 1},
+		Counter{cSubDelReqTimerExpiry, 1},
 		Counter{cSubDelReReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
 		Counter{cRestSubDelRespToXapp, 1},
@@ -4039,6 +4068,7 @@ func TestRESTSubDelReqRetryInSubmgr(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4077,6 +4107,7 @@ func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
 		Counter{cRestSubNotifToXapp, 1},
 		Counter{cRestSubDelReqFromXapp, 1},
 		Counter{cSubDelReqToE2, 1},
+		Counter{cSubDelReqTimerExpiry, 1},
 		Counter{cSubDelReReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
 		Counter{cRestSubDelRespToXapp, 1},
@@ -4100,6 +4131,7 @@ func TestRESTSubDelReqTwoRetriesNoRespInSubmgr(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4156,6 +4188,7 @@ func TestRESTSubDelReqSubDelFailRespInSubmgr(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4255,8 +4288,8 @@ func TestRESTSubReqAndSubDelOkSameAction(t *testing.T) {
 
 	//Wait that subs is cleaned
 	waitSubsCleanup(t, e2SubsId2, 10)
-
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4349,8 +4382,8 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
 	e2termConn1.SendSubsDelResp(t, delreq2, delmsg2)
 
 	waitSubsCleanup(t, e2SubsId2, 10)
-
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4373,7 +4406,7 @@ func TestRESTSubReqAndSubDelOkSameActionParallel(t *testing.T) {
 //     | RESTSubReq2                   |              |
 //     |------------------------------>|              |
 //     |             |                 |              |
-//     |               RESTSubDelResp2 |              |
+//     |               RESTSubResp2    |              |
 //     |<------------------------------|              |
 //     |             |                 | SubReq1      |
 //     |             |                 |------------->|
@@ -4409,15 +4442,18 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
 
 	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 		Counter{cRestSubReqFromXapp, 2},
+		Counter{cMergedSubscriptions, 1},
 		Counter{cRestSubRespToXapp, 2},
 		Counter{cSubReqToE2, 1},
+		Counter{cSubReqTimerExpiry, 2},
+		Counter{cSubReReqToE2, 1},
 		Counter{cRestSubFailNotifToXapp, 2},
+		Counter{cUnmergedSubscriptions, 1},
 		Counter{cRestSubDelReqFromXapp, 2},
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
 		Counter{cRestSubDelRespToXapp, 2},
 	})
-
 	const subReqCount int = 1
 
 	// Req1
@@ -4455,8 +4491,8 @@ func TestRESTSubReqAndSubDelNoAnswerSameActionParallel(t *testing.T) {
 
 	//Wait that subs is cleaned
 	waitSubsCleanup(t, e2SubsIdA.E2SubsId, 10)
-
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4490,12 +4526,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 |              |
@@ -4513,13 +4545,13 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
 
 	mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
 		Counter{cRestSubReqFromXapp, 2},
+		Counter{cMergedSubscriptions, 1},
 		Counter{cRestSubRespToXapp, 2},
 		Counter{cSubReqToE2, 1},
 		Counter{cSubFailFromE2, 1},
 		Counter{cRestSubFailNotifToXapp, 2},
+		Counter{cUnmergedSubscriptions, 1},
 		Counter{cRestSubDelReqFromXapp, 2},
-		Counter{cSubDelReqToE2, 1},
-		Counter{cSubDelRespFromE2, 1},
 		Counter{cRestSubDelRespToXapp, 2},
 	})
 
@@ -4542,11 +4574,7 @@ func TestRESTSubReqAndSubDelNokSameActionParallel(t *testing.T) {
 	fparams1.Set(crereq1)
 	e2termConn1.SendSubsFail(t, fparams1, cremsg1)
 
-	// E2t: internal delete
-	delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
 	xappConn1.WaitListedRestNotifications(t, []string{restSubId1, restSubId2})
-	e2termConn1.SendSubsDelResp(t, delreq, delmsg)
-
 	e2SubsIdA := <-xappConn1.ListedRESTNotifications
 	xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
 	e2SubsIdB := <-xappConn1.ListedRESTNotifications
@@ -4561,8 +4589,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) {
@@ -4598,6 +4626,7 @@ func TestRESTSubReqPolicyAndSubDelOk(t *testing.T) {
 	// Wait that subs is cleaned
 	waitSubsCleanup(t, e2SubsId, 10)
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4692,6 +4721,7 @@ func TestRESTSubReqPolicyChangeAndSubDelOk(t *testing.T) {
 	// Wait that subs is cleaned
 	waitSubsCleanup(t, e2SubsId, 10)
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4773,6 +4803,7 @@ func TestRESTSubReqPolicyChangeNOk(t *testing.T) {
 	// Wait that subs is cleaned
 	waitSubsCleanup(t, e2SubsId, 10)
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4876,6 +4907,7 @@ func TestRESTSubReqAndSubDelOkTwoE2termParallel(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4975,6 +5007,7 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
 	// Wait that subs is cleaned
 	waitSubsCleanup(t, e2SubsId, 10)
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -4988,6 +5021,8 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
 //     | RESTSubReq   |              |
 //     |------------->|              |
 //     |              |              |
+//     |  RESTSubResp |              |
+//     |<-------------|              |
 //     |              | SubReq       |
 //     |              |------------->|
 //     |              |              |
@@ -5003,6 +5038,15 @@ func TestRESTSubReqInsertAndSubDelOk(t *testing.T) {
 //     |              |   SubDelResp |
 //     |              |<-------------|
 //     |              |              |
+//     |    RESTNotif |              |
+//     |    unsuccess |              |
+//     |<-------------|              |
+//     |              |              |
+//     | RESTSubDelReq|              |
+//     |------------->|              |
+//     |              |              |
+//     |RESTSubDelResp|              |
+//     |<-------------|              |
 //
 //-----------------------------------------------------------------------------
 func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
@@ -5015,13 +5059,12 @@ func TestRESTSubReqNokAndSubDelOkWithRestartInMiddle(t *testing.T) {
 		Counter{cSubDelReqFromXapp, 1},
 		Counter{cSubDelReqToE2, 1},
 		Counter{cSubDelRespFromE2, 1},
+		Counter{cRestSubDelReqFromXapp, 1},
+		Counter{cRestSubDelRespToXapp, 1},
 	})
 
 	const subReqCount int = 1
 
-	// Remove possible existing subscription
-	mainCtrl.removeExistingSubscriptions(t)
-
 	params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
 
 	//Req
@@ -5036,16 +5079,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)
 }
 
 //-----------------------------------------------------------------------------
@@ -5098,15 +5144,12 @@ func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
 		Counter{cRestSubNotifToXapp, 1},
 		Counter{cRestSubDelReqFromXapp, 1},
 		Counter{cSubDelReqToE2, 1},
+		Counter{cSubDelRespFromE2, 1},
 		Counter{cRestSubDelRespToXapp, 1},
 	})
 
-	// Remove possible existing subscription
-	mainCtrl.removeExistingSubscriptions(t)
-
-	var params *teststube2ap.RESTSubsReqParams = nil
-
 	// Create subscription
+	var params *teststube2ap.RESTSubsReqParams = nil
 	restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
 	xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
 
@@ -5116,6 +5159,10 @@ func TestRESTSubReqAndSubDelOkWithRestartInMiddle(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 subscription
 	queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
 
@@ -5126,6 +5173,7 @@ func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -5182,7 +5230,6 @@ func TestRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
 //     |             |                 |              |
 //
 //-----------------------------------------------------------------------------
-
 func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
 	CaseBegin("TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle")
 
@@ -5200,12 +5247,8 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
 		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.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
 
@@ -5222,15 +5265,24 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
 	queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
 
 	mainCtrl.SimulateRestart(t)
-	xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+	xapp.Logger.Debug("mainCtrl.SimulateRestart done 1")
+
+	// 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, and wait until it has removed the first endpoint
-	subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
 	xappConn1.SendRESTSubsDelReq(t, &restSubId1)
-	mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
+	mainCtrl.WaitRESTSubscriptionDelete(restSubId1)
+	// Above wait does not work correctly anymore as this delay makes this test case work
 
 	mainCtrl.SimulateRestart(t)
-	xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+	xapp.Logger.Debug("mainCtrl.SimulateRestart done 2")
+
+	// 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"})
 
 	// Delete subscription 2
@@ -5240,6 +5292,7 @@ func TestRESTSubReqAndSubDelOkSameActionWithRestartsInMiddle(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -5333,10 +5386,11 @@ func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
 	xappConn1.TestMsgChanEmpty(t)
 	e2termConn1.TestMsgChanEmpty(t)
 	mainCtrl.wait_registry_empty(t, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 /*
-func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {
+func TestRESTPolicySubReqAndSubDelOk(t *testing.T) {  was in comments already
 	CaseBegin("TestRESTPolicySubReqAndSubDelOk")
 
 	subReqCount := 2
@@ -5380,6 +5434,7 @@ func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
 	xappConn1.TestMsgChanEmpty(t)
 	e2termConn1.TestMsgChanEmpty(t)
 	mainCtrl.wait_registry_empty(t, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
@@ -5414,6 +5469,7 @@ func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
 	mainCtrl.wait_registry_empty(t, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
 
@@ -5445,6 +5501,7 @@ func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
 	mainCtrl.wait_registry_empty(t, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
@@ -5479,6 +5536,7 @@ func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
 	mainCtrl.wait_registry_empty(t, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
@@ -5513,6 +5571,7 @@ func TestRESTTwoReportSubReqAndSubDelOkNoActParams(t *testing.T) {
 	mainCtrl.wait_registry_empty(t, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
@@ -5547,6 +5606,7 @@ func TestRESTFullAmountReportSubReqAndSubDelOk(t *testing.T) {
 	mainCtrl.wait_registry_empty(t, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
@@ -5593,7 +5653,7 @@ func TestRESTSubReqReportSameActionDiffEventTriggerDefinitionLen(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
@@ -5645,7 +5705,7 @@ func TestRESTSubReqReportSameActionDiffActionListLen(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
@@ -5691,7 +5751,7 @@ func TestRESTSubReqReportSameActionDiffActionID(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqDiffActionType(t *testing.T) {
@@ -5742,7 +5802,7 @@ func TestRESTSubReqDiffActionType(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
@@ -5793,7 +5853,7 @@ func TestRESTSubReqPolicyAndSubDelOkSameAction(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
@@ -5840,7 +5900,7 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionLen(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
@@ -5887,7 +5947,7 @@ func TestRESTSubReqReportSameActionDiffActionDefinitionContents(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
@@ -5932,7 +5992,7 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId2, 10)
 
 	mainCtrl.VerifyCounterValues(t)
-
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -5962,11 +6022,7 @@ func TestRESTSubReqReportSameActionDiffSubsAction(t *testing.T) {
 //     |                 |<-------------|
 //     | RESTNotif (fail)|              |
 //     |<----------------|              |
-//     |                 | SubDelReq    |
-//     |                 |------------->|
 //     |                 |              |
-//     |                 |   SubDelResp |
-//     |                 |<-------------|
 //
 //-----------------------------------------------------------------------------
 
@@ -5992,18 +6048,18 @@ func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
 	fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
 	e2termConn1.SendSubsFail(t, fparams, cremsg)
 
-	delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
-	e2termConn1.SendSubsDelResp(t, delreq, delmsg)
-
 	instanceId := xappConn1.WaitRESTNotification(t, restSubId)
 	xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
 
+	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)
 }
 
 //-----------------------------------------------------------------------------
@@ -6072,12 +6128,15 @@ func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
 	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)
 }
 
 //-----------------------------------------------------------------------------
@@ -6154,13 +6213,15 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
 	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)
 }
 
 //-----------------------------------------------------------------------------
@@ -6190,11 +6251,7 @@ func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
 //     |                 |<-------------|
 //     | RESTNotif (fail)|              |
 //     |<----------------|              |
-//     |                 | SubDelReq    |
-//     |                 |------------->|
 //     |                 |              |
-//     |                 |   SubDelResp |
-//     |                 |<-------------|
 //
 //-----------------------------------------------------------------------------
 func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
@@ -6220,18 +6277,18 @@ func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
 	fparams.SetCauseVal(0, 1, 3) // CauseRIC / duplicate-action
 	e2termConn1.SendSubsFail(t, fparams, cremsg)
 
-	delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
-	e2termConn1.SendSubsDelResp(t, delreq, delmsg)
-
 	instanceId := xappConn1.WaitRESTNotification(t, restSubId)
 	xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
 
+	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)
 }
 
 //-----------------------------------------------------------------------------
@@ -6298,12 +6355,15 @@ func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
 	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)
 }
 
 //-----------------------------------------------------------------------------
@@ -6375,12 +6435,15 @@ func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
 	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)
 }
 
 //-----------------------------------------------------------------------------
@@ -6442,6 +6505,7 @@ func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
 	xappConn1.TestMsgChanEmpty(t)
 	e2termConn1.TestMsgChanEmpty(t)
 	mainCtrl.wait_registry_empty(t, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6503,6 +6567,7 @@ func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
 	xappConn1.TestMsgChanEmpty(t)
 	e2termConn1.TestMsgChanEmpty(t)
 	mainCtrl.wait_registry_empty(t, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6565,6 +6630,7 @@ func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
 	xappConn1.TestMsgChanEmpty(t)
 	e2termConn1.TestMsgChanEmpty(t)
 	mainCtrl.wait_registry_empty(t, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6625,6 +6691,7 @@ func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
 	xappConn1.TestMsgChanEmpty(t)
 	e2termConn1.TestMsgChanEmpty(t)
 	mainCtrl.wait_registry_empty(t, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6686,6 +6753,7 @@ func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
 	xappConn1.TestMsgChanEmpty(t)
 	e2termConn1.TestMsgChanEmpty(t)
 	mainCtrl.wait_registry_empty(t, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6748,6 +6816,7 @@ func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
 	xappConn1.TestMsgChanEmpty(t)
 	e2termConn1.TestMsgChanEmpty(t)
 	mainCtrl.wait_registry_empty(t, 10)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6786,6 +6855,8 @@ func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
 		Counter{cRestSubReqFromXapp, 1},
 		Counter{cRestSubRespToXapp, 1},
 		Counter{cRestSubFailNotifToXapp, 1},
+		Counter{cRestSubDelReqFromXapp, 1},
+		Counter{cRestSubDelRespToXapp, 1},
 	})
 
 	const subReqCount int = 1
@@ -6805,9 +6876,13 @@ func TestRESTSubReqFailAsn1PackSubReqError(t *testing.T) {
 	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.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
@@ -6817,6 +6892,7 @@ func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
 		Counter{cRestSubReqFromXapp, 2},
 		Counter{cRestSubRespToXapp, 2},
 		Counter{cSubReqToE2, 2},
+		Counter{cSubReqTimerExpiry, 1},
 		Counter{cSubRespFromE2, 1},
 		Counter{cRestSubNotifToXapp, 1},
 		Counter{cRestSubFailNotifToXapp, 1},
@@ -6866,6 +6942,7 @@ func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 //-----------------------------------------------------------------------------
@@ -6923,15 +7000,12 @@ func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
 		Counter{cSubReqToE2, 2},
 		Counter{cSubRespFromE2, 1},
 		Counter{cRestSubNotifToXapp, 1},
-		Counter{cRestSubNotifToXapp, 1},
 		Counter{cRestSubDelReqFromXapp, 1},
 		Counter{cSubDelReqToE2, 1},
+		Counter{cSubDelRespFromE2, 1},
 		Counter{cRestSubDelRespToXapp, 1},
 	})
 
-	// Remove possible existing subscription
-	mainCtrl.removeExistingSubscriptions(t)
-
 	const e2Timeout int64 = 1
 	const e2RetryCount int64 = 0
 	const routingNeeded bool = false
@@ -6969,13 +7043,13 @@ func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(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 subscription
 	queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
 
-	xapp.Logger.Debug("Here 1")
-	//<-time.After(3 * time.Second)
-	xapp.Logger.Debug("Here 2")
-
 	// Delete subscription
 	xappConn1.SendRESTSubsDelReq(t, &restSubId)
 	delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
@@ -6985,6 +7059,7 @@ func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
 	waitSubsCleanup(t, e2SubsId, 10)
 
 	mainCtrl.VerifyCounterValues(t)
+	mainCtrl.VerifyAllClean(t)
 }
 
 ////////////////////////////////////////////////////////////////////////////////////
@@ -7078,9 +7153,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) {