[tests] Cover virtual callbacks during construction

tests/Mono.Android-Tests/Mono.Android-Tests/Java.Interop/VirtualCallbackConstructorTests.cs

@@ -0,0 +1,270 @@
+#nullable enable annotations
+
+using System;
+using System.Threading;
+
+using Android.Runtime;
+
+using Java.Interop;
+
+using NUnit.Framework;
+
+namespace Java.InteropTests
+{
+	[TestFixture]
+	[NonParallelizable]
+	[Category ("VirtualCallbackConstructorParity")]
+	public class VirtualCallbackConstructorTests
+	{
+ [Test]
+ public void ManagedFirstConstructionUsesFinalPeerThroughoutCallback ()
+ {
+ VirtualCallbackConstructorDerived.Reset ();
+ VirtualCallbackConstructorDerived.RunConcurrentLookup = true;
+
+ using var javaClass = VirtualCallbackConstructorDerived.GetJavaClass ();
+ using (var instance = new VirtualCallbackConstructorDerived (42)) {
+ Assert.AreEqual (1, VirtualCallbackConstructorDerived.ConstructorInvocations);
+ Assert.AreEqual (0, VirtualCallbackConstructorDerived.ActivationConstructorInvocations);
+ Assert.AreEqual (1, VirtualCallbackConstructorDerived.CallbackInvocations);
+ Assert.AreEqual (42, instance.CallbackValue);
+ Assert.AreSame (instance, VirtualCallbackConstructorDerived.CallbackPeer);
+ Assert.AreSame (instance, VirtualCallbackConstructorDerived.ReentrantPeer);
+ Assert.AreSame (instance, VirtualCallbackConstructorDerived.ConstructorPeer);
+ AssertConcurrentPeers (instance);
+ AssertRegisteredSame (instance);
+ }
+
+ VirtualCallbackConstructorDerived.ClearReferences ();
+ }
+
+ [Test]
+ public void JavaFirstConstructionPromotesOneProvisionalPeer ()
+ {
+ VirtualCallbackConstructorDerived.Reset ();
+ VirtualCallbackConstructorDerived.RunConcurrentLookup = true;
+
+ using (var instance = CreateFromJava (42)) {
+ Assert.AreEqual (1, VirtualCallbackConstructorDerived.ConstructorInvocations);
+ Assert.AreEqual (1, VirtualCallbackConstructorDerived.ActivationConstructorInvocations);
+ Assert.AreEqual (1, VirtualCallbackConstructorDerived.CallbackInvocations);
+ Assert.AreEqual (42, instance.CallbackValue);
+ Assert.AreSame (instance, VirtualCallbackConstructorDerived.ActivationPeer);
+ Assert.AreSame (instance, VirtualCallbackConstructorDerived.CallbackPeer);
+ Assert.AreSame (instance, VirtualCallbackConstructorDerived.ReentrantPeer);
+ Assert.AreSame (instance, VirtualCallbackConstructorDerived.ConstructorPeer);
+ AssertConcurrentPeers (instance);
+ AssertRegisteredSame (instance);
+ }
+
+ VirtualCallbackConstructorDerived.ClearReferences ();
+ }
+
+ [Test]
+ public void JavaFirstVirtualCallbackExceptionAbortsConstruction ()
+ {
+ VirtualCallbackConstructorDerived.Reset ();
+ VirtualCallbackConstructorDerived.ThrowFromCallback = true;
+
+ try {
+ var exception = Assert.Catch<Exception> (() => CreateFromJavaExpectingException (42));
+
+ Assert.IsNotNull (exception);
+ Assert.IsTrue (exception.ToString ().Contains (VirtualCallbackConstructorDerived.CallbackExceptionMessage));
+ Assert.AreEqual (0, VirtualCallbackConstructorDerived.ConstructorInvocations);
+ Assert.AreEqual (1, VirtualCallbackConstructorDerived.ActivationConstructorInvocations);
+ Assert.AreEqual (1, VirtualCallbackConstructorDerived.CallbackInvocations);
+ Assert.AreSame (VirtualCallbackConstructorDerived.ActivationPeer, VirtualCallbackConstructorDerived.CallbackPeer);
+ Assert.AreSame (VirtualCallbackConstructorDerived.CallbackPeer, VirtualCallbackConstructorDerived.ReentrantPeer);
+ } finally {
+ VirtualCallbackConstructorDerived.CallbackPeer?.Dispose ();
+ VirtualCallbackConstructorDerived.ClearReferences ();
+ }
+ }
+
+ static VirtualCallbackConstructorDerived CreateFromJava (int value)
+ {
+ using var javaClass = VirtualCallbackConstructorDerived.GetJavaClass ();
+ var constructor = JNIEnv.GetMethodID (javaClass.Handle, "<init>", "(I)V");
+ var instance = JNIEnv.StartCreateInstance (javaClass.Handle, constructor, new JValue (value));
+ JNIEnv.FinishCreateInstance (instance, javaClass.Handle, constructor, new JValue (value));
+ var result = Java.Lang.Object.GetObject<VirtualCallbackConstructorDerived> (
+ instance,
+ JniHandleOwnership.TransferLocalRef);
+ Assert.IsNotNull (result);
+ return result;
+ }
+
+ static void CreateFromJavaExpectingException (int value)
+ {
+ IntPtr instance = IntPtr.Zero;
+ try {
+ using var javaClass = VirtualCallbackConstructorDerived.GetJavaClass ();
+ var constructor = JNIEnv.GetMethodID (javaClass.Handle, "<init>", "(I)V");
+ instance = JNIEnv.StartCreateInstance (javaClass.Handle, constructor, new JValue (value));
+ JNIEnv.FinishCreateInstance (instance, javaClass.Handle, constructor, new JValue (value));
+ } finally {
+ if (instance != IntPtr.Zero) {
+ JNIEnv.DeleteLocalRef (instance);
+ }
+ }
+ }
+
+ static void AssertRegisteredSame (VirtualCallbackConstructorDerived instance)
+ {
+ var registered = Java.Lang.Object.GetObject<VirtualCallbackConstructorDerived> (
+ instance.Handle,
+ JniHandleOwnership.DoNotTransfer);
+ Assert.AreSame (instance, registered);
+ }
+
+ static void AssertConcurrentPeers (VirtualCallbackConstructorDerived instance)
+ {
+ Assert.IsNull (VirtualCallbackConstructorDerived.ConcurrentLookupException);
+ Assert.IsNotNull (VirtualCallbackConstructorDerived.ConcurrentPeers);
+ foreach (var peer in VirtualCallbackConstructorDerived.ConcurrentPeers) {
+ Assert.AreSame (instance, peer);
+ }
+ }
+	}
+
+	[Register ("net/dot/android/test/VirtualCallbackConstructorDerived")]
+	public class VirtualCallbackConstructorDerived : global::Net.Dot.Android.Test.VirtualCallbackConstructorBase
+	{
+ public const string CallbackExceptionMessage = "virtual constructor callback throw";
+ const string JavaClassName = "net.dot.android.test.VirtualCallbackConstructorDerived";
+
+ public static int ConstructorInvocations;
+ public static int ActivationConstructorInvocations;
+ public static int CallbackInvocations;
+ public static bool RunConcurrentLookup;
+ public static bool ThrowFromCallback;
+ public static VirtualCallbackConstructorDerived? ActivationPeer;
+ public static VirtualCallbackConstructorDerived? CallbackPeer;
+ public static VirtualCallbackConstructorDerived? ReentrantPeer;
+ public static VirtualCallbackConstructorDerived? ConstructorPeer;
+ public static VirtualCallbackConstructorDerived? []? ConcurrentPeers;
+ public static Exception? ConcurrentLookupException;
+
+ public int CallbackValue;
+
+ [Register (".ctor", "(I)V", "")]
+ public VirtualCallbackConstructorDerived (int value)
+ : base (value)
+ {
+ ConstructorInvocations++;
+ ConstructorPeer = this;
+ }
+
+ public VirtualCallbackConstructorDerived (IntPtr handle, JniHandleOwnership transfer)
+ : base (handle, transfer)
+ {
+ RecordActivation (this);
+ }
+
+ public override void OnConstructed (int value)
+ {
+ CallbackInvocations++;
+ CallbackValue = value;
+ CallbackPeer = this;
+ ReentrantPeer = Java.Lang.Object.GetObject<VirtualCallbackConstructorDerived> (
+ Handle,
+ JniHandleOwnership.DoNotTransfer);
+
+ if (RunConcurrentLookup) {
+ RunConcurrentLookups ();
+ }
+
+ if (ThrowFromCallback) {
+ throw new InvalidOperationException (CallbackExceptionMessage);
+ }
+ }
+
+ internal static void RecordActivation (VirtualCallbackConstructorDerived peer)
+ {
+ ActivationConstructorInvocations++;
+ ActivationPeer = peer;
+ }
+
+ internal static Java.Lang.Class GetJavaClass ()
+ => Java.Lang.Class.ForName (
+ JavaClassName,
+ initialize: true,
+ Android.App.Application.Context.ClassLoader);
+
+ static void RunConcurrentLookups ()
+ {
+ const int threadCount = 2;
+ var timeout = TimeSpan.FromSeconds (10);
+ var peers = new VirtualCallbackConstructorDerived? [threadCount];
+ var exceptions = new Exception? [threadCount];
+ var ready = new CountdownEvent (threadCount);
+ var start = new ManualResetEventSlim ();
+ var threads = new Thread [threadCount];
+
+ for (int i = 0; i < threads.Length; i++) {
+ int index = i;
+ threads [i] = new Thread (() => {
+ try {
+ ready.Signal ();
+ start.Wait ();
+ peers [index] = Java.Lang.Object.GetObject<VirtualCallbackConstructorDerived> (
+ CallbackPeer?.Handle ?? IntPtr.Zero,
+ JniHandleOwnership.DoNotTransfer);
+ } catch (Exception e) {
+ exceptions [index] = e;
+ }
+ }) {
+ IsBackground = true,
+ };
+ threads [i].Start ();
+ }
+
+ bool allReady = ready.Wait (timeout);
+ start.Set ();
+ bool allJoined = true;
+ foreach (var thread in threads) {
+ allJoined &= thread.Join (timeout);
+ }
+
+ if (allJoined) {
+ ready.Dispose ();
+ start.Dispose ();
+ }
+ if (!allReady) {
+ Assert.Fail ($"Concurrent constructor lookup workers did not become ready within {timeout}.");
+ }
+ if (!allJoined) {
+ Assert.Fail ($"Concurrent constructor lookup workers did not complete within {timeout}.");
+ }
+
+ ConcurrentPeers = peers;
+ foreach (var exception in exceptions) {
+ if (exception != null) {
+ ConcurrentLookupException = exception;
+ break;
+ }
+ }
+ }
+
+ public static void Reset ()
+ {
+ ConstructorInvocations = 0;
+ ActivationConstructorInvocations = 0;
+ CallbackInvocations = 0;
+ RunConcurrentLookup = false;
+ ThrowFromCallback = false;
+ ClearReferences ();
+ }
+
+ public static void ClearReferences ()
+ {
+ ActivationPeer = null;
+ CallbackPeer = null;
+ ReentrantPeer = null;
+ ConstructorPeer = null;
+ ConcurrentPeers = null;
+ ConcurrentLookupException = null;
+ }
+	}
+}

tests/Mono.Android-Tests/Mono.Android-Tests/Mono.Android.NET-Tests.csproj

@@ -144,6 +144,7 @@
  <Compile Include="Java.Interop\JnienvTest.cs" />
  <Compile Include="Java.Interop\TrimmableTypeMapRuntimeCoverageTests.cs" />
  <Compile Include="Java.Interop\TrimmableTypeMapTypeManagerTests.cs" />
+ <Compile Include="Java.Interop\VirtualCallbackConstructorTests.cs" />
  <Compile Include="Java.Lang\ObjectArrayMarshaling.cs" />
  <Compile Include="Java.Lang\ObjectTest.cs" />
  <Compile Include="Localization\LocalizationTests.cs" />

tests/Mono.Android-Tests/Mono.Android-Tests/java/net/dot/android/test/VirtualCallbackConstructorBase.java

@@ -0,0 +1,10 @@
+package net.dot.android.test;
+
+public class VirtualCallbackConstructorBase {
+	public VirtualCallbackConstructorBase (int value) {
+ onConstructed (value);
+	}
+
+	public void onConstructed (int value) {
+	}
+}