private String encoding;

    private Exception contentException;

    private Map<String, List<String>> headers;

    @Override
    public void close() throws IOException {
        if (contentCache != null) {
            contentCache.close();
        }
    }

    public <T> T getContent(final Function<CurlResponse, T> parser) {
        return parser.apply(this);
    }

        try {
            props.load(reader);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        } finally {
            CloseableUtil.close(reader);
        }
    }

    /**
     * プラットフォームデフォルトエンコーディングでファイルを読み込んで{@link Properties}にロードします（例外処理はラップします）。
     *
     * @param props
     *            プロパティセット。{@literal null}であってはいけません

        return ans;
    }
    void close( int f, long lastWriteTime ) throws SmbException {

        if( log.level >= 3 )
            log.println( "close: " + f );

        /*
         * Close Request / Response
         */

        send( new SmbComClose( f, lastWriteTime ), blank_resp() );
    }
    void close( long lastWriteTime ) throws SmbException {

            throw new FileAccessException("ECL0112", new Object[] { propertiesFile.getAbsolutePath() }, e);
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (final IOException e) {
                    // ignore
                }
            }
        }
        lastModified = propertiesFile.lastModified();
    }

            f.connect();
            assertFalse(true);
        }
        catch ( SmbAuthException e ) {
            // ignore
        }

        assertFalse(cifsContext.close());
    }


    // #46
    @Test
    public void testCredentialURLs () throws MalformedURLException, SmbException {
        try {
            testCredentialUrl(

             * because we might close the socket during a
             * request. However the chances are slim and the
             * retry code should ensure the overall request
             * is serviced. The alternative complicates things
             * more than I think is worth it.
             */

            if ( this.socket != null ) {
                this.socket.close();
                this.socket = null;

            counter++;
        }

        @Override
        public void close() {
            if (counter > 1) {
                counter--;
            } else {
                contextLocal.remove();
                if (context != null) {
                    try {
                        context.close();
                    } catch (final NamingException e) {
                        // ignored

        try {
            props.load(is);
            return props;
        } catch (final IOException ex) {
            throw new IORuntimeException(ex);
        } finally {
            CloseableUtil.close(is);
        }
    }

    /**
     * パスの拡張子を返します。
     *
     * @param path
     *            パス。{@literal null}であってはいけません
     * @return 拡張子
     */

        return this.defaultCredentials;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#close()
     */
    @Override
    public boolean close () throws CIFSException {
        boolean inUse = super.close();
        inUse |= this.transportPool.close();
        return inUse;
    }

            try {
                assertTrue(checkFile.exists());
            }
            finally {
                ostream.close();
                checkFile.close();
                f.delete();
            }
        }
    }


    /**
     * @author Ilan Goldfeld
     */
    // #261
    @Test