result.setGidNumber(DfTypeUtil.toLong(source.get("gidNumber")));
            result.setName(DfTypeUtil.toString(source.get("name")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    }

    @PreDestroy
    private void doDeleteFiles() {
        for (Path file : toDelete) {
            try {
                Files.delete(file);
            } catch (IOException e) {
                // ignore, we did our best...
            }
        }
    }

    @Override

    try {
      expectedResult = expected.apply(input);
    } catch (RuntimeException e) {
      expectedRuntimeException = e;
    }

    Boolean actualResult = null;
    RuntimeException actualRuntimeException = null;
    try {
      actualResult = actual.apply(input);
    } catch (RuntimeException e) {
      actualRuntimeException = e;
    }

    "NullableOptional", // Null passthrough is reasonable for type conversions
  })
  // If users use this when they shouldn't, we hope that NewApi will catch subsequent Optional calls
  @IgnoreJRERequirement
  public static <T> java.util.@Nullable Optional<T> toJavaUtil(
      @Nullable Optional<T> googleOptional) {

  @Override
  public final Service startAsync() {
    if (monitor.enterIf(isStartable)) {
      try {
        snapshot = new StateSnapshot(STARTING);
        enqueueStartingEvent();
        doStart();
      } catch (Throwable startupFailure) {
        restoreInterruptIfIsInterruptedException(startupFailure);
        notifyFailed(startupFailure);
      } finally {
        monitor.leave();
        dispatchListenerEvents();

    try {
      long startTime = System.nanoTime();
      for (long remainingNanos = timeoutNanos; ; ) {
        try {
          return lock.tryLock(remainingNanos, NANOSECONDS);
        } catch (InterruptedException interrupt) {
          interrupted = true;
          remainingNanos = remainingNanos(startTime, timeoutNanos);
        }
      }
    } finally {
      if (interrupted) {

            t.printStackTrace(pw);
            pw.flush();
            return systemHelper.abbreviateLongText(sw.toString());
        } catch (final IOException e) {
            logger.warn("Failed to print the stack trace {}", t.getMessage(), e);
        }
        return StringUtil.EMPTY;
    }

            return null;
        });
        try (InputStream inputStream = form.kuromojiFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
        }

            return null;
        });
        try (InputStream inputStream = form.protwordsFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
        }

        TermQuery termQuery = new TermQuery(new Term("title", "test"));

        try {
            queryCommand.execute(queryContext, termQuery, 1.0f);
            fail("Should throw InvalidQueryException");
        } catch (InvalidQueryException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

    @Test
    public void test_toLowercaseWildcard_enabled() {