function reset() {
			iResets += 1;
		}
******************************************************************************************
	QUnit.test("attachPatchCompleted/detachPatchCompleted", function (assert) {
		var oBinding = new ODataParentBinding({
				attachEvent : function () {},
				detachEvent : function () {}
			}),
			oBindingMock = this.mock(oBinding);

		oBindingMock.expects("attachEvent")
			.withExactArgs("patchCompleted", "~function~", "~listener~")
			.returns(oBinding);

		// code under test
		assert.strictEqual(oBinding.attachPatchCompleted("~function~", "~listener~"), oBinding);

		oBindingMock.expects("detachEvent")
			.withExactArgs("patchCompleted", "~function~", "~listener~")
			.returns(oBinding);

		// code under test
		assert.strictEqual(oBinding.detachPatchCompleted("~function~", "~listener~"), oBinding);
	});

	//*********************************************************************************************
	QUnit.test("attachPatchSent/detachPatchSent", function (assert) {
		var oBinding = new ODataParentBinding({
				attachEvent : function () {},
				detachEvent : function () {}
			}),
			oBindingMock = this.mock(oBinding);

		oBindingMock.expects("attachEvent")
			.withExactArgs("patchSent", "~function~", "~listener~")
			.returns(oBinding);

		// code under test
		assert.strictEqual(oBinding.attachPatchSent("~function~", "~listener~"), oBinding);

		oBindingMock.expects("detachEvent")
			.withExactArgs("patchSent", "~function~", "~listener~")
			.returns(oBinding);

		// code under test
		assert.strictEqual(oBinding.detachPatchSent("~function~", "~listener~"), oBinding);
	});

	//*********************************************************************************************
	QUnit.test("firePatchSent/firePatchCompleted", function (assert) {
		var oBinding = new ODataParentBinding({
				fireEvent : function () {}
			}),
			oBindingMock = this.mock(oBinding);

		oBindingMock.expects("fireEvent").withExactArgs("patchSent");

		// code under test
		oBinding.firePatchSent();

		// if there is a sequence of firePatchSent calls, the event is fired only for the first call
		// code under test
		oBinding.firePatchSent();

		// code under test
		oBinding.firePatchSent();

		// firePatchCompleted invokes a patchCompleted event only if firePatchCompleted is called
		// as often as firePatchSent
		// code under test
		oBinding.firePatchCompleted(true);

		// code under test
		oBinding.firePatchCompleted(true);

		oBindingMock.expects("fireEvent").withExactArgs("patchCompleted", {success : true});

		// code under test
		oBinding.firePatchCompleted(true);

		// code under test
		assert.throws(function () {
			oBinding.firePatchCompleted();
		}, new Error("Completed more PATCH requests than sent"));

		oBindingMock.expects("fireEvent").withExactArgs("patchSent");

		// code under test
		oBinding.firePatchSent();

		// code under test
		oBinding.firePatchSent();

		// if at least one PATCH failed patchCompleted event is fired with success = false
		// code under test
		oBinding.firePatchCompleted(false);

		oBindingMock.expects("fireEvent").withExactArgs("patchCompleted", {success : false});

		// code under test
		oBinding.firePatchCompleted(true);

		oBindingMock.expects("fireEvent").withExactArgs("patchSent");

		// code under test - bPatchSuccess is reset after patchCompleted event is fired
		oBinding.firePatchSent();

		oBindingMock.expects("fireEvent").withExactArgs("patchCompleted", {success : true});

		// code under test - bPatchSuccess is reset after patchCompleted event is fired
		oBinding.firePatchCompleted(true);
	});

	//*********************************************************************************************
	QUnit.test("destroy", function (assert) {
		var oBinding = new ODataParentBinding();

		oBinding.aChildCanUseCachePromises = [{}, {}];
		oBinding.mChildPathsReducedToParent = "~mChildPathsReducedToParent~";
		oBinding.oResumePromise = {};
		this.mock(oBinding).expects("removeReadGroupLock").withExactArgs();
		this.mock(asODataBinding.prototype).expects("destroy").on(oBinding).withExactArgs();

		// code under test
		oBinding.destroy();

		assert.strictEqual(oBinding.mAggregatedQueryOptions, undefined);
		assert.deepEqual(oBinding.aChildCanUseCachePromises, []);
		assert.deepEqual(oBinding.mChildPathsReducedToParent, {});
		assert.strictEqual(oBinding.oRefreshPromise, undefined);
		assert.strictEqual(oBinding.oResumePromise, undefined);
		assert.strictEqual(oBinding.mCanUseCachePromiseByChildPath, undefined);
	});

	//*********************************************************************************************
