Prove Controls remaps execute, and mark the IImageSourcePaint seam

Key presence is cheap to satisfy and proves little, so dispatch the
Controls-remapped properties and the focus commands through the real
composed mappers on real handlers bound to real Controls views. Each
dispatch first asserts the key actually resolves, otherwise UpdateValue on
an unknown key is a silent no-op and the test would pass vacuously -
verified by removing TizenLabelHandler's chain and watching it fail.

TizenLabelHandler is no longer excluded from the reachability theory. Core
fixed it in f90ba12: FormattedText, TextType, LineBreakMode, MaxLines and
TextTransform all resolve now, with no cast failures, so the exclusion note
was stale.

Upstream dotnet/maui#37864 is still open, so the image-background
workaround stays. Mark the exact adoption point in UpdateBackground instead,
with the image-first ordering the fix requires spelled out, and have the
expiry test report the shipped shape of IImageSourcePaint.ImageSource so the
adopter learns in one run whether the planned pattern still applies.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 8b0524d9-c874-4468-bff6-d21f31c772de

Author: Redth

src/Maui.Tizen.Core/Platform/Tizen/TizenPlatformExtensions.cs

@@ -205,6 +205,23 @@ public static void UpdateBackground(this TizenNativeView platformView, Paint? pa
 				return;
 			}
 
