Iterator<Integer> consumingIterator = Iterables.consumingIterable(queue).iterator();

    assertEquals(5, queue.peek().intValue());
    assertEquals(5, consumingIterator.next().intValue());

    assertEquals(14, queue.peek().intValue());
    assertTrue(consumingIterator.hasNext());
    assertTrue(queue.isEmpty());
  }

  public void testConsumingIterable_noIteratorCall() {

    monitor.enterWhen(notEmpty);
    try {
      return extract();
    } finally {
      monitor.leave();
    }
  }

  @CanIgnoreReturnValue
  @Override
  public @Nullable E peek() {
    Monitor monitor = this.monitor;
    if (monitor.enterIf(notEmpty)) {
      try {
        return items[takeIndex];
      } finally {
        monitor.leave();
      }
    } else {

      if (source.isEmpty()) {
        throw PermittedMetaException.NSEE;
      }

      destination.push(source.pop());
      stackWithLastReturnedElementAtTop = destination;
      return destination.peek();
    }

    private void throwIfInvalid(IteratorFeature methodFeature) {
      if (!features.contains(methodFeature)) {
        if (stackWithLastReturnedElementAtTop == null) {

		}
	}
}

func Test_metacacheReader_peek(t *testing.T) {
	r := loadMetacacheSample(t)
	defer r.Close()
	for i, want := range loadMetacacheSampleNames {
		got, err := r.peek()
		if err == io.EOF {
			break
		}
		if err != nil {
			t.Fatal(err)
		}
		if got.name != want {
			t.Errorf("entry %d, want %q, got %q", i, want, got.name)
		}
		gotObj, err := r.next()

      while (peekingItr.hasNext()) {
        Range<C> range = peekingItr.next();
        while (peekingItr.hasNext()) {
          Range<C> nextRange = peekingItr.peek();
          if (range.isConnected(nextRange)) {
            checkArgument(
                range.intersection(nextRange).isEmpty(),
                "Overlapping ranges not permitted but found %s overlapping %s",

    public boolean offer(E e) {
      synchronized (mutex) {
        return delegate().offer(e);
      }
    }

    @Override
    public @Nullable E peek() {
      synchronized (mutex) {
        return delegate().peek();
      }
    }

    @Override
    public @Nullable E poll() {
      synchronized (mutex) {
        return delegate().poll();
      }
    }

    public boolean offer(E e) {
      synchronized (mutex) {
        return delegate().offer(e);
      }
    }

    @Override
    public @Nullable E peek() {
      synchronized (mutex) {
        return delegate().peek();
      }
    }

    @Override
    public @Nullable E poll() {
      synchronized (mutex) {
        return delegate().poll();
      }
    }

	public static final field EMPTY Lokhttp3/TrailersSource;
	public abstract fun get ()Lokhttp3/Headers;
	public fun peek ()Lokhttp3/Headers;
}

public final class okhttp3/TrailersSource$Companion {
}

public final class okhttp3/TrailersSource$DefaultImpls {
	public static fun peek (Lokhttp3/TrailersSource;)Lokhttp3/Headers;
}

public abstract interface class okhttp3/WebSocket {

            context.pushedUserProperties = new HashSet<>();
            protoSession.getUserProperties().entrySet().stream()
                    .filter(k -> !sys.contains(k.getKey()))
                    .peek(k -> context.pushedUserProperties.add(k.getKey()))
                    .forEach(k -> System.setProperty(k.getKey(), k.getValue()));
        } else {
            protoSession.getUserProperties().entrySet().stream()

            } catch (e: IOException) {
              throw RuntimeException(e)
            }
          }
          return result
        }

        override fun peek(): MockResponse = queueDispatcher.peek()

        override fun close() {
          queueDispatcher.close()
        }
      }
    client =
      client
        .newBuilder()
        .proxy(server.proxyAddress)