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

                    } else {
                        if (GZIP.equals(con.getContentEncoding())) {
                            return new GZIPInputStream(con.getErrorStream());
                        } else {
                            return con.getErrorStream();
                        }
                    }
                } catch (IOException e) {

                    Thread out = new Thread(new StreamGobbler(process.getInputStream(), shellContext.writer));
                    Thread err = new Thread(new StreamGobbler(process.getErrorStream(), shellContext.logger::error));
                    out.start();
                    err.start();
                    int exitCode = process.waitFor();
                    out.join();
                    err.join();

                }
            }, "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();
                }

            CountDownLatch latch = new CountDownLatch(2);
            ByteArrayOutputStream stdout = connectStream(process.getInputStream(), latch);
            ByteArrayOutputStream stderr = connectStream(process.getErrorStream(), latch);

            process.waitFor(1, TimeUnit.MINUTES);
            latch.await(1, TimeUnit.MINUTES);
            return new ExecResult(args, process.exitValue(), stdout.toString(UTF_8), stderr.toString(UTF_8));

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

    /**

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