* timeout elapses, and only then re-interrupts the thread.
 *
 * @author Anthony Zana
 * @since 10.0
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
public final class Uninterruptibles {

  // Implementation Note: As of 3-7-11, the logic for each blocking/timeout
  // methods is identical, save for method being invoked.

import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

import jakarta.servlet.http.HttpServletRequest;

public class FessFunctions {
    private static final Logger logger = LogManager.getLogger(FessFunctions.class);

    private static final String GEO_PREFIX = "geo.";

    private static final String FACET_PREFIX = "facet.";

    private static final String PDF_DATE = "pdf_date";

import org.codelibs.core.lang.StringUtil;

/**
 * @author higa
 *
 */
public class InputStreamUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testGetBytes() throws Exception {
        final InputStream is = ResourceUtil.getResourceAsStream(StringUtil.replace(getClass().getName(), ".", "/") + ".class");
        try {
            assertNotNull("1", InputStreamUtil.getBytes(is));

package jcifs.smb1.dcerpc.msrpc;

import jcifs.smb1.smb1.SID;

class LsarSidArrayX extends lsarpc.LsarSidArray {

    LsarSidArrayX(SID[] sids) {
        this.num_sids = sids.length;
        this.sids = new lsarpc.LsarSidPtr[sids.length];
        for (int si = 0; si < sids.length; si++) {
            this.sids[si] = new lsarpc.LsarSidPtr();
            this.sids[si].sid = sids[si];
        }
    }

from typing import Annotated, Union

from fastapi import FastAPI, Header
from pydantic import BaseModel

app = FastAPI()


class CommonHeaders(BaseModel):
    host: str
    save_data: bool
    if_modified_since: Union[str, None] = None
    traceparent: Union[str, None] = None
    x_tag: list[str] = []


@app.get("/items/")
async def read_items(headers: Annotated[CommonHeaders, Header()]):

        assertThrows(
            IllegalArgumentException.class,
            () -> GeneralRange.range(ORDERING, 4, lboundType, 2, uboundType));
      }
    }
  }

  public void testCreateEmptyRangeOpenOpenFails() {
    for (Integer i : IN_ORDER_VALUES) {
      assertThrows(
          IllegalArgumentException.class,
          () -> GeneralRange.<@Nullable Integer>range(ORDERING, i, OPEN, i, OPEN));
    }

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Tests for {@link ForwardingMultiset}.
 *
 * @author Hayward Chan
 * @author Louis Wasserman
 */
public class ForwardingMultisetTest extends TestCase {

  static final class StandardImplForwardingMultiset<T> extends ForwardingMultiset<T> {
    private final Multiset<T> backingCollection;

    StandardImplForwardingMultiset(Multiset<T> backingMultiset) {

 *
 * @author Colin Decker
 */
@AndroidIncompatible // TODO(b/230620681): Make this available (even though we won't run it).
public class ByteSourceTester extends SourceSinkTester<ByteSource, byte[], ByteSourceFactory> {

  private static final ImmutableList<Method> testMethods = getTestMethods(ByteSourceTester.class);

  static TestSuite tests(String name, ByteSourceFactory factory, boolean testAsCharSource) {
    TestSuite suite = new TestSuite(name);

    assertThrows(IOException.class, () -> failSource.copyTo(new TestCharSink()));
    assertTrue(failSource.wasStreamClosed());
  }

  public void testClosesOnErrors_copyingToWriterThatThrows() {
    TestCharSource okSource = new TestCharSource(STRING);
    assertThrows(IOException.class, () -> okSource.copyTo(new TestWriter(WRITE_THROWS)));
    assertTrue(okSource.wasStreamClosed());

import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

/**
 * @author higa
 *
 */
public class ArrayMapTest {

    /**
     * @see org.junit.rules.ExpectedException
     */
    @Rule
    public ExpectedException exception = ExpectedException.none();

    ArrayMap<String, String> map;

    /**