[false, true].forEach(function (bCanceled) {
	var sTitle = "createRefreshPromise/resolveRefreshPromise, canceled=" + bCanceled;

	QUnit.test(sTitle, function (assert) {
		var oBinding = new ODataParentBinding(),
			oError = new Error(),
			oErrorPromise = Promise.reject(oError),
			oRefreshPromise;

		oError.canceled = bCanceled;

		// code under test
		assert.notOk(oBinding.isRefreshWithoutBubbling());

		// code under test
		oRefreshPromise = oBinding.createRefreshPromise("~bPreventBubbling~");

		assert.strictEqual(oRefreshPromise, oBinding.oRefreshPromise);
		assert.strictEqual(oBinding.isRefreshWithoutBubbling(), "~bPreventBubbling~");

		// code under test
		assert.strictEqual(oBinding.resolveRefreshPromise(oErrorPromise), oErrorPromise);

		assert.strictEqual(oBinding.oRefreshPromise, null);
		assert.notOk(oBinding.isRefreshWithoutBubbling());

		// code under test
		assert.strictEqual(oBinding.resolveRefreshPromise("~n/a~"), "~n/a~");

		return oRefreshPromise.then(function () {
			assert.ok(bCanceled);
		}, function (oResult) {
			assert.notOk(bCanceled);
			assert.strictEqual(oResult, oError);
		});
	});
});

	//*********************************************************************************************
