@openui5/sap.ui.core 1.120.0 → 1.120.2

package/test/sap/ui/core/qunit/types/DateFormat.qunit.js

@@ -5225,4 +5225,194 @@ sap.ui.define([
 		// code under test
 		assert.strictEqual(DateFormat.prototype.parse.call(oFormat, "~value"), "~dateObject");
 	});
+
+	//*****************************************************************************************************************
+	// BCP: 2380137559
+	QUnit.test("DateFormat: alternative month abbreviations (integrative test)", function (assert) {
+		Configuration.setLanguage("en_GB");
+		const oDateFormat = DateFormat.getDateInstance();
+		const oDate = UI5Date.getInstance(2023, 8, 15);
+
+		// code under test - format based on current CLDR version
+		assert.strictEqual(oDateFormat.format(oDate), "15 Sept 2023");
+
+		// code under test - parse abreviated month based on current CLDR version (43.0)
+		assert.strictEqual(oDateFormat.parse("15 Sept 2023").getTime(), oDate.getTime());
+
+		// code under test - parsing abreviated month based on older CLDR version (41.0) still possible
+		assert.strictEqual(oDateFormat.parse("15 Sep 2023").getTime(), oDate.getTime());
+	});
+
+	//*****************************************************************************************************************
+	QUnit.test("DateFormat#init", function (assert) {
+		const oLocalData = {
+			_getMonthsWithAlternatives() {},
+			_getMonthsStandAloneWithAlternatives() {},
+			getDayPeriods() {},
+			getDays() {},
+			getDaysStandAlone() {},
+			getEras() {},
+			getFlexibleDayPeriods() {},
+			getFlexibleDayPeriodsStandAlone() {},
+			getMonths() {},
+			getMonthsStandAlone() {},
+			getQuarters() {},
+			getQuartersStandAlone() {}
+		};
+		const oDateFormat = {
+			oFormatOptions: {calendarType: "~calendarType", pattern: "~pattern"},
+			oLocaleData: oLocalData,
+			getAllowedCharacters() {},
+			parseCldrDatePattern() {}
+		};
+		const oLocalDataMock = this.mock(oLocalData);
+		oLocalDataMock.expects("_getMonthsWithAlternatives").withExactArgs("abbreviated", "~calendarType")
+			.returns("~aMonthsAbbrev");
+		oLocalDataMock.expects("getMonths").withExactArgs("wide", "~calendarType").returns("~aMonthsWide");
+		oLocalDataMock.expects("getMonths").withExactArgs("narrow", "~calendarType").returns("~aMonthsNarrow");
+		oLocalDataMock.expects("_getMonthsStandAloneWithAlternatives").withExactArgs("abbreviated", "~calendarType")
+			.returns("~aMonthsAbbrevSt");
+		oLocalDataMock.expects("getMonthsStandAlone").withExactArgs("wide", "~calendarType").returns("~aMonthsWideSt");
+		oLocalDataMock.expects("getMonthsStandAlone").withExactArgs("narrow", "~calendarType")
+			.returns("~aMonthsNarrowSt");
+		oLocalDataMock.expects("getDays").withExactArgs("abbreviated", "~calendarType").returns("~aDaysAbbrev");
+		oLocalDataMock.expects("getDays").withExactArgs("wide", "~calendarType").returns("~aDaysWide");
+		oLocalDataMock.expects("getDays").withExactArgs("narrow", "~calendarType").returns("~aDaysNarrow");
+		oLocalDataMock.expects("getDays").withExactArgs("short", "~calendarType").returns("~aDaysShort");
+		oLocalDataMock.expects("getDaysStandAlone").withExactArgs("abbreviated", "~calendarType")
+			.returns("~aDaysAbbrevSt");
+		oLocalDataMock.expects("getDaysStandAlone").withExactArgs("wide", "~calendarType").returns("~aDaysWideSt");
+		oLocalDataMock.expects("getDaysStandAlone").withExactArgs("narrow", "~calendarType").returns("~aDaysNarrowSt");
+		oLocalDataMock.expects("getDaysStandAlone").withExactArgs("short", "~calendarType").returns("~aDaysShortSt");
+		oLocalDataMock.expects("getQuarters").withExactArgs("abbreviated", "~calendarType").returns("~aQuartersAbbrev");
+		oLocalDataMock.expects("getQuarters").withExactArgs("wide", "~calendarType").returns("~aQuartersWide");
+		oLocalDataMock.expects("getQuarters").withExactArgs("narrow", "~calendarType").returns("~aQuartersNarrow");
+		oLocalDataMock.expects("getQuartersStandAlone").withExactArgs("abbreviated", "~calendarType")
+			.returns("~aQuartersAbbrevSt");
+		oLocalDataMock.expects("getQuartersStandAlone").withExactArgs("wide", "~calendarType")
+			.returns("~aQuartersWideSt");
+		oLocalDataMock.expects("getQuartersStandAlone").withExactArgs("narrow", "~calendarType")
+			.returns("~aQuartersNarrowSt");
+		oLocalDataMock.expects("getEras").withExactArgs("abbreviated", "~calendarType").returns("~aErasAbbrev");
+		oLocalDataMock.expects("getEras").withExactArgs("wide", "~calendarType").returns("~aErasWide");
+		oLocalDataMock.expects("getEras").withExactArgs("narrow", "~calendarType").returns("~aErasNarrow");
+		oLocalDataMock.expects("getDayPeriods").withExactArgs("abbreviated", "~calendarType")
+			.returns("~aDayPeriodsAbbrev");
+		oLocalDataMock.expects("getDayPeriods").withExactArgs("wide", "~calendarType").returns("~aDayPeriodsWide");
+		oLocalDataMock.expects("getDayPeriods").withExactArgs("narrow", "~calendarType").returns("~aDayPeriodsNarrow");
+		oLocalDataMock.expects("getFlexibleDayPeriods").withExactArgs("abbreviated", "~calendarType")
+			.returns("~oFlexibleDayPeriodsAbbrev");
+		oLocalDataMock.expects("getFlexibleDayPeriods").withExactArgs("wide", "~calendarType")
+			.returns("~oFlexibleDayPeriodsWide");
+		oLocalDataMock.expects("getFlexibleDayPeriods").withExactArgs("narrow", "~calendarType")
+			.returns("~oFlexibleDayPeriodsNarrow");
+		oLocalDataMock.expects("getFlexibleDayPeriodsStandAlone").withExactArgs("abbreviated", "~calendarType")
+			.returns("~oFlexibleDayPeriodsAbbrevSt");
+		oLocalDataMock.expects("getFlexibleDayPeriodsStandAlone").withExactArgs("wide", "~calendarType")
+			.returns("~oFlexibleDayPeriodsWideSt");
+		oLocalDataMock.expects("getFlexibleDayPeriodsStandAlone").withExactArgs("narrow", "~calendarType")
+			.returns("~oFlexibleDayPeriodsNarrowSt");
+		this.mock(oDateFormat).expects("parseCldrDatePattern").withExactArgs("~pattern").returns("~aFormatArray");
+		this.mock(oDateFormat).expects("getAllowedCharacters").withExactArgs("~aFormatArray")
+			.returns("~sAllowedCharacters");
+
+		// code under test
+		DateFormat.prototype.init.call(oDateFormat);
+
+		assert.strictEqual(oDateFormat.aMonthsAbbrev, "~aMonthsAbbrev");
+		assert.strictEqual(oDateFormat.aMonthsWide, "~aMonthsWide");
+		assert.strictEqual(oDateFormat.aMonthsNarrow, "~aMonthsNarrow");
+		assert.strictEqual(oDateFormat.aMonthsAbbrevSt, "~aMonthsAbbrevSt");
+		assert.strictEqual(oDateFormat.aMonthsWideSt, "~aMonthsWideSt");
+		assert.strictEqual(oDateFormat.aMonthsNarrowSt, "~aMonthsNarrowSt");
+		assert.strictEqual(oDateFormat.aDaysAbbrev, "~aDaysAbbrev");
+		assert.strictEqual(oDateFormat.aDaysWide, "~aDaysWide");
+		assert.strictEqual(oDateFormat.aDaysNarrow, "~aDaysNarrow");
+		assert.strictEqual(oDateFormat.aDaysShort, "~aDaysShort");
+		assert.strictEqual(oDateFormat.aDaysAbbrevSt, "~aDaysAbbrevSt");
+		assert.strictEqual(oDateFormat.aDaysWideSt, "~aDaysWideSt");
+		assert.strictEqual(oDateFormat.aDaysNarrowSt, "~aDaysNarrowSt");
+		assert.strictEqual(oDateFormat.aDaysShortSt, "~aDaysShortSt");
+		assert.strictEqual(oDateFormat.aQuartersAbbrev, "~aQuartersAbbrev");
+		assert.strictEqual(oDateFormat.aQuartersWide, "~aQuartersWide");
+		assert.strictEqual(oDateFormat.aQuartersNarrow, "~aQuartersNarrow");
+		assert.strictEqual(oDateFormat.aQuartersAbbrevSt, "~aQuartersAbbrevSt");
+		assert.strictEqual(oDateFormat.aQuartersWideSt, "~aQuartersWideSt");
+		assert.strictEqual(oDateFormat.aQuartersNarrowSt, "~aQuartersNarrowSt");
+		assert.strictEqual(oDateFormat.aErasNarrow, "~aErasNarrow");
+		assert.strictEqual(oDateFormat.aErasAbbrev, "~aErasAbbrev");
+		assert.strictEqual(oDateFormat.aErasWide, "~aErasWide");
+		assert.strictEqual(oDateFormat.aDayPeriodsAbbrev, "~aDayPeriodsAbbrev");
+		assert.strictEqual(oDateFormat.aDayPeriodsNarrow, "~aDayPeriodsNarrow");
+		assert.strictEqual(oDateFormat.aDayPeriodsWide, "~aDayPeriodsWide");
+		assert.strictEqual(oDateFormat.oFlexibleDayPeriodsAbbrev, "~oFlexibleDayPeriodsAbbrev");
+		assert.strictEqual(oDateFormat.oFlexibleDayPeriodsNarrow, "~oFlexibleDayPeriodsNarrow");
+		assert.strictEqual(oDateFormat.oFlexibleDayPeriodsWide, "~oFlexibleDayPeriodsWide");
+		assert.strictEqual(oDateFormat.oFlexibleDayPeriodsAbbrevSt, "~oFlexibleDayPeriodsAbbrevSt");
+		assert.strictEqual(oDateFormat.oFlexibleDayPeriodsNarrowSt, "~oFlexibleDayPeriodsNarrowSt");
+		assert.strictEqual(oDateFormat.oFlexibleDayPeriodsWideSt, "~oFlexibleDayPeriodsWideSt");
+		assert.strictEqual(oDateFormat.aFormatArray, "~aFormatArray");
+		assert.strictEqual(oDateFormat.sAllowedCharacters, "~sAllowedCharacters");
+	});
+
+	//*****************************************************************************************************************
+	QUnit.test("DateFormat#findEntry", function (assert) {
+		const oParseHelperMock = this.mock(DateFormat._oParseHelper);
+		oParseHelperMock.expects("startsWithIgnoreCase").never();
+
+		// code under test
+		assert.deepEqual(DateFormat._oParseHelper.findEntry("foo", [], "~sLocale"), {index: -1, length: 0});
+
+		oParseHelperMock.expects("startsWithIgnoreCase").withExactArgs("~value", "f", "~sLocale").returns(true);
+		oParseHelperMock.expects("startsWithIgnoreCase").withExactArgs("~value", "foo", "~sLocale").returns(true);
+		oParseHelperMock.expects("startsWithIgnoreCase").withExactArgs("~value", "FooBar", "~sLocale").returns(false);
+
+		// code under test
+		assert.deepEqual(
+			DateFormat._oParseHelper.findEntry("~value", ["f", "foo", "fo", "FooBar", "baz"], "~sLocale"),
+			{index: 1, length: 3});
+
+		oParseHelperMock.expects("startsWithIgnoreCase").withExactArgs("~value", "a", "~sLocale").returns(false);
+		oParseHelperMock.expects("startsWithIgnoreCase").withExactArgs("~value", "f", "~sLocale").returns(true);
+		oParseHelperMock.expects("startsWithIgnoreCase").withExactArgs("~value", "alt1", "~sLocale").returns(false);
+		oParseHelperMock.expects("startsWithIgnoreCase").withExactArgs("~value", "alt2", "~sLocale").returns(true);
+		oParseHelperMock.expects("startsWithIgnoreCase").withExactArgs("~value", "alt99", "~sLocale").returns(true);
+		oParseHelperMock.expects("startsWithIgnoreCase").withExactArgs("~value", "FooBar", "~sLocale").returns(false);
+
+		// code under test
+		assert.deepEqual(
+			DateFormat._oParseHelper.findEntry("~value", ["a", "f", "x", ["alt1", "alt2", "alt3", "alt99"], "FooBar"],
+				"~sLocale"),
+			{index: 3, length: 5});
+	});
+
+	//*****************************************************************************************************************
+	QUnit.test("oSymbols.M#format: abbreviations contains array", function (assert) {
+		const oField = {digits: 3};
+		const oFormat = {aMonthsAbbrev: ["foo", "bar", ["baz", "qux"]]};
+		// code under test
+		assert.strictEqual(
+			DateFormat.prototype.oSymbols.M.format(oField, new Date(Date.UTC(2023, 1, 1)), undefined, oFormat),
+			"bar");
+
+		// code under test
+		assert.strictEqual(
+			DateFormat.prototype.oSymbols.M.format(oField, new Date(Date.UTC(2023, 2, 1)), undefined, oFormat),
+			"baz");
+	});
+
+	//*****************************************************************************************************************
+	QUnit.test("oSymbols.L#format: abbreviations contains array", function (assert) {
+		const oField = {digits: 3};
+		const oFormat = {aMonthsAbbrevSt: ["foo", "bar", ["baz", "qux"]]};
+		// code under test
+		assert.strictEqual(
+			DateFormat.prototype.oSymbols.L.format(oField, new Date(Date.UTC(2023, 1, 1)), undefined, oFormat),
+			"bar");
+
+		// code under test
+		assert.strictEqual(
+			DateFormat.prototype.oSymbols.L.format(oField, new Date(Date.UTC(2023, 2, 1)), undefined, oFormat),
+			"baz");
+	});
 });

