fnEnabler = function (sKey0) {
				assert.strictEqual(sKey0, sKey);
				return Promise.reject(oError);
			}
**************************************************************************************
	QUnit.test("sendOptimisticBatch: with optimistic batch", function (assert) {
		var oOptimisticBatch = {requests : "~aRequests~", groupId : "~sGroupId~"},
			oGetPromise = Promise.resolve(oOptimisticBatch),
			sKey = window.location.href,
			oRequestor = _Requestor.create("/", oModelInterface);

		this.mock(CacheManager).expects("get")
			.withExactArgs("sap.ui.model.odata.v4.optimisticBatch:" + sKey)
			.resolves(oGetPromise);
		this.mock(oRequestor).expects("sendBatch")
			.withExactArgs("~aRequests~", "~sGroupId~")
			.returns("~sendBatchResult~");
		this.oLogMock.expects("info")
			.withExactArgs("optimistic batch: sent ", sKey, sClassName);

		// code under test
		oRequestor.sendOptimisticBatch();

		assert.strictEqual(oRequestor.oOptimisticBatch, null);

		return oGetPromise.then(function () {
			assert.deepEqual(oRequestor.oOptimisticBatch, {key : sKey,
				firstBatch : oOptimisticBatch,
				result : "~sendBatchResult~"});
		});
	});

	//*****************************************************************************************
	QUnit.test("sendOptimisticBatch: CacheManager.get rejects", function (assert) {
		var done = assert.async(),
			oError = new Error("CacheManager.get rejected"),
			oRequestor = _Requestor.create("/", oModelInterface),
			fnReporter = function (oError0) {
				assert.strictEqual(oError0, oError);
				assert.strictEqual(oRequestor.oOptimisticBatch, null);
				done();
			};

		this.mock(CacheManager).expects("get")
			.withExactArgs("sap.ui.model.odata.v4.optimisticBatch:" + window.location.href)
			.rejects(oError);
		this.mock(oRequestor.oModelInterface).expects("getReporter")
			.withExactArgs()
			.returns(fnReporter);

		// code under test
		oRequestor.sendOptimisticBatch();

		assert.strictEqual(oRequestor.oOptimisticBatch, null);
	});

	//*****************************************************************************************
	QUnit.test("sendOptimisticBatch: #processBatch before read finished", function (assert) {
		var oOptimisticBatch = {requests : "~aRequests~", groupId : "~sGroupId~"},
			oRequestor = _Requestor.create("/", oModelInterface),
			that = this,
			oGetPromise = new Promise(function (fnResolve) {
				that.mock(oRequestor).expects("sendBatch").never();
				that.oLogMock.expects("error")
					.withExactArgs("optimistic batch: #sendBatch called before optimistic "
						+ "batch payload could be read", undefined, sClassName);
				fnResolve(oOptimisticBatch);
			});

		this.mock(CacheManager).expects("get")
			.withExactArgs("sap.ui.model.odata.v4.optimisticBatch:" + window.location.href)
			.resolves(oGetPromise);
		this.mock(oRequestor).expects("isBatchSent")
			.withExactArgs()
			.returns(true); // simulate #processBatch

		// code under test
		oRequestor.sendOptimisticBatch();

		assert.strictEqual(oRequestor.oOptimisticBatch, null);

		return oGetPromise.then(function () {
			assert.deepEqual(oRequestor.oOptimisticBatch, null);
		});
	});

	//*****************************************************************************************
	QUnit.test("processOptimisticBatch: simple cases", function (assert) {
		var oCacheManagerMock = this.mock(CacheManager),
			sKey = window.location.href,
			oModelInterfaceMock = this.mock(oModelInterface),
			oRequestor = _Requestor.create("/", oModelInterface);

		assert.strictEqual(oRequestor.oOptimisticBatch, null);

		//** !this.oOptimisticBatch -> returns undefined
		oCacheManagerMock.expects("set").never();

		oModelInterfaceMock.expects("getOptimisticBatchEnabler").never();

		// code under test
		assert.strictEqual(oRequestor.processOptimisticBatch("n/a", "n/a"), undefined);

		assert.strictEqual(oRequestor.oOptimisticBatch, null);

		//** no enabler existing -> nothing happens
		// simulate first app start w/o optimistic batch sent
		oRequestor.oOptimisticBatch = {key : sKey};
		oModelInterfaceMock.expects("getOptimisticBatchEnabler").withExactArgs()
			.returns(undefined);

		// code under test
		assert.strictEqual(oRequestor.processOptimisticBatch("n/a", "n/a"), undefined);

		assert.strictEqual(oRequestor.oOptimisticBatch, null);

		//** enabler existing, but modifying batch (method other than GET)
		oRequestor.oOptimisticBatch = {key : sKey};
		oModelInterfaceMock.expects("getOptimisticBatchEnabler").withExactArgs()
			.returns("notCalled");
		this.oLogMock.expects("warning")
			.withExactArgs("optimistic batch: modifying batch not supported", sKey, sClassName);

		// code under test
		assert.strictEqual(oRequestor.processOptimisticBatch([
				{method : "GET"},
				{method : "no GET!"}
			], "n/a"), undefined);

		//** enabler existing, but modifying batch (changeSet detected)
		oRequestor.oOptimisticBatch = {key : sKey};
		oModelInterfaceMock.expects("getOptimisticBatchEnabler").withExactArgs()
			.returns("notCalled");
		this.oLogMock.expects("warning")
			.withExactArgs("optimistic batch: modifying batch not supported", sKey, sClassName);

		// code under test
		assert.strictEqual(
			oRequestor.processOptimisticBatch([{method : "GET"}, [/*changeSet