[undefined, "/Foo/1"].forEach(function (sPathPrefix) {
	[false, true].forEach(function (bIgnoreKeptAlive) {
	var sTitle = "hasPendingChangesInDependents: bIgnoreKeptAlive = " + bIgnoreKeptAlive
		+ " sPathPrefix = " + sPathPrefix;

	QUnit.test(sTitle, function (assert) {
		var oCache1 = {
				hasPendingChangesForPath : function () {}
			},
			oCache3_1 = {
				hasPendingChangesForPath : function () {}
			},
			oCache3_2 = {
				hasPendingChangesForPath : function () {}
			},
			oCache4 = {
				hasPendingChangesForPath : function () {}
			},
			oCache5 = {
				hasPendingChangesForPath : function () {}
			},
			oContext = {
				getIndex : function () { return undefined; },
				isEffectivelyKeptAlive : function () { return false; }
			},
			oContextWithIndex = {
				getIndex : function () { return 0; },
				isEffectivelyKeptAlive : function () { return false; }
			},
			oChild1 = new ODataParentBinding({
				oCache : oCache1,
				mCacheByResourcePath : {
					"Foo/1" : oCache1
				},
				oContext : oContext,
				mParameters : {$$ownRequest : "~$$ownRequest~"}
			}),
			oChild2 = new ODataParentBinding({
				oCache : null,
				oContext : oContext
			}),
			oChild3 = new ODataParentBinding({
				mCacheByResourcePath : {
					"Foo/1" : oCache3_1,
					"Foo/2" : oCache3_2
				},
				oCache : undefined,
				oContext : oContext
			}),
			oChild4 = new ODataParentBinding({
				oCache : oCache4,
				oContext : oContextWithIndex,
				mParameters : {$$ownRequest : "~$$ownRequest~"}
			}),
			oChild5 = new ODataParentBinding({
				oCache : oCache5,
				oContext : oContext
				// no mParameters here, simulate ODPrB (see BCP: 2280060324)
			}),
			oBinding = new ODataParentBinding({
				oModel : {
					withUnresolvedBindings : function () {}
				}
			}),
			oCache1Mock = this.mock(oCache1),
			oCache3_1Mock = this.mock(oCache3_1),
			oCache3_2Mock = this.mock(oCache3_2),
			oCache4Mock = this.mock(oCache4),
			oCache5Mock = this.mock(oCache5),
			oChild1Mock = this.mock(oChild1),
			oChild2Mock = this.mock(oChild2),
			oChild3Mock = this.mock(oChild3),
			oChild4Mock = this.mock(oChild4),
			oChild5Mock = this.mock(oChild5),
			bIgnoreTransient = bIgnoreKeptAlive ? "~$$ownRequest~" : false,
			oModelMock = this.mock(oBinding.oModel);

		this.mock(oBinding).expects("getDependentBindings").exactly(9).withExactArgs()
			.returns([oChild1, oChild2, oChild3, oChild4, oChild5]); // for all C.U.T
		oModelMock.expects("withUnresolvedBindings").never(); // this is overridden at the end...
		// these are overridden by and by
		// BEWARE: cannot override #never via #atLeast, only #exactly seems to work :-(
		oCache1Mock.expects("hasPendingChangesForPath").never();
		oCache3_1Mock.expects("hasPendingChangesForPath").never();
		oCache3_2Mock.expects("hasPendingChangesForPath").never();
		oCache4Mock.expects("hasPendingChangesForPath").never();
		oCache5Mock.expects("hasPendingChangesForPath").never();
		oChild1Mock.expects("hasPendingChangesInDependents").never();
		oChild2Mock.expects("hasPendingChangesInDependents").never();
		oChild3Mock.expects("hasPendingChangesInDependents").never();
		oChild4Mock.expects("hasPendingChangesInDependents").never();
		oChild5Mock.expects("hasPendingChangesInDependents").never();

		oCache1Mock.expects("hasPendingChangesForPath").withExactArgs("", false, bIgnoreTransient)
			.returns(true);

		// code under test
		assert.strictEqual(
			oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive, sPathPrefix), true);

		oCache1Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, bIgnoreTransient).returns(false);
		oChild1Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(true);

		// code under test
		assert.strictEqual(
			oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive, sPathPrefix), true);

		oCache1Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, bIgnoreTransient).returns(false);
		oChild1Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild2Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(true);

		// code under test
		assert.strictEqual(
			oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive, sPathPrefix), true);

		oCache1Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, bIgnoreTransient).returns(false);
		oChild1Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild2Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild3Mock.expects("hasPendingChangesForPath").withExactArgs("").returns(true);

		// code under test
		assert.strictEqual(
			oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive, sPathPrefix), true);

		oCache1Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, bIgnoreTransient).returns(false);
		oChild1Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild2Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild3Mock.expects("hasPendingChangesForPath").withExactArgs("").returns(false);
		if (!sPathPrefix) {
			oCache3_1Mock.expects("hasPendingChangesForPath").withExactArgs("").returns(true);
		} else {
			if (sPathPrefix === "/Foo/1") {
				oCache3_1Mock.expects("hasPendingChangesForPath")
					.withExactArgs("").returns(false);
			}
			oChild3Mock.expects("hasPendingChangesInDependents")
				.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(true);
		}

		// code under test
		assert.strictEqual(
			oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive, sPathPrefix), true);

		oCache1Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, bIgnoreTransient).returns(false);
		oChild1Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild2Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild3Mock.expects("hasPendingChangesForPath").withExactArgs("").returns(false);
		if (!sPathPrefix) {
			oCache3_1Mock.expects("hasPendingChangesForPath")
				.withExactArgs("").returns(false);
			oCache3_2Mock.expects("hasPendingChangesForPath")
				.withExactArgs("").returns(true);
		} else {
			if (sPathPrefix === "/Foo/1") {
				oCache3_1Mock.expects("hasPendingChangesForPath")
					.withExactArgs("").returns(false);
			}
			oChild3Mock.expects("hasPendingChangesInDependents")
				.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(true);
		}

		// code under test
		assert.strictEqual(
			oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive, sPathPrefix), true);

		oCache1Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, bIgnoreTransient).returns(false);
		oChild1Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild2Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild3Mock.expects("hasPendingChangesForPath").withExactArgs("").returns(false);
		if (!sPathPrefix) {
			oCache3_1Mock.expects("hasPendingChangesForPath")
				.withExactArgs("").returns(false);
			oCache3_2Mock.expects("hasPendingChangesForPath")
				.withExactArgs("").returns(false);
		} else if (sPathPrefix === "/Foo/1") {
			oCache3_1Mock.expects("hasPendingChangesForPath")
				.withExactArgs("").returns(false);
		}
		oChild3Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(true);

		// code under test
		assert.strictEqual(
			oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive, sPathPrefix), true);

		oCache1Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, bIgnoreTransient).returns(false);
		oChild1Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild2Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild3Mock.expects("hasPendingChangesForPath").withExactArgs("").returns(false);
		if (!sPathPrefix) {
			oCache3_1Mock.expects("hasPendingChangesForPath").withExactArgs("").returns(false);
			oCache3_2Mock.expects("hasPendingChangesForPath").withExactArgs("").returns(false);
		} else if (sPathPrefix === "/Foo/1") {
			oCache3_1Mock.expects("hasPendingChangesForPath")
				.withExactArgs("").returns(false);
		}
		oChild3Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oCache4Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, false).returns(false);
		oChild4Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(false, sPathPrefix).returns(true);

		// code under test
		assert.strictEqual(
			oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive, sPathPrefix), true);

		oCache1Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, bIgnoreTransient).returns(false);
		oChild1Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild2Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oChild3Mock.expects("hasPendingChangesForPath").withExactArgs("").returns(false);
		if (!sPathPrefix) {
			oCache3_1Mock.expects("hasPendingChangesForPath")
				.withExactArgs("").returns(false);
			oCache3_2Mock.expects("hasPendingChangesForPath")
				.withExactArgs("").returns(false);
		} else if (sPathPrefix === "/Foo/1") {
			oCache3_1Mock.expects("hasPendingChangesForPath")
				.withExactArgs("").returns(false);
		}
		oChild3Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		oCache4Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, false).returns(false);
		oChild4Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(false, sPathPrefix).returns(false);
		oCache5Mock.expects("hasPendingChangesForPath")
			.withExactArgs("", false, bIgnoreKeptAlive ? undefined : false).returns(false);
		oChild5Mock.expects("hasPendingChangesInDependents")
			.withExactArgs(bIgnoreKeptAlive, sPathPrefix).returns(false);
		this.mock(oBinding).expects("getResolvedPath").withExactArgs()
			.returns("/some/absolute/path");
		oModelMock.expects("withUnresolvedBindings")
			.withExactArgs("hasPendingChangesInCaches", "some/absolute/path").returns("~bResult~");

		// code under test
		assert.strictEqual(
			oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive, sPathPrefix),
			"~bResult~");
	});
});
});

	//*********************************************************************************************
