}
      return new TreeRangeMap<>(entriesByLowerBound);
    }
  }

  private TreeRangeMap() {
    this.entriesByLowerBound = Maps.newTreeMap();
  }

  private TreeRangeMap(NavigableMap<Cut<K>, RangeMapEntry<K, V>> entriesByLowerBound) {
    this.entriesByLowerBound = entriesByLowerBound;
  }

  private static final class RangeMapEntry<K extends Comparable, V>
      extends SimpleImmutableEntry<Range<K>, V> {

import org.codelibs.fess.util.ComponentUtil;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;

public class LdapChainTest extends UnitFessTestCase {

    private LdapChain ldapChain;
    private TestLdapManager testLdapManager;
    private TestFessConfig testFessConfig;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        ldapChain = new LdapChain();

  }

  private ArrayListMultimap() {
    this(12, DEFAULT_VALUES_PER_KEY);
  }

  private ArrayListMultimap(int expectedKeys, int expectedValuesPerKey) {
    super(Platform.newHashMapWithExpectedSize(expectedKeys));
    checkNonnegative(expectedValuesPerKey, "expectedValuesPerKey");
    this.expectedValuesPerKey = expectedValuesPerKey;
  }

@NullUnmarked
public class MacHashFunctionTest extends TestCase {

  private static final ImmutableSet<String> INPUTS = ImmutableSet.of("", "Z", "foobar");

  private static final SecretKey MD5_KEY =
      new SecretKeySpec("secret key".getBytes(UTF_8), "HmacMD5");
  private static final SecretKey SHA1_KEY =
      new SecretKeySpec("secret key".getBytes(UTF_8), "HmacSHA1");
  private static final SecretKey SHA256_KEY =

  }

  private static final InvocationHandler X_RETURNER =
      new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          return "x";
        }
      };

  private static int classesInitialized = 0;

  private static class A {
    static {
      ++classesInitialized;
    }
  }

 * assertions about them.
 */
class TestLogHandler(
  private val logger: Logger,
) : TestRule,
  BeforeEachCallback,
  AfterEachCallback {
  constructor(loggerName: Class<*>) : this(Logger.getLogger(loggerName.getName()))

  private val logs = LinkedBlockingQueue<String>()

  private val handler =
    object : Handler() {
      override fun publish(logRecord: LogRecord) {

@MockitoSettings(strictness = Strictness.LENIENT)
class NtlmHttpURLConnectionTest {

    @Mock
    private HttpURLConnection mockConnection;

    private URL mockUrl;

    @Mock
    private CIFSContext mockCifsContext;

    @Mock
    private NameServiceClient mockNameServiceClient;

    private NtlmHttpURLConnection ntlmConnection;

    /**

        EnumMapAccumulator::toImmutableMap);
  }

  @IgnoreJRERequirement // see enclosing class (whose annotation Animal Sniffer ignores here...)
  private static final class EnumMapAccumulator<K extends Enum<K>, V> {
    private final BinaryOperator<V> mergeFunction;
    private @Nullable EnumMap<K, V> map = null;

    EnumMapAccumulator(BinaryOperator<V> mergeFunction) {
      this.mergeFunction = mergeFunction;
    }

        },
        EnumMapAccumulator::combine,
        EnumMapAccumulator::toImmutableMap);
  }

  private static final class EnumMapAccumulator<K extends Enum<K>, V> {
    private final BinaryOperator<V> mergeFunction;
    private @Nullable EnumMap<K, V> map = null;

    EnumMapAccumulator(BinaryOperator<V> mergeFunction) {
      this.mergeFunction = mergeFunction;
    }

@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public final class ListeningExecutorServiceTest extends TestCase {

  private Collection<? extends Callable<?>> recordedTasks;
  private long recordedTimeout;
  private TimeUnit recordedTimeUnit;

  private final ListeningExecutorService executorService = new FakeExecutorService();

  public void testInvokeAny() throws Exception {