while ( curResp != null ) {
                this.response_map.remove(curResp.getMid());
                Request next = curReq.getNext();
                if ( next != null ) {
                    curReq = next;
                    curResp = next.getResponse();
                }
                else {
                    break;
                }
            }
        }
    }

     */
    @Override
    public boolean hasNext () {
        return this.next != null;
    }


    /**
     * {@inheritDoc}
     *
     * @see java.util.Iterator#next()
     */
    @Override
    public SmbResource next () {
        SmbResource n = this.next;
        this.next = advance();
        return n;
    }


    /**
     * {@inheritDoc}
     * 

    bimap.put(1, "one");
    bimap.put(2, "two");
    bimap.put(3, "three");
    Iterator<Integer> iterator = bimap.keySet().iterator();
    iterator.next();
    iterator.next();
    iterator.remove();
    iterator.next();
    iterator.remove();
    assertEquals(1, bimap.size());
    assertEquals(1, bimap.inverse().size());
  }

    bimap.put(1, "one");
    bimap.put(2, "two");
    bimap.put(3, "three");
    Iterator<Integer> iterator = bimap.keySet().iterator();
    iterator.next();
    iterator.next();
    iterator.remove();
    iterator.next();
    iterator.remove();
    assertEquals(1, bimap.size());
    assertEquals(1, bimap.inverse().size());
  }

    assertEquals(o1, three.next().target);
    assertFalse(three.hasNext());

    three = registry.getSubscribers("");

    registry.unregister(s2);

    assertEquals(s1, three.next().target);
    assertEquals(s2, three.next().target);
    assertEquals(o1, three.next().target);
    assertFalse(three.hasNext());

    Iterator<Subscriber> two = registry.getSubscribers("");
    assertEquals(s1, two.next().target);

   * guaranteed to be equal to each other.
   */
  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  E next();

  /**
   * {@inheritDoc}
   *
   * <p>Implementations may or may not support removal when a call to {@link #peek()} has occurred
   * since the most recent call to {@link #next()}.
   *

      private final StrongKeyStrongValueEntry<K, V> next;

      LinkedStrongKeyStrongValueEntry(K key, int hash, StrongKeyStrongValueEntry<K, V> next) {
        super(key, hash);
        this.next = next;
      }

      @Override
      public StrongKeyStrongValueEntry<K, V> getNext() {
        return next;
      }
    }

        final LineIterator it = new LineIterator(reader);
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("aaa"));
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("bbb"));
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("ccc"));
        assertThat(it.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test

      @Override
      @ParametricNullness
      public T next() {
        T next = iterator.next();
        iterator.remove();
        return next;
      }

      @Override
      public String toString() {
        return "Iterators.consumingIterator(...)";
      }
    };
  }

  /**
   * Deletes and returns the next value from the iterator, or returns {@code null} if there is no

    assertRoute(selection.next(), address, Proxy.NO_PROXY, dns.lookup(uriHost, 0), uriPort)
    assertThat(selection.hasNext()).isFalse()
    assertFailsWith<NoSuchElementException> {
      selection.next()
    }
    assertThat(routeSelector.hasNext()).isFalse()
    assertFailsWith<NoSuchElementException> {
      routeSelector.next()
    }
  }

  @Test fun explicitProxyTriesThatProxysAddressesOnly() {
    val address =