* #monitor}.
   */
  private void dispatchListenerEvents() {
    if (!monitor.isOccupiedByCurrentThread()) {
      listeners.dispatch();
    }
  }

  private void enqueueStartingEvent() {
    listeners.enqueue(STARTING_EVENT);
  }

  private void enqueueRunningEvent() {
    listeners.enqueue(RUNNING_EVENT);
  }

  private void enqueueStoppingEvent(final State from) {

  public void testPeekingIteratorBehavesLikeIteratorOnThreeElementIterable() {
    actsLikeIteratorHelper(Lists.newArrayList("A", "B", "C"));
  }

  @GwtIncompatible // works but takes 5 minutes to run
  public void testPeekingIteratorAcceptsNullElements() {
    actsLikeIteratorHelper(Lists.<@Nullable String>newArrayList(null, "A", null));
  }

  public void testPeekOnEmptyList() {

            }

            assertEquals(expectedValue, rangeMap.get(i));
          }
        }
      }
    }
  }

  public void testSpanEmpty() {
    assertThrows(NoSuchElementException.class, () -> ImmutableRangeMap.of().span());
  }

  public void testSpanSingleRange() {
    for (Range<Integer> range : RANGES) {
      RangeMap<Integer, Integer> rangemap =

    mock.assertLastMethodCalled("shutdownNow");
    assertEquals(ImmutableList.of(), list);
  }

  public void testExecute() {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);
    testExecutor.execute(doNothing());
    mock.assertLastMethodCalled("execute");
  }

  public void testSubmit() throws InterruptedException, ExecutionException {
    {
      MockExecutor mock = new MockExecutor();

        startJob(NAME_PREFIX);

        waitJob(NAME_PREFIX);
        refresh();
    }

    @BeforeEach
    protected void init() {
        refresh();
    }

    @AfterEach
    protected void tearDown() {
    }

    @AfterAll
    protected static void tearDownAll() {
        deleteDocuments("label:" + CRAWL_LABEL);
        deleteLabel(labelId);
        deleteLabel(crawlLabelId);

import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

/**
 * @author koichik
 */
public class GenericsUtilTest {

    /**
     * @throws Exception
     */
    @Test
    public void testClass() throws Exception {
        final Map<TypeVariable<?>, Type> map = GenericsUtil.getTypeVariableMap(Foo.class);
        assertThat(map, is(notNullValue()));
        assertThat(map.isEmpty(), is(false));

                    String field = "value";
                    void method();
                }
            """
            : """
                public class $TEST_INTERFACE_SIMPLE_NAME {
                    public String field = "value";
                    public void method() { }
                    public $TEST_INTERFACE_SIMPLE_NAME() { }
                }
            """

    protected FilterChain filterChain;

    @PostConstruct
    public void init() {
        createFilterChain();
    }

    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        return filterChain.execute(context, query, boost);
    }

    public void add(final String name, final QueryCommand queryCommand) {
        if (name == null || queryCommand == null) {

        MockHttpURLConnection(URL u) {
            super(u);
        }

        @Override
        public void disconnect() {
            // Do Nothing
        }

        @Override
        public boolean usingProxy() {
            return false;
        }

        @Override
        public void connect() throws IOException {
            // Do Nothing
        }

        @Override

        return password;
    }

    /**
     * Set the user's password which is used when connecting to the repository.
     *
     * @param password password of the user
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * Get the username used to access the repository.
     *
     * @return username at repository
     */