function localTest(sPath, sExpected) {
				assert.strictEqual(
					// code under test
					new _MetadataConverter().resolveAliasInPath(sPath, bHandleParentheses),
					sExpected || sPath);
			}
******************************************************************************************
	QUnit.module("sap.ui.model.odata.v4.lib._MetadataConverter", {
		before : function () {
			this.__ignoreIsolatedCoverage__ = true;
		},

		beforeEach : function () {
			this.oLogMock = this.mock(Log);
			this.oLogMock.expects("warning").never();
			this.oLogMock.expects("error").never();
		}
	});

	//*********************************************************************************************
	QUnit.test("traverse", function (assert) {
		var oXML = xml(assert, "<foo><!-- a comment -->text<bar/>more text <ignore/><bar/>"
				+ "<bar><included1/><included2/></bar>"
				+ "\n<bar><innerBar/><innerBar/><innerBar2/></bar></foo>"),
			oInclude1Config = {
				included1 : {
					__processor : function (oElement) {
						this.processor("included1", oElement);
					}
				}
			},
			oInclude2Config = {
				included2 : {
					__processor : function (oElement) {
						this.processor("included2", oElement);
					}
				}
			},
			oSchemaConfig = {
				bar : {
					__processor : function (oElement) {
						this.processor("bar", oElement);
					},
					__include : [oInclude1Config, oInclude2Config],
					innerBar : {
						__processor : function (oElement) {
							this.processor("innerBar", oElement);
						}
					},
					innerBar2 : {
						__processor : function (oElement) {
							this.processor("innerBar2", oElement);
						}
					}
				}
			},
			oMetadataConverter = new _MetadataConverter();

		oMetadataConverter.bar = 0;
		oMetadataConverter.innerBar = 0;
		oMetadataConverter.innerBar2 = 0;
		oMetadataConverter.included1 = 0;
		oMetadataConverter.included2 = 0;
		oMetadataConverter.processor = function (sExpectedName, oElement) {
			assert.strictEqual(oElement.nodeType, 1, "is an Element");
			assert.strictEqual(oElement.localName, sExpectedName);
			this[sExpectedName] += 1;
		};

		oMetadataConverter.traverse(oXML.documentElement, oSchemaConfig);
		assert.strictEqual(oMetadataConverter.bar, 4);
		assert.strictEqual(oMetadataConverter.innerBar, 2);
		assert.strictEqual(oMetadataConverter.innerBar2, 1);
		assert.strictEqual(oMetadataConverter.included1, 1);
		assert.strictEqual(oMetadataConverter.included2, 1);
	});

	//*********************************************************************************************
	QUnit.test("traverse: __postProcessor", function (assert) {
		var oXML = xml(assert, "<And><Bool>true</Bool><Bool>false</Bool></And>"),
			oResult = new _MetadataConverter().traverse(oXML.documentElement, {
				__postProcessor : function (_oElement, aResults) {
					return {$And : aResults};
				},
				Bool : {
					__postProcessor : function (oElement, aResults) {
						assert.deepEqual(aResults, []);
						return oElement.childNodes[0].nodeValue === "true";
					}
				}
			});

			assert.deepEqual(oResult, {$And : [true, false]});
	});

	//*********************************************************************************************
	QUnit.test("resolveAlias", function (assert) {
		var oMetadataConverter = new _MetadataConverter();

		oMetadataConverter.aliases = {
			display : "org.example.vocabularies.display."
		};

		assert.strictEqual(oMetadataConverter.resolveAlias(undefined), undefined);
		assert.strictEqual(oMetadataConverter.resolveAlias(null), null);
		assert.strictEqual(oMetadataConverter.resolveAlias(""), "");
		assert.strictEqual(oMetadataConverter.resolveAlias("display.Foo"),
			"org.example.vocabularies.display.Foo");
		assert.strictEqual(oMetadataConverter.resolveAlias("display.bar.Foo"),
			"display.bar.Foo");
		assert.strictEqual(oMetadataConverter.resolveAlias("bar.Foo"), "bar.Foo");
		assert.strictEqual(oMetadataConverter.resolveAlias("Foo"), "Foo");
	});

	//*********************************************************************************************
	QUnit.test("resolveAliasInParentheses: no ()", function (assert) {
		var oMetadataConverter = new _MetadataConverter();

		this.mock(oMetadataConverter).expects("resolveAlias").withExactArgs("f.Action")
			.returns("foo.Action");

		// code under test
		assert.strictEqual(oMetadataConverter.resolveAliasInParentheses(undefined, "f.Action"),
			"foo.Action");
	});

	//*********************************************************************************************
	QUnit.test("resolveAliasInParentheses: ()", function (assert) {
		var oMetadataConverter = new _MetadataConverter(),
			that = this;

		this.mock(oMetadataConverter).expects("resolveAlias").withExactArgs("f.Action")
			.callsFake(function () {
				// avoid mock for "code under test"
				that.mock(oMetadataConverter).expects("resolveAliasInParentheses")
					.withArgs(true, "")
					.returns("");

				return "foo.Action";
			});

		// code under test
		assert.strictEqual(
			oMetadataConverter.resolveAliasInParentheses(true, "f.Action()"),
			"foo.Action()");
	});

	//*********************************************************************************************
	QUnit.test("resolveAliasInParentheses: (...)", function (assert) {
		var oMetadataConverter = new _MetadataConverter(),
			that = this;

		this.mock(oMetadataConverter).expects("resolveAlias").withExactArgs("f.Action")
			.callsFake(function () {
				// avoid mock for "code under test"
				that.mock(oMetadataConverter).expects("resolveAliasInParentheses")
					.withArgs(true, "b.Type")
					.returns("bar.Type");

				return "foo.Action";
			});

		// code under test
		assert.strictEqual(
			oMetadataConverter.resolveAliasInParentheses(true, "f.Action(b.Type)"),
			"foo.Action(bar.Type)");
	});

	//*********************************************************************************************
	QUnit.test("resolveAliasInParentheses: (,,)", function (assert) {
		var oMetadataConverter = new _MetadataConverter(),
			oMetadataConverterMock = this.mock(oMetadataConverter);

		oMetadataConverterMock.expects("resolveAlias").withExactArgs("f.Action")
			.callsFake(function () {
				// avoid mock for "code under test"
				oMetadataConverterMock.expects("resolveAliasInParentheses")
					.withArgs(true, "b.Type")
					.returns("bar.Type");
				oMetadataConverterMock.expects("resolveAliasInParentheses")
					.withArgs(true, "Collection(c.ComplexType)")
					.returns("Collection(custom.ComplexType)");
				oMetadataConverterMock.expects("resolveAliasInParentheses")
					.withArgs(true, "Edm.Int")
					.returns("Edm_Int"); // just to have some difference between input and output

				return "foo.Action";
			});

		// code under test
		assert.strictEqual(oMetadataConverter.resolveAliasInParentheses(true,
				"f.Action(b.Type,Collection(c.ComplexType),Edm.Int)"),
			"foo.Action(bar.Type,Collection(custom.ComplexType),Edm_Int)");
	});

	//*********************************************************************************************
	QUnit.test("resolveAliasInParentheses: switched off", function (assert) {
		var oMetadataConverter = new _MetadataConverter();

		this.mock(oMetadataConverter).expects("resolveAlias")
			.withExactArgs("Products(ID=ProductID)")
			.returns("~");

		// code under test
		assert.strictEqual(
			oMetadataConverter.resolveAliasInParentheses(false, "Products(ID=ProductID)"), "~");
	});

	//*********************************************************************************************
	QUnit.test("resolveAliasInPath", function (assert) {
		var bHandleParentheses = {/*false, true