function conditional(bP1isNull, bP2isNull, bComplexBinding, sType) {
		var sTitle = "conditional: " + bP1isNull + ", " + bP2isNull + ", bComplexBinding = "
				+ bComplexBinding;

		QUnit.test(sTitle, function (assert) {
			var oBasics = this.mock(Basics),
				oExpectedPathValue = {
					complexBinding : false,
					foo : "bar",
					value : [0, 1/*, 2*/]
				},
				oExpression = this.mock(Expression),
				oPathValue = {
					complexBinding : bComplexBinding,
					foo : "bar",
					value : [0, 1/*, 2*/] // length 2 is unrealistic, but must not matter here!
				},
				oNullParameter = {result : "constant", type : "edm:Null", value : "null"},
				oParameter0 = {result : "expression", value : "A"},
				oParameter1 = bP1isNull ? oNullParameter
					: {result : "expression", type : "foo", value : "B"},
				oParameter2 = bP2isNull ? oNullParameter
					: {result : "expression", type : "foo", value : "C"},
				oWrappedParameter0 = {result : "expression", value : "(A)"},
				oWrappedParameter1 = bP1isNull ? oNullParameter
					: {result : "expression", type : "foo", value : "(B)"},
				oWrappedParameter2 = bP2isNull ? oNullParameter
					: {result : "expression", type : "foo", value : "(C)"};

			oExpression.expects("parameter")
				.withExactArgs(bComplexBinding
					? oExpectedPathValue
					: sinon.match.same(oPathValue).and(sinon.match({complexBinding : false})),
					0, "Edm.Boolean")
				.returns(SyncPromise.resolve(oParameter0));
			oExpression.expects("parameter")
				.withExactArgs(sinon.match.same(oPathValue), 1)
				.returns(SyncPromise.resolve(oParameter1));
			oExpression.expects("parameter")
				.withExactArgs(sinon.match.same(oPathValue), 2)
				.returns(SyncPromise.resolve(oParameter2));

			oExpression.expects("wrapExpression")
				.withExactArgs(sinon.match.same(oParameter0)).returns(oWrappedParameter0);
			oExpression.expects("wrapExpression")
				.withExactArgs(sinon.match.same(oParameter1)).returns(oWrappedParameter1);
			oExpression.expects("wrapExpression")
				.withExactArgs(sinon.match.same(oParameter2)).returns(oWrappedParameter2);

			oBasics.expects("resultToString")
				.withExactArgs(sinon.match.same(oWrappedParameter0), true, false, true)
				.returns("(A)");
			oBasics.expects("resultToString")
				.withExactArgs(sinon.match.same(oWrappedParameter1), true,
					sinon.match.same(oPathValue.complexBinding), undefined)
				.returns(oWrappedParameter1.value);
			oBasics.expects("resultToString")
				.withExactArgs(sinon.match.same(oWrappedParameter2), true,
					sinon.match.same(oPathValue.complexBinding), undefined)
				.returns(oWrappedParameter2.value);

			// code under test
			assert.deepEqual(Expression.conditional(oPathValue).unwrap(), {
				result : "expression",
				type : sType || "foo",
				value : "(A)?" + oWrappedParameter1.value + ":" + oWrappedParameter2.value
			});

			assert.strictEqual(oPathValue.complexBinding, bComplexBinding, "unchanged");
		});
	}
******************************************************************************************
	QUnit.test("apply: unknown function", function (assert) {
		var oError = new SyntaxError(),
			oPathValue = {path : "/my/path", value : {$Apply : [], $Function : "foo"}},
			oPathValueFunction = {value : oPathValue.value.$Function},
			oBasics = this.mock(Basics);

		oBasics.expects("descend")
			.withExactArgs(sinon.match.same(oPathValue), "$Function", "string")
			.returns(oPathValueFunction);
		oBasics.expects("error")
			.withExactArgs(sinon.match.same(oPathValueFunction), "unknown function: foo",
				sAnnotationHelper)
			.throws(oError);

		assertRejected(assert, Expression.apply(oPathValue), oError);
	});

	//*********************************************************************************************
	["concat", "fillUriTemplate", "uriEncode"].forEach(function (sName) {
		QUnit.test("apply: " + sName, function (assert) {
			var oPathValue = {},
				oResult = {/*SyncPromise