}

        body.crudMode = CrudMode.CREATE;
        final RequestHeader reqHeader = getRequestHeader(body).map(entity -> {
            try {
                reqHeaderService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }

        }

        body.crudMode = CrudMode.CREATE;
        final WebAuthentication webAuth = getWebAuthentication(body).map(entity -> {
            try {
                webAuthService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }

                        repositorySystem.injectAuthentication(request.getRepositorySession(), Arrays.asList(repo));
                        repos.add(repo);
                    } catch (InvalidRepositoryException e) {
                        throw new ProjectBuildingException("", "Invalid remote repository " + repository, e);
                    }
                    normalized = true;

     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, Settings settings) throws IOException {
        try {
            delegate.write(writer, settings.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException(e);
        }
    }

    /**
     * Method write.
     *
     * @param stream a stream object.
     * @param settings a settings object.

                    ssn.treeConnectLogon();
                }
            }
            return new NtlmChallenge(trans.getServerEncryptionKey(), dc);
        }
        catch ( SmbException e ) {
            throw e;
        }
        catch ( IOException e ) {
            throw new SmbException("Connection failed", e);
        }
    }


    /**
     * @return
     */

        try {
            MessageDigestUtil.digest(null, text);
            assertTrue(false);
        } catch (final EmptyArgumentException e) {
            assertTrue(true);
        }
        try {
            MessageDigestUtil.digest("HOGE", text);
            assertTrue(false);
        } catch (final NoSuchAlgorithmRuntimeException e) {
            assertTrue(true);
        }
    }

        }
        return null;
    }

    public void setBoostValue(final String value) {
        if (value != null) {
            try {
                boost = Float.parseFloat(value);
            } catch (final Exception e) {}
        }
    }

    @Override
    public String getIndexingTarget(final String input) {
        // always return true
        return Constants.TRUE;
    }

    @Override

          v0(),
          getMap().putIfAbsent(k0(), v0()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_unsupportedPresentDifferentValue() {
    try {
      getMap().putIfAbsent(k0(), v3());
    } catch (UnsupportedOperationException tolerated) {
    }

            }
        }
        if (executeCallbacks.size() > 0) {
            try {
                executeCallbacks.stream().forEach(callback -> callback.accept(response));
            } catch (final Exception ignore) {}
        }
        latch.countDown();
    }

    public void reject(final Throwable t) {
        final ArrayList<Consumer<Throwable>> executeCallbacks;
        synchronized (Deferred.this) {

      try {
        try {
          urls.add(new File(entry).toURI().toURL());
        } catch (SecurityException e) { // File.toURI checks to see if the file is a directory
          urls.add(new URL("file", null, new File(entry).getAbsolutePath()));
        }
      } catch (MalformedURLException e) {
        AssertionError error = new AssertionError("malformed class path entry: " + entry);