function addTest(oExclusiveAnnotation) {
				var oConstraints = {},
					oMinMax = {},
					oProperty = {type : "Edm.Decimal"};

				oMinMax[sType] = "10";
				oProperty["Org.OData.Validation.V1." + sMinOrMax] = oMinMax;
				oConstraints[sMinOrMaxLower] = "10";
				if (oExclusiveAnnotation) {
					oMinMax["Org.OData.Validation.V1.Exclusive"] = oExclusiveAnnotation;
					oConstraints[sMinOrMaxLower + "Exclusive"] = "true";
				}
				QUnit.test("path: type=Edm.Decimal, " + sMinOrMax + " as " + sType + ", exclusive="
						+ JSON.stringify(oExclusiveAnnotation), function (assert) {
					this.testPathReturningProperty(assert, oProperty, oConstraints);
				});
			}
******************************************************************************************
	[
		{constant : "Bool", type : "Edm.Boolean",
			values : ["true", "false", "TRUE", "False"]},
		{constant : "Bool", error : true,
			values : ["foo", "not false", "trueish"]},

		{constant : "Date", type : "Edm.Date",
			values : ["2000-01-01"]},
		{constant : "Date", error : true,
			values : ["20000101", "2000-01-01T16:00:00Z",
				"2000-00-01", "2000-13-01", "2000-01-00", "2000-01-32",
				// Note: negative year values not supported at SAP
				"-0006-12-24", "-6-12-24"]},

		{constant : "DateTimeOffset", type : "Edm.DateTimeOffset",
			values : [
				"2000-01-01T16:00Z",
				"2000-01-01t16:00:00z",
				"2000-01-01T16:00:00.0Z",
				"2000-01-01T16:00:00.000Z",
				"2000-01-02T01:00:00.000+09:00",
				"2000-01-02T06:00:00.000+14:00", // http://www.w3.org/TR/xmlschema11-2/#nt-tzFrag
				"2000-01-01T16:00:00.000456789012Z"
			]},
		{constant : "DateTimeOffset", error : true,
			values : [
				"2000-01-01",
				"2000-01-32T16:00:00.000Z",
				"2000-01-01T16:00:00.1234567890123Z",
				"2000-01-01T16:00:00.000+14:01", // http://www.w3.org/TR/xmlschema11-2/#nt-tzFrag
				"2000-01-01T16:00:00.000+00:60",
				"2000-01-01T16:00:00.000~00:00",
				"2000-01-01T16:00:00.Z",
				// Note: negative year values not supported at SAP
				"-0006-12-24T00:00:00Z",
				"-6-12-24T16:00:00Z"]},

		{constant : "Decimal", type : "Edm.Decimal", values : ["+1.1", "+123.123", "-123.1",
			"+123.1", "1.123", "-1.123", "123.1", "1", "-123"]},
		{constant : "Decimal", error : true, values : ["3,14", "1e+12", "INF", "-INF", "NaN"]},

		{constant : "Float", type : "Edm.Double",
			values : ["1.23e4", "31415.926535", "0.1E-3", "INF", "-INF", "NaN"]},
		{constant : "Float", error : true,
			values : ["foo", "1a", "1e", "3,23", "0.1e-", "Inf", "-iNF", "NAN"]},

		{constant : "Guid", type : "Edm.Guid", values : ["12345678-ABCD-EFab-cdef-123456789012"]},
		{constant : "Guid", error : true, values : [
				"123g5678-1234-1234-1234-123456789abc",
				"12345-1234-1234-1234-123456789abc",
				"12_45678-1234-1234-1234-123456789abc"]},

		{constant : "Int", type : "Edm.Int64",
			values : ["-9007199254740992", "9007199254740992", "10000000000000000"]},
		{constant : "Int", type : "Edm.Int32",
			values : ["-9007199254740991", "0", "9007199254740991"]},
		{constant : "Int", error : true,
			values : ["INF", "-INF", "NaN", "12345678901234567890", "1.0", "1a", "1e3"]},

		{constant : "String", type : "Edm.String", values : ["", "foo"]},

		{constant : "TimeOfDay", type : "Edm.TimeOfDay",
			values : ["23:59", "23:59:59", "23:59:59.1", "23:59:59.123",
				"23:59:59.123456789012"]},
		{constant : "TimeOfDay", error : true,
			values : ["23", "23:60", "23:59:60", "24:00:00", "23:59:59.1234567890123"]}
	].forEach(function (oFixture) {
		oFixture.values.forEach(function (sConstantValue, i) {
			var oValue = {};

			function testIt(oRawValue, sProperty, sConstantValue) {
				QUnit.test("14.4.x Constant Expression: " + JSON.stringify(oRawValue),
					function (assert) {
						var oModel = {},
							oInterface = {
								getModel : function () { return oModel; }
							},
							oPathValue = {
								asExpression : false,
								path : "/my/path",
								value : oRawValue,
								withType : true
							},
							oConstantPathValue = {
								asExpression : false,
								path : "/my/path/" + sProperty,
								value : oRawValue[sProperty],
								withType : true
							},
							oError = new SyntaxError(),
							oExpectedResult,
							oResult;

						if (oFixture.error) {
							this.mock(Basics).expects("error")
								.withExactArgs(oConstantPathValue, "Expected " + oFixture.constant
									+ " value but instead saw '" + oConstantPathValue.value + "'")
								.throws(oError);

							assert.throws(function () {
								Expression.expression(oInterface, oPathValue);
							}, oError);
						} else {
							this.mock(Basics).expects("error").never();

							oExpectedResult = {
								result : "constant",
								value : sConstantValue,
								type : oFixture.type
							};

							//********** first test with bindTexts: false
							oResult = Expression.expression(oInterface, oPathValue);

							assert.deepEqual(oResult, oExpectedResult, "bindTexts: false");

							//********** second test with bindTexts: true
							oInterface.getSetting = function (sName) {
								assert.strictEqual(sName, "bindTexts");
								return true;
							};

							if (oFixture.constant === "String") {
								this.mock(Expression).expects("replaceIndexes")
									.withExactArgs(sinon.match.same(oModel),
										oConstantPathValue.path)
									.returns("/replaced");
							}
							oResult = Expression.expression(oInterface, oPathValue);

							if (oFixture.constant === "String") {
								assert.deepEqual(oResult, {
									ignoreTypeInPath : true,
									result : "binding",
									type : "Edm.String",
									value : "/##/replaced"
								}, "bindTexts");
							} else {
								assert.deepEqual(oResult, oExpectedResult, "bindTexts: true");
							}
						}
					}
				);
			}

			oValue[oFixture.constant] = sConstantValue;
			testIt(oValue, oFixture.constant, sConstantValue);
			testIt({Type : oFixture.constant, Value : sConstantValue}, "Value", sConstantValue);
		});
	});

	//*********************************************************************************************
	[{
		property : {type : "Edm.Boolean"},
		constraints : {}
	}, {
		property : {type : "Edm.Byte", nullable : "false"},
		constraints : {nullable : "false"}
	}, {
		property : {type : "Edm.DateTime", "sap:display-format": "DateOnly"},
		constraints : {displayFormat : "DateOnly"}
	}, {
		property : {type : "Edm.Decimal", precision : "10", scale : "variable"},
		constraints : {precision : "10", scale : "variable"}
	}, {
		property : {type : "Edm.String", maxLength : "30", nullable : "false"},
		constraints : {maxLength : "30", nullable : "false"}
	}, {
		property : {type : "Edm.String", maxLength : "30",
			"com.sap.vocabularies.Common.v1.IsDigitSequence" : { "Bool" : "true" }},
		constraints : {maxLength : "30", isDigitSequence : "true"}
	}, {
		property : {type : "Edm.String", maxLength : "30",
			"com.sap.vocabularies.Common.v1.IsDigitSequence" : { "Bool" : "false" }},
		constraints : {maxLength : "30", isDigitSequence : "false"}
	}, {
		property : {type : "Edm.String", maxLength : "30",
			"com.sap.vocabularies.Common.v1.IsDigitSequence" : {}},
		constraints : {maxLength : "30", isDigitSequence : "true"}
	}].forEach(function (oFixture) {
		QUnit.test("path: type=" + oFixture.property.type + ", constraints="
				+ JSON.stringify(oFixture.constraints), function (assert) {
			this.testPathReturningProperty(assert, oFixture.property, oFixture.constraints);
		});
	});

	//*********************************************************************************************
	["Decimal", "String"].forEach(function (sType) {
		["Minimum", "Maximum"].forEach(function (sMinOrMax) {
			var sMinOrMaxLower = sMinOrMax.toLowerCase();

			/*
Adds a test for a decimal with minimum/maximum value.
@param {object} [oExclusiveAnnotation]
  The value for the "Org.OData.Validation.V1.Exclusive" annotation