*
 * <p>If your iterator supports modification through {@code remove()}, you may wish to override the
 * verify() method, which is called after each sequence and is guaranteed to be called
 * using the latest values obtained from {@link IteratorTester#newTargetIterator()}.
 *
 * <p>The value you pass to the parameter {@code steps} should be greater than the length of your

FIELD com.google.common.util.concurrent.ExecutionSequencer.ThreadConfinedTaskQueue.nextExecutor com.google.common.util.concurrent.ExecutionSequencer.TaskNonReentrantExecutor
# Real cycle, but the runningState field is null'ed on completion of the future.
FIELD com.google.common.util.concurrent.AggregateFuture.runningState
FIELD java.util.AbstractMap.keySet com.google.common.collect.AbstractMapBasedMultimap.NavigableKeySet

    }

    // Test process method with null origin
    public void test_processWithNullOrigin() {
        HttpServletRequest request = createMockRequest();
        HttpServletResponse response = createMockResponse();

        corsHandler.process(null, request, response);

        assertTrue("process should be called", processCalled);
        assertNull("origin should be null", processOrigin);

 * </ol>
 * <p>
 * Implementations of this interface will be discovered through the Java ServiceLoader mechanism
 * and will be called in sequence during model building.
 * <p>
 * Example usage:
 * <pre>
 * public class CustomModelTransformer implements ModelTransformer {

        assertFalse(emptyGenerator.generate(null, outputFile));
        assertFalse(emptyGenerator.generate("thumbnailId", null));
        assertFalse(emptyGenerator.generate(null, null));
    }

    public void test_destroy() {
        // Initialize without container
        emptyGenerator = new EmptyGenerator();

        // Test that destroy method can be called without error
        emptyGenerator.destroy();

 *
 * <p>{@code ByteSink} provides two kinds of methods:
 *
 * <ul>
 *   <li><b>Methods that return a stream:</b> These methods should return a <i>new</i>, independent
 *       instance each time they are called. The caller is responsible for ensuring that the
 *       returned stream is closed.
 *   <li><b>Convenience methods:</b> These are implementations of common operations that are

 *
 * <p>{@code ByteSink} provides two kinds of methods:
 *
 * <ul>
 *   <li><b>Methods that return a stream:</b> These methods should return a <i>new</i>, independent
 *       instance each time they are called. The caller is responsible for ensuring that the
 *       returned stream is closed.
 *   <li><b>Convenience methods:</b> These are implementations of common operations that are

        // Verify close was called, but implementation should handle idempotency
        verify(idempotentTree, times(2)).close();
    }

    /**
     * Test for unwrap with null parameter.
     * Verifies behavior when null is passed to unwrap.
     */
    @Test
    void testUnwrap_withNullParameter() {
        when(smbTree.unwrap(null)).thenThrow(new NullPointerException("Type cannot be null"));

    /*
     * Even though it's weird to pass a defaultValue that is null, some callers do so. Those who
     * pass a literal "null" should probably just use `get`, but I would expect other callers to
     * pass an expression that *might* be null. This could happen with:
     *
     * - a `getFooOrDefault(@Nullable Foo defaultValue)` method that returns

            }

            @Override
            public jakarta.servlet.ServletConnection getServletConnection() {
                return null;
            }

            @Override
            public String getAuthType() {
                return null;
            }

            @Override
            public jakarta.servlet.http.Cookie[] getCookies() {
                return null;