Class<?> finalizableReferenceClass,
      ReferenceQueue<Object> queue,
      PhantomReference<Object> frqReference) {
    /*
     * We use FinalizableReference.class for two things:
     *
     * 1) To invoke FinalizableReference.finalizeReferent()
     *
     * 2) To detect when FinalizableReference's class loader has to be garbage collected, at which
     * point, Finalizer can stop running
     */

        .build()
  }

  private fun newVirtualThreadPerTaskExecutor(): ExecutorService {
    return Executors::class.java.getMethod("newVirtualThreadPerTaskExecutor").invoke(null) as ExecutorService
  }

  @Test
  fun testRequest() {
    server.enqueue(MockResponse())

    val request = Request(server.url("/"))

    client.newCall(request).execute().use {

      this.map = map;
      this.setUpRan = setUpRan;
    }

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Throwable {
      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);
      } catch (InvocationTargetException e) {
        throw e.getCause();
      } catch (IllegalAccessException e) {

  public void testNextDown() throws Exception {
    Method jdkNextDown = getJdkNextDown();
    for (double d : FINITE_DOUBLE_CANDIDATES) {
      assertEquals(jdkNextDown.invoke(null, d), DoubleUtils.nextDown(d));
    }
  }

  private static Method getJdkNextDown() throws Exception {
    try {
      return Math.class.getMethod("nextDown", double.class);

    }

    /**
     * The main entry point.
     */
    public int run(String[] args) throws IOException {
        try (Invoker<R> invoker = createInvoker()) {
            return invoker.invoke(parseArguments(args));
        } catch (ParserException e) {
            System.err.println(e.getMessage());
            return 1;
        } catch (InvokerException e) {
            return 1;
        } finally {

```

#### Option B: Paste your code here or provide a link to a custom end-to-end colab

```
(You can paste links or attach files by dragging & dropping them below)
- Include code to invoke the TFLite Converter Python API and the errors.
- Provide links to your TensorFlow model and (optionally) TensorFlow Lite Model.
```

### 3. Failure after conversion

        return new DefaultForkedMavenParser();
    }

    @Test
    void defaultFs(@TempDir(cleanup = CleanupMode.ON_SUCCESS) Path tempDir) throws Exception {
        invoke(tempDir, Arrays.asList("clean", "verify"));
    }

    Feature<?>[] presentFeatures;
    Feature<?>[] absentFeatures;
    try {
      presentFeatures = (Feature<?>[]) annotationClass.getMethod("value").invoke(testerAnnotation);
      absentFeatures = (Feature<?>[]) annotationClass.getMethod("absent").invoke(testerAnnotation);
    } catch (Exception e) {
      throw new IllegalArgumentException("Error extracting features from tester annotation.", e);
    }

import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.cli.mvn.MavenInvokerRequest;
import org.apache.maven.api.cli.mvn.MavenOptions;

/**
 * Represents a request to invoke Maven in a forked JVM.
 * This interface extends the {@link MavenInvokerRequest}, adding capabilities specific to forked Maven executions.
 *
 * @since 4.0.0
 */
@Experimental

    if (host in insecureHosts) return listOf()
    try {
      val method =
        checkServerTrustedMethod
          ?: throw CertificateException("Failed to call checkServerTrusted")
      return method.invoke(delegate, chain, authType, host) as List<Certificate>
    } catch (e: InvocationTargetException) {
      throw e.targetException
    }
  }