package/test/sap/ui/core/qunit/types/DateInterval.qunit.js

@@ -110,7 +110,7 @@ sap.ui.define([
 			"Cannot format date interval: " + oDate1 + " is expected as an Array but given the wrong format");
 		assert.strictEqual(oDateInterval.formatValue([oDate1], "string"), "", "format type with invalid parameter");
 		// logged by DataType.getType
-		this.oLogMock.expects("error").withExactArgs("data type 'untype' could not be found.");
+		this.oLogMock.expects("error").withExactArgs("[FUTURE FATAL] data type 'untype' could not be found.");
 		checkFormatException(assert, oDateInterval, [oDate1, oDate2], "untype",
 			"Don't know how to format Date to untype");
 
@@ -142,7 +142,7 @@ sap.ui.define([
 			[oDate1, oDate2], "Interval string can be parsed into an array of dates");
 		checkParseException(assert, oDateInterval, "Nov 6", "string", "DateInterval.Invalid");
 		// logged by DataType.getType
-		this.oLogMock.expects("error").withExactArgs("data type 'untype' could not be found.");
+		this.oLogMock.expects("error").withExactArgs("[FUTURE FATAL] data type 'untype' could not be found.");
 		checkParseException(assert, oDateInterval, "Nov 6 - Dec 6, 2003", "untype",
 			"Don't know how to parse a date interval from untype");
 

package/test/sap/ui/core/qunit/ui5classes/ManagedObjectRegistry.qunit.js

@@ -0,0 +1,161 @@
+/* global QUnit, sinon */
+sap.ui.define(["sap/ui/base/ManagedObjectRegistry", "sap/ui/base/ManagedObject"],
+	function (ManagedObjectRegistry, ManagedObject) {
+		"use strict";
+
+		function createInstance(aInstanceId, FNClass) {
+			var aInstance = [];
+			var sTimeStamp = Date.now().toString(); // Ensure that ids are unique
+			aInstanceId.forEach(function (sId) {
+				aInstance.push(new FNClass(sId + sTimeStamp));
+			});
+			return aInstance;
+		}
+
+		function destroyInstance(aInstance) {
+			aInstance.forEach(function (oInstance) {
+				oInstance.destroy();
+			});
+		}
+
+		QUnit.module("ManagedObjectRegistry (Happy Path)");
+
+		QUnit.test("Should mixin register/deregister", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			const registry = ManagedObjectRegistry.create();
+			registry.init(Foo);
+
+			assert.ok(Foo.prototype.register, "Has register prototype function");
+			assert.ok(Foo.prototype.deregister, "Has deregister prototype function");
+		});
+
+		QUnit.test("Construction and destruction", function (assert) {
+			var aInstanceId = ["A", "B", "C"];
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			const registry = ManagedObjectRegistry.create();
+			registry.init(Foo);
+
+			var aInstance = createInstance(aInstanceId, Foo);
+			assert.equal(registry.size, 3, "3 instances added");
+			destroyInstance(aInstance);
+			assert.equal(registry.size, 0, "3 instances removed");
+		});
+
+		QUnit.test("Should retrieve added instances as copy", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			const registry = ManagedObjectRegistry.create();
+			registry.init(Foo);
+
+			var oFoo = new Foo("A");
+
+			var mElementsInRegistry = registry.all();
+			assert.equal(Object.keys(mElementsInRegistry).length, 1, "Contains 1 instance in map");
+			assert.equal(Object.getPrototypeOf(mElementsInRegistry), null, "Retrieved object contains no prototype functions");
+
+			oFoo.destroy();
+		});
+
+		QUnit.test("Should retrieve instance by id", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			const registry = ManagedObjectRegistry.create();
+			registry.init(Foo);
+
+			var oFoo1 = new Foo("A");
+			var oFoo2 = new Foo("B");
+
+			assert.ok(registry.get("B"), "Retrieves instance with id B");
+			destroyInstance([oFoo1, oFoo2]);
+		});
+
+		QUnit.test("Should execute callback for all instances", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			const registry = ManagedObjectRegistry.create();
+			registry.init(Foo);
+
+			var aCallbackCallee = [];
+			var oFoo1 = new Foo("A");
+			var oFoo2 = new Foo("B");
+			var oFoo3 = new Foo("C");
+
+			var fnCallback = function(oInstance, sId) {
+				aCallbackCallee.push(oInstance);
+			};
+			var fnCallbackSpy = sinon.spy(fnCallback);
+
+			registry.forEach(fnCallbackSpy);
+			assert.equal(fnCallbackSpy.callCount, 3, "Executed callback 3 times");
+			assert.ok(aCallbackCallee.indexOf(oFoo1) !== -1, "Executed callback for oFoo1");
+			assert.ok(aCallbackCallee.indexOf(oFoo2) !== -1, "Executed callback for oFoo2");
+			assert.ok(aCallbackCallee.indexOf(oFoo3) !== -1, "Executed callback for oFoo3");
+
+			destroyInstance([oFoo1, oFoo2, oFoo3]);
+		});
+
+		QUnit.module("ManagedObjectRegistry (Sad Path)");
+
+		QUnit.test("Should ensure that static registry property is immutable", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			const registry = ManagedObjectRegistry.create();
+			registry.init(Foo);
+
+			assert.throws(function () {
+				registry.mutator = null;
+			}, "Throw on mutation");
+		});
+
+
+		QUnit.test("Should ensure that extended function is subclass of ManagedObject", function (assert) {
+			assert.throws(function () {
+				const registry = ManagedObjectRegistry.create();
+				registry.init(function Foo() { });
+			}, new TypeError("ManagedObjectRegistry mixin can only be applied to subclasses of sap.ui.base.ManagedObject"),
+				"throws because function is not subclass of ManagedObject");
+		});
+
+		QUnit.test("Should throw when object with same id is added", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			const registry = ManagedObjectRegistry.create();
+			registry.init(Foo);
+
+			assert.throws(function () {
+				new Foo("A");
+				new Foo("A");
+			}, new Error("Error: adding object \"object\" with duplicate id 'A'"), "Same ids are not allowed");
+		});
+
+	});

