@openui5/sap.ui.core 1.120.1 → 1.120.2

package/test/sap/ui/core/qunit/routing/async/Router.qunit.js

@@ -432,7 +432,7 @@ sap.ui.define([
 		});
 
 
-		assert.ok(oLogSpy.withArgs("The 'viewName' option shouldn't be used in Route. please use 'view' instead").calledOnce, "The error log is done and the log message is correct");
+		assert.ok(oLogSpy.calledWith(sinon.match(/The 'viewName' option shouldn't be used in Route. please use 'view' instead/)), "The error log is done and the log message is correct");
 	});
 
 	QUnit.test("subroute handling", function(assert) {
@@ -2476,70 +2476,120 @@ sap.ui.define([
 	QUnit.module("nested components", {
 		beforeEach: function() {
 			hasher.setHash("");
-			return Component.create({
-				name: "qunit.router.component.parentRoute.Parent",
-				id: "parent"
-			}).then(function(oComponent) {
-				var that = this;
-				this.oParentComponent = oComponent;
-				this.oParentComponent.getRouter().initialize();
 
-				var oRootView = oComponent.getRootControl();
-				var oComponentContainer = oRootView.byId("container");
-
-				return new Promise(function(resolve, reject) {
-					oRootView.placeAt("qunit-fixture");
-					oComponentContainer.attachComponentCreated(function(oEvent) {
-						that.oChildComponent = oEvent.getParameter("component");
-						resolve();
+			this.createComponent = function(sComponentName) {
+				return Component.create({
+					name: sComponentName,
+					id: "parent"
+				}).then(function(oComponent) {
+					var that = this;
+					this.oParentComponent = oComponent;
+					this.oParentComponent.getRouter().initialize();
+
+					this.oRootView = oComponent.getRootControl();
+					var oComponentContainer = that.oRootView.byId("container");
+
+					return new Promise(function(resolve, reject) {
+						that.oRootView.placeAt("qunit-fixture");
+						oComponentContainer.attachComponentCreated(function(oEvent) {
+							that.oChildComponent = oEvent.getParameter("component");
+							resolve();
+						});
 					});
-				});
-			}.bind(this));
+				}.bind(this));
+			};
 		},
 		afterEach: function () {
+			this.oRootView.destroy();
 			this.oParentComponent.destroy();
 			this.oChildComponent.destroy();
 		}
 	});
 
 	QUnit.test("fire events", function(assert) {
-		// Arrange
-		var oParentRouteMatchedEvent,
-			oParentRouteMatchedEventSpy = sinon.spy(function(oEvent) {
-				// save the oEvent because EventProvider will overwrite it otherwise
-				oParentRouteMatchedEvent = deepExtend({}, oEvent);
-			}),
-			oParentRoutePatternMatchedEventSpy = sinon.spy(),
-			oChildRouteMatchedEvent,
-			oChildRouteMatchedEventSpy = sinon.spy(function(oEvent) {
-				oChildRouteMatchedEvent = deepExtend({}, oEvent);
-			}),
-			oChildRoutePatternMatchedEventSpy = sinon.spy(),
-			oParentRoute = this.oParentComponent.getRouter().getRoute("category"),
-			oChildRoute = this.oChildComponent.getRouter().getRoute("product"),
-			oParentRouteMatchedSpy = sinon.spy(oParentRoute, "_routeMatched"),
-			oChildRouteMatchedSpy = sinon.spy(oChildRoute, "_routeMatched");
+		return this.createComponent("qunit.router.component.parentRoute.Parent")
+			.then(function() {
+				// Arrange
+				var oParentRouteMatchedEvent,
+					oParentRouteMatchedEventSpy = this.spy(function(oEvent) {
+						// save the oEvent because EventProvider will overwrite it otherwise
+						oParentRouteMatchedEvent = deepExtend({}, oEvent);
+					}),
+					oParentRoutePatternMatchedEventSpy = this.spy(),
+					oChildRouteMatchedEvent,
+					oChildRouteMatchedEventSpy = this.spy(function(oEvent) {
+						oChildRouteMatchedEvent = deepExtend({}, oEvent);
+					}),
+					oChildRoutePatternMatchedEventSpy = this.spy(),
+					oParentRoute = this.oParentComponent.getRouter().getRoute("category"),
+					oChildRoute = this.oChildComponent.getRouter().getRoute("product"),
+					oParentRouteMatchedSpy = this.spy(oParentRoute, "_routeMatched"),
+					oChildRouteMatchedSpy = this.spy(oChildRoute, "_routeMatched");
+
+				oParentRoute.attachMatched(oParentRouteMatchedEventSpy);
+				oParentRoute.attachPatternMatched(oParentRoutePatternMatchedEventSpy);
+				oChildRoute.attachMatched(oChildRouteMatchedEventSpy);
+				oChildRoute.attachPatternMatched(oChildRoutePatternMatchedEventSpy);
+
+				// Act
+				hasher.setHash("category/0/product/0");
 
-		oParentRoute.attachMatched(oParentRouteMatchedEventSpy);
-		oParentRoute.attachPatternMatched(oParentRoutePatternMatchedEventSpy);
-		oChildRoute.attachMatched(oChildRouteMatchedEventSpy);
-		oChildRoute.attachPatternMatched(oChildRoutePatternMatchedEventSpy);
+				// Assert
+				assert.strictEqual(oParentRouteMatchedSpy.callCount, 1, "Parent should be matched");
+				assert.strictEqual(oChildRouteMatchedSpy.callCount, 1, "Child is matched");
+
+				return Promise.all([oParentRouteMatchedSpy.returnValues[0], oChildRouteMatchedSpy.returnValues[0]]).then(function() {
+					assert.strictEqual(oParentRouteMatchedEventSpy.callCount, 1, "routeMatched fired for parent route");
+					assert.strictEqual(oParentRoutePatternMatchedEventSpy.callCount, 0, "routePatternMatched not fired for parent route");
+					assert.strictEqual(oParentRouteMatchedEvent.getParameter("nestedRoute"), oChildRoute, "childRoute is passed to event listeners");
+					assert.strictEqual(oChildRouteMatchedEventSpy.callCount, 1, "routeMatched fired for child route");
+					assert.strictEqual(oChildRoutePatternMatchedEventSpy.callCount, 1, "routePatternMatched fired for child route");
+					assert.strictEqual(oChildRouteMatchedEvent.getParameter("nestedRoute"), undefined, "no route is passed to event listeners");
+				});
+			}.bind(this));
+	});
 
-		// Act
-		hasher.setHash("category/0/product/0");
+	QUnit.test("fire events with extended parent component", function(assert) {
+		return this.createComponent("qunit.router.component.parentRoute.ParentExtended")
+			.then(function() {
+				// Arrange
+				var oParentRouteMatchedEvent,
+					oParentRouteMatchedEventSpy = this.spy(function(oEvent) {
+						// save the oEvent because EventProvider will overwrite it otherwise
+						oParentRouteMatchedEvent = deepExtend({}, oEvent);
+					}),
+					oParentRoutePatternMatchedEventSpy = this.spy(),
+					oChildRouteMatchedEvent,
+					oChildRouteMatchedEventSpy = this.spy(function(oEvent) {
+						oChildRouteMatchedEvent = deepExtend({}, oEvent);
+					}),
+					oChildRoutePatternMatchedEventSpy = this.spy(),
+					oParentRoute = this.oParentComponent.getRouter().getRoute("category"),
+					oChildRoute = this.oChildComponent.getRouter().getRoute("product"),
+					oParentRouteMatchedSpy = this.spy(oParentRoute, "_routeMatched"),
+					oChildRouteMatchedSpy = this.spy(oChildRoute, "_routeMatched");
+
+				oParentRoute.attachMatched(oParentRouteMatchedEventSpy);
+				oParentRoute.attachPatternMatched(oParentRoutePatternMatchedEventSpy);
+				oChildRoute.attachMatched(oChildRouteMatchedEventSpy);
+				oChildRoute.attachPatternMatched(oChildRoutePatternMatchedEventSpy);
+
+				// Act
+				hasher.setHash("category/0/product/0");
 
-		// Assert
-		assert.strictEqual(oParentRouteMatchedSpy.callCount, 1, "Parent should be matched");
-		assert.strictEqual(oChildRouteMatchedSpy.callCount, 1, "Child is matched");
-
-		return Promise.all([oParentRouteMatchedSpy.returnValues[0], oChildRouteMatchedSpy.returnValues[0]]).then(function() {
-			assert.strictEqual(oParentRouteMatchedEventSpy.callCount, 1, "routeMatched fired for parent route");
-			assert.strictEqual(oParentRoutePatternMatchedEventSpy.callCount, 0, "routePatternMatched not fired for parent route");
-			assert.strictEqual(oParentRouteMatchedEvent.getParameter("nestedRoute"), oChildRoute, "childRoute is passed to event listeners");
-			assert.strictEqual(oChildRouteMatchedEventSpy.callCount, 1, "routeMatched fired for child route");
-			assert.strictEqual(oChildRoutePatternMatchedEventSpy.callCount, 1, "routePatternMatched fired for child route");
-			assert.strictEqual(oChildRouteMatchedEvent.getParameter("nestedRoute"), undefined, "no route is passed to event listeners");
-		});
+				// Assert
+				assert.strictEqual(oParentRouteMatchedSpy.callCount, 1, "Parent should be matched");
+				assert.strictEqual(oChildRouteMatchedSpy.callCount, 1, "Child is matched");
+
+				return Promise.all([oParentRouteMatchedSpy.returnValues[0], oChildRouteMatchedSpy.returnValues[0]]).then(function() {
+					assert.strictEqual(oParentRouteMatchedEventSpy.callCount, 1, "routeMatched fired for parent route");
+					assert.strictEqual(oParentRoutePatternMatchedEventSpy.callCount, 0, "routePatternMatched not fired for parent route");
+					assert.strictEqual(oParentRouteMatchedEvent.getParameter("nestedRoute"), oChildRoute, "childRoute is passed to event listeners");
+					assert.strictEqual(oChildRouteMatchedEventSpy.callCount, 1, "routeMatched fired for child route");
+					assert.strictEqual(oChildRoutePatternMatchedEventSpy.callCount, 1, "routePatternMatched fired for child route");
+					assert.strictEqual(oChildRouteMatchedEvent.getParameter("nestedRoute"), undefined, "no route is passed to event listeners");
+				});
+			}.bind(this));
 	});
 
 	function resetBrowserHash() {

package/test/sap/ui/core/qunit/routing/async/Target.qunit.js

@@ -302,7 +302,7 @@ sap.ui.define([
 			}, function(oError) {
 				// Assert
 				assert.ok(oError instanceof Error, "The promise is rejected with an error object");
-				assert.equal(oError.message, "The target myTarget has a control id or a parent but no 'controlAggregation' was set, so the target could not be displayed. - Target: myTarget", "The error message is correct");
+				assert.ok(oError.message.includes("The target myTarget has a control id or a parent but no 'controlAggregation' was set, so the target could not be displayed. - Target: myTarget"), "The error message is correct");
 			});
 	});
 

package/test/sap/ui/core/qunit/routing/async/Targets.qunit.js

@@ -355,7 +355,7 @@ sap.ui.define([
 		// Act
 		return this.oTargets.display("foo").then(function(aViewInfos) {
 			assert.strictEqual(aViewInfos[0].name, "foo", "Matching target info is returned");
-			assert.strictEqual(aViewInfos[0].error, "The target with the name \"foo\" does not exist!", "Matching error message is returned");
+			assert.ok(aViewInfos[0].error.includes("The target with the name \"foo\" does not exist!"), "Matching error message is returned");
 			// Assert
 			sinon.assert.calledWith(oErrorStub, sinon.match(/does not exist/), sinon.match(this.oTargets));
 		}.bind(this));
@@ -377,7 +377,7 @@ sap.ui.define([
 			assert.ok(Array.isArray(aViewInfos), "Did resolve with an array of the view infos");
 			assert.strictEqual(aViewInfos.length, 2, "Did resolve with two viewinfos");
 			assert.strictEqual(aViewInfos[1].name, "firstTarget", "Did resolve with first target");
-			assert.strictEqual(aViewInfos[0].error, "The target with the name \"foo\" does not exist!", "Did resolve with the error message of the erroneous target");
+			assert.ok(aViewInfos[0].error.includes("The target with the name \"foo\" does not exist!"), "Did resolve with the error message of the erroneous target");
 		}.bind(this));
 	});
 
@@ -1030,9 +1030,8 @@ sap.ui.define([
 		return oDisplayed.then(function() {
 			// Assert
 			assert.ok(fnEventSpy.notCalled, "the event isn't fired");
-			sinon.assert.calledWith(
-				oLogSpy,
-				"The target with the name \"foo\" where the titleChanged event should be fired does not exist!",
+			assert.ok(
+				oLogSpy.calledWith(sinon.match(/The target with the name \"foo\" where the titleChanged event should be fired does not exist!/)),
 				this.oTargets
 			);
 		}.bind(this));

package/test/sap/ui/core/qunit/routing/async/TitleHistory.qunit.js

@@ -634,7 +634,7 @@ sap.ui.define([
 
 		return this.oRouteMatchedSpies["product"].returnValues[0].then(function() {
 			// Assert
-			sinon.assert.calledWith(this.spy, "Routes with dynamic parts cannot be resolved as home route.");
+			assert.ok(this.spy.calledWith(sinon.match(/Routes with dynamic parts cannot be resolved as home route./)));
 			assert.strictEqual(oParameters.history.length, 0, "Home route shouldn't be added to history.");
 			assert.deepEqual(this.oRouter.getTitleHistory()[0], {
 				hash: "/product",

package/test/sap/ui/core/qunit/routing/fixture/router/component/parentRoute/Child/Component.js

@@ -5,6 +5,7 @@ sap.ui.define([
 
 	var Component = UIComponent.extend("qunit.router.component.parentRoute.Child.Component", {
 		metadata : {
+			interfaces: ["sap.ui.core.IAsyncContentCreation"],
 			manifest: "json"
 		},
 		init : function() {

package/test/sap/ui/core/qunit/routing/fixture/router/component/parentRoute/Child/manifest.json

@@ -8,13 +8,9 @@
 	"sap.ui5": {
 		"rootView": {
 			"viewName": "qunit.router.component.parentRoute.Child.view.RootView",
-			"type": "XML",
-			"async": true
+			"type": "XML"
 		},
 		"routing": {
-			"config": {
-				"async": true
-			},
 			"routes": [
 				{
 					"pattern": "product/{id}",

package/test/sap/ui/core/qunit/routing/fixture/router/component/parentRoute/Parent/Component.js

@@ -5,6 +5,7 @@ sap.ui.define([
 
 	var Component = UIComponent.extend("qunit.router.component.parentRoute.Parent.Component", {
 		metadata : {
+			interfaces: ["sap.ui.core.IAsyncContentCreation"],
 			manifest: "json"
 		}
 	});

package/test/sap/ui/core/qunit/routing/fixture/router/component/parentRoute/Parent/manifest.json

@@ -8,13 +8,9 @@
 	"sap.ui5": {
 		"rootView": {
 			"viewName": "qunit.router.component.parentRoute.Parent.view.RootView",
-			"type": "XML",
-			"async": true
+			"type": "XML"
 		},
 		"routing": {
-			"config": {
-				"async": true
-			},
 			"routes": [
 				{
 					"pattern": "category/{id}",

package/test/sap/ui/core/qunit/routing/fixture/router/component/parentRoute/ParentExtended/Component.js

@@ -0,0 +1,15 @@
+sap.ui.define([
+	'qunit/router/component/parentRoute/Parent/Component'
+], function(ParentComponent) {
+	"use strict";
+
+	var Component = ParentComponent.extend("qunit.router.component.parentRoute.ParentExtended.Component", {
+		metadata : {
+			interfaces: ["sap.ui.core.IAsyncContentCreation"],
+			manifest: "json"
+		}
+	});
+
+	return Component;
+
+});

package/test/sap/ui/core/qunit/routing/fixture/router/component/parentRoute/ParentExtended/manifest.json

@@ -0,0 +1,8 @@
+{
+	"sap.app": {
+		"id": "qunit.router.component.parentRoute.ParentExtended",
+		"applicationVersion": {
+			"version": "1.0.0"
+		}
+	}
+}

package/test/sap/ui/core/qunit/routing/sync/Router.qunit.js

@@ -330,7 +330,7 @@ sap.ui.define([
 		router.parse("view1");
 
 		assert.strictEqual(oRoute._oConfig.name, "name", "Route has correct name");
-		assert.ok(oLogSpy.withArgs("The 'viewName' option shouldn't be used in Route. please use 'view' instead").calledOnce, "The error log is done and the log message is correct");
+		assert.ok(oLogSpy.calledWith(sinon.match(/The 'viewName' option shouldn't be used in Route. please use 'view' instead/)), "The error log is done and the log message is correct");
 
 		oViewCreateStub.restore();
 		oLogSpy.restore();
@@ -1976,7 +1976,7 @@ sap.ui.define([
 
 		this.oRouter.attachRouteMatched(function() {
 			// Assert
-			sinon.assert.calledWith(this.spy, "Routes with dynamic parts cannot be resolved as home route.");
+			assert.ok(this.spy.calledWith(sinon.match(/Routes with dynamic parts cannot be resolved as home route./)));
 			assert.strictEqual(oParameters.history.length, 0, "Home route shouldn't be added to history.");
 			assert.deepEqual(this.oRouter.getTitleHistory()[0], {
 				hash: "/product",

package/test/sap/ui/core/qunit/routing/sync/Targets.qunit.js

@@ -757,9 +757,8 @@ sap.ui.define([
 
 		// Assert
 		assert.ok(fnEventSpy.notCalled, "the event isn't fired");
-		sinon.assert.calledWith(
-			oLogSpy,
-			"The target with the name \"foo\" where the titleChanged event should be fired does not exist!",
+		assert.ok(oLogSpy.calledWith(
+			sinon.match(/The target with the name \"foo\" where the titleChanged event should be fired does not exist!/)),
 			this.oTargets
 		);
 	});

package/test/sap/ui/core/qunit/testdata/fragments/XMLTestFragmentWithXMLView.fragment.xml

@@ -0,0 +1,5 @@
+<layout:HorizontalLayout xmlns:layout="sap.ui.layout" xmlns:mvc="sap.ui.core.mvc" xmlns="sap.m">
+	<Button id="btn1InXmlFragment" text="Hello XML World" press="doSomething"/>
+	<Button text="{/someText}" />
+	<mvc:View viewName="testdata.fragments.views.View" async="true" type="XML" />
+</layout:HorizontalLayout>

package/test/sap/ui/core/qunit/testsuites/testsuite.base.configuration.qunit.js

@@ -20,7 +20,7 @@ sap.ui.define([], function() {
 				page: "test-resources/sap/ui/core/qunit/base/Config_bootstrap.qunit.html"
 			},
 			"base/Config_cascade": {
-				page: "test-resources/sap/ui/core/qunit/base/Config_cascade.qunit.html?sap-ui-paramA=url"
+				page: "test-resources/sap/ui/core/qunit/base/Config_cascade.qunit.html?sap-ui-paramA=url&sap-ui-param-merged-object={\"objectKeyUrl\":\"urlObject\"}"
 			},
 			"base/Config_noUrl": {
 				page: "test-resources/sap/ui/core/qunit/base/Config_noUrl.qunit.html?sap-ui-foo-bar=url"

package/test/sap/ui/core/qunit/testsuites/testsuite.control.framework.qunit.js

@@ -51,6 +51,9 @@ sap.ui.define(function() {
 					libs: "sap.m"
 				}
 			},
+			/**
+			 * @deprecated since 1.120
+			 */
 			ControlRenderer: {
 				title: "sap.ui.core.Control (ControlRenderer)"
 			},
@@ -75,6 +78,7 @@ sap.ui.define(function() {
 				},
 				module: [
 					"testdata/core/Element_base.qunit",
+					"testdata/core/Element_base_legacyAPIs.qunit",
 					"testdata/core/Element_contextualSettings.qunit",
 					"testdata/core/Element_data.qunit",
 					"testdata/core/Element_delegates.qunit",

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");