}
	_, err = writer.Write([]byte("aaaaaaaaaa"))
	if err != nil {
		t.Fatal(err)
	}
	_, err = writer.Write([]byte("aaaaa"))
	if err != nil {
		t.Fatal(err)
	}
	if bw, ok := writer.(io.Closer); ok {
		bw.Close()
	}

	reader := newBitrotReader(disk, nil, volume, filePath, 35, bitrotAlgo, bitrotWriterSum(writer), 10)
	b := make([]byte, 10)
	if _, err = reader.ReadAt(b, 0); err != nil {
		t.Fatal(err)
	}

import org.codelibs.core.net.URLUtil;

/**
 * Utility class for {@link Properties} operations.
 *
 * @author higa
 */
public abstract class PropertiesUtil {

    /**
     * Do not instantiate.
     */
    protected PropertiesUtil() {
    }

    /**
     * Wraps exception handling for {@link Properties#load(InputStream)}.
     * <p>
     * The input stream is not closed.
     * </p>
     *

    }
  }

  @Throws(IOException::class)
  fun flush() {
    withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

      frameHeader(

```

dann ist das ein „Callable“ (ein „Aufrufbares“).

## Klassen als Abhängigkeiten { #classes-as-dependencies_1 }

Möglicherweise stellen Sie fest, dass Sie zum Erstellen einer Instanz einer Python-Klasse die gleiche Syntax verwenden.

Zum Beispiel:

```Python
class Cat:
    def __init__(self, name: str):
        self.name = name


fluffy = Cat(name="Mr Fluffy")
```

        }
    }

    @Override
    public void close() throws IOException {
        state = RdmaConnectionState.CLOSING;

        try {
            if (socketChannel != null) {
                socketChannel.close();
            }
        } finally {
            state = RdmaConnectionState.CLOSED;
        }

        log.debug("TCP RDMA connection closed");
    }

        this.inputStream = inputStream;
    }

    /**
     * Overrides the close method to ignore the close operation.
     * The underlying input stream will not be closed.
     *
     * @throws IOException if an I/O error occurs (not thrown in this implementation)
     */
    @Override
    public void close() throws IOException {
        // inputStream.close();
    }

    /**

                        causes = new ArrayList<>();
                    }
                    causes.add(e);
                }
            }
        }
        if (causes != null) {
            InvokerException exception = new InvokerException("Unable to close context");
            causes.forEach(exception::addSuppressed);
            throw exception;
        }
    }

                when(smbFile.isOpen()).thenReturn(false);
                return null;
            }
        }).when(smbFile).close(anyLong());

        smbRandomAccessFile.close();

        // After close, file should report as not open
        // Mock the read to throw an exception when file is closed
        doAnswer(new Answer<Void>() {
            @Override

     *
     * @see jcifs.SmbPipeHandle#close()
     */
    @Override
    public synchronized void close() throws CIFSException {
        final boolean wasOpen = isOpen();
        this.open = false;
        if (this.input != null) {
            this.input.close();
            this.input = null;
        }

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

   * most [BufferedSource] instances, but not of [Buffer].
   */
  private fun responseBody(content: String): ResponseBody {
    val data = Buffer().writeUtf8(content)
    val source: Source =
      object : Source {
        var closed = false

        override fun close() {
          closed = true
        }

        override fun read(