@Override
        public InputStream getInputStream() {
            throw new AssertionError("HEAD request should not read input stream");
        }

        @Override
        public InputStream getErrorStream() {
            throw new AssertionError("HEAD request should not read error stream");
        }

        @Override
        public Map<String, List<String>> getHeaderFields() {

            return null;
        }

        @Override
        public InputStream getInputStream() {
            return inputStream;
        }

        @Override
        public InputStream getErrorStream() {
            return null;
        }

        @Override
        public int waitFor() throws InterruptedException {
            return 0;
        }

        @Override

        @Override
        public java.io.InputStream getInputStream() {
            return new java.io.ByteArrayInputStream(new byte[0]);
        }

        @Override
        public java.io.InputStream getErrorStream() {
            return new java.io.ByteArrayInputStream(new byte[0]);
        }
    }

    private static class TestInputStreamThread extends InputStreamThread {
        private final String output;

            return null;
        }

        @Override
        public java.io.InputStream getInputStream() {
            return null;
        }

        @Override
        public java.io.InputStream getErrorStream() {
            return null;
        }
    }

    private static class TestInputStreamThread extends InputStreamThread {
        private final String output;

            return null;
        }

        @Override
        public java.io.InputStream getInputStream() {
            return null;
        }

        @Override
        public java.io.InputStream getErrorStream() {
            return null;
        }
    }

    // Mock FessConfig implementation
    private class MockFessConfig extends TestFessConfig {
        private static final long serialVersionUID = 1L;

        ProcessBuilder pb = new ProcessBuilder(cmd);
        Process p = pb.start();
        Future<String> outFuture = readStreamAsync(p.getInputStream());
        Future<String> errFuture = readStreamAsync(p.getErrorStream());
        int code = p.waitFor();
        String out = outFuture.get();
        String err = errFuture.get();
        return new ExecResult(code, out, err);
    }

        Process process = pb.start();

        Future<String> stdoutFuture = readStreamAsync(process.getInputStream());
        Future<String> stderrFuture = readStreamAsync(process.getErrorStream());

        int returnCode = process.waitFor();
        String stdout = stdoutFuture.get();
        String stderr = stderrFuture.get();
        return new ExecResult(stdout, stderr, returnCode);
    }

        ProcessBuilder pb = new ProcessBuilder(cmd);
        Process p = pb.start();
        String out = readFully(p.getInputStream());
        String err = readFully(p.getErrorStream());
        int code = p.waitFor();
        return new ExecResult(code, out, err);
    }

    private static String readFully(InputStream in) throws IOException {

                    }
                });
                CommonPoolUtil.execute(() -> {
                    try {
                        CloseableUtil.closeQuietly(p.getErrorStream());
                    } catch (final Exception e) {
                        logger.warn("Could not close a process error stream.", e);
                    }
                });

                        } else {
                            return con.getInputStream();
                        }
                    } else {
                        final InputStream errorStream = con.getErrorStream();
                        if (errorStream == null) {
                            return new ByteArrayInputStream(new byte[0]);
                        }