* The file wagon, provided the referenced location is on a local
    filesystem.

    It is not possible to determine whether a file-based location will
    be available except on a case-by-case basis (or a root-url by
    root-url basis). We may want to move the offline sensitivity entirely to
    Maven-Artifact, below, so we can be smarter about testing filesystem-based
    repositories, etc.

func Index(s, sep []byte) int {
	n := len(sep)
	switch {
	case n == 0:
		return 0
	case n == 1:
		return IndexByte(s, sep[0])
	case n == len(s):
		if Equal(sep, s) {
			return 0
		}
		return -1
	case n > len(s):
		return -1
	case n <= bytealg.MaxLen:
		// Use brute force when s and sep both are small
		if len(s) <= bytealg.MaxBruteForce {

import org.opensearch.transport.client.Client;

/**
 * Test class for refactoring changes made to Suggester class.
 *
 * Tests cover:
 * - Index alias helper method (getIndicesForAlias)
 * - Edge cases for switchIndex with EXPECTED_INDEX_COUNT
 * - Index lifecycle with refactored methods
 */
public class SuggesterRefactoringTest {
    static OpenSearchRunner runner;
    static Client client;

    @BeforeClass

  public static Closer create() {
    return new Closer(SUPPRESSING_SUPPRESSOR);
  }

  @VisibleForTesting final Suppressor suppressor;

  // only need space for 2 elements in most cases, so try to use the smallest array possible
  private final Deque<Closeable> stack = new ArrayDeque<>(4);
  private @Nullable Throwable thrown;

  @VisibleForTesting
  Closer(Suppressor suppressor) {

import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link PairedStatsAccumulator}. This tests the stats methods for instances built with
 * {@link PairedStatsAccumulator#add}, and various error cases of that method. For tests of the
 * {@link PairedStatsAccumulator#snapshot} method which returns {@link PairedStats} instances, see
 * {@link PairedStatsTest}.
 *
 * @author Pete Gillin
 */
@NullUnmarked

                assertNotNull(context);
                assertTrue(context.getContextType() > 0);
            }
        }
    }

    @Nested
    @DisplayName("Edge Cases and Error Handling")
    class EdgeCasesTest {

        @Test
        @DisplayName("Should handle maximum size arrays")
        void testMaximumSizeArrays() throws SMBProtocolDecodingException {

    for (; t != null; t = t.getCause()) {
      boolean firstTimeSeen = seen.add(t);
      if (!firstTimeSeen) {
        /*
         * We've seen this, so we've seen its causes, too. No need to re-add them. (There's one case
         * where this isn't true, but we ignore it: If we record an exception, then someone calls
         * initCause() on it, and then we examine it again, we'll conclude that we've seen the whole

            assertTrue(init.getContextFlag(NegTokenInit.CONFIDENTIALITY));
            assertFalse(init.getContextFlag(NegTokenInit.MUTUAL_AUTHENTICATION));
        }
    }

    @Nested
    @DisplayName("Edge Cases and Error Conditions")
    class EdgeCasesTests {

        @Test
        @DisplayName("Parse handles empty token gracefully")
        void testParseEmptyToken() {
            byte[] emptyToken = new byte[0];

                "-1, -1", // Negative values (edge case)
                "100, 200" // Free space greater than capacity (edge case)
        })
        void shouldHandleVariousValues(long capacity, long free) {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(capacity, free);

import java.util.concurrent.atomic.AtomicInteger;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import jcifs.smb.SmbException;

/**
 * Test cases for AuthenticationRateLimiter
 */
public class AuthenticationRateLimiterTest {

    private AuthenticationRateLimiter rateLimiter;

    @BeforeEach
    public void setUp() {