package/test/sap/ui/core/qunit/ui5classes/ManagedObjectRegistry_legacyAPIs.qunit.js

@@ -0,0 +1,150 @@
+/* global QUnit, sinon */
+sap.ui.define(["sap/ui/base/ManagedObjectRegistry", "sap/ui/base/ManagedObject"],
+	function (ManagedObjectRegistry, ManagedObject) {
+		"use strict";
+
+		function createInstance(aInstanceId, FNClass) {
+			var aInstance = [];
+			var sTimeStamp = Date.now().toString(); // Ensure that ids are unique
+			aInstanceId.forEach(function (sId) {
+				aInstance.push(new FNClass(sId + sTimeStamp));
+			});
+			return aInstance;
+		}
+
+		function destroyInstance(aInstance) {
+			aInstance.forEach(function (oInstance) {
+				oInstance.destroy();
+			});
+		}
+
+		QUnit.module("ManagedObjectRegistry (Happy Path)");
+
+		QUnit.test("Should mixin object", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			ManagedObjectRegistry.apply(Foo);
+
+			assert.ok(Foo.prototype.register, "Has register prototype function");
+			assert.ok(Foo.prototype.deregister, "Has deregister prototype function");
+			assert.ok(Foo.hasOwnProperty("registry"), "Extended object has static property \"registry\"");
+		});
+
+		QUnit.test("Construction and destruction", function (assert) {
+			var aInstanceId = ["A", "B", "C"];
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+			ManagedObjectRegistry.apply(Foo);
+
+			var aInstance = createInstance(aInstanceId, Foo);
+			assert.equal(Foo.registry.size, 3, "3 instances added");
+			destroyInstance(aInstance);
+			assert.equal(Foo.registry.size, 0, "3 instances removed");
+		});
+
+		QUnit.test("Should retrieve added instances as copy", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			ManagedObjectRegistry.apply(Foo);
+
+			var oFoo = new Foo("A");
+
+			var mElementsInRegistry = Foo.registry.all();
+			assert.equal(Object.keys(mElementsInRegistry).length, 1, "Contains 1 instance in map");
+			assert.equal(Object.getPrototypeOf(mElementsInRegistry), null, "Retrieved object contains no prototype functions");
+
+			oFoo.destroy();
+		});
+
+		QUnit.test("Should retrieve instance by id", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			ManagedObjectRegistry.apply(Foo);
+
+			var oFoo1 = new Foo("A");
+			var oFoo2 = new Foo("B");
+
+			assert.ok(Foo.registry.get("B"), "Retrieves instance with id B");
+			destroyInstance([oFoo1, oFoo2]);
+		});
+
+		QUnit.test("Should execute callback for all instances", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+
+			ManagedObjectRegistry.apply(Foo);
+			var aCallbackCallee = [];
+			var oFoo1 = new Foo("A");
+			var oFoo2 = new Foo("B");
+			var oFoo3 = new Foo("C");
+
+			var fnCallback = function(oInstance, sId) {
+				aCallbackCallee.push(oInstance);
+			};
+			var fnCallbackSpy = sinon.spy(fnCallback);
+
+			Foo.registry.forEach(fnCallbackSpy);
+			assert.equal(fnCallbackSpy.callCount, 3, "Executed callback 3 times");
+			assert.ok(aCallbackCallee.indexOf(oFoo1) !== -1, "Executed callback for oFoo1");
+			assert.ok(aCallbackCallee.indexOf(oFoo2) !== -1, "Executed callback for oFoo2");
+			assert.ok(aCallbackCallee.indexOf(oFoo3) !== -1, "Executed callback for oFoo3");
+
+			destroyInstance([oFoo1, oFoo2, oFoo3]);
+		});
+
+		QUnit.module("ManagedObjectRegistry (Sad Path)");
+
+		QUnit.test("Should ensure that static registry property is immutable", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+			ManagedObjectRegistry.apply(Foo);
+
+			assert.throws(function () {
+				Foo.registry.mutator = null;
+			}, "Throw on mutation");
+		});
+
+
+		QUnit.test("Should ensure that extended function is subclass of ManagedObject", function (assert) {
+			assert.throws(function () {
+				ManagedObjectRegistry.apply(function Foo() { });
+			}, new TypeError("ManagedObjectRegistry mixin can only be applied to subclasses of sap.ui.base.ManagedObject"),
+				"throws because function is not subclass of ManagedObject");
+		});
+
+		QUnit.test("Should throw when object with same id is added", function (assert) {
+			var Foo = ManagedObject.extend("Foo", {
+				constructor: function () {
+					ManagedObject.apply(this, arguments);
+				}
+			});
+			ManagedObjectRegistry.apply(Foo);
+
+			assert.throws(function () {
+				new Foo("A");
+				new Foo("A");
+			}, new Error("Error: adding object \"object\" with duplicate id 'A'"), "Same ids are not allowed");
+		});
+
+	});

