@Override
  public @Nullable Entry<K, V> firstEntry() {
    return Iterators.<@Nullable Entry<K, V>>getNext(entryIterator(), null);
  }

  @Override
  public @Nullable Entry<K, V> lastEntry() {
    return Iterators.<@Nullable Entry<K, V>>getNext(descendingEntryIterator(), null);
  }

  @Override
  public @Nullable Entry<K, V> pollFirstEntry() {

     * @return the new first entry for the table
     */
    @GuardedBy("this")
    @Nullable E removeFromChain(E first, E entry) {
      int newCount = count;
      E newFirst = entry.getNext();
      for (E e = first; e != entry; e = e.getNext()) {
        E next = copyEntry(e, newFirst);
        if (next != null) {
          newFirst = next;
        } else {
          newCount--;
        }
      }

            task.getMilestone().convention(project.getProviders().fileContents(project.getIsolated().getRootProject().getProjectDirectory().file("version.txt")).getAsText().map(String::trim));
        });

        tasks.register("updateFixedIssuesInReleaseNotes", UpdateFixedIssuesInReleaseNotes.class, task -> {
            task.setGroup("release notes");

        ReferenceEntry<K, V> first, ReferenceEntry<K, V> entry) {
      int newCount = count;
      ReferenceEntry<K, V> newFirst = entry.getNext();
      for (ReferenceEntry<K, V> e = first; e != entry; e = e.getNext()) {
        ReferenceEntry<K, V> next = copyEntry(e, newFirst);
        if (next != null) {
          newFirst = next;
        } else {
          removeCollectedEntry(e);

        list.addLast("3");
        SLinkedList<String>.Entry e = list.getFirstEntry();
        assertThat(e.getPrevious(), is(nullValue()));
        assertThat(e.getNext().getElement(), is("2"));
        e = list.getLastEntry();
        assertThat(e.getNext(), is(nullValue()));
        assertThat(e.getPrevious().getElement(), is("2"));
        list.getEntry(1).remove();
        assertThat(list.getFirst(), is("1"));

  @Override
  public @Nullable Entry<K, V> firstEntry() {
    return Iterators.<@Nullable Entry<K, V>>getNext(entryIterator(), null);
  }

  @Override
  public @Nullable Entry<K, V> lastEntry() {
    return Iterators.<@Nullable Entry<K, V>>getNext(descendingEntryIterator(), null);
  }

  @Override
  public @Nullable Entry<K, V> pollFirstEntry() {

  /** Returns the hash prefix given the current mask. */
  static int getHashPrefix(int value, int mask) {
    return value & ~mask;
  }

  /** Returns the index, or 0 if the entry is "null". */
  static int getNext(int entry, int mask) {
    return entry & mask;
  }

  /** Returns a new value combining the prefix and suffix using the given mask. */
  static int maskCombine(int prefix, int suffix, int mask) {

                parser.parseSearchWords(words, null, fields, null, null, 1, defaultReadingConverter, defaultNormalizer, analyzer, null);

        assertNotNull(item);
        assertEquals("test", item.getText());
    }

    @Test
    public void test_parseSearchWords_withPartialReadings() throws Exception {
        String[] words = new String[] { "word1", "word2", "word3" };

            customScope = ScopeUtil.getScopeFromMods(mods);
        }
        final Scope surroundingScope = ScopeUtil.getSurroundingScope(ast);

        final String outerTypeName = ast.findFirstToken(TokenTypes.IDENT).getText();

        return customScope.isIn(scope)
            && (surroundingScope == null || surroundingScope.isIn(scope))
            && (excludeScope == null
                || customScope.isIn(excludeScope) == false

      assertEquals(hashOne, entryOne.getHash());
      assertThat(entryOne.getNext()).isNull();
      assertThat(copyOne.getValue()).isEqualTo(valueOne);

      InternalEntry<Object, Object, ?> copyTwo = segment.copyForTesting(entryTwo, copyOne);
      assertThat(copyTwo.getKey()).isEqualTo(keyTwo);
      assertEquals(hashTwo, copyTwo.getHash());
      assertThat(copyTwo.getNext()).isEqualTo(copyOne);