function expectVisitAndRefresh(aPromises) {
			that.mock(oBinding).expects("visitSideEffects").withExactArgs(sGroupId,
					sinon.match.same(aPaths), bHeader ? undefined : oContext, aPromises)
				.callsFake(function (_sGroupId, _aPaths, _oContext, aPromises0) {
					aPromises0.push(Promise.resolve());
					aPromises0.push(Promise.reject(oCanceledError));
					if (bRecursionRejects) {
						aPromises0.push(Promise.reject(oError));
					}
				});
			that.mock(oBinding).expects("refreshDependentListBindingsWithoutCache")
				.exactly(bRecursionRejects ? 0 : 1).withExactArgs().resolves("~");
		}
******************************************************************************************
[false, true].forEach(function (bHeader) {
	QUnit.test("requestSideEffects: deleting in other group, " + bHeader, function (assert) {
		var oCacheMock = this.getCacheMock(), // must be called before creating the binding
			oBinding = bindList(this, "/Set"),
			oContext = bHeader ? oBinding.getHeaderContext() : undefined;

		this.mock(_Helper).expects("isDataAggregation").withExactArgs(oBinding.mParameters)
			.returns(false);
		this.mock(_AggregationHelper).expects("isAffected").never();
		oCacheMock.expects("isDeletingInOtherGroup").withExactArgs("group").returns(true);
		oCacheMock.expects("getPendingRequestsPromise").never();
		oCacheMock.expects("requestSideEffects").never();
		this.mock(oBinding).expects("refreshSingle").never();

		// code under test
		assert.throws(function () {
			oBinding.requestSideEffects("group", ["n/a", ""], oContext);
		}, new Error("Must not request side effects when there is a pending delete in a different "
			+ "batch group"));
	});
});

	//*********************************************************************************************
	QUnit.test("requestSideEffects: wait for getPendingRequestsPromise()", function (assert) {
		var oCacheMock = this.getCacheMock(), // must be called before creating the binding
			oBinding = bindList(this, "/Set"),
			fnResolve,
			oPendingRequestsPromise = new Promise(function (resolve) {
				fnResolve = resolve;
			}),
			oPromise;

		this.mock(_Helper).expects("isDataAggregation").withExactArgs(oBinding.mParameters)
			.returns(false);
		this.mock(_AggregationHelper).expects("isAffected").never();
		oCacheMock.expects("isDeletingInOtherGroup").never();
		oCacheMock.expects("getPendingRequestsPromise").twice().withExactArgs()
			.returns(oPendingRequestsPromise);

		// code under test
		oPromise = oBinding.requestSideEffects("group", ["A"], "~oContext~");

		assert.strictEqual(oPromise.isPending(), true);

		this.mock(oBinding).expects("requestSideEffects")
			.withExactArgs("group", ["A"], "~oContext~").returns("~result~");

		// code under test
		fnResolve();

		return oPromise.then(function (vResult) {
			assert.strictEqual(vResult, "~result~");
		});
	});

	//*********************************************************************************************
	QUnit.test("requestSideEffects: call refreshInternal for relative binding", function (assert) {
		var oBinding = bindList(this, "relative", this.oModel.createBindingContext("/")),
			oContext = oBinding.getHeaderContext(),
			oResult = {};

		oBinding.iCurrentEnd = 42;
		this.mock(oBinding).expects("refreshSingle").never();
		this.mock(oBinding).expects("refreshInternal").withExactArgs("", "group", false, true)
			.resolves(oResult);

		// code under test
		return oBinding.requestSideEffects("group", [""], oContext).then(function (oResult0) {
			assert.strictEqual(oResult0, oResult);
		});
	});

	//*********************************************************************************************
	QUnit.test("requestSideEffects: call refreshSingle for relative binding", function (assert) {
		var oBinding = bindList(this, "relative", this.oModel.createBindingContext("/")),
			oContext = Context.create(this.oModel, {}, "/EMPLOYEES('42')"),
			oGroupLock = {},
			oResult = {};

		this.mock(this.oModel).expects("withUnresolvedBindings")
			.withExactArgs("removeCachesAndMessages", "EMPLOYEES('42')");
		this.mock(oBinding).expects("lockGroup").withExactArgs("group").returns(oGroupLock);
		this.mock(oBinding).expects("refreshSingle")
			.withExactArgs(sinon.match.same(oContext), sinon.match.same(oGroupLock),
				/*bAllowRemoval