package/test/sap/ui/core/qunit/ui5classes/testsuite.ui5classes.qunit.js

@@ -0,0 +1,84 @@
+sap.ui.define(function() {
+
+	"use strict";
+	return {
+		name: "TestSuite for BaseObject, ManagedObject and their Helpers",
+		defaults: {
+			loader:{
+				paths:{
+					"fixture": "test-resources/sap/ui/core/qunit/ui5classes/fixture/"
+				}
+			},
+			qunit: {
+				version: 2
+			},
+			sinon: {
+				version: 4
+			},
+			module: "./{name}.qunit"
+		},
+		tests: {
+			AlternativeTypes: {
+				title: "QUnit Page for AlternativeTypes",
+				loader: {
+					paths: {
+						"sap/ui/testlib": "test-resources/sap/ui/core/qunit/testdata/uilib/"
+					}
+				},
+				ui5: {
+					libs: "sap.ui.testlib"
+				}
+			},
+			DataType: {
+				coverage : {
+					only : "sap/ui/base/DataType"
+				},
+				title: "QUnit Page for sap/ui/base/DataType"
+			},
+			ManagedObject: {
+				title: "sap.ui.base.ManagedObject"
+			},
+			ManagedObject_BindingParser: {
+				title: "sap.ui.base.ManagedObject (no core boot)",
+				bootCore: false
+			},
+			ManagedObject_forwardAggregation: {
+				title: "sap.ui.base.ManagedObject (forward Aggregation)"
+			},
+			ManagedObject_isPropertyInitial: {
+				title: "sap.ui.base.ManagedObject (is Property Initial)"
+			},
+			ManagedObjectObserver: {
+				title: "sap.ui.base.ManagedObjectObserver"
+			},
+			ManagedObjectRegistry: {
+				title: "sap.ui.base.ManagedObjectRegistry"
+			},
+			ManagedObjectRegistry_legacyAPIs: {
+				title: "sap.ui.base.ManagedObjectRegistry_legacyAPIs"
+			},
+			ManagedObjectMetadata: {
+				title: "sap.ui.base.ManagedObjectMetadata",
+				sinon: {
+					version: 1, // bridge does not support nested modules
+					qunitBridge: true
+				}
+			},
+			/**
+			 * @deprecated As of version 1.111 Mostly testing deprecated APIs
+			 */
+			Metadata: {
+				title: "sap.ui.base.Metadata"
+			},
+			Object: {
+				title: "sap.ui.base.Object"
+			},
+			/**
+			 * @deprecated As of version 1.111
+			 */
+			Object_legacyAPIs: {
+				title: "sap.ui.base.Object (legacy APIs)"
+			}
+		}
+	};
+});

