@openui5/sap.ui.core 1.120.2 → 1.120.4

package/test/sap/ui/core/qunit/odata/v4/data/metadata_special_cases.xml

@@ -87,6 +87,7 @@
 				<Property Name="CValue" Type="Edm.Int16"/>
 				<NavigationProperty Name="CtoA" Partner="AtoCs" Type="special.cases.A"/>
 				<NavigationProperty Name="CtoD" Partner="DtoC" Type="special.cases.D"/>
+				<NavigationProperty Name="CtoEs" Partner="EtoC" Type="Collection(special.cases.E)"/>
 			</EntityType>
 			<EntityType Name="D">
 				<Key>
@@ -97,6 +98,14 @@
 				<NavigationProperty Name="DtoB" Partner="BtoDs" Type="special.cases.B"/>
 				<NavigationProperty Name="DtoC" Partner="CtoD" Type="special.cases.C"/>
 			</EntityType>
+			<EntityType Name="E">
+				<Key>
+					<PropertyRef Name="EID"/>
+				</Key>
+				<Property Name="EID" Type="Edm.Int16" Nullable="false"/>
+				<Property Name="EValue" Type="Edm.Int16"/>
+				<NavigationProperty Name="EtoC" Partner="CtoEs" Type="special.cases.C"/>
+			</EntityType>
 			<ComplexType Name="Address">
 				<Property Name="City" Type="Edm.String"/>
 				<Property Name="ZIP" Type="Edm.String" MaxLength="5" />
@@ -303,6 +312,24 @@
 					</Collection>
 				</Annotation>
 			</Annotations>
+			<Annotations Target="special.cases.E/EValue">
+				<Annotation Term="com.sap.vocabularies.Common.v1.ValueList" Qualifier="same">
+					<Record>
+						<PropertyValue Property="Label" String="Same label ;-)" />
+					</Record>
+				</Annotation>
+				<Annotation Term="com.sap.vocabularies.Common.v1.ValueListRelevantQualifiers">
+					<Collection>
+						<If>
+							<Eq>
+								<Path>EtoC/CValue</Path>
+								<Path>EtoC/CtoA/AValue</Path>
+							</Eq>
+							<String>same</String>
+						</If>
+					</Collection>
+				</Annotation>
+			</Annotations>
 			<Annotations Target="special.cases.ArtistsType">
 				<Annotation Qualifier="OldChart" Term="Org.OData.Aggregation.V1.RecursiveHierarchy">
 					<Record>

package/test/sap/ui/core/qunit/odata/v4/lib/_AggregationCache.qunit.js

