assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Integer.class)));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Number.class)));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Object.class)));

        assertThat(it.hasNext(), is(not(true)));
    }

    /**

    }

    /**
     * Checks if a next page exists.
     *
     * @return true if a next page exists, false otherwise
     */
    public boolean isExistNextPage() {
        return existNextPage;
    }

    /**
     * Sets whether a next page exists.
     *
     * @param existNextPage true if a next page exists, false otherwise
     */

      putThread(this, Thread.currentThread());
    }

    // non-volatile write to the next field. Should be made visible by a subsequent CAS on
    // waitersField.
    void setNext(@Nullable Waiter next) {
      putNext(this, next);
    }

    void unpark() {
      // This is racy with removeWaiter. The consequence of the race is that we may spuriously call

    Iterator<?> expectedIter = expected.iterator();
    Iterator<?> actualIter = actual.iterator();

    while (expectedIter.hasNext() && actualIter.hasNext()) {
      if (!equal(expectedIter.next(), actualIter.next())) {
        fail(
            "contents were not equal and in the same order: "
                + "expected = "
                + expected
                + ", actual = "
                + actual);

    /**
     * Test method for {@link org.codelibs.core.collection.EmptyIterator#next()}.
     */
    @Test
    public void testNext() {
        exception.expect(ClUnsupportedOperationException.class);
        exception.expectMessage(is("next"));
        final EmptyIterator<String> emptyIterator = new EmptyIterator<String>();
        emptyIterator.next();
    }

      putThread(this, Thread.currentThread());
    }

    // non-volatile write to the next field. Should be made visible by a subsequent CAS on
    // waitersField.
    void setNext(@Nullable Waiter next) {
      putNext(this, next);
    }

    void unpark() {
      // This is racy with removeWaiter. The consequence of the race is that we may spuriously call

    }

    @Override
    public boolean hasNext() {
      if (nextEntry == null) {
        while (iterator.hasNext()) {
          Entry<K, Timestamped<V>> next = iterator.next();
          if (!isExpired(next.getValue())) {
            nextEntry = next;
            return true;
          }
        }
        return false;
      }
      return true;
    }

    @Override
    public void remove() {

   */
  public final void set(int i, double newValue) {
    long next = doubleToRawLongBits(newValue);
    longs.set(i, next);
  }

  /**
   * Eventually sets the element at position {@code i} to the given value.
   *
   * @param i the index
   * @param newValue the new value
   */
  public final void lazySet(int i, double newValue) {
    long next = doubleToRawLongBits(newValue);
    longs.lazySet(i, next);
  }

                return Integer.valueOf(from);
              }
            });

    Iterator<Integer> resultIterator = result.iterator();
    resultIterator.next();

    assertThrows(NumberFormatException.class, () -> resultIterator.next());
  }

  public void testNullFriendlyTransform() {
    List<@Nullable Integer> input = asList(1, 2, null, 3);
    Iterable<String> result =
        Iterables.transform(

    }

    /**
     * Checks if a next page exists after the current page.
     *
     * @return true if a next page exists, false otherwise
     */
    public boolean isExistNextPage() {
        return existNextPage;
    }

    /**
     * Sets whether a next page exists after the current page.
     *
     * @param existNextPage true if a next page exists, false otherwise
     */