package/test/sap/ui/core/qunit/util/ViewSerializer.qunit.js

@@ -6,11 +6,12 @@ sap.ui.define([
 	"sap/m/Image",
 	"sap/m/Label",
 	"sap/ui/core/UIArea",
+	"sap/ui/core/UIAreaRegistry",
 	"sap/ui/core/mvc/XMLView",
 	"sap/ui/core/util/serializer/ViewSerializer",
 	"sap/ui/qunit/utils/createAndAppendDiv"
 ],
-	function (Log, Button, Image, Label, UIArea, XMLView, ViewSerializer, createAndAppendDiv) {
+	function (Log, Button, Image, Label, UIArea, UIAreaRegistry, XMLView, ViewSerializer, createAndAppendDiv) {
 		"use strict";
 
 		createAndAppendDiv(["xmlViewArea", "xmlViewWithoutControllerArea"]);
@@ -68,7 +69,7 @@ sap.ui.define([
 		});
 
 		QUnit.test("Serialize, Re-Instantiate and Check an XML View", function (assert) {
-			var oViewSerializer = new ViewSerializer(UIArea.registry.get("xmlViewArea"), null, "sap.m");
+			var oViewSerializer = new ViewSerializer(UIAreaRegistry.get("xmlViewArea"), null, "sap.m");
 
 			var mXMLViews = oViewSerializer.serializeToXML();
 			var sXMLResult = mXMLViews["serializer.view.TestXml"];
@@ -84,7 +85,7 @@ sap.ui.define([
 		});
 
 		QUnit.test("Serialize, Check if a view that has no controller is still serializable", function (assert) {
-			var oViewSerializer = new ViewSerializer(UIArea.registry.get("xmlViewWithoutControllerArea"), null, "sap.m");
+			var oViewSerializer = new ViewSerializer(UIAreaRegistry.get("xmlViewWithoutControllerArea"), null, "sap.m");
 
 			var mXMLViews = oViewSerializer.serializeToXML();
 			var sResult = mXMLViews["serializer.view.TestViewWithoutController"];