@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() {

    @Override
    public boolean usingProxy() {
        return connection.usingProxy();
    }

    @Override
    public InputStream getErrorStream() {
        try {
            handshake();
        } catch (final IOException ex) {}
        return connection.getErrorStream();
    }

    private int parseResponseCode() throws IOException {
        try {

    }

    @Override
    public boolean usingProxy() {
        return this.connection.usingProxy();
    }

    @Override
    public InputStream getErrorStream() {
        handshake();
        return this.connection.getErrorStream();
    }

    private int parseResponseCode() throws IOException {
        try {
            final String response = this.connection.getHeaderField(0);

        @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);
    }

        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 {

                when(conn.getHeaderField(index++)).thenReturn(entry.getValue().get(0));
            }
        }

        if (code >= 400 && stream != null) {
            when(conn.getErrorStream()).thenReturn(stream);
        } else if (stream != null) {
            when(conn.getInputStream()).thenReturn(stream);
        }
    }

    /**

                }
            }, "ProcessCloser-input-" + sessionId).start();
            new Thread(() -> {
                try {
                    CloseableUtil.closeQuietly(process.getErrorStream());
                } catch (final Exception e) {
                    logger.warn("Could not close a process error stream.", e);
                } finally {
                    latch.countDown();
                }