@openui5/sap.ui.core 1.122.0 → 1.123.0

package/test/sap/ui/core/qunit/odata/v4/lib/_AggregationCache.qunit.js

@@ -729,16 +729,19 @@ sap.ui.define([
 		assert.strictEqual(
 			oCache.calculateKeyPredicate("~oElement~", "~mTypeForMetaPath~", "~metapath~"),
 			"~sPredicate~");
+
+		if (oPICT.oParentGroupNode) {
+			assert.strictEqual(oCache.$parentFilter, "~filter~");
+		} else {
+			assert.notOk("$parentFilter" in oCache);
+		}
 	});
 });
 
 	//*********************************************************************************************
 [undefined, {}].forEach(function (oParentGroupNode, i) {
 	QUnit.test("createGroupLevelCache: recursive hierarchy, #" + i, function (assert) {
-		var oAggregation = {
-				hierarchyQualifier : "X",
-				$metaPath : "/meta/path"
-			},
+		var oAggregation = {hierarchyQualifier : "X"},
 			oCache = {},
 			mCacheQueryOptions = {},
 			iLevel = oParentGroupNode ? 3 : 1,
@@ -756,7 +759,7 @@ sap.ui.define([
 				.withExactArgs(sinon.match.same(oParentGroupNode), "filter").returns(undefined);
 			this.mock(oAggregationCache).expects("getTypes").withExactArgs().returns("~getTypes~");
 			this.mock(_Helper).expects("getKeyFilter")
-				.withExactArgs(sinon.match.same(oParentGroupNode), "/meta/path", "~getTypes~")
+				.withExactArgs(sinon.match.same(oParentGroupNode), "/Foo", "~getTypes~")
 				.returns("~filter~");
 		}
 		this.mock(_AggregationHelper).expects("getAllProperties").never();
@@ -794,6 +797,12 @@ sap.ui.define([
 		assert.strictEqual(
 			oCache.calculateKeyPredicate("~oElement~", "~mTypeForMetaPath~", "~metapath~"),
 			"~sPredicate~");
+
+		if (oParentGroupNode) {
+			assert.strictEqual(oCache.$parentFilter, "~filter~");
+		} else {
+			assert.notOk("$parentFilter" in oCache);
+		}
 	});
 });
 
@@ -1066,7 +1075,6 @@ sap.ui.define([
 			$DistanceFromRoot : "DistFromRoot",
 			$DrillState : "myDrillState",
 			$LimitedDescendantCount : "LtdDescendant_Count",
-			$metaPath : "~metaPath~",
 			$NodeProperty : "NodeID",
 			$path : "/path",
 			aggregate : {},
@@ -1087,7 +1095,7 @@ sap.ui.define([
 		oCache.aElements[25] = {"@$ui5.node.level" : 5};
 		oCache.aElements[26] = {"@$ui5.node.level" : 3};
 		const oHelperMock = this.mock(_Helper);
-		oHelperMock.expects("getKeyFilter").withExactArgs(oNode, "~metaPath~", "~Types~")
+		oHelperMock.expects("getKeyFilter").withExactArgs(oNode, "/Foo", "~Types~")
 			.returns("~Key~");
 		this.mock(this.oRequestor).expects("buildQueryString")
 			.withExactArgs(null, {$apply : "ancestors($root/path,X,NodeID,filter(~Key~),1)"})
@@ -1139,7 +1147,7 @@ sap.ui.define([
 						"LtdDescendant_Count"], "~GroupLock~", true)
 					.resolves();
 				oNodePropertyExpectation = oCacheMock.expects("requestNodeProperty")
-					.withExactArgs("~Parent~", "~GroupLock~")
+					.withExactArgs("~Parent~", "~GroupLock~", false)
 					.resolves();
 
 				return {value : ["~Parent~"]};
@@ -1173,7 +1181,6 @@ sap.ui.define([
 			$DistanceFromRoot : "DistFromRoot",
 			$DrillState : "myDrillState",
 			$LimitedDescendantCount : "LtdDescendant_Count",
-			$metaPath : "~metaPath~",
 			$NodeProperty : "NodeID",
 			$path : "/path",
 			aggregate : {},
@@ -1188,7 +1195,7 @@ sap.ui.define([
 		const oNode = {};
 		oCache.aElements[22] = {"@$ui5.node.level" : 0};
 		oCache.aElements[23] = oNode;
-		this.mock(_Helper).expects("getKeyFilter").withExactArgs(oNode, "~metaPath~", "~Types~")
+		this.mock(_Helper).expects("getKeyFilter").withExactArgs(oNode, "/Foo", "~Types~")
 			.returns("~Key~");
 		this.mock(this.oRequestor).expects("buildQueryString")
 			.withExactArgs(null, {$apply : "ancestors($root/path,X,NodeID,filter(~Key~),1)"})
@@ -1231,7 +1238,6 @@ sap.ui.define([
 			$DistanceFromRoot : "DistFromRoot",
 			$DrillState : "myDrillState",
 			$LimitedDescendantCount : "LtdDescendant_Count",
-			$metaPath : "~metaPath~",
 			$NodeProperty : "NodeID",
 			$path : "/path",
 			aggregate : {},
@@ -1246,7 +1252,7 @@ sap.ui.define([
 		const oNode = {};
 		oCache.aElements[22] = {"@$ui5.node.level" : 0};
 		oCache.aElements[23] = oNode;
-		this.mock(_Helper).expects("getKeyFilter").withExactArgs(oNode, "~metaPath~", "~Types~")
+		this.mock(_Helper).expects("getKeyFilter").withExactArgs(oNode, "/Foo", "~Types~")
 			.returns("~Key~");
 		this.mock(this.oRequestor).expects("buildQueryString")
 			.withExactArgs(null, {$apply : "ancestors($root/path,X,NodeID,filter(~Key~),1)"})
@@ -1757,33 +1763,41 @@ sap.ui.define([
 	iFirstLevelLength : 3,
 	iExpectedStart : 0,
 	iExpectedLength : 33
-}, {
+}, { // prefetch wins; less than iStart
 	iFirstLevelIndex : 25,
 	iFirstLevelLength : 1,
 	iOutOfPlaceCount : 5,
 	iPrefetchLength : 10,
-	iExpectedStart : 10,
-	iExpectedLength : 26
-}, {
-	iFirstLevelIndex : 21,
-	iFirstLevelLength : 1,
-	iOutOfPlaceCount : 5,
-	iExpectedStart : 0,
-	iExpectedLength : 42
-}, {
-	iFirstLevelIndex : 20,
+	iExpectedStart : 15,
+	iExpectedLength : 21
+}, { // out of place count wins; less than iStart
+	iFirstLevelIndex : 25,
 	iFirstLevelLength : 1,
-	iOutOfPlaceCount : 5,
-	iPrefetchLength : 0,
+	iOutOfPlaceCount : 10,
+	iPrefetchLength : 5,
 	iExpectedStart : 15,
-	iExpectedLength : 6
-}, {
+	iExpectedLength : 16
+}, { // prefetch wins; more than iStart
+	iFirstLevelIndex : 2,
+	iFirstLevelLength : 1,
+	iOutOfPlaceCount : 3,
+	iPrefetchLength : 5,
+	iExpectedStart : 0,
+	iExpectedLength : 8
+}, { // out of place count wins; more than iStart
 	iFirstLevelIndex : 2,
 	iFirstLevelLength : 1,
 	iOutOfPlaceCount : 5,
-	iPrefetchLength : 0,
+	iPrefetchLength : 1,
+	iExpectedStart : 0,
+	iExpectedLength : 4
+}, { // oFirstLevel already requested data
+	bHasGrandTotal : false,
+	bHasRequestedData : true,
+	iFirstLevelIndex : 0,
+	iFirstLevelLength : 3,
 	iExpectedStart : 0,
-	iExpectedLength : 3
+	iExpectedLength : 23
 }].forEach(function (oFixture, i) {
 	QUnit.test("readFirst: #" + i, function (assert) {
 		var oAggregation = { // filled before by buildApply
@@ -1820,6 +1834,7 @@ sap.ui.define([
 			oCache.oGrandTotalPromise = SyncPromise.resolve(oGrandTotal);
 			_Helper.setPrivateAnnotation(oGrandTotal, "copy", oGrandTotalCopy);
 		}
+		oCache.oFirstLevel.bSentRequest = oFixture.bHasRequestedData;
 		for (i = 0; i < Math.min(iExpectedLength, 42); i += 1) {
 			oReadResult.value.push({});
 		}
@@ -1828,8 +1843,12 @@ sap.ui.define([
 			.returns(oFixture.iOutOfPlaceCount ?? 0);
 		this.mock(oCache.oFirstLevel).expects("read")
 			.withExactArgs(iExpectedStart, iExpectedLength, 0, "~oGroupLock~", "~fnDataRequested~")
-			.returns(SyncPromise.resolve(Promise.resolve(oReadResult)));
-		this.mock(oCache).expects("requestOutOfPlaceNodes").withExactArgs("~oGroupLock~")
+			.callsFake(function () {
+				oCache.oFirstLevel.bSentRequest = true;
+				return SyncPromise.resolve(Promise.resolve(oReadResult));
+			});
+		this.mock(oCache).expects("requestOutOfPlaceNodes")
+			.exactly(oFixture.bHasRequestedData ? 0 : 1).withExactArgs("~oGroupLock~")
 			.returns([Promise.resolve("~outOfPlaceResult0~"),
 				Promise.resolve("~outOfPlaceResult1~"), Promise.resolve("~outOfPlaceResult2~")]);
 		if (oFixture.bHasGrandTotal) {
@@ -1871,7 +1890,10 @@ sap.ui.define([
 				.returns("~placeholder~" + i);
 		}
 		const oHandleOutOfPlaceNodesExpectation = this.mock(oCache).expects("handleOutOfPlaceNodes")
-			.withExactArgs(["~outOfPlaceResult0~", "~outOfPlaceResult1~", "~outOfPlaceResult2~"]);
+			.withExactArgs(oFixture.bHasRequestedData
+				? []
+				: ["~outOfPlaceResult0~", "~outOfPlaceResult1~", "~outOfPlaceResult2~"]
+			);
 
 		// code under test
 		return oCache.readFirst(oFixture.iFirstLevelIndex, oFixture.iFirstLevelLength,
@@ -2877,12 +2899,8 @@ sap.ui.define([
 					cache : oGroupLevelCache,
 					groupLevelCount : 7,
 					spliced : [{
-						"@$ui5._" : {
-							parent : oCache.oFirstLevel, // unrealistic!
-							predicate : "('A')",
-							rank : 23
-						},
-						"@$ui5.node.level" : 10
+						"@$ui5._" : {placeholder : true},
+						"@$ui5.node.level" : 0
 					}, {
 						"@$ui5._" : {placeholder : true, predicate : "n/a", rank : 24},
 						"@$ui5.node.level" : 11
@@ -2902,8 +2920,12 @@ sap.ui.define([
 						},
 						"@$ui5.node.level" : 12
 					}, {
-						"@$ui5._" : {placeholder : true},
-						"@$ui5.node.level" : 0
+						"@$ui5._" : {
+							parent : oCache.oFirstLevel, // unrealistic!
+							predicate : "('A')",
+							rank : 27
+						},
+						"@$ui5.node.level" : 10
 					}],
 					rank : 42
 				},
@@ -2923,6 +2945,7 @@ sap.ui.define([
 		if (bStale) {
 			oGroupNode["@$ui5._"].spliced.$stale = true;
 		}
+		oGroupNode["@$ui5._"].spliced.$level = 9;
 		oGroupNode["@$ui5._"].spliced.$rank = 12;
 		aElements = [{}, oGroupNode, {}, {}];
 		oCache.aElements = aElements.slice();
@@ -2944,12 +2967,12 @@ sap.ui.define([
 			.withExactArgs(sinon.match.same(_GroupLock.$cached), sinon.match.same(aSpliced[2]))
 			.returns(SyncPromise.resolve(100));
 		if (bStale) {
-			oCacheMock.expects("turnIntoPlaceholder")
-				.withExactArgs(sinon.match.same(aSpliced[0]), "('A')");
 			oCacheMock.expects("turnIntoPlaceholder")
 				.withExactArgs(sinon.match.same(aSpliced[2]), "('C')");
 			oCacheMock.expects("turnIntoPlaceholder")
 				.withExactArgs(sinon.match.same(aSpliced[3]), "('created')");
+			oCacheMock.expects("turnIntoPlaceholder")
+				.withExactArgs(sinon.match.same(aSpliced[4]), "('A')");
 			oCacheMock.expects("turnIntoPlaceholder")
 				.withExactArgs(sinon.match.same(aSpliced[200000]), "('D')");
 		} else {
@@ -2973,8 +2996,7 @@ sap.ui.define([
 				["0", "1", "2", "3", "4", "5", "6", "200002", "200003", "200004", "$byPredicate",
 					"$count"]);
 			assert.strictEqual(oCache.aElements[2], aSpliced[0]);
-			assert.strictEqual(aSpliced[0]["@$ui5.node.level"], 6);
-			assert.strictEqual(aSpliced[0]["@$ui5._"].rank, 53);
+			assert.strictEqual(aSpliced[0]["@$ui5.node.level"], 0, "unchanged");
 			assert.strictEqual(oCache.aElements[3], aSpliced[1]);
 			assert.strictEqual(aSpliced[1]["@$ui5.node.level"], 7);
 			assert.strictEqual(aSpliced[1]["@$ui5._"].rank, 24);
@@ -2984,7 +3006,8 @@ sap.ui.define([
 			assert.strictEqual(_Helper.hasPrivateAnnotation(aSpliced[2], "expanding"), bStale,
 				"deleted only if not stale");
 			assert.notOk("rank" in aSpliced[3]["@$ui5._"]);
-			assert.strictEqual(aSpliced[4]["@$ui5.node.level"], 0, "unchanged");
+			assert.strictEqual(aSpliced[4]["@$ui5.node.level"], 6);
+			assert.strictEqual(aSpliced[4]["@$ui5._"].rank, 57);
 			assert.strictEqual(oCache.aElements[200002], aSpliced[200000]);
 			assert.strictEqual(aSpliced[200000]["@$ui5.node.level"], 6);
 			assert.strictEqual(aSpliced[200000]["@$ui5._"].rank, 200023);
@@ -2994,10 +3017,10 @@ sap.ui.define([
 			assert.strictEqual(oCache.aElements[200004], aElements[3]);
 
 			assert.deepEqual(oCache.aElements.$byPredicate, bStale ? {} : {
-				"('A')" : aSpliced[0],
 				"('C')" : aSpliced[2],
 				"('created')" : aSpliced[3],
 				"($uid=1-23)" : aSpliced[3],
+				"('A')" : aSpliced[4],
 				"('D')" : aSpliced[200000]
 			});
 		});
@@ -3213,7 +3236,8 @@ sap.ui.define([
 					collapsed : oCollapsed,
 					predicate : "('1')",
 					rank : "~rank~"
-				}
+				},
+				"@$ui5.node.level" : "~level~"
 			}, {
 				"@$ui5._" : {predicate : "('2')", transientPredicate : "($uid=1-23)"}
 			}, {
@@ -3232,6 +3256,7 @@ sap.ui.define([
 					rank : "~rank~"
 				},
 				"@$ui5.node.isExpanded" : false,
+				"@$ui5.node.level" : "~level~",
 				A : "10" // placeholder for an aggregate with subtotals
 			}, {
 				"@$ui5._" : {predicate : "('4')"}
@@ -3288,6 +3313,7 @@ sap.ui.define([
 				"('1')" : aElements[1],
 				"('4')" : aElements[4]
 			});
+		assert.strictEqual(aElements[1]["@$ui5._"].spliced.$level, "~level~");
 		assert.strictEqual(aElements[1]["@$ui5._"].spliced.$rank, "~rank~");
 	});
 	});
@@ -4572,7 +4598,7 @@ new parent was expanded before = ${bSpliced}, make root = ${bMakeRoot}`;
 
 		assert.strictEqual(oSyncPromise.isPending(), true);
 
-		return oSyncPromise.then(function (iResult) {
+		return oSyncPromise.then(function ([iResult]) {
 				assert.strictEqual(iResult, !bParentIsLeaf ? "~iResult~" : 1);
 				assert.deepEqual(oCache.aElements, bParentIsLeaf
 					 ? ["a", "~oOldParent~", "d", "e", "f", "g", oParentNode, oChildNode, "i"]
@@ -4690,6 +4716,8 @@ make root = ${bMakeRoot}`;
 	}
 
 	QUnit.test(sTitle, async function (assert) {
+		var oUpdateExistingExpectation;
+
 		const oCache = _AggregationCache.create(this.oRequestor, "n/a", "", {}, {
 				$ParentNavigationProperty : "myParent",
 				expandTo : Number.MAX_SAFE_INTEGER,
@@ -4699,8 +4727,9 @@ make root = ${bMakeRoot}`;
 			"@$ui5.node.isExpanded" : bNewParentExpanded,
 			"@$ui5.node.level" : 9
 		};
+		// Note: oParentNode's index in aElements MUST not matter!
 		oCache.aElements
-			= ["a", "~oOldParent~", "~oChildNode~", "d", "e", "f", "g", oParentNode, "i"];
+			= ["a", "~oOldParent~", "~oChildNode~", "d", "e", "f", "g", "h", "i"];
 		oCache.aElements.$byPredicate = {
 			"('23')" : "~oChildNode~",
 			"('42')" : oParentNode
@@ -4721,9 +4750,12 @@ make root = ${bMakeRoot}`;
 				}, {"myParent@odata.bind" : bMakeRoot ? null : "Foo('42')"},
 				/*fnSubmit*/null, /*fnCancel*/sinon.match.func)
 			.resolves({"@odata.etag" : "etag"});
-		const oUpdateExistingExpectation = oHelperMock.expects("updateExisting")
-			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('23')", "~oChildNode~",
-				{"@odata.etag" : "etag", "@$ui5.node.level" : bMakeRoot ? 1 : 10});
+		oCacheMock.expects("expand").exactly(bNewParentExpanded === false ? 1 : 0)
+			.withExactArgs(_GroupLock.$cached, "('42')").returns(SyncPromise.resolve(47));
+		oHelperMock.expects("updateAll")
+			.exactly(oParentNode && bNewParentExpanded === undefined ? 1 : 0)
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('42')",
+				sinon.match.same(oParentNode), {"@$ui5.node.isExpanded" : true});
 		oHelperMock.expects("getPrivateAnnotation")
 			.withExactArgs("~oChildNode~", "descendants", 0).returns(4);
 		oCacheMock.expects("adjustDescendantCount")
@@ -4731,48 +4763,40 @@ make root = ${bMakeRoot}`;
 			.callsFake(function () {
 				assert.notOk(oUpdateExistingExpectation.called, "old level needed!");
 				assert.deepEqual(oCache.aElements,
-					["a", "~oOldParent~", "~oChildNode~", "d", "e", "f", "g", oParentNode, "i"],
-					"not spliced yet");
-			});
-		oCacheMock.expects("shiftRank").withExactArgs(2, -(4 + 1))
-			.callsFake(function () {
-				assert.deepEqual(oCache.aElements,
-					["a", "~oOldParent~", "~oChildNode~", "d", "e", "f", "g", oParentNode, "i"],
+					["a", "~oOldParent~", "~oChildNode~", "d", "e", "f", "g", "h", "i"],
 					"not spliced yet");
 			});
 		oHelperMock.expects("getPrivateAnnotation")
 			.withExactArgs("~oChildNode~", "rank").returns("~rank~");
+		const oShiftRankForMoveExpectation = oCacheMock.expects("shiftRankForMove")
+			.withExactArgs("~rank~", 4 + 1, 17);
 		this.mock(oCache.oFirstLevel).expects("move").withExactArgs("~rank~", 17, 4 + 1);
-		const oSetRankExpectation = oHelperMock.expects("setPrivateAnnotation")
-			.withExactArgs("~oChildNode~", "rank", 17);
-		oCacheMock.expects("expand").exactly(bNewParentExpanded === false ? 1 : 0)
-			.withExactArgs(_GroupLock.$cached, "('42')").returns(SyncPromise.resolve(47));
-		oCacheMock.expects("shiftRank").withExactArgs(7, +(4 + 1))
-			.callsFake(function () {
-				assert.ok(oSetRankExpectation.called, "new rank needed");
-				assert.deepEqual(oCache.aElements,
-					["a", "~oOldParent~", "d", "e", "f", "g", oParentNode, "~oChildNode~", "i"],
-					"already moved");
+		oUpdateExistingExpectation = oHelperMock.expects("updateExisting")
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('23')", "~oChildNode~", {
+				"@odata.etag" : "etag",
+				"@$ui5.node.level" : bMakeRoot ? 1 : 10,
+				"@$ui5.context.isTransient" : undefined
 			});
+		oHelperMock.expects("setPrivateAnnotation").withExactArgs("~oChildNode~", "rank", 17);
+		const oGetArrayIndexExpectation = oCacheMock.expects("getArrayIndex").withExactArgs(17)
+			.returns(7);
 		oCacheMock.expects("adjustDescendantCount")
 			.withExactArgs("~oChildNode~", 7, +(4 + 1))
 			.callsFake(function () {
 				assert.deepEqual(oCache.aElements,
-					["a", "~oOldParent~", "d", "e", "f", "g", oParentNode, "~oChildNode~", "i"],
+					["a", "~oOldParent~", "d", "e", "f", "g", "h", "~oChildNode~", "i"],
 					"already moved");
 			});
-		oHelperMock.expects("updateAll")
-			.exactly(oParentNode && bNewParentExpanded === undefined ? 1 : 0)
-			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('42')",
-				sinon.match.same(oParentNode), {"@$ui5.node.isExpanded" : true});
 
 		// code under test
-		const iResult
+		const [iResult, iNewIndex]
 			= await oCache.move("~oGroupLock~", "Foo('23')", bMakeRoot ? undefined : "Foo('42')");
 
 		assert.strictEqual(iResult, bNewParentExpanded === false ? 47 + 1 : 1);
+		assert.strictEqual(iNewIndex, 7);
 		assert.deepEqual(oCache.aElements,
-			["a", "~oOldParent~", "d", "e", "f", "g", oParentNode, "~oChildNode~", "i"]);
+			["a", "~oOldParent~", "d", "e", "f", "g", "h", "~oChildNode~", "i"]);
+		assert.ok(oShiftRankForMoveExpectation.calledBefore(oGetArrayIndexExpectation));
 	});
 	});
 });
@@ -4873,7 +4897,7 @@ make root = ${bMakeRoot}`;
 								return Promise.resolve("~iRank~");
 							});
 						oNodeExpectation = that.mock(oCache).expects("requestNodeProperty")
-							.withExactArgs(sinon.match.same(oEntityData), "~oGroupLock~")
+							.withExactArgs(sinon.match.same(oEntityData), "~oGroupLock~", true)
 							.returns(new Promise(function (resolve0) {
 								setTimeout(function () {
 									bNodePropertyCompleted = true;
@@ -5137,39 +5161,97 @@ make root = ${bMakeRoot}`;
 	});
 });
 
+	//*********************************************************************************************
+	QUnit.test("shiftRankForMove", function (assert) {
+		const oCache = _AggregationCache.create(this.oRequestor, "Foo", "", {}, {
+			hierarchyQualifier : "X"
+		});
+
+		function setup(aRanks) {
+			return aRanks.map(function (iRank) {
+				return {"@$ui5._" : {rank : iRank}};
+			});
+		}
+
+		// Note: order does not really matter
+		// "The subtree itself is unaffected and may, but need not be present."
+		// 2: subtree's root node, 3: missing, 4: part of subtree
+		oCache.aElements = setup([0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11]);
+
+		function expect(aExpectedRanks) {
+			assert.deepEqual(
+				oCache.aElements.map((oElement) => oElement["@$ui5._"].rank),
+				aExpectedRanks
+			);
+		}
+
+		// code under test
+		oCache.shiftRankForMove(2, 3, 2);
+
+		expect([0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11]);
+
+		// code under test
+		oCache.shiftRankForMove(2, 3, 7);
+
+		expect([0, 1, 2, 4, 5 - 3, 6 - 3, 7 - 3, 8 - 3, 9 - 3, 10, 11]);
+
+		// 7: subtree's root node, 8: missing, 9: part of subtree
+		oCache.aElements = setup([0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11]);
+
+		// code under test
+		oCache.shiftRankForMove(7, 3, 2);
+
+		expect([0, 1, 2 + 3, 3 + 3, 4 + 3, 5 + 3, 6 + 3, 7, 9, 10, 11]);
+	});
+
 	//*********************************************************************************************
 [true, false].forEach((bInheritResult) => {
-	QUnit.test("requestProperties: bInheritResult = " + bInheritResult, async function (assert) {
+	[true, false].forEach((bDropFilter) => {
+		const sTitle = "requestProperties: bInheritResult = " + bInheritResult
+			+ ", bDropFilter = " + bDropFilter;
+
+	QUnit.test(sTitle, async function (assert) {
 		const oCache = _AggregationCache.create(this.oRequestor, "Foo", "", {}, {
 			hierarchyQualifier : "X",
-			$LimitedRank : "~LimitedRank~",
-			$metaPath : "/meta/path"
+			$LimitedRank : "~LimitedRank~"
 		});
-		const oParentCache = {getQueryOptions : mustBeMocked};
+		const oParentCache = {
+			$parentFilter : "~parentFilter~",
+			getQueryOptions : mustBeMocked
+		};
 		const aSelect = ["path/to/property0", "path/to/property1"];
 		const oHelperMock = this.mock(_Helper);
 		oHelperMock.expects("getPrivateAnnotation").withExactArgs("~oElement~", "parent")
 			.returns(oParentCache);
-		this.mock(oParentCache).expects("getQueryOptions").withExactArgs()
+		this.mock(oParentCache).expects("getQueryOptions").exactly(bDropFilter ? 0 : 1)
+			.withExactArgs()
+			// Note: buildApply4Hierarchy has already removed $$filterBeforeAggregate, $filter,
+			// and $orderby and integrated these into $apply!
 			.returns({
-				$$filterBeforeAggregate : "n/a",
 				$apply : "A.P.P.L.E.",
 				$count : "n/a",
 				$expand : "n/a",
-				$filter : "n/a",
-				$orderby : "n/a",
-				$search : "n/a",
 				$select : ["n/a"],
 				foo : "bar",
 				"sap-client" : "123"
 			});
 		this.mock(oCache).expects("getTypes").withExactArgs().returns("~getTypes~");
+		this.mock(_AggregationHelper).expects("dropFilter").exactly(bDropFilter ? 1 : 0)
+			.withExactArgs(sinon.match.same(oCache.oAggregation),
+				sinon.match.same(oCache.mQueryOptions), "~parentFilter~")
+			.returns({
+				$apply : "A.P.P.L.E.",
+				foo : "bar",
+				"sap-client" : "123"
+			});
 		oHelperMock.expects("getKeyFilter")
-			.withExactArgs("~oElement~", "/meta/path", "~getTypes~").returns("~filter~");
+			.withExactArgs("~oElement~", "/Foo", "~getTypes~").returns("~filter~");
 		this.mock(oCache.oRequestor).expects("buildQueryString")
-			.withExactArgs("/meta/path", {
+			.withExactArgs("/Foo", {
 				$apply : "A.P.P.L.E.",
-				$filter : "~filter~"
+				$filter : "~filter~",
+				foo : "bar",
+				"sap-client" : "123"
 			}, false, true)
 			.returns("~queryString~");
 		const oGroupLock = {getUnlockedCopy : mustBeMocked};
@@ -5177,7 +5259,7 @@ make root = ${bMakeRoot}`;
 			.returns("~oGroupLockCopy~");
 		this.mock(oCache.oRequestor).expects("request")
 			.withExactArgs("GET", "Foo~queryString~", "~oGroupLockCopy~", undefined, undefined,
-				undefined, undefined, "/meta/path", undefined, false, {$select : aSelect},
+				undefined, undefined, "/Foo", undefined, false, {$select : aSelect},
 				sinon.match.same(oCache))
 			.resolves({
 				"@odata.context" : "n/a",
@@ -5194,8 +5276,10 @@ make root = ${bMakeRoot}`;
 
 		assert.strictEqual(
 			// code under test
-			await oCache.requestProperties("~oElement~", aSelect, oGroupLock, bInheritResult),
-				bInheritResult ? undefined : "~oResult~");
+			await oCache
+				.requestProperties("~oElement~", aSelect, oGroupLock, bInheritResult, bDropFilter),
+			bInheritResult ? undefined : "~oResult~");
+	});
 	});
 });
 
@@ -5226,12 +5310,12 @@ make root = ${bMakeRoot}`;
 		this.mock(_Helper).expects("drillDown").withExactArgs("~oElement~", "path/to/NodeID")
 			.returns(undefined);
 		this.mock(oCache).expects("requestProperties")
-			.withExactArgs("~oElement~", ["path/to/NodeID"], "~oGroupLock~", true)
+			.withExactArgs("~oElement~", ["path/to/NodeID"], "~oGroupLock~", true, "~bDropFilter~")
 			.resolves(undefined);
 
 		assert.strictEqual(
 			// code under test
-			await oCache.requestNodeProperty("~oElement~", "~oGroupLock~"),
+			await oCache.requestNodeProperty("~oElement~", "~oGroupLock~", "~bDropFilter~"),
 			undefined, "without a defined result");
 	});
 
@@ -5248,7 +5332,7 @@ make root = ${bMakeRoot}`;
 
 		assert.strictEqual(
 			// code under test
-			await oCache.requestNodeProperty("~oElement~", "~oGroupLock~"),
+			await oCache.requestNodeProperty("~oElement~", "~oGroupLock~", "n/a"),
 			undefined, "without a defined result");
 	});
 
@@ -5293,6 +5377,8 @@ make root = ${bMakeRoot}`;
 				"If-Match" : sinon.match.same(oElement)
 			})
 			.callsFake(() => {
+				this.mock(oCache.oTreeState).expects("delete")
+					.withExactArgs(sinon.match.same(oElement));
 				this.mock(_Cache).expects("getElementIndex")
 					.withExactArgs(sinon.match.same(oCache.aElements), "~predicate~", 2)
 					.returns(4);
@@ -5593,18 +5679,16 @@ make root = ${bMakeRoot}`;
 	});
 
 	//*********************************************************************************************
-	QUnit.test("handleOutOfPlaceNodes", function () {
+	QUnit.test("handleOutOfPlaceNodes", function (assert) {
 		const oCache = _AggregationCache.create(this.oRequestor, "Foo", "", {}, {
 			hierarchyQualifier : "X",
+			$DrillState : "~DrillState~",
 			$LimitedRank : "~LimitedRank~"
 		});
-		oCache.aElements.$byPredicate = {
-			"~predicate2~" : "~node2~",
-			"~predicate4~" : "~node4~"
-		};
+		oCache.aElements.$byPredicate = {"~predicate2~" : "~node2~"};
 		const oRankResult = {
 			value : ["~parent1RankResult~", "~node2RankResult~", "~node3RankResult~",
-				"~node1RankResult~", "~parent2RankResult~", "~node4RankResult~"]
+				"~node1RankResult~", "~parent2RankResult~"]
 		};
 		const oOutOfPlaceNodeResult1 = {
 			value : ["~node1Data~", "~node2Data~"]
@@ -5615,9 +5699,13 @@ make root = ${bMakeRoot}`;
 		const oOutOfPlaceNodeResult3 = {
 			value : ["~node4Data~"]
 		};
+		const oOutOfPlaceNodeResult4 = {
+			value : ["~node5Data~"]
+		};
 		const oCacheMock = this.mock(oCache);
 		const oFirstLevelMock = this.mock(oCache.oFirstLevel);
 		const oHelperMock = this.mock(_Helper);
+		const oTreeStateMock = this.mock(oCache.oTreeState);
 
 		oCacheMock.expects("getTypes").atLeast(1).withExactArgs().returns("~types~");
 		// oRankResult
@@ -5636,12 +5724,26 @@ make root = ${bMakeRoot}`;
 		oHelperMock.expects("getKeyPredicate")
 			.withExactArgs("~parent2RankResult~", "/Foo", "~types~")
 			.returns("~parent2Predicate~");
-		oHelperMock.expects("getKeyPredicate")
-			.withExactArgs("~node4RankResult~", "/Foo", "~types~")
-			.returns("~predicate4~");
+
+		oTreeStateMock.expects("getOutOfPlacePredicates").withExactArgs()
+			.returns(["~predicate1~", "~predicate2~", "~predicate3~", "~predicate4~",
+				"~predicate5~", "~predicate6NowInPlace~", "~predicate7NowInPlace~"]);
+
+		// parent1
+		//   node1
+		//   node2
+		// node3
+		// parent2 (collapsed)
+		//   node4 (no rank)
+		//     node5 (no rank)
+
 		// "~node1Data~"
 		oHelperMock.expects("getKeyPredicate").withExactArgs("~node1Data~", "/Foo", "~types~")
 			.returns("~predicate1~");
+		oTreeStateMock.expects("getOutOfPlace").withExactArgs("~predicate1~")
+			.returns({parentPredicate : "~parent1Predicate~"});
+		oHelperMock.expects("drillDown").withExactArgs("~parent1RankResult~", "~DrillState~")
+			.returns("expanded");
 		oHelperMock.expects("merge").withExactArgs("~node1Data~", "~node1RankResult~");
 		oHelperMock.expects("drillDown").withExactArgs("~node1Data~", "~LimitedRank~").returns("4");
 		oFirstLevelMock.expects("calculateKeyPredicate")
@@ -5650,12 +5752,14 @@ make root = ${bMakeRoot}`;
 			.callsFake(function () {
 				oCache.aElements.$byPredicate["~predicate1~"] = "~node1Data~";
 			});
-		// "~node2Data~"
+		// "~node2Data~": already in $byPredicate
 		oHelperMock.expects("getKeyPredicate").withExactArgs("~node2Data~", "/Foo", "~types~")
 			.returns("~predicate2~");
 		// "~node3Data~"
 		oHelperMock.expects("getKeyPredicate").withExactArgs("~node3Data~", "/Foo", "~types~")
 			.returns("~predicate3~");
+		oTreeStateMock.expects("getOutOfPlace").withExactArgs("~predicate3~")
+			.returns({/*no parentPredicate*/});
 		oHelperMock.expects("merge").withExactArgs("~node3Data~", "~node3RankResult~");
 		oHelperMock.expects("drillDown").withExactArgs("~node3Data~", "~LimitedRank~").returns("5");
 		oFirstLevelMock.expects("calculateKeyPredicate")
@@ -5664,11 +5768,27 @@ make root = ${bMakeRoot}`;
 			.callsFake(function () {
 				oCache.aElements.$byPredicate["~predicate3~"] = "~node3Data~";
 			});
-		// "~node4Data~"
+		// "~node4Data~": parent is collapsed
 		oHelperMock.expects("getKeyPredicate").withExactArgs("~node4Data~", "/Foo", "~types~")
 			.returns("~predicate4~");
+		oTreeStateMock.expects("getOutOfPlace").withExactArgs("~predicate4~")
+			.returns({parentPredicate : "~parent2Predicate~"});
+		oHelperMock.expects("drillDown").withExactArgs("~parent2RankResult~", "~DrillState~")
+			.returns("collapsed");
+		// "~node5Data~": below node4 (no rank)
+		oHelperMock.expects("getKeyPredicate").withExactArgs("~node5Data~", "/Foo", "~types~")
+			.returns("~predicate5~");
+		oTreeStateMock.expects("getOutOfPlace").withExactArgs("~predicate5~")
+			.returns({parentPredicate : "~predicate4~"});
+
+		const oDeleteOutOfPlace6Expectation = oTreeStateMock.expects("deleteOutOfPlace")
+			.withExactArgs("~predicate6NowInPlace~");
+		const oDeleteOutOfPlace7Expectation = oTreeStateMock.expects("deleteOutOfPlace")
+			.withExactArgs("~predicate7NowInPlace~");
+
 		// move nodes
-		this.mock(oCache.oTreeState).expects("getOutOfPlaceGroupedByParent").withExactArgs()
+		const oOutOfPlaceGroupedByParentExpectation = oTreeStateMock
+			.expects("getOutOfPlaceGroupedByParent").withExactArgs()
 			.returns([{
 				nodePredicates : "~parent1NodePredicates~",
 				parentPredicate : "~parent1Predicate~"
@@ -5687,8 +5807,13 @@ make root = ${bMakeRoot}`;
 		oCacheMock.expects("moveOutOfPlaceNodes").withExactArgs(undefined, "~rootNodePredicates~");
 
 		// code under test
-		oCache.handleOutOfPlaceNodes(
-			[oRankResult, oOutOfPlaceNodeResult1, oOutOfPlaceNodeResult2, oOutOfPlaceNodeResult3]);
+		oCache.handleOutOfPlaceNodes([oRankResult, oOutOfPlaceNodeResult1, oOutOfPlaceNodeResult2,
+			oOutOfPlaceNodeResult3, oOutOfPlaceNodeResult4]);
+
+		assert.ok(oDeleteOutOfPlace6Expectation
+			.calledBefore(oOutOfPlaceGroupedByParentExpectation));
+		assert.ok(oDeleteOutOfPlace7Expectation
+			.calledBefore(oOutOfPlaceGroupedByParentExpectation));
 	});
 
 	//*********************************************************************************************
@@ -5739,11 +5864,13 @@ make root = ${bMakeRoot}`;
 			hierarchyQualifier : "X",
 			$LimitedRank : "~LimitedRank~"
 		});
-		oCache.aElements = ["~foo~", "~parent~", "~node2~", "~bar~", "~node1~", "~node3~"];
+		const oNode3 = {"@$ui5.node.isExpanded" : true};
+		oCache.aElements
+			= ["~foo~", "~parent~", "~node2~", "~bar~", "~node1~", oNode3, "~node4~"];
 		oCache.aElements.$byPredicate = {
 			"~predicate1~" : "~node1~",
 			"~predicate2~" : "~node2~",
-			"~predicate3~" : "~node3~"
+			"~predicate3~" : oNode3
 		};
 
 		const oHelperMock = this.mock(_Helper);
@@ -5751,15 +5878,26 @@ make root = ${bMakeRoot}`;
 			.returns(0);
 		oHelperMock.expects("getPrivateAnnotation").withExactArgs("~parent~", "rank")
 			.returns("~iParentRank~");
+		this.mock(oCache).expects("collapse").withExactArgs("~predicate3~")
+			.callsFake(function () {
+				assert.strictEqual(oCache.aElements.indexOf(oNode3), 5, "not yet moved");
+			});
+		this.mock(oCache).expects("expand")
+			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~predicate3~")
+			.callsFake(function () {
+				assert.strictEqual(oCache.aElements.indexOf(oNode3), 2,
+					"moved immediately behind parent (snapshot)");
+			});
 
 		// code under test
 		oCache.moveOutOfPlaceNodes("~iParentRank~",
 			// the order is important: node2 is not moved, moving node3 shifts the location of
 			// node1 which must be searched again (aElements.indexOf(...))
-			["~predicate2~", "~predicate3~", "~predicate1~"]);
+			// node4 has changed its parent
+			["~predicate2~", "~predicate3~", "~predicate4~", "~predicate1~"]);
 
 		assert.deepEqual(oCache.aElements,
-			["~foo~", "~parent~", "~node1~", "~node3~", "~node2~", "~bar~"]);
+			["~foo~", "~parent~", "~node1~", oNode3, "~node2~", "~bar~", "~node4~"]);
 	});
 
 	//*********************************************************************************************