function drillDown(sPath, bCreateOnDemand) {
			return oCache.drillDown(oData, sPath, null, bCreateOnDemand).getResult();
		}
******************************************************************************************
	QUnit.test("_Cache#resetChangesForPath: PATCHes", function (assert) {
		var oCache = new _Cache(this.oRequestor, "TEAMS"),
			oCacheMock = this.mock(oCache),
			oCall1,
			oCall2,
			oCall3;

		oCache.mChangeRequests = {
			"foo/ba" : ["foo/ba"],
			"foo/bar" : ["foo/bar/1", "foo/bar/2"],
			"foo/bar('1')" : ["foo/bar(1)"],
			"foo/bars" : ["foo/bars"],
			"foo/bar/baz" : ["foo/bar/baz"]
		};

		oCacheMock.expects("checkSharedRequest").withExactArgs();
		this.oRequestorMock.expects("removeChangeRequest").withExactArgs("foo/bar/baz");
		oCall1 = this.oRequestorMock.expects("removeChangeRequest").withExactArgs("foo/bar(1)");
		oCall2 = this.oRequestorMock.expects("removeChangeRequest").withExactArgs("foo/bar/2");
		oCall3 = this.oRequestorMock.expects("removeChangeRequest").withExactArgs("foo/bar/1");

		// code under test
		oCache.resetChangesForPath("foo/bar");

		sinon.assert.callOrder(oCall1, oCall2, oCall3);
		assert.deepEqual(oCache.mChangeRequests, {
			"foo/ba" : ["foo/ba"],
			"foo/bars" : ["foo/bars"]
		});

		oCacheMock.expects("checkSharedRequest").withExactArgs();
		this.oRequestorMock.expects("removeChangeRequest").withExactArgs("foo/ba");
		this.oRequestorMock.expects("removeChangeRequest").withExactArgs("foo/bars");

		// code under test
		oCache.resetChangesForPath("");

		assert.deepEqual(oCache.mChangeRequests, {});
	});

	//*********************************************************************************************
	QUnit.test("_Cache#resetChangesForPath: remove POSTs with given path", function (assert) {
		var oBody0 = {"@$ui5._" : {transient : "update"}},
			oBody1 = {"@$ui5._" : {transient : "update2"}},
			oBody2 = {"@$ui5._" : {transient : "update"}},
			oBody3 = {"@$ui5._" : {transient : "update"}},
			oBody4 = {"@$ui5._" : {transient : "update"}},
			oBody5 = {"@$ui5._" : {
				transient : "$inactive.foo", transientPredicate : "($uid=123-3)"
			}},
			oCache = new _Cache(this.oRequestor, "TEAMS"),
			oCall1,
			oCall2;

		oCache.mPostRequests = {
			"foo/ba" : [oBody0],
			"foo/bar" : [oBody1, oBody2],
			"foo/bars" : [oBody3],
			"foo/bar/baz" : [oBody4, oBody5]
		};

		this.mock(oCache).expects("checkSharedRequest").withExactArgs();
		oCall1 = this.oRequestorMock.expects("removePost")
			.withExactArgs("update", sinon.match.same(oBody2));
		oCall2 = this.oRequestorMock.expects("removePost")
			.withExactArgs("update2", sinon.match.same(oBody1));
		this.oRequestorMock.expects("removePost").withExactArgs("update", sinon.match.same(oBody4));
		this.mock(_Helper).expects("resetInactiveEntity")
			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "($uid=123-3)",
				sinon.match.same(oBody5));
		this.oRequestorMock.expects("removePost").withArgs("$inactive.foo").never();

		// code under test
		oCache.resetChangesForPath("foo/bar");

		sinon.assert.callOrder(oCall1, oCall2);
		// resetChangesForPath will not clean up oCache.mPostRequests by itself, but via
		// _Requestor#removePost which is mocked here
		assert.deepEqual(oCache.mPostRequests, {
			"foo/ba" : [oBody0],
			"foo/bar" : [oBody1, oBody2],
			"foo/bars" : [oBody3],
			"foo/bar/baz" : [oBody4, oBody5]
		});
	});

	//*********************************************************************************************
	QUnit.test("_Cache#resetChangesForPath: top-level", function (assert) {
		var oBody0 = {"@$ui5._" : {transient : "update"}},
			oBody1 = {"@$ui5._" : {transient : "update"}},
			oBody2 = {"@$ui5._" : {
				transient : "$inactive.foo", transientPredicate : "($uid=123-3)"
			}},
			oCache = new _Cache(this.oRequestor, "TEAMS");

		oCache.mPostRequests = {
			"foo/ba" : [oBody0],
			"foo/bars" : [oBody1],
			"foo/bar/baz" : [oBody2]
		};

		this.mock(oCache).expects("checkSharedRequest").withExactArgs();
		this.oRequestorMock.expects("removePost").withExactArgs("update", sinon.match.same(oBody0));
		this.oRequestorMock.expects("removePost").withExactArgs("update", sinon.match.same(oBody1));
		this.mock(_Helper).expects("resetInactiveEntity")
			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "($uid=123-3)",
				sinon.match.same(oBody2));
		this.oRequestorMock.expects("removePost").withArgs("$inactive.foo").never();

		// code under test
		oCache.resetChangesForPath("");

		// resetChangesForPath will not clean up oCache.mPostRequests by itself, but via
		// _Requestor#removePost which is mocked here
		assert.deepEqual(oCache.mPostRequests, {
			"foo/ba" : [oBody0],
			"foo/bars" : [oBody1],
			"foo/bar/baz" : [oBody2]
		});
	});

	//*********************************************************************************************
	QUnit.test("_Cache#resetChangesForPath: inactive contexts", function () {
		var oPostBody = [
			{"@$ui5._" : {transient : "update"}},
			{"@$ui5._" : {transient : "$inactive.foo", transientPredicate : "($uid=123-3)"}},
			{"@$ui5._" : {transient : "$inactive.foo", transientPredicate : "($uid=123-3)"},
				"@$ui5.context.isInactive" : 1},
			{"@$ui5._" : {transient : "$inactive.foo", transientPredicate : "($uid=123-3)"},
				"@$ui5.context.isInactive" : true},
			{"@$ui5._" : {transient : "$inactive.foo", transientPredicate : "($uid=4711)"},
				"@$ui5.context.isInactive" : 1}
			],
			oCache = new _Cache(this.oRequestor, "TEAMS"),
			oCacheMock = this.mock(oCache);

		oCache.mPostRequests = {"foo/bar" : oPostBody};

		oCacheMock.expects("checkSharedRequest").withExactArgs();
		this.mock(_Helper).expects("resetInactiveEntity")
			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "($uid=123-3)", oPostBody[2]);
		this.mock(this.oRequestor).expects("removePost").never();

		// code under test
		oCache.resetChangesForPath("($uid=123-3)");

		oCacheMock.expects("checkSharedRequest").withExactArgs();

		// code under test
		oCache.resetChangesForPath("(");

		oCacheMock.expects("checkSharedRequest").withExactArgs();

		// code under test
		oCache.resetChangesForPath("/foo/bar($uid=");

		oCacheMock.expects("checkSharedRequest").withExactArgs();

		// code under test
		oCache.resetChangesForPath("~");
	});

	//*********************************************************************************************
	QUnit.test("_Cache#setActive", function (assert) {
		var oCache = new _Cache(this.oRequestor, "TEAMS");

		oCache.iActiveUsages = 99;
		oCache.mChangeRequests = {path : {}};
		oCache.mChangeListeners = {path1 : "~listener1~", path2 : "~listener2~"};

		// code under test
		oCache.setActive(true);

		assert.strictEqual(oCache.iActiveUsages, 100);
		assert.strictEqual(oCache.hasPendingChangesForPath("path"), true);
		assert.strictEqual(oCache.iInactiveSince, Infinity);

		// code under test
		oCache.setActive(false);

		assert.strictEqual(oCache.iActiveUsages, 99);
		assert.strictEqual(oCache.iInactiveSince, Infinity);
		assert.deepEqual(oCache.mChangeListeners, {path1 : "~listener1~", path2 : "~listener2~"});

		oCache.iActiveUsages = 1;

		this.mock(Date).expects("now").withExactArgs().returns(42);

		// code under test
		oCache.setActive(false);

		assert.strictEqual(oCache.iActiveUsages, 0);
		assert.strictEqual(oCache.iInactiveSince, 42);
		assert.deepEqual(oCache.mChangeListeners, {});

		// code under test
		oCache.setActive(true);

		assert.strictEqual(oCache.iActiveUsages, 1);
		assert.strictEqual(oCache.iInactiveSince, Infinity);
	});

	//*********************************************************************************************
	QUnit.test("_Cache#checkSharedRequest: not shared", function () {
		var oCache = new _Cache(this.oRequestor, "TEAMS");

		oCache.checkSharedRequest();
	});

	//*********************************************************************************************
	QUnit.test("_Cache#checkSharedRequest: shared", function (assert) {
		var oCache = new _Cache(this.oRequestor, "TEAMS", undefined, false, undefined, true);

		assert.throws(function () {
			oCache.checkSharedRequest();
		}, new Error(oCache + " is read-only"));
	});

	//*********************************************************************************************
	QUnit.test("_Cache#drillDown", function (assert) {
		var oCache = new _Cache(this.oRequestor, "Products('42')"),
			oCacheMock = this.mock(_Cache),
			oData = [{
				foo : {
					bar : 42,
					empty : "",
					emptyList : [],
					list : [{/*created