function check(sValue) {
			assert.deepEqual(Expression.constant(oInterface, {value : sValue}, "String"), {
				result : "constant",
				type : "Edm.String",
				value : sValue
			});
		}
******************************************************************************************
	[undefined, {resolvedPath : undefined}].forEach(function (oTarget) {
		QUnit.test("path: followPath returns " + Basics.toJSON(oTarget), function (assert) {
			var oExpectedResult = {
					result : "binding",
					value : "unsupported"
				},
				oInterface = {
					getModel : function () {}
				},
				oPathValue = {
					path : "/dataServices/schema/0/entityType/0/foo/Path",
					value : "unsupported"
				},
				oResult;

			this.mock(Basics).expects("followPath").returns(oTarget);
			this.oLogMock.expects("warning").withExactArgs(
				"Could not find property 'unsupported' starting from '" + oPathValue.path + "'",
				null, "sap.ui.model.odata.AnnotationHelper");

			oResult = Expression.path(oInterface, oPathValue);

			assert.deepEqual(oResult, oExpectedResult, "result");
		});
	});

	//*********************************************************************************************
	[
		{property : "Path", value : {Path : "foo"}},
		{property : "Value", value : {Type : "Path", Value : "foo"}},
		{property : "PropertyPath", value : {PropertyPath : "foo"}},
		{property : "Value", value : {Type : "PropertyPath", Value : "foo"}}
	].forEach(function (oFixture) {
		QUnit.test("expression: " + JSON.stringify(oFixture.value), function (assert) {
			var oInterface = {},
				oPathValue = {value : oFixture.value},
				oSubPathValue = {},
				oResult = {},
				oBasics = this.mock(Basics);

			if (oFixture.value.Type) {
				oBasics.expects("property")
					.withExactArgs(sinon.match.same(oPathValue), "Type", "string")
					.returns(oFixture.value.Type);
			}
			oBasics.expects("descend")
				.withExactArgs(sinon.match.same(oPathValue), oFixture.property)
				.returns(oSubPathValue);
			this.mock(Expression).expects("path")
				.withExactArgs(sinon.match.same(oInterface), oSubPathValue)
				.returns(oResult);

			assert.strictEqual(Expression.expression(oInterface, oPathValue), oResult);
		});
	});

	//*********************************************************************************************
	[
		{property : "Apply", value : {Apply : {}}},
		{property : "Value", value : {Type : "Apply", Value : {}}}
	].forEach(function (oFixture) {
		QUnit.test("expression: " + JSON.stringify(oFixture.value), function (assert) {
			var oInterface = {},
				oPathValue = {value : oFixture.value},
				oSubPathValue = {},
				oResult = {},
				oBasics = this.mock(Basics);

			if (oFixture.value.Type) {
				oBasics.expects("property")
					.withExactArgs(sinon.match.same(oPathValue), "Type", "string").returns("Apply");
			}
			oBasics.expects("descend")
				.withExactArgs(sinon.match.same(oPathValue), oFixture.property)
				.returns(oSubPathValue);
			this.mock(Expression).expects("apply")
				.withExactArgs(sinon.match.same(oInterface), sinon.match.same(oSubPathValue))
				.returns(oResult);

			assert.strictEqual(Expression.expression(oInterface, oPathValue), oResult);
		});
	});

	//*********************************************************************************************
	[
		{property : "If", value : {If : []}},
		{property : "Value", value : {Type : "If", Value : []}}
	].forEach(function (oFixture) {
		QUnit.test("expression: " + JSON.stringify(oFixture.value), function (assert) {
			var oInterface = {},
				oPathValue = {value : oFixture.value},
				oSubPathValue = {},
				oResult = {},
				oBasics = this.mock(Basics);

			if (oFixture.value.Type) {
				oBasics.expects("property")
					.withExactArgs(sinon.match.same(oPathValue), "Type", "string").returns("If");
			}
			oBasics.expects("descend")
				.withExactArgs(sinon.match.same(oPathValue), oFixture.property)
				.returns(oSubPathValue);
			this.mock(Expression).expects("conditional")
				.withExactArgs(sinon.match.same(oInterface), sinon.match.same(oSubPathValue))
				.returns(oResult);

			assert.strictEqual(Expression.expression(oInterface, oPathValue), oResult);
		});
	});

	//*********************************************************************************************
	["And", "Eq", "Ge", "Gt", "Le", "Lt", "Ne", "Or"
	].forEach(function (sOperator) {
		var oDirect = {},
			oOperatorValue = {};

		function testOperator(oRawValue, sProperty) {
			QUnit.test("expression: " + JSON.stringify(oRawValue), function (assert) {
				var oInterface = {},
					oPathValue = {
						asExpression : true,
						path : "/my/path",
						value : oRawValue,
						withType : true
					},
					oSubPathValue = {
						asExpression : true,
						path : "/my/path/" + sProperty,
						value : oOperatorValue,
						withType : true
					},
					oResult = {};

				this.mock(Expression).expects("operator")
					.withExactArgs(sinon.match.same(oInterface), oSubPathValue, sOperator)
					.returns(oResult);

				assert.strictEqual(Expression.expression(oInterface, oPathValue), oResult);
			});
		}

		oDirect[sOperator] = oOperatorValue;
		testOperator(oDirect, sOperator);
		testOperator({Type : sOperator, Value : oOperatorValue}, "Value");
	});

	//*********************************************************************************************
	(function () {
		var oOperatorValue = {};

		function testNot(oRawValue, sProperty) {
			QUnit.test("expression: " + JSON.stringify(oRawValue), function (assert) {
				var oInterface = {},
					oPathValue = {
						asExpression : true,
						path : "/my/path",
						value : oRawValue,
						withType : true
					},
					oSubPathValue = {
						asExpression : true,
						path : "/my/path/" + sProperty,
						value : oOperatorValue,
						withType : true
					},
					oResult = {};

				this.mock(Expression).expects("not")
					.withExactArgs(sinon.match.same(oInterface), oSubPathValue).returns(oResult);

				assert.strictEqual(Expression.expression(oInterface, oPathValue), oResult);
			});
		}

		testNot({Not : oOperatorValue}, "Not");
		testNot({Type : "Not", Value : oOperatorValue}, "Value");
	}());

	//*********************************************************************************************
	(function () {
		var oNullValue = {};

		function testNull(oRawValue, sProperty) {
			QUnit.test("expression: " + JSON.stringify(oRawValue), function (assert) {
				var oInterface = {},
					oPathValue = {path : "/my/path", value : oRawValue};

				assert.deepEqual(Expression.expression(oInterface, oPathValue), {
					result : "constant",
					value : "null",
					type : "edm:Null"
				});
			});
		}

		testNull({Null : oNullValue}, "Null");
		testNull({Type : "Null", Value : oNullValue}, "Value");
	}());

	//*********************************************************************************************
	QUnit.test("expression: unknown", function (assert) {
		var oPathValue = {value : {}};

		this.mock(Basics).expects("error")
			.withExactArgs(sinon.match.same(oPathValue), "Unsupported OData expression");

		Expression.expression({}, oPathValue);
	});

	//*********************************************************************************************
	QUnit.test("String constants {@i18n>...} turned into a binding", function (assert) {
		var oInterface = {
				getSetting : function (sName) {}
			};

		// make sure that setting 'bindTexts' has no influence at all
		this.mock(oInterface).expects("getSetting").never();

		assert.deepEqual(Expression.constant(oInterface, {value : "{@i18n>foo/bar}"}, "String"), {
			ignoreTypeInPath : true,
			result : "binding",
			type : "Edm.String",
			value : "@i18n>foo/bar"
		});
	});

	//*********************************************************************************************
	QUnit.test("Only simple binding syntax allowed for {@i18n>...}", function (assert) {
		var oInterface = {
				getSetting : function (sName) {}
			};

		/*
@param {string} sValue