@openui5/sap.ui.core 1.123.0 → 1.124.0

package/test/sap/ui/core/qunit/mvc/Controller.qunit.js

@@ -6,9 +6,10 @@ sap.ui.define([
 	'sap/ui/core/ElementRegistry',
 	'sap/ui/core/mvc/XMLView',
 	'sap/ui/core/mvc/Controller',
+	'sap/base/future',
 	'sap/base/Log',
 	'sap/ui/qunit/utils/nextUIUpdate'
-], function(Component, Fragment, Element, ElementRegistry, XMLView, Controller, Log, nextUIUpdate) {
+], function(Component, Fragment, Element, ElementRegistry, XMLView, Controller, future, Log, nextUIUpdate) {
 	"use strict";
 
 	QUnit.module("Controller.create API");
@@ -24,6 +25,7 @@ sap.ui.define([
 			})
 			.then(function(oController) {
 				assert.equal(oController.double(8), 16, "Controller implementation was correctly returned");
+				oController.destroy();
 				done();
 			});
 		});
@@ -41,10 +43,14 @@ sap.ui.define([
 		});
 
 		sap.ui.require(["sap/ui/core/Component"], function(Component) {
+			let oCreatedComponent;
 			Component.create({
 				name: "mvc.testdata.ControllerExtensionTest.Test1"
 			})
 			.then(function(oComponent) {
+				oCreatedComponent = oComponent;
+				//oControl is a view and we must take care of the loaded promise.
+				//Actually nested Views/Fragments are created in the 'old' not fully async way
 				return oComponent.getRootControl().loaded();
 			})
 			.then(function(oView) {
@@ -53,6 +59,7 @@ sap.ui.define([
 				assert.ok(oController.triple, "Controller should be extended with 'triple' function");
 				assert.equal(oController.double(3), 6, "Controller implementation works correctly");
 				assert.equal(oController.triple(3), 9, "Controller implementation works correctly");
+				oCreatedComponent.destroy();
 				done();
 			});
 		});
@@ -96,6 +103,10 @@ sap.ui.define([
 					this._pFragment = Fragment.load({
 						name: "testdata.fragments.XMLView",
 						type: "XML"
+					}).then(function(oControl) {
+						//oControl is a view and we must take care of the loaded promise.
+						//Actually nested Views/Fragments are created in the 'old' not fully async way
+						return oControl.loaded();
 					});
 				}
 			});
@@ -203,6 +214,10 @@ sap.ui.define([
 					this._pFragment = Fragment.load({
 						name: "testdata.fragments.XMLView",
 						type: "XML"
+					}).then(function(oControl) {
+						//oControl is a view and we must take care of the loaded promise.
+						//Actually nested Views/Fragments are created in the 'old' not fully async way
+						return oControl.loaded();
 					}).then(function(oControl) {
 						this.getView().addDependent(oControl);
 					}.bind(this));
@@ -294,6 +309,10 @@ sap.ui.define([
 							name: "testdata.fragments.XMLView",
 							type: "XML",
 							id: "horst"
+						}).then(function(oControl) {
+							//oControl is a view and we must take care of the loaded promise.
+							//Actually nested Views/Fragments are created in the 'old' not fully async way
+							return oControl.loaded();
 						}).then(function() {
 							res([]);
 						});
@@ -310,6 +329,7 @@ sap.ui.define([
 				return pFragmentReady.then(function() {
 					assert.equal(oComponent, Component.getOwnerComponentFor(oView.getDependents()[0]), "Owner component set cortrectly for fragment");
 					oComponent.destroy();
+					oView.destroy();
 				});
 			});
 		});
@@ -328,8 +348,12 @@ sap.ui.define([
 							name: "testdata.fragments.XMLView",
 							type: "XML",
 							addToDependents: false
-						}).then(function() {
-							res([]);
+						}).then(function(oControl) {
+							//oControl is a view and we must take care of the loaded promise.
+							//Actually nested Views/Fragments are created in the 'old' not fully async way
+							return oControl.loaded();
+						}).then(function(oFragment) {
+							res(oFragment);
 						});
 					}.bind(this));
 				}
