Introduce an AtomicHelper test simple enough to run under Android.

This test doesn't exercise any alternative `AtomicHelper` implementations; it merely checks that `AbstractFutureState` selects the implementation that we expect under each given environment.

This CL is prompted by my discovery today that I'd gotten a Proguard config wrong. I corrected the config in cl/742724817, but this new test suggests that (at least in under our monorepo's build toolchain, which differs from typical external Android toolchains!) `AbstractFutureState` continued doing the right thing throughout, even under optimization/minification (which I tested locally), apparently because the optimizer autodetected that we were reflecting on the fields. Still, we shouldn't rely on that.

I also cleaned up the existing `AtomicHelper` tests to use a package-private method instead of reading a `private` field. The motivation for that change is that my new test was failing under minification because the class name did not match the expected value. That forced me to expose something more stable about the choice of `AtomicHelper` to the tests. And once I had that, I figured that I might as well use it in the existing tests. Maybe someday I'll update `AggregateFutureStateFallbackAtomicHelperTest` similarly.

This CL continues [work to migrate `guava-android` off `Unsafe`](#7742).

RELNOTES=n/a
PiperOrigin-RevId: 742859752

Author: cpovirk

android/guava-tests/test/com/google/common/util/concurrent/AbstractFutureDefaultAtomicHelperTest.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2015 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.common.util.concurrent;
+
+import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
+import static com.google.common.truth.Truth.assertThat;
+
+import junit.framework.TestCase;
+import org.jspecify.annotations.NullUnmarked;
+
+/**
+ * Tests that {@link AbstractFutureState} uses the expected {@code AtomicHelper} implementation.
+ *
+ * <p>We have more thorough testing of {@code AtomicHelper} implementations in {@link
+ * AbstractFutureFallbackAtomicHelperTest}. The advantage to this test is that it can run under
+ * Android.
+ */
+@NullUnmarked
+public class AbstractFutureDefaultAtomicHelperTest extends TestCase {
+  public void testUsingExpectedAtomicHelper() throws Exception {
+    assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("UnsafeAtomicHelper");
+  }
+
+  private static boolean isJava8() {
+    return JAVA_SPECIFICATION_VERSION.value().equals("1.8");
+  }
+}

android/guava-tests/test/com/google/common/util/concurrent/AbstractFutureFallbackAtomicHelperTest.java

@@ -15,9 +15,9 @@
 package com.google.common.util.concurrent;
 
 import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
+import static com.google.common.truth.Truth.assertThat;
 
 import com.google.common.collect.ImmutableSet;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.net.URLClassLoader;
@@ -111,9 +111,9 @@ private void checkHelperVersion(ClassLoader classLoader, String expectedHelperCl
       throws Exception {
     // Make sure we are actually running with the expected helper implementation
     Class<?> abstractFutureStateClass = classLoader.loadClass(AbstractFutureState.class.getName());
-    Field helperField = abstractFutureStateClass.getDeclaredField("ATOMIC_HELPER");
-    helperField.setAccessible(true);
-    assertEquals(expectedHelperClassName, helperField.get(null).getClass().getSimpleName());
+    Method helperMethod = abstractFutureStateClass.getDeclaredMethod("atomicHelperTypeForTest");
+    helperMethod.setAccessible(true);
+    assertThat(helperMethod.invoke(null)).isEqualTo(expectedHelperClassName);
   }
 
   private static ClassLoader getClassLoader(final Set<String> disallowedClassNames) {

android/guava/src/com/google/common/util/concurrent/AbstractFutureState.java

@@ -24,6 +24,7 @@
 import static java.util.logging.Level.SEVERE;
 
 import com.google.common.annotations.GwtCompatible;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.util.concurrent.AbstractFuture.Listener;
 import com.google.common.util.concurrent.internal.InternalFutureFailureAccess;
 import com.google.j2objc.annotations.ReflectionSupport;
@@ -490,6 +491,11 @@ private void removeWaiter(Waiter node) {
   // blocking. This value is what AbstractQueuedSynchronizer uses.
   private static final long SPIN_THRESHOLD_NANOS = 1000L;
 
+  @VisibleForTesting
+  static String atomicHelperTypeForTest() {
+    return ATOMIC_HELPER.atomicHelperTypeForTest();
+  }
+
   private abstract static class AtomicHelper {
     /** Non-volatile write of the thread to the {@link Waiter#thread} field. */
     abstract void putThread(Waiter waiter, Thread newValue);
@@ -514,6 +520,8 @@ abstract boolean casListeners(
     /** Performs a CAS operation on {@link AbstractFutureState#valueField}. */
     abstract boolean casValue(
         AbstractFutureState<?> future, @Nullable Object expect, Object update);
+
+    abstract String atomicHelperTypeForTest();
   }
 
   /**
@@ -622,6 +630,11 @@ boolean casListeners(
     boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
       return UNSAFE.compareAndSwapObject(future, VALUE_OFFSET, expect, update);
     }
+
+    @Override
+    String atomicHelperTypeForTest() {
+      return "UnsafeAtomicHelper";
+    }
   }
 
   /** {@link AtomicHelper} based on {@link AtomicReferenceFieldUpdater}. */
@@ -678,6 +691,11 @@ boolean casListeners(
     boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
       return valueUpdater.compareAndSet(future, expect, update);
     }
+
+    @Override
+    String atomicHelperTypeForTest() {
+      return "AtomicReferenceFieldUpdaterAtomicHelper";
+    }
   }
 
   /**
@@ -753,5 +771,10 @@ boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object
         return false;
       }
     }
+
+    @Override
+    String atomicHelperTypeForTest() {
+      return "SynchronizedHelper";
+    }
   }
 }

guava-tests/test/com/google/common/util/concurrent/AbstractFutureDefaultAtomicHelperTest.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2015 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.common.util.concurrent;
+
+import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
+import static com.google.common.truth.Truth.assertThat;
+
+import junit.framework.TestCase;
+import org.jspecify.annotations.NullUnmarked;
+
+/**
+ * Tests that {@link AbstractFutureState} uses the expected {@code AtomicHelper} implementation.
+ *
+ * <p>We have more thorough testing of {@code AtomicHelper} implementations in {@link
+ * AbstractFutureFallbackAtomicHelperTest}. The advantage to this test is that it can run under
+ * Android.
+ */
+@NullUnmarked
+public class AbstractFutureDefaultAtomicHelperTest extends TestCase {
+  public void testUsingExpectedAtomicHelper() throws Exception {
+    if (isJava8()) {
+      assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("UnsafeAtomicHelper");
+    } else {
+      assertThat(AbstractFutureState.atomicHelperTypeForTest()).isEqualTo("VarHandleAtomicHelper");
+    }
+  }
+
+  private static boolean isJava8() {
+    return JAVA_SPECIFICATION_VERSION.value().equals("1.8");
+  }
+}

guava-tests/test/com/google/common/util/concurrent/AbstractFutureFallbackAtomicHelperTest.java

@@ -15,9 +15,9 @@
 package com.google.common.util.concurrent;
 
 import static com.google.common.base.StandardSystemProperty.JAVA_SPECIFICATION_VERSION;
+import static com.google.common.truth.Truth.assertThat;
 
 import com.google.common.collect.ImmutableSet;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.net.URLClassLoader;
@@ -134,9 +134,9 @@ private void checkHelperVersion(ClassLoader classLoader, String expectedHelperCl
       throws Exception {
     // Make sure we are actually running with the expected helper implementation
     Class<?> abstractFutureStateClass = classLoader.loadClass(AbstractFutureState.class.getName());
-    Field helperField = abstractFutureStateClass.getDeclaredField("ATOMIC_HELPER");
-    helperField.setAccessible(true);
-    assertEquals(expectedHelperClassName, helperField.get(null).getClass().getSimpleName());
+    Method helperMethod = abstractFutureStateClass.getDeclaredMethod("atomicHelperTypeForTest");
+    helperMethod.setAccessible(true);
+    assertThat(helperMethod.invoke(null)).isEqualTo(expectedHelperClassName);
   }
 
   private static ClassLoader getClassLoader(final Set<String> disallowedClassNames) {

guava/src/com/google/common/util/concurrent/AbstractFutureState.java

@@ -24,6 +24,7 @@
 import static java.util.logging.Level.SEVERE;
 
 import com.google.common.annotations.GwtCompatible;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.util.concurrent.AbstractFuture.Listener;
 import com.google.common.util.concurrent.internal.InternalFutureFailureAccess;
 import com.google.j2objc.annotations.J2ObjCIncompatible;
@@ -496,6 +497,11 @@ private void removeWaiter(Waiter node) {
   // blocking. This value is what AbstractQueuedSynchronizer uses.
   private static final long SPIN_THRESHOLD_NANOS = 1000L;
 
+  @VisibleForTesting
+  static String atomicHelperTypeForTest() {
+    return ATOMIC_HELPER.atomicHelperTypeForTest();
+  }
+
   private enum VarHandleAtomicHelperMaker {
     INSTANCE {
       /**
@@ -554,6 +560,8 @@ abstract boolean casListeners(
     /** Performs a CAS operation on {@link AbstractFutureState#valueField}. */
     abstract boolean casValue(
         AbstractFutureState<?> future, @Nullable Object expect, Object update);
+
+    abstract String atomicHelperTypeForTest();
   }
 
   /** {@link AtomicHelper} based on {@link VarHandle}. */
@@ -624,6 +632,11 @@ boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object
     private static LinkageError newLinkageError(Throwable cause) {
       return new LinkageError(cause.toString(), cause);
     }
+
+    @Override
+    String atomicHelperTypeForTest() {
+      return "VarHandleAtomicHelper";
+    }
   }
 
   /**
@@ -716,6 +729,11 @@ boolean casListeners(
     boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
       return UNSAFE.compareAndSwapObject(future, VALUE_OFFSET, expect, update);
     }
+
+    @Override
+    String atomicHelperTypeForTest() {
+      return "UnsafeAtomicHelper";
+    }
   }
 
   /** {@link AtomicHelper} based on {@link AtomicReferenceFieldUpdater}. */
@@ -772,6 +790,11 @@ boolean casListeners(
     boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
       return valueUpdater.compareAndSet(future, expect, update);
     }
+
+    @Override
+    String atomicHelperTypeForTest() {
+      return "AtomicReferenceFieldUpdaterAtomicHelper";
+    }
   }
 
   /**
@@ -847,5 +870,10 @@ boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object
         return false;
       }
     }
+
+    @Override
+    String atomicHelperTypeForTest() {
+      return "SynchronizedHelper";
+    }
   }
 }