@openui5/sap.ui.core 1.117.1 → 1.119.0

package/src/sap/ui/qunit/qunit-coverage-istanbul.js

@@ -97,6 +97,26 @@
 		return oUrl.toString();
 	}
 
+	// Some of the reporting configurations could be set on the frontend
+	// Take those configurations and parse them
+	function getConfig() {
+		if (!oScript) {
+			return {};
+		}
+
+		var oConfig = {};
+		var watermarkProps = ["statements", "functions", "branches", "lines"];
+		watermarkProps.reduce(function(acc, prop) {
+			if (oScript.hasAttribute("data-sap-ui-cover-watermarks-" + prop)) {
+				acc["watermarks"] = acc["watermarks"] || {};
+				acc["watermarks"][prop] = JSON.parse(oScript.getAttribute("data-sap-ui-cover-watermarks-" + prop));
+			}
+			return acc;
+		}, oConfig);
+
+		return oConfig;
+	}
+
 	// check for coverage being active or not
 	if (QUnit.urlParams.coverage) {
 
@@ -126,19 +146,53 @@
 			if (window.top !== window){
 				return;
 			}
-			sap.ui.require(["sap/base/util/fetch"], function (fetch) {
-				fetch("/.ui5/coverage/report", {
-					method: "POST",
-					body: JSON.stringify(window.top.__coverage__),
-					headers: {
-						"Content-Type": "application/json"
+			sap.ui.require(["sap/base/util/fetch", "sap/base/util/Version"], function (fetch, Version) {
+				var oConfig = getConfig();
+				var oWatermarks = oConfig.watermarks;
+
+				fetch("/.ui5/coverage/ping", {
+					method: "GET"
+				})
+				.then(function (pResponse) {
+					return pResponse.json();
+				})
+				.then(function(oMiddlewareConfig){
+					// As of version >= 1.1.0 @ui5/middleware-code-coverage supports more enhanced structure for
+					// the request body. Directly sending the new coverage object will cause an error for older versions.
+					var oMiddlewareVersion = new Version(oMiddlewareConfig.version);
+					var bIsLegacyAPI = oMiddlewareVersion.compareTo("1.1.0") < 0;
+
+					if (bIsLegacyAPI) {
+						if (oWatermarks) {
+							// eslint-disable-next-line no-console
+							console.error(
+								"Coverage option \"watermarks\" is provided, but the current version of " +
+								"@ui5/middleware-code-coverage (" + oMiddlewareVersion.toString() + ") doesn't support it. " +
+								"Please upgrade @ui5/middleware-code-coverage to v1.1.0 or higher."
+							);
+						}
+						return window.top.__coverage__; // Backwards compatibility
+					} else {
+						return {
+							coverage: window.top.__coverage__,
+							watermarks: oWatermarks
+						};
 					}
+				}).then(function (oRequestBody) {
+					return fetch("/.ui5/coverage/report", {
+						method: "POST",
+						body: JSON.stringify(oRequestBody),
+						headers: {
+							"Content-Type": "application/json"
+						}
+					});
 				})
 				.then(function (pResponse) {
 					return pResponse.json();
 				})
 				.then(function (oData) {
 					var aReports = oData.availableReports;
+					// eslint-disable-next-line max-nested-callbacks
 					var oHTMLReport = aReports.filter(function (oCurReport) {
 						// HTML is the only one that make sense and
 						// provides understandable information

package/src/sap/ui/qunit/utils/ControlIterator.js

@@ -53,7 +53,7 @@ sap.ui.define(['sap/ui/core/Core', "sap/ui/VersionInfo"],
 	 * @namespace
 	 *
 	 * @author SAP SE
-	 * @version 1.117.1
+	 * @version 1.119.0
 	 *
 	 * @public
 	 * @since 1.48.0

package/src/sap/ui/qunit/utils/MemoryLeakCheck.js

@@ -6,8 +6,8 @@
 
 /*global QUnit*/
 
-sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core' /* provides sap.ui.getCore() */ ],
-		function(Element, Control) {
+sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', "sap/ui/qunit/utils/nextUIUpdate", 'sap/ui/core/Core' /* provides sap.ui.getCore() */ ],
+		function(Element, Control, nextUIUpdate) {
 	"use strict";
 
 	if ( typeof QUnit === "undefined" ) {
@@ -27,7 +27,7 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 	 * @namespace
 	 *
 	 * @author SAP SE
-	 * @version 1.117.1
+	 * @version 1.119.0
 	 *
 	 * @public
 	 * @since 1.48.0
@@ -66,7 +66,7 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 	// Has some special logic to ignore or work around problems where certain controls do not work standalone.
 	var _checkControl = function(sControlName, fnControlFactory, fnSomeAdditionalFunction, bControlCannotRender) {
 
-		QUnit.test("Control " + sControlName + " should not have any memory leaks", function(assert) {
+		QUnit.test("Control " + sControlName + " should not have any memory leaks", async function(assert) {
 			var oControl1 = fnControlFactory();
 
 			assert.ok(oControl1, "calling fnControlFactory() should return something (a control)");
@@ -90,7 +90,7 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 			if (oControl1.placeAt && !bControlCannotRender) {
 				try {
 					oControl1.placeAt("qunit-fixture");
-					sap.ui.getCore().applyChanges();
+					await nextUIUpdate();
 
 				} catch (e) {
 					// control didn't say it has problems with rendering!
@@ -101,11 +101,11 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 
 			if (fnSomeAdditionalFunction) {
 				fnSomeAdditionalFunction(oControl1);
-				sap.ui.getCore().applyChanges();
+				await nextUIUpdate();
 			}
 
 			oControl1.destroy();
-			sap.ui.getCore().applyChanges();
+			await nextUIUpdate();
 
 
 			// Render Control Instance 2 - any new controls leaked?
@@ -116,21 +116,20 @@ sap.ui.define([ 'sap/ui/core/Element', 'sap/ui/core/Control', 'sap/ui/core/Core'
 
 			if (oControl2.placeAt && !bControlCannotRender) {
 				oControl2.placeAt("qunit-fixture");
-				sap.ui.getCore().applyChanges();
+				await nextUIUpdate();
 
 				oControl2.rerender(); // just re-render again - this finds problems
-				sap.ui.getCore().applyChanges();
 			}
 
 			if (fnSomeAdditionalFunction) {
 				fnSomeAdditionalFunction(oControl2);
-				sap.ui.getCore().applyChanges();
+				await nextUIUpdate();
 			}
 
 			// check what's left after destruction
 
 			oControl2.destroy();
-			sap.ui.getCore().applyChanges();
+			await nextUIUpdate();
 			var mPostElements = getAllAliveControls();
 
 			// controls left over by second instance are real leaks that will grow proportionally to instance count => ERROR

package/src/sap/ui/qunit/utils/nextUIUpdate.js

@@ -0,0 +1,51 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+sap.ui.define([
+    "sap/base/Log",
+    "sap/ui/core/Rendering"
+], function(
+    Log,
+    Rendering
+) {
+	"use strict";
+
+    /**
+     * Return a Promise that resolves when the next Rendering is ready.
+     * If no rendering is sheduled it resolves immediately.
+     *
+     * @namespace
+     * @alias module:sap/ui/qunit/utils/nextUIUpdate
+     * @public
+     * @returns {Promise<undefined>} A promise resolving when the next UI update is finished
+     */
+    function nextUIUpdate() {
+        return new Promise(function(resolve) {
+            function isUpdated() {
+                Rendering.detachUIUpdated(isUpdated);
+                resolve();
+            }
+
+            if (Rendering.isPending()) {
+                Rendering.attachUIUpdated(isUpdated);
+            } else {
+                resolve();
+            }
+        });
+    }
+
+    /**
+     * Force a synchrounous rendering.
+     *
+     * @function
+     * @private
+     */
+    nextUIUpdate.runSync = function() {
+        Log.warning("Synchronous rendering forced: Please migrate to asynchronous rendering");
+        Rendering.renderPendingUIUpdates("forced sync rendering...");
+    };
+
+    return nextUIUpdate;
+});

package/src/sap/ui/qunit/utils/waitForThemeApplied.js

@@ -3,12 +3,18 @@
  * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
  * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
  */
-sap.ui.define(["sap/ui/core/Core"], function(Core) {
+sap.ui.define([
+	"sap/ui/core/Core",
+	"sap/ui/core/Theming"
+], (
+	Core,
+	Theming
+) => {
 	"use strict";
 
 	/**
 	 * Checks whether the theme has already been applied and if not, waits for the
-	 * 'ThemeChanged' event to be fired.
+	 * 'applied' event to be fired.
 	 *
 	 * @example <caption>This module can be used to delay the QUnit test start.
 	 * When using the Test Starter, the Promise can be returned from the test module.</caption>
@@ -26,22 +32,18 @@ sap.ui.define(["sap/ui/core/Core"], function(Core) {
 	 *
 	 * @returns {Promise} Promise that resolves when the theme has been applied
 	 */
-	var waitForThemeApplied = function() {
+	const waitForThemeApplied = () => {
+		let bCoreIsReady = false;
+		Core.ready(() => {
+			bCoreIsReady = true;
+		});
 
-		if (typeof sap === "undefined" || !sap.ui || typeof sap.ui.getCore !== "function") {
+		if (!bCoreIsReady) {
 			return Promise.reject(new Error("UI5 Core must be loaded and booted before using the sap/ui/qunit/utils/waitForThemeApplied module"));
 		}
 
-		return new Promise(function(resolve /*, reject*/) {
-			if (Core.isThemeApplied()) {
-				resolve();
-			} else {
-				var themeChanged = function() {
-					resolve();
-					Core.detachThemeChanged(themeChanged);
-				};
-				Core.attachThemeChanged(themeChanged);
-			}
+		return new Promise((resolve /*, reject*/) => {
+			Theming.attachAppliedOnce(resolve);
 		});
 	};
 

package/src/sap/ui/test/BlanketReporterUI.view.xml

@@ -2,6 +2,7 @@
 		controllerName="sap.ui.test.BlanketReporterUI"
 		xmlns="sap.m"
 		xmlns:table="sap.ui.table"
+		xmlns:tablerm="sap.ui.table.rowmodes"
 		xmlns:core="sap.ui.core"
 		xmlns:mvc="sap.ui.core.mvc"
 		xmlns:form="sap.ui.layout.form">
@@ -34,8 +35,7 @@
 			visible="{= %{/branchTracking}}"/>
 	</form:SimpleForm>
 	<table:Table id="Files" selectionMode="Single" selectionBehavior="RowOnly" rows="{/files}"
-			rowSelectionChange="onRowSelection" visibleRowCountMode="Interactive"
-			minAutoRowCount="1" visibleRowCount="{/visible}">
+			rowSelectionChange="onRowSelection">
 		<table:extension>
 			<HBox>
 				<CheckBox selected="{/filterThreshold}" text="Below Threshold ({/threshold} %)"
@@ -43,6 +43,9 @@
 				<CheckBox select="onRowSelection" selected="{/showHits}" text="Show Hits"/>
 			</HBox>
 		</table:extension>
+		<table:rowMode>
+			<tablerm:Interactive rowCount="{/visible}" minRowCount="1"/>
+		</table:rowMode>
 		<table:columns>
 			<table:Column width="5em" hAlign="Right">
 				<table:label>

package/src/sap/ui/test/ModuleTracking.js

@@ -0,0 +1,326 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2023 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+(function () {
+	"use strict";
+	/*global QUnit */
+	/*eslint no-alert: 0, no-warning-comments: 0 */
+
+	const oScript = Array.from(document.getElementsByTagName("script"))
+		.find((oScript) => /ModuleTracking.js$/.test(oScript.getAttribute("src")));
+
+	function clone(o) {
+		return o && JSON.parse(JSON.stringify(o));
+	}
+
+	//**********************************************************************************************
+	// Code for tracking "Uncaught (in promise)" for sap.ui.base.SyncPromise inside QUnit tests
+	//**********************************************************************************************
+	var Log,
+		sClassName = "sap.ui.base.SyncPromise",
+		iNo = 0,
+		mUncaughtById = {},
+		mUncaughtPromise2Reason = new Map();
+
+	/**
+	 * Check for uncaught errors in sync promises and provide an appropriate report to the given
+	 * optional reporter.
+	 *
+	 * @param {function} [fnReporter]
+	 *   Optional reporter to receive a report
+	 */
+	function checkUncaught(fnReporter) {
+		var sId,
+			iLength = Object.keys(mUncaughtById).length
+				+ (mUncaughtPromise2Reason ? mUncaughtPromise2Reason.size : 0),
+			sMessage = "Uncaught (in promise): " + iLength + " times\n",
+			oPromise,
+			vReason,
+			oResult,
+			itValues;
+
+		if (iLength) {
+			for (sId in mUncaughtById) {
+				oPromise = mUncaughtById[sId];
+				if (oPromise.getResult() && oPromise.getResult().stack) {
+					sMessage += oPromise.getResult().stack;
+				} else {
+					sMessage += oPromise.getResult();
+				}
+				if (oPromise.$error.stack) {
+					sMessage += "\n>>> SyncPromise rejected with above reason...\n"
+						+ oPromise.$error.stack.split("\n").slice(2).join("\n"); // hide listener
+				}
+				sMessage += "\n\n";
+			}
+			mUncaughtById = {};
+
+			//TODO for (let vReason of mUncaughtPromise2Reason.values()) {...}
+			if (mUncaughtPromise2Reason && mUncaughtPromise2Reason.size) {
+				itValues = mUncaughtPromise2Reason.values();
+				for (;;) {
+					oResult = itValues.next();
+					if (oResult.done) {
+						break;
+					}
+					vReason = oResult.value;
+					sMessage += (vReason && vReason.stack || vReason) + "\n\n";
+				}
+				mUncaughtPromise2Reason.clear();
+			}
+
+			if (fnReporter) {
+				fnReporter(sMessage);
+			} else if (Log) {
+				Log.info(`Clearing ${iLength} uncaught promises`, sMessage, sClassName);
+			}
+		}
+	}
+
+	if (oScript.getAttribute("data-uncaught-in-promise") !== "true") {
+		/*
+		 * Listener for "unhandledrejection" events to keep track of "Uncaught (in promise)".
+		 */
+		window.addEventListener("unhandledrejection", function (oEvent) {
+			if (oEvent.reason && oEvent.reason.$uncaughtInPromise) { // ignore exceptional cases
+				return;
+			}
+
+			if (mUncaughtPromise2Reason) {
+				mUncaughtPromise2Reason.set(oEvent.promise, oEvent.reason);
+				oEvent.preventDefault(); // do not report on console
+			} else { // QUnit already done
+				alert("Uncaught (in promise) " + oEvent.reason);
+			}
+		});
+
+		/*
+		 * Listener for "rejectionhandled" events to keep track of "Uncaught (in promise)".
+		 */
+		window.addEventListener("rejectionhandled", function (oEvent) {
+			if (mUncaughtPromise2Reason) {
+				mUncaughtPromise2Reason.delete(oEvent.promise);
+			}
+		});
+	}
+
+	/**
+	 * Listener for sync promises which become (un)caught.
+	 *
+	 * @param {sap.ui.base.SyncPromise} oPromise
+	 *   A sync promise
+	 * @param {boolean} bCaught
+	 *   Tells whether the given sync promise became caught
+	 */
+	function listener(oPromise, bCaught) {
+		if (bCaught) {
+			delete mUncaughtById[oPromise.$id];
+			if (Log) {
+				Log.info(`Promise ${oPromise.$id} caught`,
+					Object.keys(mUncaughtById), sClassName);
+			}
+			return;
+		}
+
+		oPromise.$id = iNo++;
+		oPromise.$error = new Error();
+		mUncaughtById[oPromise.$id] = oPromise;
+		if (Log) {
+			Log.info(`Promise ${oPromise.$id} rejected with ${oPromise.getResult()}`,
+				Object.keys(mUncaughtById), sClassName);
+		}
+	}
+
+	//**********************************************************************************************
+	// Methods dealing with Istanbul
+	//**********************************************************************************************
+
+	// the initial coverage per module (identified by resource name), taken when QUnit starts
+	let mInitialCoverageByModule;
+	const mCoverageSnapshotByModule = {};
+	const bTestsFiltered = /(testId|filter)=/.test(window.location.search);
+
+	function filterCoverage() {
+		// only keep the coverage for the actually tested modules
+		if (window.__coverage__ && Object.keys(mCoverageSnapshotByModule ).length) {
+			window.__coverage__ = mCoverageSnapshotByModule;
+		}
+	}
+
+	function getResourceName(sModuleName) {
+		if (!window.__coverage__) {
+			return undefined;
+		}
+		const sPath = `${sModuleName.replace(/\./g, "/")}.js`;
+		return Object.keys(window.__coverage__)
+			.find((sResourceName) => sResourceName.endsWith(sPath));
+	}
+
+	function resetBranchCounts(oCurrent, oInitial) {
+		const oCurrentCounts = oCurrent.b;
+		const oInitialCounts = oInitial.b;
+		for (const [sKey, aInitialCounts] of Object.entries(oInitialCounts)) {
+			const aCurrentCounts = oCurrentCounts[sKey];
+			aInitialCounts.forEach((iCount, i) => { aCurrentCounts[i] = iCount; });
+		}
+	}
+
+	function resetCounts(oCurrent, oInitial, sList) {
+		const oCurrentCounts = oCurrent[sList];
+		const oInitialCounts = oInitial[sList];
+		for (const [sKey, iCount] of Object.entries(oInitialCounts)) {
+			oCurrentCounts[sKey] = iCount;
+		}
+	}
+
+	function resetModuleCoverage(sModuleName) {
+		const sResourceName = getResourceName(sModuleName);
+		if (sResourceName) {
+			// keep only coverage for the module loading
+			const oCurrent = window.__coverage__[sResourceName];
+			const oInitial = mInitialCoverageByModule[sResourceName];
+			resetBranchCounts(oCurrent, oInitial);
+			resetCounts(oCurrent, oInitial, "f");
+			resetCounts(oCurrent, oInitial, "s");
+		}
+	}
+
+	function saveInitialCoverage() {
+		// the coverage from the module loading
+		mInitialCoverageByModule = clone(window.__coverage__);
+	}
+
+	/**
+	 * Takes a snapshot and verify that all branches, statements and functions are covered.
+	 *
+	 * @param {string} sModuleName - The module name
+	 * @returns {boolean} Whether the coverage is bad
+	 */
+	function handleModuleCoverage(sModuleName) {
+		const sResourceName = getResourceName(sModuleName);
+		if (!sResourceName) {
+			return false;
+		}
+		const oCoverage = clone(window.__coverage__[sResourceName]);
+		mCoverageSnapshotByModule[sResourceName] = oCoverage;
+		if (bTestsFiltered) {
+			return false;
+		}
+		return Object.values(oCoverage.b).some((aCounts) => aCounts.some((iCount) => iCount === 0))
+			|| Object.values(oCoverage.f).some((iCount) => iCount === 0)
+			|| Object.values(oCoverage.s).some((iCount) => iCount === 0);
+	}
+
+	//**********************************************************************************************
+	// Intercept QUnit
+	// Each module shall only be covered when its own tests run. For this purpose we keep the
+	// initial module states. When a module is started, we revert its coverage to the initial state.
+	// When it's finished we take a snapshot. In the end we only keep the snapshots.
+	//**********************************************************************************************
+
+	const fnModule = QUnit.module.bind(QUnit);
+
+	/**
+	 * Wrapper for <code>QUnit.module</code> to check for uncaught errors in sync promises and
+	 * for 100% isolated test coverage.
+	 *
+	 * @param {string} sTitle
+	 *   The module's title
+	 * @param {object} [mHooks]
+	 *   Optional map of hooks, e.g. "beforeEach"
+	 */
+	function module(sTitle, mHooks) {
+		mHooks = mHooks || {};
+		const fnAfter = mHooks.after || function () {};
+		const fnAfterEach = mHooks.afterEach || function () {};
+		const fnBefore = mHooks.before || function () {};
+		const fnBeforeEach = mHooks.beforeEach || function () {};
+
+		mHooks.after = function (assert) {
+			if (!this.__ignoreIsolatedCoverage__ && handleModuleCoverage(sTitle)) {
+				assert.ok(false, `${sTitle}: Coverage below 100%`);
+			}
+
+			return fnAfter.apply(this, arguments);
+		};
+
+		mHooks.afterEach = function (assert) {
+			const fnCheckUncaught = checkUncaught.bind(null, assert.ok.bind(assert, false));
+
+			function error(oError) {
+				fnCheckUncaught();
+				throw oError;
+			}
+
+			function success(vResult) {
+				if (vResult && typeof vResult.then === "function") {
+					return vResult.then(success, error);
+				}
+				fnCheckUncaught();
+				return vResult;
+			}
+
+			try {
+				return success(fnAfterEach.apply(this, arguments));
+			} catch (oError) {
+				return error(oError);
+			}
+		};
+
+		mHooks.before = function () {
+			const oResult = fnBefore.apply(this, arguments);
+			if (!this.__ignoreIsolatedCoverage__) {
+				resetModuleCoverage(sTitle);
+			}
+			return oResult;
+		};
+
+		mHooks.beforeEach = function () {
+			checkUncaught(); // cleans up what happened before
+			return fnBeforeEach.apply(this, arguments);
+		};
+
+		fnModule(sTitle, mHooks);
+	}
+
+	if (QUnit.module !== module) {
+		QUnit.module = module;
+		sap.ui.require([
+			"sap/base/Log",
+			"sap/ui/base/SyncPromise"
+		], function (Log0, SyncPromise) {
+			if (Log0.isLoggable(Log0.Level.INFO, sClassName)) {
+				Log = Log0;
+			}
+			SyncPromise.listener = listener;
+		});
+
+		QUnit.begin(() => {
+			// allow easier module selection: larger list, one click selection
+			document.body.style.overflow = "scroll"; // always show scrollbar, avoid flickering
+			document.getElementById("qunit-modulefilter-dropdown-list").style.maxHeight = "none";
+
+			document.getElementById("qunit-modulefilter-dropdown")
+				.addEventListener("click", function (oMouseEvent) {
+					if (oMouseEvent.target.tagName === "LABEL"
+							&& oMouseEvent.target.innerText !== "All modules") {
+						setTimeout(function () {
+							// click on label instead of checkbox triggers "Apply" automatically
+							document.getElementById("qunit-modulefilter-actions").firstChild
+								.dispatchEvent(new MouseEvent("click"));
+						});
+					}
+				});
+
+			// remember which lines have been covered initially, at load time
+			saveInitialCoverage();
+		});
+
+		QUnit.done(() => {
+			filterCoverage();
+		});
+	}
+}());

package/src/sap/ui/test/OpaPlugin.js

@@ -107,7 +107,7 @@ sap.ui.define([
 				}
 
 				if (oOptions.viewId) {
-					var oCoreElement = UI5Element.registry.get(oOptions.viewId);
+					var oCoreElement = UI5Element.getElementById(oOptions.viewId);
 					if (oCoreElement instanceof View && (!sViewName || oCoreElement.getViewName() === sViewName)) {
 						oView = oCoreElement;
 					}
@@ -509,7 +509,7 @@ sap.ui.define([
 				var hasExpectedType = makeTypeFilterFn(oOptions.controlType);
 
 				if (typeof oOptions.id === "string") {
-					var oControl = UI5Element.registry.get(oOptions.id) || null;
+					var oControl = UI5Element.getElementById(oOptions.id) || null;
 
 					if (oControl && !hasExpectedType(oControl)) {
 						this._oLogger.error("A control with global ID '" + oOptions.id + "' is found but does not have required controlType '" +
@@ -539,7 +539,7 @@ sap.ui.define([
 				var aUnmatchedIds = [];
 
 				aMatchIds.forEach(function (sId) {
-					var oControl = UI5Element.registry.get(sId);
+					var oControl = UI5Element.getElementById(sId);
 					// only return defined controls
 					if (oControl && hasExpectedType(oControl) && !oControl.bIsDestroyed) {
 						aMatchingControls.push(oControl);