OptionalEntity<ProtwordsItem> item = protwordsFile.get(999);
        assertFalse(item.isPresent());
    }

    public void test_get_withUnloadedData() {
        // Test getting item when data is not loaded yet
        OptionalEntity<ProtwordsItem> item = protwordsFile.get(1);
        assertTrue(item.isPresent());
        assertEquals("test1", item.get().getInput());
    }

    void testKnownMapping() {
        final int dosErr = 0x00010001;
        final int expectedNt = 0xc0000002;
        Optional<Integer> actual = findNtStatus(dosErr);
        assertTrue(actual.isPresent(), String.format("Mapping for %08x should exist", dosErr));
        assertEquals(expectedNt, actual.get(), String.format("NTSTATUS for %08x should be %08x", dosErr, expectedNt));
    }

    @Test

   *
   * @throws IOException if an I/O error occurs
   * @since 15.0
   */
  public boolean isEmpty() throws IOException {
    Optional<Long> sizeIfKnown = sizeIfKnown();
    if (sizeIfKnown.isPresent()) {
      return sizeIfKnown.get() == 0L;
    }
    Closer closer = Closer.create();
    try {
      InputStream in = closer.register(openStream());
      return in.read() == -1;
    } catch (Throwable e) {

  @SuppressWarnings("unchecked") // implementation is "fully variant"
  static <T> Optional<T> withType() {
    return (Optional<T>) INSTANCE;
  }

  private Absent() {}

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

  @Override
  public T get() {
    throw new IllegalStateException("Optional.get() cannot be called on an absent value");
  }

  @Override
  public T or(T defaultValue) {

     * if applicable.
     */
    default boolean effectiveVerbose() {
        return options().isPresent() && options().orElseThrow().verbose().orElse(false)
                || ciInfo().isPresent() && ciInfo().orElseThrow().isVerbose();
    }

@GwtCompatible
final class Present<T> extends Optional<T> {
  private final T reference;

  Present(T reference) {
    this.reference = reference;
  }

  @Override
  public boolean isPresent() {
    return true;
  }

  @Override
  public T get() {
    return reference;
  }

  @Override
  public T or(T defaultValue) {

   * otherwise returns an empty stream.
   */
  public static <T> Stream<T> stream(com.google.common.base.Optional<T> optional) {
    return optional.isPresent() ? Stream.of(optional.get()) : Stream.empty();
  }

  /**
   * If a value is present in {@code optional}, returns a stream containing only that element,
   * otherwise returns an empty stream.
   *

                          && (m.getModifiers() & (PUBLIC | PROTECTED | PRIVATE)) == 0)
              .transform(Method::getDeclaringClass);
      if (!supersWithPackagePrivateWriteReplace.isPresent()) {
        continue;
      }
      assertWithMessage(
              "To help optimizers, any class that inherits a package-private writeReplace() method"
                  + " should override that method.\n"

        if (jobExecutor == null) {
            throw new ScheduledJobException("No jobExecutor: " + scriptType);
        }

        if (!jobManager.findJobByUniqueOf(LaJobUnique.of(id)).isPresent()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Job {} is running.", id);
            }
            return;
        }

        TimeoutTask task = null;
        try {

      @Override
      String read(ByteSource byteSource, Charset cs) throws IOException {
        Optional<Long> size = byteSource.sizeIfKnown();
        // if we know the size and it fits in an int
        if (size.isPresent() && size.get().longValue() == size.get().intValue()) {
          // otherwise try to presize a StringBuilder
          // it is kind of lame that we need to construct a decoder to access this value.