Arrays.fill(buffer, (byte) 0);

            int startIndex = 100;
            request.writeBytesWireFormat(buffer, startIndex);

            // Verify data is at correct position
            for (int i = 0; i < data.length; i++) {
                assertEquals((byte) 0xAB, buffer[startIndex + 48 + i]);
            }
        }

        @Test

{position:-webkit-sticky;position:sticky;bottom:0;z-index:1020}}@media (min-width:992px){.sticky-lg-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}.sticky-lg-bottom{position:-webkit-sticky;position:sticky;bottom:0;z-index:1020}}@media (min-width:1200px){.sticky-xl-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}.sticky-xl-bottom{position:-webkit-sticky;position:sticky;bottom:0;z-index:1020}}@media (min-width:1400px){.sticky-xxl-top{position:-webkit-sticky;position:...

    setSucceeds(lastEntry, entryIndex);
    setSucceeds(entryIndex, ENDPOINT);
  }

  @Override
  void accessEntry(int index) {
    if (accessOrder) {
      // delete from previous position...
      setSucceeds(getPredecessor(index), getSuccessor(index));
      // ...and insert at the end.
      setSucceeds(lastEntry, index);
      setSucceeds(index, ENDPOINT);
      incrementModCount();
    }

            long offset = 1000L;
            long length = 2000L;
            int flags = Smb2Lock.SMB2_LOCKFLAG_UNLOCK;

            lock = new Smb2Lock(offset, length, flags);

            // Test encoding at position 10
            int encoded = lock.encode(buffer, 10);

            assertEquals(24, encoded);
            assertEquals(offset, SMBUtil.readInt8(buffer, 10));

        byte[] buffer = new byte[32];
        int bytesWritten = hmac.engineDigest(buffer, 5, 16);

        assertEquals(16, bytesWritten);
        // Check that bytes were written to the correct position
        byte[] extractedResult = Arrays.copyOfRange(buffer, 5, 21);
        assertEquals(16, extractedResult.length);
    }

    @Test
    void testEngineDigestWithInsufficientBuffer() {

* `write(data)`: Writes `data` (`str` or `bytes`) to the file.
* `read(size)`: Reads `size` (`int`) bytes/characters of the file.
* `seek(offset)`: Goes to the byte position `offset` (`int`) in the file.
    * E.g., `await myfile.seek(0)` would go to the start of the file.
    * This is especially useful if you run `await myfile.read()` once and then need to read the contents again.

     })\n    }\n  }\n\n  // Static\n\n  _getContainerId() {\n    if (this._config.position == POSITION_TOP_RIGHT) {\n      return SELECTOR_CONTAINER_TOP_RIGHT\n    }\n\n    if (this._config.position == POSITION_TOP_LEFT) {\n      return SELECTOR_CONTAINER_TOP_LEFT\n    }\n\n    if (this._config.position == POSITION_BOTTOM_RIGHT) {\n      return SELECTOR_CONTAINER_BOTTOM_RIGHT\n    }\n\n    if (this._config.position == POSITION_BOTTOM_LEFT) {\n      return SELECTOR_CONTAINER_BOTTOM_LEFT\n    }\n ...

   * @param errorMessageTemplate a template for the exception message should the check fail. The
   *     message is formed by replacing each {@code %s} placeholder in the template with an
   *     argument. These are matched by position - the first {@code %s} gets {@code
   *     errorMessageArgs[0]}, etc. Unmatched arguments will be appended to the formatted message in
   *     square braces. Unmatched placeholders will be left as-is.

// and can be read back from another goroutine.
// It is safe to concurrently read and write RingBuffer.
type RingBuffer struct {
	buf       []byte
	size      int
	r         int // next position to read
	w         int // next position to write
	isFull    bool
	err       error
	block     bool
	mu        sync.Mutex
	wg        sync.WaitGroup
	readCond  *sync.Cond // Signaled when data has been read.

* `write(daten)`: Schreibt `daten` (`str` oder `bytes`) in die Datei.
* `read(anzahl)`: Liest `anzahl` (`int`) bytes/Zeichen aus der Datei.
* `seek(versatz)`: Geht zur Position `versatz` (`int`) in der Datei.
    * z. B. würde `await myfile.seek(0)` zum Anfang der Datei gehen.
    * Das ist besonders dann nützlich, wenn Sie `await myfile.read()` einmal ausführen und dann diese Inhalte erneut auslesen müssen.