* * `Response.body().close()`
 * * `Response.body().source().close()`
 * * `Response.body().charStream().close()`
 * * `Response.body().byteStream().close()`
 * * `Response.body().bytes()`
 * * `Response.body().string()`
 *
 * There is no benefit to invoking multiple `close()` methods for the same response body.
 *
 * For synchronous calls, the easiest way to make sure a response body is closed is with a `try`

        throw new IOException("Failed to reconnect durable handle");
    }
}

@Override
public void close() throws IOException {
    try {
        // Normal close operations
        super.close();
    } finally {
        // Don't release durable handle on close if it's persistent
        if (handleManager != null && handleType != HandleType.PERSISTENT) {

            }

            switch (SessionServicePacket.readPacketType(in, header, 0)) {
            case SessionServicePacket.SESSION_KEEP_ALIVE:
                break;
            case SessionServicePacket.SESSION_MESSAGE:
                bip = SessionServicePacket.readLength(header, 0);
                break;
            case -1:
                if (tot > 0) {
                    return tot;
                }

        switch (resourceType) {
        case FILE_HANDLE:
            return "Close unused file handles or increase the file handle limit";
        case CONNECTION:
            return "Close idle connections or increase the connection pool size";
        case MEMORY:
            return "Reduce buffer sizes or increase heap memory";
        case DISK_SPACE:

import jcifs.Configuration;
import jcifs.internal.smb2.ServerMessageBlock2;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;

/**
 * Test class for Smb2CloseRequest functionality
 */
@DisplayName("Smb2CloseRequest Tests")
class Smb2CloseRequestTest {

    private Configuration mockConfig;
    private CIFSContext mockContext;
    private byte[] testFileId;
    private String testFileName;

                break;
            case 7: // Kerberos Time
                // DERGeneralizedTime derTime = KerberosUtil.readAs(tagged,
                // DERGeneralizedTime.class);
                break;
            case 8: // Kerberos Time
                // DERGeneralizedTime derTime = KerberosUtil.readAs(tagged,
                // DERGeneralizedTime.class);
                break;

			break
		}
		queryDB = tx.Clauses(clause.Gt{Column: clause.Column{Table: clause.CurrentTable, Name: clause.PrimaryKey}, Value: primaryValue})
	}

	tx.RowsAffected = rowsAffected
	return tx
}

func (db *DB) assignInterfacesToValue(values ...interface{}) {
	for _, value := range values {
		switch v := value.(type) {
		case []clause.Expression:
			for _, expr := range v {

            throws GeneralSecurityException {
        switch (dialect) {
        case Smb2Constants.SMB2_DIALECT_0202:
        case Smb2Constants.SMB2_DIALECT_0210:
            this.algorithmName = "HmacSHA256";
            this.provider = null;
            this.signingKey = sessionKey.clone();
            break;
        case Smb2Constants.SMB2_DIALECT_0300:
        case Smb2Constants.SMB2_DIALECT_0302:

                case '\t':
                case '\n':
                case '#':
                    for (i = 0; i < x && x == ext.length && buf[i] == ext[i]; i++) {

                    }
                    if (i == ext.length) {
                        return new String(type, 0, t, "ASCII");
                    }
                    if (ch == '#') {
                        state = ST_COMM;

## A "callable" instance { #a-callable-instance }

In Python there's a way to make an instance of a class a "callable".

Not the class itself (which is already a callable), but an instance of that class.

To do that, we declare a method `__call__`:

{* ../../docs_src/dependencies/tutorial011_an_py39.py hl[12] *}