@@ -4,6 +4,7 @@
 sap.ui.define([
 	"sap/base/Log",
 	"sap/ui/base/SyncPromise",
+	"sap/ui/model/odata/ODataUtils",
 	"sap/ui/model/odata/v4/lib/_AggregationCache",
 	"sap/ui/model/odata/v4/lib/_AggregationHelper",
 	"sap/ui/model/odata/v4/lib/_Cache",
@@ -11,8 +12,8 @@ sap.ui.define([
 	"sap/ui/model/odata/v4/lib/_GroupLock",
 	"sap/ui/model/odata/v4/lib/_Helper",
 	"sap/ui/model/odata/v4/lib/_MinMaxHelper"
-], function (Log, SyncPromise, _AggregationCache, _AggregationHelper, _Cache, _ConcatHelper,
-		_GroupLock, _Helper, _MinMaxHelper) {
+], function (Log, SyncPromise, ODataUtils, _AggregationCache, _AggregationHelper, _Cache,
+		_ConcatHelper, _GroupLock, _Helper, _MinMaxHelper) {
 	/*eslint no-sparse-arrays: 0 */
 	"use strict";
 
@@ -1547,7 +1548,7 @@ sap.ui.define([
 			oGrandTotal = {},
 			oGrandTotalCopy = {},
 			iOffset = oFixture.bHasGrandTotal && oFixture.grandTotalAtBottomOnly !== true ? 1 : 0,
-			iPrefetchLength = 100,
+			iPrefetchLength = 20,
 			oReadResult = {
 				value : []
 			},
@@ -1563,12 +1564,12 @@ sap.ui.define([
 			oCache.oGrandTotalPromise = SyncPromise.resolve(oGrandTotal);
 			_Helper.setPrivateAnnotation(oGrandTotal, "copy", oGrandTotalCopy);
 		}
-		for (i = 0; i < iFirstLevelLength; i += 1) {
+		for (i = 0; i < Math.min(iFirstLevelLength + iPrefetchLength, 42); i += 1) {
 			oReadResult.value.push({});
 		}
 		oReadResult.value.$count = 42;
 		this.mock(oCache.oFirstLevel).expects("read")
-			.withExactArgs(iFirstLevelIndex, iFirstLevelLength, iPrefetchLength,
+			.withExactArgs(iFirstLevelIndex, iFirstLevelLength + iPrefetchLength, 0,
 				"~oGroupLock~", "~fnDataRequested~")
 			.returns(SyncPromise.resolve(Promise.resolve(oReadResult)));
 		if (oFixture.bHasGrandTotal) {
@@ -1604,7 +1605,7 @@ sap.ui.define([
 				.withExactArgs(iExpectedLevel, i, sinon.match.same(oCache.oFirstLevel))
 				.returns("~placeholder~" + i);
 		}
-		for (i = iFirstLevelIndex + iFirstLevelLength; i < 42; i += 1) {
+		for (i = iFirstLevelIndex + iFirstLevelLength + iPrefetchLength; i < 42; i += 1) {
 			oAggregationHelperMock.expects("createPlaceholder")
 				.withExactArgs(iExpectedLevel, i, sinon.match.same(oCache.oFirstLevel))
 				.returns("~placeholder~" + i);
@@ -1618,7 +1619,7 @@ sap.ui.define([
 				for (i = 0; i < iFirstLevelIndex; i += 1) {
 					assert.strictEqual(oCache.aElements[iOffset + i], "~placeholder~" + i);
 				}
-				for (i = iFirstLevelIndex + iFirstLevelLength; i < 42; i += 1) {
+				for (i = iFirstLevelIndex + iFirstLevelLength + iPrefetchLength; i < 42; i += 1) {
 					assert.strictEqual(oCache.aElements[iOffset + i], "~placeholder~" + i);
 				}
 
@@ -1721,47 +1722,94 @@ sap.ui.define([
 			},
 			oGroupLockMock = this.mock(oGroupLock),
 			aReadResult0 = [{}, {}],
-			aReadResult1 = [{}];
+			aReadResult1 = [{}, {}, {}, {}];
 
 		oCache.aElements = [
 			{/* expanded node */},
 			oFirstLeaf,
 			_AggregationHelper.createPlaceholder(1, 1, "~oGroupLevelCache~"),
 			_AggregationHelper.createPlaceholder(1, 2, "~oGroupLevelCache~"),
-			_AggregationHelper.createPlaceholder(0, 1, "~oFirstLevelCache~")
+			_AggregationHelper.createPlaceholder(0, 1, "~oFirstLevelCache~"),
+			_AggregationHelper.createPlaceholder(0, 2, "~oFirstLevelCache~"),
+			_AggregationHelper.createPlaceholder(0, 3, "~oFirstLevelCache~"),
+			_AggregationHelper.createPlaceholder(0, 4, "~oFirstLevelCache~")
 		];
 		oCache.aElements.$byPredicate = {};
-		oCache.aElements.$count = 42;
+		oCache.aElements.$count = 7;
 
+		const oReadRangeExpectation = this.mock(ODataUtils).expects("_getReadRange")
+			.withExactArgs(sinon.match.same(oCache.aElements), 1, 4, 5, sinon.match.func)
+			.returns({length : 9, start : 1}); // note: beyond $count
 		oGroupLockMock.expects("getUnlockedCopy").withExactArgs().returns("~oGroupLockCopy0~");
 		oGroupLockMock.expects("getUnlockedCopy").withExactArgs().returns("~oGroupLockCopy1~");
 		oCacheMock.expects("readGap")
 			.withExactArgs("~oGroupLevelCache~", 2, 4, "~oGroupLockCopy0~", "~fnDataRequested~")
 			.returns(addElementsLater(oCache, aReadResult0, 2));
 		oCacheMock.expects("readGap")
-			.withExactArgs("~oFirstLevelCache~", 4, 5, "~oGroupLockCopy1~", "~fnDataRequested~")
+			.withExactArgs("~oFirstLevelCache~", 4, 8, "~oGroupLockCopy1~", "~fnDataRequested~")
 			.returns(addElementsLater(oCache, aReadResult1, 4));
 		oGroupLockMock.expects("unlock").withExactArgs();
 
 		// code under test
-		return oCache.read(1, 4, 0, oGroupLock, "~fnDataRequested~").then(function (oResult) {
+		return oCache.read(1, 4, 5, oGroupLock, "~fnDataRequested~").then((oResult) => {
 			assert.strictEqual(oResult.value.length, 4);
 			assert.strictEqual(oResult.value[0], oFirstLeaf);
 			assert.strictEqual(oResult.value[1], aReadResult0[0]);
 			assert.strictEqual(oResult.value[2], aReadResult0[1]);
 			assert.strictEqual(oResult.value[3], aReadResult1[0]);
-			assert.strictEqual(oResult.value.$count, 42);
+			assert.strictEqual(oResult.value.$count, 7);
 
 			assert.strictEqual(oCache.aElements[1], oFirstLeaf);
 			assert.strictEqual(oCache.aElements[2], aReadResult0[0]);
 			assert.strictEqual(oCache.aElements[3], aReadResult0[1]);
 			assert.strictEqual(oCache.aElements[4], aReadResult1[0]);
+			assert.strictEqual(oCache.aElements[5], aReadResult1[1]);
+			assert.strictEqual(oCache.aElements[6], aReadResult1[2]);
+			assert.strictEqual(oCache.aElements[7], aReadResult1[3]);
+
+			const fnReadRangeCallback = oReadRangeExpectation.args[0][4];
+
+			// code under test
+			assert.notOk(fnReadRangeCallback({}));
+
+			const oGroupLevelCache = {isMissing : mustBeMocked};
+			this.mock(oGroupLevelCache).expects("isMissing").withExactArgs(0).returns("~");
+			let oEntity = {
+				"@$ui5._" : {
+					parent : oGroupLevelCache,
+					placeholder : true,
+					rank : 0
+				}
+			};
+
+			// code under test
+			assert.strictEqual(fnReadRangeCallback(oEntity), "~");
+
+			oEntity = {
+				"@$ui5._" : {
+					placeholder : 1,
+					predicate : "('~')"
+				}
+			};
+			oCache.aElements.$byPredicate["('~')"] = oEntity;
+
+			// code under test
+			assert.ok(fnReadRangeCallback(oEntity));
+
+			oCache.aElements.$byPredicate["('~')"] = SyncPromise.resolve();
+
+			// code under test
+			assert.notOk(fnReadRangeCallback(oEntity));
 		});
 	});
 
 	//*********************************************************************************************
-[1, 2].forEach(function (iLength) {
-	QUnit.test("read: gap at start, iLength = " + iLength, function (assert) {
+[
+	{iStart : 0, iLength : 1, iPrefetchLength : 0},
+	{iStart : 0, iLength : 2, iPrefetchLength : 0},
+	{iStart : 1, iLength : 1, iPrefetchLength : 1}
+].forEach(function (oFixture) {
+	QUnit.test("read: gap at start " + JSON.stringify(oFixture), function (assert) {
 		var oAggregation = { // filled before by buildApply
 				aggregate : {},
 				group : {},
@@ -1782,6 +1830,10 @@ sap.ui.define([
 		oCache.aElements.$byPredicate = {};
 		oCache.aElements.$count = 42;
 
+		this.mock(ODataUtils).expects("_getReadRange")
+			.withExactArgs(sinon.match.same(oCache.aElements), oFixture.iStart, oFixture.iLength,
+				oFixture.iPrefetchLength, sinon.match.func)
+			.returns({length : 2, start : 0});
 		this.mock(oGroupLock).expects("getUnlockedCopy").withExactArgs()
 			.returns("~oGroupLockCopy~");
 		this.mock(oCache).expects("readGap")
@@ -1790,10 +1842,12 @@ sap.ui.define([
 		this.mock(oGroupLock).expects("unlock").withExactArgs();
 
 		// code under test
-		return oCache.read(0, iLength, 0, oGroupLock, "~fnDataRequested~").then(function (oResult) {
-			assert.strictEqual(oResult.value.length, iLength);
-			assert.strictEqual(oResult.value[0], aReadResult[0]);
-			if (iLength > 1) {
+		return oCache.read(oFixture.iStart, oFixture.iLength, oFixture.iPrefetchLength, oGroupLock,
+				"~fnDataRequested~"
+		).then(function (oResult) {
+			assert.strictEqual(oResult.value.length, oFixture.iLength);
+			assert.strictEqual(oResult.value[0], oFixture.iStart ? oFirstLeaf : aReadResult[0]);
+			if (oFixture.iLength > 1) {
 				assert.strictEqual(oResult.value[1], oFirstLeaf);
 			}
 			assert.strictEqual(oResult.value.$count, 42);

package/test/sap/ui/core/qunit/odata/v4/lib/_Cache.qunit.js

@@ -8585,7 +8585,7 @@ sap.ui.define([
 			this.mock(oCountChangeListener).expects("onChange");
 			this.mock(oCache).expects("visitResponse")
 				.withExactArgs(sinon.match.same(oPostResult), sinon.match.same(mTypeForMetaPath),
-					"/TEAMS/TEAM_2_EMPLOYEES", sPathInCache + sTransientPredicate);
+					"/TEAMS/TEAM_2_EMPLOYEES", sPathInCache + sTransientPredicate, undefined, true);
 			// simulate a lack of key predicate => the transient predicate is kept
 			oHelperMock.expects("getPrivateAnnotation")
 				.withExactArgs(sinon.match.same(oPostResult), "predicate")
@@ -9108,7 +9108,7 @@ sap.ui.define([
 			.returns({});
 		oCacheMock.expects("visitResponse")
 			.withExactArgs(sinon.match.same(oPostResult), sinon.match.same(mTypeForMetaPath),
-				"/Employees", sTransientPredicate);
+				"/Employees", sTransientPredicate, undefined, true);
 		oHelperMock.expects("updateSelected")
 			.withExactArgs(sinon.match.same(oCache.mChangeListeners), sTransientPredicate,
 				sinon.match.same(oCache.aElements[0]), sinon.match.same(oPostResult), undefined,
@@ -12941,6 +12941,31 @@ sap.ui.define([
 		assert.strictEqual(oCache.iLimit, 3);
 	});
 
+	//*********************************************************************************************
+	QUnit.test("CollectionCache#isMissing", function (assert) {
+		const oCache = _Cache.create(this.oRequestor, "SalesOrders");
+
+		oCache.aElements = [{}];
+
+		// code under test
+		assert.notOk(oCache.isMissing(0));
+		assert.ok(oCache.isMissing(1));
+
+		oCache.$tail = Promise.resolve();
+		oCache.aReadRequests = [{iStart : 5, iEnd : 8}, {iStart : 20, iEnd : 10000}];
+
+		// code under test
+		assert.notOk(oCache.isMissing(0));
+		assert.ok(oCache.isMissing(4));
+		assert.notOk(oCache.isMissing(5));
+		assert.notOk(oCache.isMissing(7));
+		assert.ok(oCache.isMissing(8));
+		assert.ok(oCache.isMissing(19));
+		assert.notOk(oCache.isMissing(20));
+		assert.notOk(oCache.isMissing(9999));
+		assert.ok(oCache.isMissing(10000));
+	});
+
 	//*********************************************************************************************
 	QUnit.test("from$skip", function (assert) {
 		var aCollection = [];

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

@@ -1,5 +1,10 @@
 /*global QUnit */
-sap.ui.define(["sap/ui/core/format/FileSizeFormat", "sap/ui/core/Locale"], function (FileSizeFormat, Locale) {
+sap.ui.define([
+	"sap/base/Log",
+	"sap/base/i18n/Localization",
+	"sap/ui/core/Locale",
+	"sap/ui/core/format/FileSizeFormat"
+], function (Log, Localization, Locale, FileSizeFormat) {
 	"use strict";
 
 	var oFormatBinary = FileSizeFormat.getInstance({ binaryFilesize: true, maxFractionDigits: 2 }, new Locale("en"));
@@ -10,6 +15,7 @@ sap.ui.define(["sap/ui/core/format/FileSizeFormat", "sap/ui/core/Locale"], funct
 	var aDecimalUnitNames = ["Kilobyte", "Megabyte", "Gigabyte", "Terabyte", "Petabyte", "Exabyte", "Zettabyte", "Yottabyte"];
 	var aBinaryUnits;
 	var aDecimalUnits;
+	const sDefaultLanguage = Localization.getLanguage();
 
 	function extractUnits(names) {
 		return names.map(function (name) {
@@ -91,6 +97,15 @@ sap.ui.define(["sap/ui/core/format/FileSizeFormat", "sap/ui/core/Locale"], funct
 	QUnit.module("sap.ui.core.format.FileSizeFormat", {
 		before() {
 			this.__ignoreIsolatedCoverage__ = true;
+		},
+		beforeEach() {
+			this.oLogMock = this.mock(Log);
+			this.oLogMock.expects("warning").never();
+			this.oLogMock.expects("error").never();
+			Localization.setLanguage("en-US");
+		},
+		afterEach() {
+			Localization.setLanguage(sDefaultLanguage);
 		}
 	});
 
@@ -108,6 +123,7 @@ sap.ui.define(["sap/ui/core/format/FileSizeFormat", "sap/ui/core/Locale"], funct
 		checkFormat("binary", "1", "1 Byte");
 		checkFormat("binary", "0x1", "1 Byte");
 		checkFormat("binary", 1048575, "1 MiB");
+		checkFormat("binary", NaN, " Byte"); // NumberFormat by default formats NaN to empty string
 	});
 
 	QUnit.test("format decimal", function (assert) {
@@ -124,6 +140,7 @@ sap.ui.define(["sap/ui/core/format/FileSizeFormat", "sap/ui/core/Locale"], funct
 		checkFormat("decimal", "1", "1 Byte");
 		checkFormat("decimal", "0x1", "1 Byte");
 		checkFormat("decimal", 999999, "1 MB");
+		checkFormat("binary", NaN, " Byte");
 	});
 
 	QUnit.test("format default", function (assert) {
@@ -139,6 +156,7 @@ sap.ui.define(["sap/ui/core/format/FileSizeFormat", "sap/ui/core/Locale"], funct
 		checkFormat("default", 1, "1 Byte");
 		checkFormat("default", "1", "1 Byte");
 		checkFormat("default", "0x1", "1 Byte");
+		checkFormat("binary", NaN, " Byte");
 	});
 
 	QUnit.test("parse binary", function (assert) {

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

@@ -353,6 +353,12 @@ sap.ui.define([
 				{
 					targetDate: Date.UTC(2011, 11, 30, 0),
 					targetTimezone: "Pacific/Apia",
+					// even if time zone offset is +14:00, timezoneDiff has to be 10 otherwise we get a wrong date
+					timezoneDiff: 10
+				},
+				{
+					targetDate: Date.UTC(2011, 11, 31, 0),
+					targetTimezone: "Pacific/Apia",
 					timezoneDiff: -14
 				}
 			].forEach(function (oFixture) {
@@ -619,5 +625,111 @@ sap.ui.define([
 					year: "1970"
 				});
 		});
-	}
-);
+
+	//*********************************************************************************************
+[
+	{oDate: new Date(Date.UTC(2023, 8, 30, 15)), iExpectedOffset: -10},
+	{oDate: new Date(Date.UTC(2023, 9, 1, 3)), iExpectedOffset: -11},
+	{oDate: new Date(Date.UTC(2023, 9, 1, 2)), iExpectedOffset: -10},
+	{oDate: new Date(Date.UTC(2023, 8, 30, 16)), iExpectedOffset: -10},
+	{oDate: new Date(Date.UTC(2024, 3, 6, 15)), iExpectedOffset: -11},
+	{oDate: new Date(Date.UTC(2024, 3, 7, 14)), iExpectedOffset: -10},
+	{oDate: new Date(Date.UTC(2024, 3, 6, 17)), iExpectedOffset: -11}
+].forEach((oFixture, i) => {
+	QUnit.test("calculateOffset: Australia/Hobart, #" + i, function (assert) {
+		assert.strictEqual(TimezoneUtil.calculateOffset(oFixture.oDate, "Australia/Hobart"),
+			oFixture.iExpectedOffset * 3600);
+	});
+});
+
+	//*********************************************************************************************
+[
+	{oDate: new Date(Date.UTC(2023, 8, 2, 21)), iExpectedOffset: 6},
+	{oDate: new Date(Date.UTC(2023, 8, 2, 22)), iExpectedOffset: 6},
+	{oDate: new Date(Date.UTC(2023, 8, 2, 23)), iExpectedOffset: 5},
+	{oDate: new Date(Date.UTC(2023, 8, 3, 10)), iExpectedOffset: 5},
+	{oDate: new Date(Date.UTC(2024, 3, 6, 21)), iExpectedOffset: 5},
+	{oDate: new Date(Date.UTC(2024, 3, 7, 2)), iExpectedOffset: 6},
+	{oDate: new Date(Date.UTC(2024, 3, 8, 10)), iExpectedOffset: 6}
+].forEach((oFixture, i) => {
+	QUnit.test("calculateOffset: Pacific/Easter, #" + i, function (assert) {
+		assert.strictEqual(TimezoneUtil.calculateOffset(oFixture.oDate, "Pacific/Easter"),
+			oFixture.iExpectedOffset * 3600);
+	});
+});
+
+	//*********************************************************************************************
+	QUnit.test("calculateOffset: Daylight Saving Time (DST) switch far away", function (assert) {
+		const oDate = {getTime() {}};
+		const oDateInTimezone = {getTime() {}};
+		const sTimezone = "~sTimezone";
+		const oTimezoneUtilMock = this.mock(TimezoneUtil);
+		this.mock(oDate).expects("getTime").returns(42000);
+		this.mock(oDateInTimezone).expects("getTime").returns(13000);
+		oTimezoneUtilMock.expects("convertToTimezone").withExactArgs(sinon.match.same(oDate), sTimezone)
+			.returns(oDateInTimezone);
+		// -> iInitialOffset = 42000 - 13000 = 29000
+		const oFirstGuessInTimezone = {getTime() {}};
+		this.mock(oFirstGuessInTimezone).expects("getTime").returns(42000);
+		oTimezoneUtilMock.expects("convertToTimezone").withExactArgs(new Date(/*42000 + 29000*/71000), sTimezone)
+			.returns(oFirstGuessInTimezone);
+		// -> iSecondOffset = 71000 - 42000 = 29000
+
+		// code under test - both time zone offsets are equal
+		assert.strictEqual(TimezoneUtil.calculateOffset(oDate, sTimezone), 29);
+	});
+
+	//*********************************************************************************************
+	QUnit.test("calculateOffset: DST switch, second guess matches", function (assert) {
+		const oDate = {getTime() {}};
+		const oDateInTimezone = {getTime() {}};
+		const sTimezone = "~sTimezone";
+		const oTimezoneUtilMock = this.mock(TimezoneUtil);
+		this.mock(oDate).expects("getTime").returns(42000);
+		this.mock(oDateInTimezone).expects("getTime").returns(13000);
+		oTimezoneUtilMock.expects("convertToTimezone").withExactArgs(sinon.match.same(oDate), sTimezone)
+			.returns(oDateInTimezone);
+		// -> iInitialOffset = 42000 - 13000 = 29000
+		const oFirstGuessInTimezone = {getTime() {}};
+		this.mock(oFirstGuessInTimezone).expects("getTime").returns(38000);
+		oTimezoneUtilMock.expects("convertToTimezone").withExactArgs(new Date(/*42000 + 29000*/71000), sTimezone)
+			.returns(oFirstGuessInTimezone);
+		// -> iSecondOffset = 71000 - 38000 = 33000
+		const oSecondGuessInTimezone = {getTime() {}};
+		this.mock(oSecondGuessInTimezone).expects("getTime").returns(42000);
+		oTimezoneUtilMock.expects("convertToTimezone").withExactArgs(new Date(/*42000 + 33000*/75000), sTimezone)
+			.returns(oSecondGuessInTimezone);
+
+		// code under test - both time zone offsets are equal
+		assert.strictEqual(TimezoneUtil.calculateOffset(oDate, sTimezone), 33);
+	});
+
+	//*********************************************************************************************
+[true, false].forEach((bUseFirstOffset) => {
+	const sTitle = "calculateOffset: DST switch, second guess doesn't match, use "
+		+ (bUseFirstOffset ? "first" : "second") + " offset";
+	QUnit.test(sTitle, function (assert) {
+		const oDate = {getTime() {}};
+		const oDateInTimezone = {getTime() {}};
+		const sTimezone = "~sTimezone";
+		const oTimezoneUtilMock = this.mock(TimezoneUtil);
+		this.mock(oDate).expects("getTime").returns(42000);
+		this.mock(oDateInTimezone).expects("getTime").returns(13000);
+		oTimezoneUtilMock.expects("convertToTimezone").withExactArgs(sinon.match.same(oDate), sTimezone)
+			.returns(oDateInTimezone);
+		// -> iInitialOffset = 42000 - 13000 = 29000
+		const oFirstGuessInTimezone = {getTime() {}};
+		this.mock(oFirstGuessInTimezone).expects("getTime").returns(38000);
+		oTimezoneUtilMock.expects("convertToTimezone").withExactArgs(new Date(/*42000 + 29000*/71000), sTimezone)
+			.returns(oFirstGuessInTimezone);
+		// -> iSecondOffset = 71000 - 38000 = 33000
+		const oSecondGuessInTimezone = {getTime() {}};
+		this.mock(oSecondGuessInTimezone).expects("getTime").returns(bUseFirstOffset ? 34000 : 44000);
+		oTimezoneUtilMock.expects("convertToTimezone").withExactArgs(new Date(/*42000 + 33000*/75000), sTimezone)
+			.returns(oSecondGuessInTimezone);
+
+		// code under test - both time zone offsets are equal
+		assert.strictEqual(TimezoneUtil.calculateOffset(oDate, sTimezone), bUseFirstOffset ? 29 : 33);
+	});
+});
+});

package/test/sap/ui/core/qunit/util/reflection/JsControlTreeModifier.qunit.js

@@ -243,6 +243,26 @@ sap.ui.define([
 			assert.strictEqual(oContentAggregation[1], oMovedButton);
 		});
 
+		QUnit.test("replaceAllAggregation", async function(assert) {
+			const oHBox = this.oXmlView.byId("hbox1");
+			const aNewControls = [
+				new Button("button4"),
+				new Button("button5"),
+				new Button("button6")
+			];
+			const aOldControls = oHBox.getItems();
+			await JsControlTreeModifier.replaceAllAggregation(oHBox, "items", aNewControls);
+			const aItems = oHBox.getItems();
+			assert.strictEqual(aItems.length, 3, "the aggregation has 3 items");
+			assert.strictEqual(aItems[0].getId(), "button4", "the items are the new ones");
+			assert.strictEqual(aItems[1].getId(), "button5", "the items are the new ones");
+			assert.strictEqual(aItems[2].getId(), "button6", "the items are the new ones");
+
+			aOldControls.forEach((oControl) => {
+				oControl.destroy();
+			});
+		});
+
 		QUnit.test("createAndAddCustomData adds Custom Data properly", function(assert) {
 			var oCreateStub = sandbox.stub(JsControlTreeModifier, "createControl").resolves("foo");
 			var oSetPropertyStub = sandbox.stub(JsControlTreeModifier, "setProperty");

package/test/sap/ui/core/qunit/util/reflection/XmlTreeModifier.qunit.js

@@ -207,8 +207,8 @@ sap.ui.define([
 					assert.equal(aDefaultAggregationElements.length, 2);
 					assert.equal(aDefaultAggregationElements[0].localName, "Label");
 					assert.equal(aDefaultAggregationElements[0].namespaceURI, "sap.m");
-					assert.equal(aDefaultAggregationElements[0].localName, "Label");
-					assert.equal(aDefaultAggregationElements[0].namespaceURI, "sap.m");
+					assert.equal(aDefaultAggregationElements[1].localName, "Label");
+					assert.equal(aDefaultAggregationElements[1].namespaceURI, "sap.m");
 				});
 		});
 
@@ -485,6 +485,24 @@ sap.ui.define([
 				});
 		});
 
+		[0, 1].forEach(function(iIndex) {
+			QUnit.test(`replaceAllAggregation ${iIndex}`, async function(assert) {
+				const oVBox = XmlTreeModifier._children(this.oXmlView)[iIndex];
+				const oNewItem1 = await XmlTreeModifier.createControl("sap.m.Text", this.oComponent, this.oXmlView2);
+				const oNewItem2 = await XmlTreeModifier.createControl("sap.m.Text", this.oComponent, this.oXmlView2);
+				const oNewItem3 = await XmlTreeModifier.createControl("sap.m.Text", this.oComponent, this.oXmlView2);
+				await XmlTreeModifier.replaceAllAggregation(oVBox, "items", [oNewItem1, oNewItem2, oNewItem3]);
+				const oNewAggregation = await XmlTreeModifier.getAggregation(oVBox, "items");
+				assert.strictEqual(oNewAggregation.length, 3, "three items are in the aggregation");
+				assert.strictEqual(oNewAggregation[0].localName, "Text");
+				assert.strictEqual(oNewAggregation[0].namespaceURI, "sap.m");
+				assert.strictEqual(oNewAggregation[1].localName, "Text");
+				assert.strictEqual(oNewAggregation[1].namespaceURI, "sap.m");
+				assert.strictEqual(oNewAggregation[2].localName, "Text");
+				assert.strictEqual(oNewAggregation[2].namespaceURI, "sap.m");
+			});
+		});
+
 		QUnit.test("getVisible", function (assert) {
 			var oVBox = XmlTreeModifier._children(this.oXmlView)[0];
 			var aChildNodes = XmlTreeModifier._children(oVBox);

package/test/sap/ui/core/relnotes/changes-1.120.json

@@ -663,5 +663,57 @@
         ]
       }
     ]
+  },
+  "1.120.3": {
+    "date": "January 2024",
+    "notes": [
+      {
+        "id": "f4688297e2b2df8f83eb5c8c533d3ac72d9e0cda",
+        "type": "FIX",
+        "text": " sap.ui.model.odata.v2.ODataTreeBinding: consider deep path for context"
+      },
+      {
+        "id": "f8667e5865f4f831d6019ce3be63818a29c36f49",
+        "type": "FIX",
+        "text": " sap.base.i18n.date.TimezoneUtils.calculateOffset: Fix Daylight Saving Time issues",
+        "references": [
+          {
+            "type": "BCP",
+            "reference": "2370140369"
+          }
+        ]
+      }
+    ]
+  },
+  "1.120.4": {
+    "date": "January 2024",
+    "notes": [
+      {
+        "id": "af61e41ea8060843c7d3d2d0cf4a3fd62f2077f7",
+        "type": "FIX",
+        "text": " sap/ui/model/odata/ODataMetadata#_getPropertyMetadata: fix for complex type property"
+      },
+      {
+        "id": "c22c5b0911ca2a9af5a5488e69e4d3a6f484ad1b",
+        "type": "FIX",
+        "text": " sap.ui.core.cldr.zh_TW.json: Replace \"B\" to \"a\" in default timeFormats",
+        "references": [
+          {
+            "type": "BCP",
+            "reference": "2380141822"
+          }
+        ]
+      },
+      {
+        "id": "3473d4adbd3220a2f1251663d5f1955a95b09c30",
+        "type": "FIX",
+        "text": " sap/ui/model/odata/_ODataMetaModelUtils#merge: liftSAPData is called with correct parameters"
+      },
+      {
+        "id": "b3b59d532ae43e5f230f21449e85c89d702156a6",
+        "type": "FIX",
+        "text": " sap.ui.model.analytics.AnalyticalBinding: handle properties of type Edm.time in grouping"
+      }
+    ]
   }
 }