function checkBatchQueue(oBatchQueue0, sGroupId) {
			assert.strictEqual(oRequestor.mBatchQueue[sGroupId], oBatchQueue0);
			assert.strictEqual(oBatchQueue0.length, 1);
			assert.strictEqual(oBatchQueue0.iChangeSet, 0);
			assert.strictEqual(oBatchQueue0[0].length, 0);
			assert.strictEqual(oBatchQueue0[0].iSerialNumber, 0);
		}
**************************************************************************************
	QUnit.test("relocateAll: without entity", function (assert) {
		var oBody1 = {key : "value 1"},
			oBody2 = {key : "value 2"},
			oEntity = {},
			oRequestor = _Requestor.create("/Service/", oModelInterface),
			oRequestorMock = this.mock(oRequestor),
			oYetAnotherEntity = {};

		oRequestor.request("PATCH", "Employees('1')",
			this.createGroupLock("$parked.$auto"), {"If-Match" : oEntity}, oBody1);
		oRequestor.request("DELETE", "Employees('2')",
			this.createGroupLock("$parked.$auto"), {"If-Match" : oYetAnotherEntity});
		oRequestor.request("PATCH", "Employees('1')",
			this.createGroupLock("$parked.$auto"), {"If-Match" : oEntity}, oBody2);

		oRequestorMock.expects("addChangeToGroup")
			.withExactArgs(sinon.match({
				method : "PATCH",
				url : "Employees('1')",
				body : sinon.match.same(oBody1)
			}), "$auto");
		oRequestorMock.expects("addChangeToGroup")
			.withExactArgs(sinon.match({
				method : "PATCH",
				url : "Employees('1')",
				body : sinon.match.same(oBody2)
			}), "$auto");
		oRequestorMock.expects("addChangeToGroup")
			.withExactArgs(sinon.match({
				method : "DELETE",
				url : "Employees('2')"
			}), "$auto");

		// code under test
		oRequestor.relocateAll("$parked.$auto", "$auto");

		assert.strictEqual(oRequestor.hasChanges("$parked.$auto", oEntity), false);
		assert.strictEqual(oRequestor.hasChanges("$parked.$auto", oYetAnotherEntity), false);
	});

	//*********************************************************************************************
	QUnit.test("request: $cached as groupId fails synchronously", function (assert) {
		var oGroupLock = {getGroupId : mustBeMocked},
			oRequestor = _Requestor.create("/");

		this.mock(oGroupLock).expects("getGroupId").withExactArgs().returns("$cached");
		assert.throws(function () {
			//code under test
			oRequestor.request("GET", "/FOO", oGroupLock);
		}, function (oError) {
			assert.strictEqual(oError.message, "Unexpected request: GET /FOO");
			assert.strictEqual(oError.$cached, true);
			return oError instanceof Error;
		});
	});

	//*********************************************************************************************
[false, true].forEach(function (bHasCancelFunction) {
	QUnit.test("request: GroupLock is canceled, " + bHasCancelFunction, function (assert) {
		var fnCancel = sinon.spy(),
			oGroupLock = {
				getGroupId : mustBeMocked,
				isCanceled : mustBeMocked
			},
			oRequestor = _Requestor.create("/");

		this.mock(oGroupLock).expects("getGroupId").withExactArgs().returns("$auto");
		this.mock(oGroupLock).expects("isCanceled").withExactArgs().returns(true);

		//code under test
		return oRequestor.request("GET", "/FOO", oGroupLock, undefined, undefined, undefined,
			bHasCancelFunction ? fnCancel : undefined
		).then(function () {
			assert.ok(false);
		}, function (oError) {
			assert.strictEqual(fnCancel.callCount, bHasCancelFunction ? 1 : 0);
			assert.strictEqual(oError.message, "Request already canceled");
			assert.strictEqual(oError.canceled, true);
			assert.ok(oError instanceof Error);
		});
	});
});

	//*********************************************************************************************
	QUnit.test("doConvertResponse (V4)", function (assert) {
		var oPayload = {},
			oRequestor = _Requestor.create("/");

		// code under test
		assert.strictEqual(oRequestor.doConvertResponse(oPayload), oPayload);
	});

	//*********************************************************************************************
	QUnit.test("convertResourcePath (V4)", function (assert) {
		var sResourcePath = {},
			oRequestor = _Requestor.create("/");

		// code under test
		assert.strictEqual(oRequestor.convertResourcePath(sResourcePath), sResourcePath);
	});

	//*********************************************************************************************
	QUnit.test("convertQueryOptions", function (assert) {
		var oExpand = {},
			oRequestor = _Requestor.create("/");

		this.mock(oRequestor).expects("convertExpand")
			.withExactArgs(sinon.match.same(oExpand), undefined).returns("expand");

		assert.deepEqual(oRequestor.convertQueryOptions("/Foo", {
			foo : "bar",
			$apply : "filter(Price gt 100)",
			$count : "true",
			$expand : oExpand,
			$filter : "SO_2_BP/CompanyName eq 'SAP'",
			$foo : "bar", // to show that any system query option is accepted
			$levels : "5",
			$orderby : "GrossAmount asc",
			$search : "EUR",
			$select : ["select1", "select2"]
		}), {
			foo : "bar",
			$apply : "filter(Price gt 100)",
			$count : "true",
			$expand : "expand",
			$filter : "SO_2_BP/CompanyName eq 'SAP'",
			$foo : "bar",
			$levels : "5",
			$orderby : "GrossAmount asc",
			$search : "EUR",
			$select : "select1,select2"
		});

		assert.deepEqual(oRequestor.convertQueryOptions("/Foo", {
			foo : "bar",
			"sap-client" : "111",
			$apply : "filter(Price gt 100)",
			$count : true,
			$expand : oExpand,
			$filter : "SO_2_BP/CompanyName eq 'SAP'",
			$orderby : "GrossAmount asc",
			$search : "EUR",
			$select : ["select1", "select2"]
		}, /*bDropSystemQueryOptions