@@ -340,8 +364,9 @@ sap.ui.define([
 			definition: "<mvc:View xmlns:mvc='sap.ui.core.mvc' controllerName='my.Controller06'>" +
 				"</mvc:View>"
 		}).then(function(oView) {
-			return pFragmentReady.then(function() {
+			return pFragmentReady.then(function(oFragment) {
 				assert.equal(oView.getDependents().length, 0, "Fragment is not added to the dependents aggregation of the view");
+				oFragment.destroy();
 				oView.destroy();
 			});
 		});
@@ -360,6 +385,10 @@ sap.ui.define([
 							name: "testdata.fragments.XMLView",
 							type: "XML",
 							autoPrefixId: false
+						}).then(function(oControl) {
+							//oControl is a view and we must take care of the loaded promise.
+							//Actually nested Views/Fragments are created in the 'old' not fully async way
+							return oControl.loaded();
 						}).then(function() {
 							res([]);
 						});
@@ -394,6 +423,10 @@ sap.ui.define([
 							type: "XML",
 							id: "myFragment",
 							autoPrefixId: false
+						}).then(function(oControl) {
+							//oControl is a view and we must take care of the loaded promise.
+							//Actually nested Views/Fragments are created in the 'old' not fully async way
+							return oControl.loaded();
 						}).then(function() {
 							res([]);
 						});
@@ -416,7 +449,13 @@ sap.ui.define([
 
 	QUnit.module("Controller Lifecycle-Hooks");
 
-	QUnit.test("Shouldn't return any values", async (assert) => {
+	/**
+	 * In 2.x calling a hook will throw an error when a value is returned
+	 * @deprecated
+	 */
+
+	QUnit.test("Shouldn't return any values (future=false)", async (assert) => {
+		future.active = false;
 		const aPromises = [];
 		sap.ui.define("my/Controller09.controller", ["sap/ui/core/mvc/Controller"], function(Controller) {
 			return Controller.extend("my.Controller09", {
@@ -441,13 +480,14 @@ sap.ui.define([
 			});
 		});
 
-		/**
-		 * @deprecated
-		 */
 		const oErrorLogSpy = sinon.spy(Log, "error");
 		const oFatalLogSpy = sinon.spy(Log, "fatal");
+		const oController = await Controller.create({
+			name: "my.Controller09"
+		});
 		const oView = await XMLView.create({
-			viewName: "example.mvc.asyncHooks"
+			viewName: "example.mvc.asyncHooks",
+			controller: oController
 		});
 		assert.ok(oView, "View is created");
 		assert.ok(oFatalLogSpy.getCall(0).calledWith("[FUTURE FATAL] The registered Event Listener 'onInit' must not have a return value."), "Correct Fatal Log displayed");
@@ -462,9 +502,6 @@ sap.ui.define([
 		oView.destroy();
 		assert.ok(oFatalLogSpy.getCall(3).calledWith("[FUTURE FATAL] The registered Event Listener 'onExit' must not have a return value."), "Correct Fatal Log displayed");
 
-		/**
-		 * @deprecated
-		 */
 		await (async () => {
 			await Promise.allSettled(aPromises);
 			assert.equal(oErrorLogSpy.callCount, 2, "Two error logs should occur reg. rejected Promises.");
@@ -474,5 +511,120 @@ sap.ui.define([
 		})();
 
 		oFatalLogSpy.restore();
+		future.active = undefined;
+	});
+
+	QUnit.test("onInit Shouldn't return any values (future=true)", async (assert) => {
+		future.active = true;
+		sap.ui.define("my/Controller10.controller", ["sap/ui/core/mvc/Controller"], function(Controller) {
+			return Controller.extend("my.Controller10", {
+				onInit: function() {
+					return "onInit returns a String value";
+				}
+			});
+		});
+
+		const expectedMessage = "The registered Event Listener 'onInit' must not have a return value.";
+		const oController = await Controller.create({
+			name: "my.Controller10"
+		});
+		await assert.rejects(XMLView.create({
+			viewName: "example.mvc.asyncHooks",
+			controller: oController
+		}), new Error(expectedMessage), "onInit must throw an error as it has a return value");
+
+		future.active = undefined;
+	});
+
+	QUnit.test("onExit Shouldn't return any values (future=true)", async (assert) => {
+		future.active = true;
+		let oOnExitPromise;
+		sap.ui.define("my/Controller11.controller", ["sap/ui/core/mvc/Controller"], function(Controller) {
+			return Controller.extend("my.Controller11", {
+				onExit: function() {
+					const oPromise = Promise.reject(new Error("onExit returns rejected Promise."));
+					oOnExitPromise = oPromise;
+					return oPromise;
+				}
+			});
+		});
+
+		const expectedMessage = "The registered Event Listener 'onExit' must not have a return value.";
+		const oController = await Controller.create({
+			name: "my.Controller11"
+		});
+		const oView = await XMLView.create({
+			viewName: "example.mvc.asyncHooks",
+			controller: oController
+		});
+
+		assert.throws(() => {
+			oView.destroy();
+		}, new Error(expectedMessage), "onExit must throw an error as it has a return value");
+
+		await oOnExitPromise.catch((err) => {
+			assert.equal(err.message, "onExit returns rejected Promise.", "onExit promise rejected");
+		});
+
+		future.active = undefined;
+	});
+
+	QUnit.test("onBeforeRendering Shouldn't return any values (future=true)", async (assert) => {
+		future.active = true;
+
+		sap.ui.define("my/Controller12.controller", ["sap/ui/core/mvc/Controller"], function(Controller) {
+			return Controller.extend("my.Controller12", {
+				onBeforeRendering: async function() {
+					const oPromise = Promise.resolve("async onBeforeRendering returns resolved Promise.");
+					await oPromise;
+				}
+			});
+		});
+
+		const expectedMessage = "The registered Event Listener 'onBeforeRendering' must not have a return value.";
+		const oController = await Controller.create({
+			name: "my.Controller12"
+		});
+		const oView = await XMLView.create({
+			viewName: "example.mvc.asyncHooks",
+			controller: oController
+		});
+		oView.placeAt("qunit-fixture");
+
+		await assert.rejects(nextUIUpdate(), new Error(expectedMessage), "onBeforeRendering must throw an error as it has a return value");
+
+		future.active = undefined;
+		oView.destroy();
+	});
+
+	QUnit.test("onAfterRendering Shouldn't return any values (future=true)", async (assert) => {
+		future.active = true;
+		let oOnAfterRenderingPromise;
+		sap.ui.define("my/Controller13.controller", ["sap/ui/core/mvc/Controller"], function(Controller) {
+			return Controller.extend("my.Controller13", {
+				onAfterRendering: async function() {
+					const oPromise = Promise.reject(new Error("async onAfterRendering returns rejected Promise."));
+					oOnAfterRenderingPromise =  oPromise;
+					await oPromise;
+				}
+			});
+		});
+
+		const expectedMessage = "The registered Event Listener 'onAfterRendering' must not have a return value.";
+		const oController = await Controller.create({
+			name: "my.Controller13"
+		});
+		const oView = await XMLView.create({
+			viewName: "example.mvc.asyncHooks",
+			controller: oController
+		});
+		oView.placeAt("qunit-fixture");
+
+		await assert.rejects(nextUIUpdate(), new Error(expectedMessage), "onAfterRendering must throw an error as it has a return value");
+		await oOnAfterRenderingPromise.catch((err) => {
+			assert.equal(err.message, "async onAfterRendering returns rejected Promise.", "onAfterRendering promise rejected");
+		});
+		future.active = undefined;
+		oView.destroy();
 	});
 });

package/test/sap/ui/core/qunit/mvc/EventHandlerResolver.qunit.js

@@ -3,10 +3,12 @@ sap.ui.define([
 	"sap/ui/core/Control",
 	"sap/ui/model/json/JSONModel",
 	"sap/ui/core/mvc/EventHandlerResolver",
+	"sap/base/future",
 	"sap/base/Log",
 	"sap/ui/model/type/Integer",
-	"sap/ui/model/type/Date"
-], function(Control, JSONModel, EventHandlerResolver, Log, IntegerType, DateType) {
+	"sap/ui/model/type/Date",
+	"sap/ui/model/type/String"
+], function(Control, JSONModel, EventHandlerResolver, future, Log, IntegerType, DateType, StringType) {
 	"use strict";
 
 	var oController;
@@ -75,8 +77,11 @@ sap.ui.define([
 		}
 	});
 
-
-	QUnit.test("Plain handler resolution", function(assert) {
+	/**
+	 * @deprecated
+	 */
+	QUnit.test("Plain handler resolution (future=false)", function(assert) {
+		future.active = false;
 		var fnController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod", oController)[0];
 		assert.equal(fnController, oController.fnControllerMethod, "Controller method should be found");
 
@@ -90,6 +95,28 @@ sap.ui.define([
 
 		var fnGlobal = EventHandlerResolver.resolveEventHandler("ns.deepMethod", oController);
 		assert.strictEqual(fnGlobal, undefined, "Function name with deeper path shouldn't be searched in the controller");
+		future.active = undefined;
+	});
+
+	QUnit.test("Plain handler resolution (future=true)", function(assert) {
+		future.active = true;
+		var fnController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod", oController)[0];
+		assert.equal(fnController, oController.fnControllerMethod, "Controller method should be found");
+
+		/**
+		 * @deprecated
+		 */
+		(() => {
+			var fnGlobal = EventHandlerResolver.resolveEventHandler("testEventHandlerResolver.subobject.someGlobalMethod", oController)[0];
+			assert.equal(fnGlobal, window.testEventHandlerResolver.subobject.someGlobalMethod, "Global method should be found");
+		})();
+
+		assert.throws(() => {
+				EventHandlerResolver.resolveEventHandler("ns.deepMethod", oController);
+			},
+			new Error("Event handler name 'ns.deepMethod' could not be resolved to an event handler function"),
+			"Function name with deeper path shouldn't be searched in the controller");
+		future.active = undefined;
 	});
 
 	QUnit.test("Handler resolution when parentheses are present", function(assert) {
@@ -141,7 +168,11 @@ sap.ui.define([
 		assert.equal(oSpy.callCount, 1, "Module method should be called once");
 	});
 
+	/**
+	 * @deprecated
+	 */
 	QUnit.test("Log warning for usage of not properly XML-required modules", function(assert) {
+		future.active = false;
 		var logSpy = sinon.spy(Log, "warning");
 
 		// immediately call the resolving handler
@@ -154,6 +185,22 @@ sap.ui.define([
 		assert.ok(logSpy.calledWith(sinon.match(/Event handler name 'Module.someMethod\(\)' could not be resolved to an event handler function/)));
 
 		logSpy.restore();
+		future.active = undefined;
+	});
+
+	QUnit.test("Throw error for usage of not properly XML-required modules (future=true)", function(assert) {
+		future.active = true;
+
+		const sExpectedMessage = "Event handler name 'Module.someMethod()' could not be resolved to an event handler function";
+		// immediately call the resolving handler
+		assert.throws(() => EventHandlerResolver.resolveEventHandler("Module.someMethod()", oController, {Module: {}}),
+			new Error(sExpectedMessage),
+			"Error thrown");
+		// test without associated controller
+		assert.throws(() => EventHandlerResolver.resolveEventHandler("Module.someMethod()", null, {Module: {}}),
+			new Error(sExpectedMessage),
+			"Error thrown");
+		future.active = undefined;
 	});
 
 	QUnit.test("'this' context when no parenthese is present", function(assert) {
@@ -432,8 +479,11 @@ sap.ui.define([
 		}
 	});
 
-
-	QUnit.test("error cases (and edge cases)", function(assert) {
+	/**
+	 * @deprecated
+	 */
+	QUnit.test("error cases (and edge cases) (future=false)", function(assert) {
+		future.active = false;
 		var fnFromController;
 
 		// unclosed braces
@@ -519,6 +569,94 @@ sap.ui.define([
 		}, function(err){
 			return err.message.indexOf("Bad") > -1;
 		}, "Error should be thrown for non-closed double quotes");
+		future.active = undefined;
+	});
+
+	QUnit.test("error cases (and edge cases) (future=true)", function(assert) {
+		future.active = true;
+		let fnFromController;
+
+		// unclosed braces
+		assert.throws(() => {
+			fnFromController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod(${/someModelProperty)", oController)[0];
+			fnFromController(oDummyEvent);
+		} , (err) => {
+			return err.message.indexOf("no closing braces found") > -1;
+		}, "Correct error should be thrown for non-matching braces");
+
+		// unresolvable formatter
+		fnFromController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod(${path:'/someModelProperty', formatter: '.myNotExistingFormatter'})", oController)[0];
+		assert.throws(() => fnFromController(oDummyEvent),
+			new Error("formatter function .myNotExistingFormatter not found!"),
+			"Error should be thrown for unresolvable formatter");
+
+		// globals within the expression
+		const spy = sinon.spy(Log, "warning");
+		fnFromController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod(Math.max(1))", oController)[0];
+		fnFromController(oDummyEvent);
+		assert.equal(spy.callCount, 2, "Warning should be logged for globals inside parameter section");
+		assert.ok(spy.args[0][0].indexOf("Unsupported global identifier") > -1, "Warning should be logged for globals inside parameter section");
+		Log.warning.restore();
+
+		// wrong expression syntax
+		assert.throws(() => {
+			fnFromController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod(${/someModelProperty} + {/someModelProperty})", oController)[0];
+			fnFromController(oDummyEvent);
+		}, (err) => {
+			return err.message.indexOf("Expected IDENTIFIER") > -1;
+		}, "Error should be thrown for expression syntax error");
+
+		// no expressions within
+		assert.throws(() => EventHandlerResolver.resolveEventHandler(".fnControllerMethod({= 'abc'})", oController),
+			new Error("It looks like an event handler parameter contains a binding expression ({=...}). This is not allowed because the entire event handler is already considered an expression: .fnControllerMethod({= 'abc'})"),
+			"Error should be thrown for expressions inside parameter section");
+		assert.throws(() => {
+			fnFromController(oDummyEvent);
+		}, (err) => {
+			return true; // browser-dependent message
+		}, "Error should be thrown for expressions inside parameter section");
+
+		// starting with a brace
+		assert.throws(() => {
+			fnFromController = EventHandlerResolver.resolveEventHandler("(${/someModelProperty})", oController)[0];
+			fnFromController(oDummyEvent);
+		}, (err) => {
+			return err.message.indexOf("starts with a bracket") > -1;
+		}, "Error should be thrown when starting with a bracket");
+
+		// wrong binding path
+		/*	TODO: help the user detect such issues without making too much noise when an empty value is perfectly fine
+		spy = sinon.spy(Log, "warning");
+		fnFromController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod(${/thisdoesnotExist})", oController)[0];
+		fnFromController(oDummyEvent);
+		assert.equal(spy.callCount, 1, "Warning should be logged for empty values (which may indicate wrong bindings)");
+		assert.ok(spy.args[0][0].indexOf("EventHandlerResolver: no value was returned") > -1, "Warning should be logged for empty values (which may indicate wrong bindings)");
+		*/
+
+		// too many closing braces
+		assert.throws(() => {
+			fnFromController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod(${/someModelProperty}})", oController)[0];
+			fnFromController(oDummyEvent);
+		}, (err) => {
+			return err.message.indexOf("but instead saw }") > -1;
+		}, "Error should be thrown for too many closing braces");
+
+		// non-closed single quotes
+		assert.throws(() => {
+			fnFromController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod('x)", oController)[0];
+			fnFromController(oDummyEvent);
+		}, (err) => {
+			return err.message.indexOf("Bad") > -1;
+		}, "Error should be thrown for non-closed single quotes");
+
+		// non-closed double quotes
+		assert.throws(() => {
+			fnFromController = EventHandlerResolver.resolveEventHandler(".fnControllerMethod(\"x)", oController)[0];
+			fnFromController(oDummyEvent);
+		}, (err) => {
+			return err.message.indexOf("Bad") > -1;
+		}, "Error should be thrown for non-closed double quotes");
+		future.active = undefined;
 	});
 
 	QUnit.module("sap.ui.core.mvc.EventHandlerResolver - parse()");

package/test/sap/ui/core/qunit/mvc/View.qunit.js

@@ -30,7 +30,7 @@ sap.ui.define([
 		oView.destroy();
 	});
 
-	/**
+/**
 	 * @deprecated As of 1.120
 	 */
 	QUnit.module("sap.ui.core.mvc.View#runPreprocessor(sync)", {
@@ -828,7 +828,7 @@ sap.ui.define([
 		}
 	});
 
-	/**
+/**
 	 * @deprecated As of version 1.110
 	 */
 	QUnit.test("Sync view created via constructor", function(assert) {

package/test/sap/ui/core/qunit/mvc/XMLTemplateProcessor.qunit.js

@@ -5,20 +5,22 @@ sap.ui.define([
 	"sap/ui/core/mvc/View",
 	"sap/ui/core/mvc/XMLView",
 	"sap/ui/util/XMLHelper",
+	"sap/base/future",
 	"sap/base/Log",
 	"sap/ui/base/DesignTime",
 	"sap/ui/thirdparty/jquery"
-], function (coreLibrary, XMLTemplateProcessor, View, XMLView, XMLHelper, Log, DesignTime, jQuery) {
+], function (coreLibrary, XMLTemplateProcessor, View, XMLView, XMLHelper, future, Log, DesignTime, jQuery) {
 	"use strict";
 
 	// shortcut for sap.ui.core.mvc.ViewType
 	var ViewType = coreLibrary.mvc.ViewType;
 
 	var sRootView =
-		'<mvc:View height="100%" xmlns:mvc="sap.ui.core.mvc" xmlns="sap.m" id="root">' +
+		'<mvc:View height="100%" xmlns:mvc="sap.ui.core.mvc" xmlns="sap.m">' +
 		'</mvc:View>';
 
-	var sView =
+
+	const sView =
 		'<mvc:View height="100%" xmlns:mvc="sap.ui.core.mvc" xmlns:core="sap.ui.core" xmlns="sap.m" id="view" ' +
 			'xmlns:dt="sap.ui.dt" displayBlock="true" unknownProperty="true">' +
 			'<Panel id="panel">' +
@@ -35,7 +37,42 @@ sap.ui.define([
 				'</content>' +
 			'</Panel>' +
 		'</mvc:View>';
+	const sView2 =
+		'<mvc:View height="100%" xmlns:mvc="sap.ui.core.mvc" xmlns:core="sap.ui.core" xmlns="sap.m" ' +
+			'xmlns:dt="sap.ui.dt" displayBlock="true" >' +
+			'<Panel id="panel">' +
+				'<content>' +
+					'<Button text="Button" id="button"></Button>' +
+					'<Button text="Button With Designtime Data" id="buttonWithDTData" dt:test="testvalue"></Button>' +
+					'<Button text="Button using core:require" id="buttonRequire" core:require="{Link:\'sap/m/Link\'}"></Button>' +
+					'<Button text="Button using Designtime Data and core:require" id="buttonWithDTDataAndRequire" dt:test="testvalue2" core:require="{Link:\'sap/m/Link\'}"></Button>' +
+					'<Button text="StashedButton" id="stashedButton" stashed="true"></Button>' +
+					'<Button text="Wrong Type value" id="brokenButton"></Button>' +
+					'<core:ExtensionPoint name="extension">' +
+						'<Button text="ExtensionButton" id="extensionButton"></Button>' +
+					'</core:ExtensionPoint>' +
+				'</content>' +
+			'</Panel>' +
+		'</mvc:View>';
 
+	const sView3 =
+		'<mvc:View height="100%" xmlns:mvc="sap.ui.core.mvc" xmlns:core="sap.ui.core" xmlns="sap.m" ' +
+			'xmlns:dt="sap.ui.dt" displayBlock="true" >' +
+			'<Panel id="panel">' +
+				'<content>' +
+					'<Button text="Button" id="button"></Button>' +
+					'<Button text="Button With Designtime Data" id="buttonWithDTData" dt:test="testvalue"></Button>' +
+					'<Button text="Button using core:require" id="buttonRequire" core:require="{Link:\'sap/m/Link\'}"></Button>' +
+					'<Button text="Button using Designtime Data and core:require" id="buttonWithDTDataAndRequire" dt:test="testvalue2" core:require="{Link:\'sap/m/Link\'}"></Button>' +
+					'<Button text="StashedButton" id="stashedButton" stashed="true"></Button>' +
+					'<Button text="Wrong Type value" id="brokenButton" type="somethingInvalid"></Button>' +
+					'<Button text="Wrong Type value" id="brokenButton"></Button>' +
+					'<core:ExtensionPoint name="extension">' +
+						'<Button text="ExtensionButton" id="extensionButton"></Button>' +
+					'</core:ExtensionPoint>' +
+				'</content>' +
+			'</Panel>' +
+		'</mvc:View>';
 
 	/**
 	 * @deprecated As of version 1.120
@@ -78,8 +115,12 @@ sap.ui.define([
 		}.bind(this));
 	});
 
-	QUnit.module("parseScalarType", {
+	/**
+	 * @deprecated
+	 */
+	QUnit.module("parseScalarType (future=false)", {
 		beforeEach: function() {
+			future.active = false;
 			this.oLogSpy = sinon.spy(Log, "error");
 			this.pViewLoaded = XMLView.create({
 				definition: sView
@@ -90,6 +131,7 @@ sap.ui.define([
 			return this.pViewLoaded.then(function (oView) {
 				this.oLogSpy.restore();
 				oView.destroy();
+				future.active = undefined;
 			}.bind(this));
 		}
 	});
@@ -99,6 +141,19 @@ sap.ui.define([
 		assert.ok(this.oLogSpy.calledWith(sinon.match(/Value 'somethingInvalid' is not valid for type 'sap.m.ButtonType'./)), "Log.error spy was called");
 	});
 
+	QUnit.module("parseScalarType (future=true)", {});
+
+	QUnit.test("Error Logging of invalid type values", async function (assert) {
+		future.active = true;
+		const oView = XMLView.create({
+			definition: sView3
+		});
+		assert.rejects(oView);
+		await oView.catch((err) => {
+			assert.ok(err.message.includes("Value 'somethingInvalid' is not valid for type 'sap.m.ButtonType'.", "View creation rejected with type error"));
+		});
+	});
+
 	/**
 	 * @deprecated As of version 1.110
 	 */
@@ -532,7 +587,7 @@ sap.ui.define([
 	QUnit.module("Custom Settings",{
 		beforeEach: function() {
 			this.pView = XMLView.create({
-				definition: sView,
+				definition: sView2,
 				id: "view"
 			});
 			this.xml = XMLHelper.parse(sView);