@Test
    void testExtractProjectIdFallback() throws Exception {
        // Use reflection to access the private extractProjectId method
        Method extractProjectIdMethod =
                DefaultProjectBuilder.class.getDeclaredMethod("extractProjectId", ModelBuilderResult.class);
        extractProjectIdMethod.setAccessible(true);

        // Create a mock ModelBuilderResult with null effectiveModel but available rawModel

    assertFalse(
        Visibility.PUBLIC.isVisible(VisibilityMethods.class.getDeclaredMethod("privateMethod")));
    assertFalse(
        Visibility.PUBLIC.isVisible(
            VisibilityMethods.class.getDeclaredMethod("packagePrivateMethod")));
    assertFalse(
        Visibility.PUBLIC.isVisible(VisibilityMethods.class.getDeclaredMethod("protectedMethod")));
    assertTrue(

    static WildcardType getWildcardType(String methodName) throws Exception {
      ParameterizedType parameterType =
          (ParameterizedType)
              WithWildcardType.class.getDeclaredMethod(methodName, List.class)
                  .getGenericParameterTypes()[0];
      return (WildcardType) parameterType.getActualTypeArguments()[0];
    }
  }

  public void testNewWildcardType() throws Exception {

      return invokable;
    }

    static Invokable<?, Object> method(String name, Class<?>... parameterTypes) throws Exception {
      Invokable<?, Object> invokable =
          Invokable.from(A.class.getDeclaredMethod(name, parameterTypes));
      assertEquals(name, invokable.getName());
      assertEquals(A.class, invokable.getDeclaringClass());
      return invokable;
    }

    native void nativeMethod();

  private fun getProcess(): String? =
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
      getProcessName()
    } else {
      Class
        .forName("android.app.ActivityThread")
        .getDeclaredMethod("currentProcessName")
        .apply { isAccessible = true }
        .invoke(null) as String
    }

      // private TrustAnchor findTrustAnchorByIssuerAndSignature(X509Certificate lastCert);
      val method =
        trustManager.javaClass.getDeclaredMethod(
          "findTrustAnchorByIssuerAndSignature",
          X509Certificate::class.java,
        )
      method.isAccessible = true
      CustomTrustRootIndex(trustManager, method)

 *
 * @author Ben Yu
 */
@NullUnmarked
final class ForwardingObjectTester {

  private static final Method DELEGATE_METHOD;

  static {
    try {
      DELEGATE_METHOD = ForwardingObject.class.getDeclaredMethod("delegate");
      DELEGATE_METHOD.setAccessible(true);
    } catch (SecurityException e) {
      throw new RuntimeException(e);
    } catch (NoSuchMethodException e) {
      throw new AssertionError(e);
    }

       * trivially, but it's enough to skip these ones.
       */
      ) {
        continue;
      }
      Class<?> clazz = info.load();
      try {
        Method unused = clazz.getDeclaredMethod("writeReplace");
        continue; // It overrides writeReplace, so it's safe.
      } catch (NoSuchMethodException e) {
        // This is a class whose supertypes we want to examine. We'll do that below.
      }

 * on classpath.
 */
open class AndroidSocketAdapter(
  private val sslSocketClass: Class<in SSLSocket>,
) : SocketAdapter {
  private val setUseSessionTickets: Method =
    sslSocketClass.getDeclaredMethod("setUseSessionTickets", Boolean::class.javaPrimitiveType)
  private val setHostname = sslSocketClass.getMethod("setHostname", String::class.java)

    Class<?> abstractFutureStateClass = classLoader.loadClass(AbstractFutureState.class.getName());
    Method helperMethod = abstractFutureStateClass.getDeclaredMethod("atomicHelperTypeForTest");
    helperMethod.setAccessible(true);
    assertThat(helperMethod.invoke(null)).isEqualTo(expectedHelperClassName);
  }