parentBuilder) {
    return ListTestSuiteBuilder.using(
            new MultimapGetGenerator<K, V>(parentBuilder.getSubjectGenerator()))
        .withFeatures(computeMultimapGetFeatures(parentBuilder.getFeatures()))
        .named(parentBuilder.getName() + ".get[key]")
        .suppressing(parentBuilder.getSuppressedTests())
        .createTestSuite();
  }

  @Override
  TestSuite computeMultimapAsMapGetTestSuite(

    if (parentBuilder.getFeatures().contains(SERIALIZABLE)) {
      derivedSuites.add(
          SetTestSuiteBuilder.using(
                  new ReserializedSetGenerator<E>(parentBuilder.getSubjectGenerator()))
              .named(getName() + " reserialized")
              .withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))
              .suppressing(parentBuilder.getSuppressedTests())

    if (parentBuilder.getFeatures().contains(SERIALIZABLE)) {
      derivedSuites.add(
          ListTestSuiteBuilder.using(
                  new ReserializedListGenerator<E>(parentBuilder.getSubjectGenerator()))
              .named(getName() + " reserialized")
              .withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))

    @Override
    public void visitSpecAnnotation(IntegrationTestTimeout timeout, SpecInfo spec) {
        for (FeatureInfo feature : spec.getFeatures()) {
            if (!feature.getFeatureMethod().getReflection().isAnnotationPresent(IntegrationTestTimeout.class)) {
                visitFeatureAnnotation(timeout, feature);
            }
        }
    }

        return buffer.toString();
    }

    public int getNature() {
        return RELEASE;
    }

    public ArtifactRepositoryPolicy getPolicy(ArtifactRepository repository) {
        int nature = getNature();
        if ((nature & RepositoryMetadata.RELEASE_OR_SNAPSHOT) == RepositoryMetadata.RELEASE_OR_SNAPSHOT) {

            final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            factory.setFeature(Constants.FEATURE_SECURE_PROCESSING, true);
            factory.setFeature(Constants.FEATURE_EXTERNAL_GENERAL_ENTITIES, false);
            factory.setFeature(Constants.FEATURE_EXTERNAL_PARAMETER_ENTITIES, false);
            factory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, StringUtil.EMPTY);

        try {
            final SAXParserFactory factory = SAXParserFactory.newInstance();
            factory.setFeature(org.codelibs.fess.crawler.Constants.FEATURE_SECURE_PROCESSING, true);
            factory.setFeature(org.codelibs.fess.crawler.Constants.FEATURE_EXTERNAL_GENERAL_ENTITIES, false);
            factory.setFeature(org.codelibs.fess.crawler.Constants.FEATURE_EXTERNAL_PARAMETER_ENTITIES, false);

        if (!spec.getReflection().isAnnotationPresent(RunFor) &&
            !spec.getReflection().isAnnotationPresent(Ignore) &&
            !spec.getReflection().isAnnotationPresent(NoRunFor)) {
            spec.getFeatures()
                .findAll {
                    !it.getFeatureMethod().getReflection().isAnnotationPresent(RunFor.class) &&
                        !it.getFeatureMethod().getReflection().isAnnotationPresent(Ignore.class)

                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to set a property.", e);
                }
            }
        }
        try {
            factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
        } catch (final ParserConfigurationException e) {
            throw new ParserConfigurationRuntimeException(e);
        }
        return factory;
    }

    /**

    }

    public boolean isSnapshot() {
        return artifact.isSnapshot();
    }

    public int getNature() {
        return isSnapshot() ? SNAPSHOT : RELEASE;
    }

    public ArtifactRepository getRepository() {
        return artifact.getRepository();
    }