deferred.promise().getResponse(10, TimeUnit.SECONDS);
            fail();
        } catch (SuggesterException e) {
            assertEquals("org.codelibs.fess.suggest.exception.SuggesterException: test", e.getMessage());
        }
    }

            metadata.storeInLocalRepository(localRepo, localRepo);
            merged = true;
        } catch (Exception e) {
            throw new RepositoryException(e.getMessage(), e);
        }
    }

    public boolean isMerged() {
        return merged;
    }

    public String getGroupId() {
        return emptify(metadata.getGroupId());
    }

     */
    Exception getException();

    /**
     * Gets the message that describes this problem.
     *
     * @return The message describing this problem, never {@code null}.
     */
    String getMessage();

    /**
     * Gets the severity level of this problem.
     *
     * @return The severity level of this problem, never {@code null}.
     */
    Severity getSeverity();

        try {
            return versionParser.parseVersionRange(range);
        } catch (VersionParserException e) {
            throw new AssertionError(range + " should be valid but failed to parse due to: " + e.getMessage(), e);
        }
    }

    private void parseInvalid(String range) {
        try {
            versionParser.parseVersionRange(range);
            fail(range + " should be invalid");

        for (ModelProblem problem : graphResult.getProblems()) {
            if (problem.getSeverity() == ModelProblem.Severity.WARNING) {
                logger.warn(problem.getMessage());
            } else {
                logger.error(problem.getMessage());
            }
        }

        if (!graphResult.hasErrors()) {
            ProjectDependencyGraph projectDependencyGraph = graphResult.get();

        ProblemCollector collector = ProblemCollectorFactory.newInstance(null);
        problems.forEach(p -> collector.add(
                Problem.Severity.valueOf(p.getSeverity().name()),
                p.getMessage(),
                p.getLineNumber(),
                p.getColumnNumber(),
                p.getException()));
        return collector.getProblems();
    }

            der.writeObject(new DERTaggedObject(true, 1, new DERSequence(fields)));
            return collector.toByteArray();
        }
        catch ( IOException ex ) {
            throw new IllegalStateException(ex.getMessage());
        }
    }


    @Override
    protected void parse ( byte[] token ) throws IOException {
        try ( ASN1InputStream der = new ASN1InputStream(token) ) {

        assertArgumentNotNull("zis", zis);

        try {
            zis.closeEntry();
        } catch (final IOException e) {
            logger.log(format("ECL0017", e.getMessage()), e);
        }
    }

            der.writeObject(derApplicationSpecific);
            return collector.toByteArray();
        }
        catch ( IOException ex ) {
            throw new IllegalStateException(ex.getMessage());
        }
    }


    @Override
    protected void parse ( byte[] token ) throws IOException {

        try ( ASN1InputStream is = new ASN1InputStream(token) ) {

                writeSecurityBuffer(type1, 24, 32 + domain.length, workstation);
            }
            return type1;
        } catch (IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    public String toString() {
        String suppliedDomain = getSuppliedDomain();
        String suppliedWorkstation = getSuppliedWorkstation();