+			// ADOPTION SEAM for dotnet/maui#37864 (public read-only IImageSourcePaint).
+			//
+			// The image case must be matched HERE, before the solid/ToColor branches below, or an
+			// image paint keeps flattening to a colour exactly as it does today:
+			//
+			//     if (paint is IImageSourcePaint image)
+			//     {
+			//         platformView.UpdateBackgroundImageSourceAsync(image.ImageSource, provider)
+			//             .FireAndForgetOnUiThread();
+			//         return;
+			//     }
+			//
+			// UpdateBackgroundImageSourceAsync already exists and works (ViewExtensions.cs); the
+			// only missing piece is a public way to detect that the paint is an image at all.
+			// Deliberately NOT done by reflecting over MAUI's internal ImageSourcePaint - see
+			// UpstreamGapExpiryTests, which fails when the contract ships so this cannot be missed.
+
 			if (paint is SolidPaint solid && solid.Color is Color color)
 			{
 				platformView.UpdateBackgroundColor(color.ToTizen());

tests/Maui.Tizen.Core.UnitTests/TizenControlHandlers.cs

@@ -82,6 +82,29 @@ public static IReadOnlySet<string> GetNeutralMapperKeys(string neutralHandlerNam
 			return GetMapperKeys(handlerType);
 		}
 
+		/// <summary>
+		/// Resolves a command from a handler's public static <c>CommandMapper</c>.
+		/// </summary>
+		/// <remarks>
+		/// <c>CommandMapper</c> exposes no key enumeration, only <c>GetCommand</c>, so a command's
+		/// presence can only be established by resolving it.
+		/// </remarks>
+		public static Delegate? GetCommandMapperCommand(Type handlerType, string key)
+		{
+			ControlsRemap.Force();
+
+			var field = handlerType.GetField("CommandMapper", BindingFlags.Public | BindingFlags.Static)
+				?? throw new InvalidOperationException($"{handlerType.Name} has no public static 'CommandMapper' field.");
+
+			var mapper = field.GetValue(null)
+				?? throw new InvalidOperationException($"{handlerType.Name}.CommandMapper is null.");
+
+			var getCommand = mapper.GetType().GetMethod("GetCommand", [typeof(string)])
+				?? throw new InvalidOperationException($"{handlerType.Name}.CommandMapper has no GetCommand(string).");
+
+			return (Delegate?)getCommand.Invoke(mapper, [key]);
+		}
+
 		/// <summary>A control handler and the MAUI types it must stay in step with.</summary>
 		/// <param name="HandlerType">The Tizen handler.</param>
 		/// <param name="VirtualViewType">The MAUI interface it serves.</param>

tests/Maui.Tizen.Core.UnitTests/TizenHandlerMapperTests.cs

@@ -113,18 +113,16 @@ public void EveryChainedMappingInvokesWithoutCastFailure(TizenControlHandlers.Co
 		/// Asserted by observing a key that only exists once Controls has remapped, rather than
 		/// by inspecting the chain structure - it is the reachability that matters.
 		/// </remarks>
-		/// <remarks>
-		/// <c>TizenLabelHandler</c> is deliberately absent: it belongs to the core slice, still
-		/// chains <c>TizenViewMappers.ViewMapper</c> rather than <c>LabelHandler.Mapper</c>, and
-		/// therefore does not yet receive <c>FormattedText</c>, <c>TextType</c>,
-		/// <c>LineBreakMode</c>, <c>MaxLines</c> or <c>TextTransform</c>. Asserting it here would
-		/// fail on someone else's in-flight file; it is reported to the core slice instead.
-		/// </remarks>
 		[Theory]
 		[InlineData(typeof(TizenCheckBoxHandler), "Color")]
 		[InlineData(typeof(TizenButtonHandler), "IsInAccessibleTree")]
 		[InlineData(typeof(TizenEntryHandler), "Description")]
 		[InlineData(typeof(TizenPickerHandler), "Hint")]
+		[InlineData(typeof(TizenPickerHandler), "ItemsSource")]
+		[InlineData(typeof(TizenStepperHandler), "Increment")]
+		[InlineData(typeof(TizenLabelHandler), "FormattedText")]
+		[InlineData(typeof(TizenLabelHandler), "TextType")]
+		[InlineData(typeof(TizenLabelHandler), "MaxLines")]
 		public void ControlsRemappedKeysReachTheBackend(Type handlerType, string key)
 		{
 			ControlsRemap.Force();
@@ -219,6 +217,105 @@ public void ViewCommandKeysMatchTheTizenBaseMapper()
 			}
 		}
 
+		/// <summary>
+		/// The Controls-remapped keys and the focus commands actually <em>execute</em> against a
+		/// Tizen handler, not merely resolve.
+		/// </summary>
+		/// <remarks>
+		/// <para>
+		/// Key presence and command presence are cheap to satisfy and prove little - a chained
+		/// mapper makes every key resolve. This dispatches through the real composed mappers on a
+		/// real handler bound to a real Controls virtual view, so a mapping that resolves to
+		/// something uncallable fails here.
+		/// </para>
+		/// <para>
+		/// <see cref="InvalidCastException"/> is the failure that matters: MAUI's static mappers are
+		/// closed over its concrete handler type, so a key this backend has not overridden throws
+		/// rather than no-ops. Off-platform no-op side effects are ignored, since the host lane has
+		/// no NUI.
+		/// </para>
+		/// </remarks>
+		[Fact]
+		public void ControlsRemappedPropertiesAndFocusCommandsExecute()
+		{
+			ControlsRemap.Force();
+
+			var label = new Controls.Label();
+			var labelHandler = new TizenLabelHandler();
+			labelHandler.SetVirtualView(label);
+
+			// FormattedText is contributed exclusively by Label.RemapForControls.
+			DispatchProperty(labelHandler, label, "FormattedText");
+			DispatchProperty(labelHandler, label, "TextType");
+
+			var entry = new Controls.Entry();
+			var entryHandler = new TizenEntryHandler();
+			entryHandler.SetVirtualView(entry);
+
+			foreach (var command in new[] { nameof(IView.Focus), nameof(IView.Unfocus) })
+				DispatchCommand(entryHandler, entry, command, new FocusRequest());
+
+			// The two keys that were genuinely throwing before they were given Tizen bodies.
+			var picker = new Controls.Picker();
+			var pickerHandler = new TizenPickerHandler();
+			pickerHandler.SetVirtualView(picker);
+			DispatchProperty(pickerHandler, picker, "ItemsSource");
+
+			var stepper = new Controls.Stepper();
+			var stepperHandler = new TizenStepperHandler();
+			stepperHandler.SetVirtualView(stepper);
+			DispatchProperty(stepperHandler, stepper, "Increment");
+		}
+
+		static void DispatchProperty(IElementHandler handler, IElement view, string key)
+		{
+			// Without this the test would be vacuous: UpdateValue on a key no mapper defines does
+			// nothing at all and passes silently.
+			Assert.True(
+				TizenControlHandlers.GetMapperKeys(handler.GetType()).Contains(key),
+				$"{handler.GetType().Name}.Mapper does not define '{key}', so dispatching it is a " +
+				"no-op and this test would prove nothing.");
+
+			try
+			{
+				handler.UpdateValue(key);
+			}
+			catch (InvalidCastException ex)
+			{
+				Assert.Fail(
+					$"Dispatching '{key}' to {handler.GetType().Name} threw InvalidCastException: " +
+					$"{ex.Message}. The key resolves through MAUI's chained mapper, which is closed " +
+					"over MAUI's concrete handler, so this backend must override it.");
+			}
+			catch (Exception)
+			{
+				// An off-platform no-op stand-in has no NUI to touch; only a cast failure means the
+				// composition itself is wrong.
+			}
+		}
+
+		static void DispatchCommand(IElementHandler handler, IElement view, string key, object? args)
+		{
+			Assert.True(
+				TizenControlHandlers.GetCommandMapperCommand(handler.GetType(), key) is not null,
+				$"{handler.GetType().Name}.CommandMapper does not resolve '{key}', so invoking it " +
+				"is a no-op and this test would prove nothing.");
+
+			try
+			{
+				handler.Invoke(key, args);
+			}
+			catch (InvalidCastException ex)
+			{
+				Assert.Fail(
+					$"Invoking command '{key}' on {handler.GetType().Name} threw " +
+					$"InvalidCastException: {ex.Message}.");
+			}
+			catch (Exception)
+			{
+			}
+		}
+
 		/// <summary>
 		/// A mapping referenced by a mapper must not be declared inside <c>#if TIZEN</c>.
 		/// </summary>

tests/Maui.Tizen.Core.UnitTests/UpstreamGapExpiryTests.cs

@@ -60,13 +60,26 @@ public void ImageSourcePaintIsStillInternal()
 				assembly.GetType("Microsoft.Maui.IImageSourcePaint")
 				?? assembly.GetType("Microsoft.Maui.Graphics.IImageSourcePaint");
 
+			// Reported in the failure message so the adopter learns in one run whether the shipped
+			// shape still matches the planned pattern match, rather than discovering it mid-edit.
+			var imageSourceProperty = publicContract?.GetProperty("ImageSource");
+			var shape = publicContract is null
+				? string.Empty
+				: imageSourceProperty is null
+					? "\n\nNOTE: the shipped interface has NO 'ImageSource' property, so the planned " +
+					  "adoption below does not apply as written - re-read the final upstream shape first."
+					: $"\n\nShipped shape: {imageSourceProperty.PropertyType.Name} ImageSource " +
+					  $"{{ {(imageSourceProperty.CanRead ? "get; " : "")}{(imageSourceProperty.CanWrite ? "set; " : "")}}} " +
+					  "- matches the planned consumption-only adoption.";
+
 			Assert.True(
 				publicContract is null,
 				$"""
 				MAUI now exposes '{publicContract?.FullName}'. This is the upstream fix from
 				dotnet/maui#37864 landing, and the image-background workaround should now be removed.
 
-				Adopt it by pattern matching image-first in the background mapping:
+				Adopt it at the ADOPTION SEAM comment in TizenPlatformExtensions.UpdateBackground, by
+				pattern matching image-first:
 
 				    if (paint is IImageSourcePaint imagePaint)
 				        // route imagePaint.ImageSource through UpdateBackgroundImageSourceAsync
@@ -75,7 +88,7 @@ MAUI now exposes '{publicContract?.FullName}'. This is the upstream fix from
 				Match the image case BEFORE the solid/ToColor fallback, or an image paint keeps
 				flattening to a colour exactly as it does today. Use the interface directly - no
 				reflection and no internal types. Then delete this test and update the
-				"MAUI extensibility blockers" section of docs/wave-a-handlers.md.
+				"MAUI extensibility blockers" section of docs/wave-a-handlers.md.{shape}
 				""");
 
 			// The gap is only real while the concrete type is genuinely inaccessible. If this