try (BufferedInputStream bis = new BufferedInputStream(responseData.getResponseBody())) {
            resultData.setData(IOUtils.toByteArray(bis));
            resultData.setEncoding(responseData.getCharSet());
            return resultData;
        } catch (final IOException e) {
            throw new CrawlerSystemException("Could not convert the input stream.", e);
        }

    }

    /*

        try (final InputStream in = responseData.getResponseBody()) {
            final InputSource is = new InputSource(in);
            if (responseData.getCharSet() != null) {
                is.setEncoding(responseData.getCharSet());
            }
            parser.parse(is);
        } catch (final Exception e) {
            throw new CrawlingAccessException("Could not parse " + responseData.getUrl(), e);
        }

                out.write(ins);
            }
        });
    }

    public void setOsddPath(final String osddPath) {
        this.osddPath = osddPath;
    }

    public void setEncoding(final String encoding) {
        this.encoding = encoding;
    }

    public void setContentType(final String contentType) {
        this.contentType = contentType;
    }

                }
            }
        }

        private ArtifactCollection getResolvedArtifacts(Configuration configuration, final IdeDependencyVisitor visitor) {
            return configuration.getIncoming().artifactView(new Action<ArtifactView.ViewConfiguration>() {
                @Override
                public void execute(ArtifactView.ViewConfiguration viewConfiguration) {
                    viewConfiguration.lenient(true);

        where:
        [method, role] << [
            ['getResolvedConfiguration()', 'getBuildDependencies()', 'getIncoming().getFiles()', 'getIncoming().getResolutionResult()', 'getResolvedConfiguration()'],
            ['canBeResolved = false', 'canBeResolved = false; canBeConsumed = false']
        ].combinations()
    }

                    }
                }
            }

            task checkLenient {
                doLast {
                    def artifacts = configurations.conf.getIncoming().artifactView { lenient = true }.artifacts.artifacts
                    assert artifacts.size() == 0
                    assert candidates == ${candidates}
                }
            }
"""

        when:

                return "none";
            }
        });
        final OsddHelper osddHelper = new OsddHelper();
        osddHelper.setOsddPath("osdd/osdd.xml");
        osddHelper.setEncoding(Constants.UTF_8);
        osddHelper.init();
        assertTrue(osddHelper.hasOpenSearchFile());

        final StreamResponse streamResponse = osddHelper.asStream();

            }
            charsetName = Constants.UTF_8_CHARSET.name();
            resultData.setData(content.getBytes(Constants.UTF_8_CHARSET));
        }
        resultData.setEncoding(charsetName);
        return resultData;
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * org.codelibs.fess.crawler.transformer.Transformer#getData(org.codelibs.fess.crawler.entity

            report.getReportTask().configure(task -> {
                Callable<FileCollection> testResults = () ->
                    testResultsConf.getIncoming().artifactView(view -> {
                        view.withVariantReselection();
                        view.componentFilter(id -> id instanceof ProjectComponentIdentifier);
                        view.attributes(attributes -> {

        nativeRuntime.extendsFrom(getImplementationDependencies());

        ArtifactView includeDirs = includePathConfiguration.getIncoming().artifactView(viewConfiguration -> {
           viewConfiguration.attributes(attributeContainer -> {
               attributeContainer.attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, ArtifactTypeDefinition.DIRECTORY_TYPE);