*     annotation type, rather than an interface
   */
  <T> T newProxy(T target, Class<T> interfaceType, long timeoutDuration, TimeUnit timeoutUnit);

  /**
   * Invokes a specified Callable, timing out after the specified time limit. If the target method
   * call finishes before the limit is reached, the return value or a wrapped exception is

    @Mock
    private Request<CommonServerMessageBlockResponse> request;

    @Mock
    private CommonServerMessageBlockResponse response;

    @Test
    @DisplayName("connectLogon invokes underlying implementation")
    void connectLogon_invocation_isForwarded() throws Exception {
        // Act
        tree.connectLogon(context);

        // Assert - verify interaction with dependency

 */

package com.google.common.util.concurrent;

import com.google.common.annotations.GwtCompatible;
import java.util.concurrent.Executor;

/**
 * An {@link Executor} that runs each task in the thread that invokes {@link Executor#execute
 * execute}.
 */
@GwtCompatible
enum DirectExecutor implements Executor {
  INSTANCE;

  @Override
  public void execute(Runnable command) {
    command.run();
  }

The format is compatible with GCC's response file implementation to ensure interoperability with existing build systems.

### Go command {#go-command}

`go test` now invokes the stdversion vet check by default.
This reports the use of standard library symbols that are too new
for the Go version in force in the referring file,
as determined by `go` directive in `go.mod` and build tags on the file.

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import org.jspecify.annotations.Nullable;

/**
 * Phantom reference with a {@code finalizeReferent()} method which a background thread invokes
 * after the garbage collector reclaims the referent. This is a simpler alternative to using a
 * {@link ReferenceQueue}.
 *
 * <p>Unlike a normal phantom reference, this reference will be cleared automatically.
 *

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import org.jspecify.annotations.Nullable;

/**
 * Weak reference with a {@code finalizeReferent()} method which a background thread invokes after
 * the garbage collector reclaims the referent. This is a simpler alternative to using a {@link
 * ReferenceQueue}.
 *
 * @author Bob Lee
 * @since 2.0
 */
@J2ktIncompatible
@GwtIncompatible

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import org.jspecify.annotations.Nullable;

/**
 * Weak reference with a {@code finalizeReferent()} method which a background thread invokes after
 * the garbage collector reclaims the referent. This is a simpler alternative to using a {@link
 * ReferenceQueue}.
 *
 * @author Bob Lee
 * @since 2.0
 */
@J2ktIncompatible
@GwtIncompatible

        NdrShort decoded = new NdrShort(0);
        decoded.decode(buf);
        assertEquals(123, decoded.value, "decoded value should equal original");
    }

    /**
     * Verify that encode invokes NdrBuffer.enc_ndr_short via a mocked
     * (spied) buffer.
     */
    @Test
    void encodeWithSpiedBufferCallsEncMethod() throws NdrException {
        NdrShort ns = new NdrShort(42);

    /**
     * Invokes the method and returns its result.
     *
     * @param <T>
     *            the return type of the method
     * @param target
     *            the target object. Must not be {@literal null}
     * @param args
     *            the method arguments
     * @return the result of the method
     */
    <T> T invoke(Object target, Object... args);

    /**

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import org.jspecify.annotations.Nullable;

/**
 * Soft reference with a {@code finalizeReferent()} method which a background thread invokes after
 * the garbage collector reclaims the referent. This is a simpler alternative to using a {@link
 * ReferenceQueue}.
 *
 * @author Bob Lee
 * @since 2.0
 */
@J2ktIncompatible
@GwtIncompatible