[false, true].forEach(function (bIgnoreKeptAlive) {
	var sTitle = "hasPendingChangesInDependents:setKeepAlive = " + bIgnoreKeptAlive;

	QUnit.test(sTitle, function (assert) {
		var oContext0 = {
				getIndex : function () { return 1; },
				isEffectivelyKeptAlive : function () {}
			},
			oContext1 = {
				getIndex : function () { return 1; },
				isEffectivelyKeptAlive : function () {}
			},
			oContext2 = {
				getIndex : function () { return undefined; },
				isEffectivelyKeptAlive : function () {}
			},
			oChild0 = new ODataParentBinding({
				oCache : undefined,
				oContext : oContext0
			}),
			oChild1 = new ODataParentBinding({
				oCache : undefined,
				oContext : oContext1
			}),
			oChild2 = new ODataParentBinding({
				oCache : undefined,
				oContext : oContext2
			}),
			oBinding = new ODataParentBinding();

		this.mock(oBinding).expects("getDependentBindings").withExactArgs()
			.returns([oChild0, oChild1, oChild2]);
		this.mock(oChild0).expects("hasPendingChangesForPath").withExactArgs("").returns(false);
		this.mock(oChild0).expects("hasPendingChangesInDependents").withExactArgs(false, undefined)
			.returns(false);
		if (bIgnoreKeptAlive) {
			this.mock(oContext0).expects("isEffectivelyKeptAlive").withExactArgs().returns(false);
			this.mock(oContext1).expects("isEffectivelyKeptAlive").withExactArgs().returns(true);
			this.mock(oContext1).expects("getIndex").never();
			this.mock(oContext2).expects("isEffectivelyKeptAlive").withExactArgs().returns(false);
			this.mock(oChild1).expects("hasPendingChangesForPath").never();
			this.mock(oChild2).expects("hasPendingChangesForPath").withExactArgs("").returns(true);
		} else {
			this.mock(oContext0).expects("isEffectivelyKeptAlive").never();
			this.mock(oContext1).expects("isEffectivelyKeptAlive").never();
			this.mock(oContext2).expects("isEffectivelyKeptAlive").never();
			this.mock(oChild1).expects("hasPendingChangesForPath").withExactArgs("").returns(true);
			this.mock(oChild2).expects("hasPendingChangesForPath").never();
		}

		// code under test
		assert.strictEqual(oBinding.hasPendingChangesInDependents(bIgnoreKeptAlive), true);
	});
});

	//*********************************************************************************************
