* thread immediately fails with the same exception:
     *
     * Thread1: calls setException(), which returns true, context switch before it can CAS
     * seenExceptionsField to its exception
     *
     * Thread2: calls setException(), which returns false, CASes seenExceptionsField to its

	scanStateStarted
	scanStateSuccess
	scanStateError

	// Time in which the initiator of a scan must have reported back.
	metacacheMaxRunningAge = time.Minute

	// Max time between client calls before dropping an async cache listing.
	metacacheMaxClientWait = 3 * time.Minute

	// metacacheBlockSize is the number of file/directory entries to have in each block.
	metacacheBlockSize = 5000

import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link AbstractFuture} that use a non-{@link TrustedFuture} for {@link
 * AbstractFuture#setFuture} calls.
 */
@GwtCompatible
@NullUnmarked
public class UntrustedInputFutureTest extends AbstractAbstractFutureTest {
  @Override
  AbstractFuture<Integer> newDelegate() {

/**
 * A set multimap which forwards all its method calls to another set multimap. Subclasses should
 * override one or more methods to modify the behavior of the backing multimap as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code

	return opts, nil
}

// get ObjectOptions for Copy calls with encryption headers provided on the target side and source side metadata
func copyDstOpts(ctx context.Context, r *http.Request, bucket, object string, metadata map[string]string) (opts ObjectOptions, err error) {
	return putOptsFromReq(ctx, r, bucket, object, metadata)
}

// get ObjectOptions for Copy calls with encryption headers provided on the source side

import org.junit.Ignore;

/**
 * Common superclass for {@link MultisetSetCountUnconditionallyTester} and {@link
 * MultisetSetCountConditionallyTester}. It is used by those testers to test calls to the
 * unconditional {@code setCount()} method and calls to the conditional {@code setCount()} method
 * when the expected present count is correct.
 *
 * @author Chris Povirk
 */
@GwtCompatible

        verify(watchHandle, times(1)).watch();
    }

    /**
     * Test call() method delegates to watch()
     */
    @Test
    void testCall() throws CIFSException {
        // Setup mock behavior
        when(watchHandle.call()).thenReturn(mockNotifications);

        // Execute
        List<FileNotifyInformation> result = watchHandle.call();

        // Verify
        assertNotNull(result);

You send it a token and it returns an authenticated user.

This provider might be charging you per request, and calling it might take some extra time than if you had a fixed mock user for tests.

You probably want to test the external provider once, but not necessarily call it for every test that runs.

    @DisplayName("ensureTreeConnected caches tree and acquires on each call")
    void testEnsureTreeConnectedCaching() throws CIFSException {
        // Arrange: first ensureTreeConnected comes from pipe
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree); // method returns itself per implementation

        // Act: call twice

     * improving performance for repeated calls with the same input.
     *
     * @param callback The original function to be memoized. It takes a String as input and returns a String.
     * @return A new {@code UnaryOperator<String>} that caches the results of the original function.
     *         If the original function returns null for a given input, null will be cached and returned for subsequent calls with the same input.
     *