// Should have created 4 indices (config x2, user x1, log x1)
        assertEquals(4, testClient.createdIndices.size());
        // Should have called addMapping for each created index
        assertEquals(4, testClient.addMappingCalls.size());
        // Should have called createAlias for each created index
        assertEquals(4, testClient.createAliasCalls.size());
        // No reindex calls since indices are new

     */
    InetAddress toInetAddress() throws UnknownHostException;

    /**
     * Guess called name to try for session establishment. These
     * methods are used by the smb package.
     *
     * @return guessed name
     */
    String firstCalledName();

    /**
     * Guess next called name to try for session establishment. These
     * methods are used by the smb package.
     *

   * <p>This method should return promptly; prefer to do work on a different thread where it is
   * convenient. It is invoked exactly once on service shutdown, even when {@link #stopAsync} is
   * called multiple times.
   *
   * <p>If {@link #stopAsync} is called on a {@link State#STARTING} service, this method is not
   * invoked immediately. Instead, it will be deferred until after the service is {@link

    listener = new MockFutureListener(resultFuture);
  }

  public void testFutureGetBeforeCallback() throws Exception {
    // Verify that get throws a timeout exception before the callback is called.
    assertThrows(TimeoutException.class, () -> resultFuture.get(1L, MILLISECONDS));
  }

  public void testFutureGetThrowsWrappedException() throws Exception {
    inputFuture.setException(EXCEPTION);

            if (file != null) {
                lastPath = file.getPath();
            }
            return true;
        }
    }

    @Nested
    @DisplayName("Happy path – accept is called and returns true")
    class HappyPath {
        @Test
        void acceptWithMockedFile() throws Exception {
            SmbFile mockFile = mock(SmbFile.class);

   * Returns the index of the first matching BMP character in a character sequence, or {@code -1} if
   * no matching character is present.
   *
   * <p>The default implementation iterates over the sequence in forward order calling {@link
   * #matches} for each character.
   *
   * @param sequence the character sequence to examine from the beginning
   * @return an index, or {@code -1} if no character matches
   */

            }
        };
        ComponentUtil.register(factory, "webApiManagerFactory");

        // Execute
        webApiFilter.doFilter(request, response, chain);

        // Verify manager was called and chain was not called directly
        assertTrue(managerCalled.get());
        assertFalse(chainCalled.get());
    }

    // Test doFilter with ServletRequest and ServletResponse (not HTTP variants)
    @Test

 *
 * <p>{@link #processLine} will be called for each line that is read, and should return {@code
 * false} when you want to stop processing.
 *
 * @author Miles Barr
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
public interface LineProcessor<T extends @Nullable Object> {

  /**
   * This method will be called once for each line.
   *

//
// Buffer panics if it is called after scanning has started.
func (s *Scanner) Buffer(buf []byte, max int) {
	if s.scanCalled {
		panic("Buffer called after Scan")
	}
	s.buf = buf[0:cap(buf)]
	s.maxTokenSize = max
}

// Split sets the split function for the [Scanner].
// The default split function is [ScanLines].
//
// Split panics if it is called after scanning has started.

import okio.IOException

interface Callback {
  /**
   * Called when the request could not be executed due to cancellation, a connectivity problem or
   * timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(
    call: Call,
    e: IOException,
  )

  /**