[undefined, "/Foo/1"].forEach(function (sPathPrefix) {
	QUnit.test("resetChangesInDependents, sPathPrefix: " + sPathPrefix, function (assert) {
		var oCache1 = {
				resetChangesForPath : function () {}
			},
			oCache3 = {
				resetChangesForPath : function () {}
			},
			oCache31 = {
				resetChangesForPath : function () {}
			},
			oCache32 = {
				resetChangesForPath : function () {}
			},
			oChild1 = new ODataParentBinding({
				oCachePromise : SyncPromise.resolve(Promise.resolve(oCache1))
			}),
			oChild2 = new ODataParentBinding({
				oCachePromise : SyncPromise.resolve(null)
			}),
			oChild3 = new ODataParentBinding({
				oCachePromise : SyncPromise.resolve(Promise.resolve(oCache3)),
				mCacheByResourcePath : {
					"Foo/1" : oCache31,
					"Foo/2" : oCache32
				}
			}),
			oBinding = new ODataParentBinding({
				getDependentBindings : function () {}
			}),
			aPromises = [];

		this.mock(oBinding).expects("getDependentBindings")
			.withExactArgs().returns([oChild1, oChild2, oChild3]);
		this.mock(oCache1).expects("resetChangesForPath").withExactArgs("");
		this.mock(oChild1).expects("resetChangesInDependents")
			.withExactArgs(sinon.match.same(aPromises), sPathPrefix)
			.callsFake(function (aPromises0) {
				aPromises0.push("foo");
			});
		this.mock(oChild1).expects("resetInvalidDataState").withExactArgs();
		this.mock(oChild2).expects("resetChangesInDependents")
			.withExactArgs(sinon.match.same(aPromises), sPathPrefix)
			.callsFake(function (aPromises0) {
				aPromises0.push("bar");
			});
		this.mock(oChild2).expects("resetInvalidDataState").withExactArgs();
		this.mock(oCache3).expects("resetChangesForPath").withExactArgs("");
		this.mock(oChild3).expects("resetChangesInDependents")
			.withExactArgs(sinon.match.same(aPromises), sPathPrefix)
			.callsFake(function (aPromises0) {
				aPromises0.push("baz");
			});
		this.mock(oChild3).expects("resetInvalidDataState").withExactArgs();
		this.mock(oCache31).expects("resetChangesForPath")
			.exactly(!sPathPrefix || sPathPrefix === "/Foo/1" ? 1 : 0)
			.withExactArgs("");
		this.mock(oCache32).expects("resetChangesForPath").exactly(!sPathPrefix ? 1 : 0)
			.withExactArgs("");

		// code under test
		oBinding.resetChangesInDependents(aPromises, sPathPrefix);

		assert.strictEqual(aPromises.length, 6);
		assert.ok(SyncPromise.isThenable(aPromises[0]));
		assert.strictEqual(aPromises[1], "foo");
		assert.strictEqual(aPromises[2], undefined);
		assert.strictEqual(aPromises[3], "bar");
		assert.ok(SyncPromise.isThenable(aPromises[4]));
		assert.strictEqual(aPromises[5], "baz");

		return Promise.all(aPromises);
	});
});

	//*********************************************************************************************
	QUnit.test("resetChangesInDependents: synchronous error", function (assert) {
		var oBinding = new ODataParentBinding({
				getDependentBindings : function () {}
			}),
			oCache = {
				resetChangesForPath : function () {}
			},
			oChild = new ODataParentBinding({
				oCachePromise : SyncPromise.resolve(oCache)
			}),
			oError = new Error("Intentionally failed"),
			aPromises = [];

		this.mock(oBinding).expects("getDependentBindings").withExactArgs().returns([oChild]);
		this.mock(oCache).expects("resetChangesForPath").withExactArgs("").throws(oError);
		this.mock(oChild).expects("resetChangesInDependents").never();

		assert.throws(function () {
			// code under test
			oBinding.resetChangesInDependents(aPromises);
		}, oError);
	});

	//*********************************************************************************************
	[{
	}, {
		oContext : null,
		bPrefix : true
	}, {
		oContext : {getPath : function () {}}
	}].forEach(function (oFixture, i) {
		QUnit.test("visitSideEffects, " + i, function (assert) {
			var oBinding = new ODataParentBinding(),
				oChild0 = {
					oCache : {}, //TODO what if this is still pending?
					getPath : function () { return "foo(0)"; },
					requestSideEffects : function () {}
				},
				oChild1 = {
					oCache : {},
					getPath : function () { return "bar(1)"; }
				},
				oChild2 = {
					oCache : null, // no own cache
					getPath : function () { return "n/a/toN"; },
					visitSideEffects : function () {}
				},
				oChild3 = {
					oCache : {},
					getPath : function () { return "baz(3)"; },
					requestSideEffects : function () {}
				},
				oChild4 = {
					oCache : {},
					oOperation : "~truthy~",
					// getPath must not be called
					requestSideEffects : function () {}
				},
				sGroupId = "group",
				oHelperMock = this.mock(_Helper),
				oModel = {
					getDependentBindings : function () {}
				},
				aPaths = [],
				aPaths0 = ["A"],
				aPaths1 = [/*empty!