int length = 0x12345678;
            SrvCopychunk chunk = new SrvCopychunk(sourceOffset, targetOffset, length);
            byte[] buffer = new byte[EXPECTED_SIZE];

            // When
            int bytesWritten = chunk.encode(buffer, 0);

            // Then
            assertEquals(EXPECTED_SIZE, bytesWritten);
            assertEquals(chunk.size(), bytesWritten);

            // Verify complete structure

// lineTooLong is generated as chunk header is bigger than 4KiB.
var errLineTooLong = errors.New("header line too long")

// malformed encoding is generated when chunk header is wrongly formed.
var errMalformedEncoding = errors.New("malformed chunked encoding")

// chunk is considered too big if its bigger than > 16MiB.
var errChunkTooBig = errors.New("chunk too big: choose chunk size <= 16MiB")

        }

        @Test
        @DisplayName("Should return correct size with single chunk")
        void testSizeWithSingleChunk() {
            // Given
            byte[] sourceKey = new byte[SOURCE_KEY_SIZE];
            SrvCopychunk chunk = new SrvCopychunk(0, 0, 0);
            SrvCopychunkCopy copy = new SrvCopychunkCopy(sourceKey, chunk);

            // When
            int size = copy.size();

            // Then

      if (closed) return
      closed = true
      detachTimeout(timeout)
      state = STATE_READ_RESPONSE_HEADERS
    }
  }

  /**
   * An HTTP body with alternating chunk sizes and chunk bodies. It is the caller's responsibility
   * to buffer chunks; typically by using a buffered sink with this sink.
   */
  private inner class ChunkedSink : Sink {

        }

        @Test
        @DisplayName("Should handle mismatched chunk and total bytes")
        void testMismatchedValues() throws SMBProtocolDecodingException {
            // This could happen if the last chunk is smaller
            byte[] buffer = createValidCopyChunkResponse(10, // 10 chunks
                    65536, // Last chunk size (not average)
                    589824 // Total less than 10 * 65536
            );

	}
	f.(*fileWriter).crc32 = fakeHash32{}
	chunk := make([]byte, chunkSize)
	for i := range chunk {
		chunk[i] = '.'
	}
	for i := 0; i < chunks; i++ {
		_, err := f.Write(chunk)
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	if frag := int(size % chunkSize); frag > 0 {
		_, err := f.Write(chunk[:frag])
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	end := []byte("END\n")

      for (int remaining = len; remaining >= 3; remaining -= 3) {
        int chunk = (bytes[i++] & 0xFF) << 16 | (bytes[i++] & 0xFF) << 8 | (bytes[i++] & 0xFF);
        target.append(alphabet.encode(chunk >>> 18));
        target.append(alphabet.encode((chunk >>> 12) & 0x3F));
        target.append(alphabet.encode((chunk >>> 6) & 0x3F));
        target.append(alphabet.encode(chunk & 0x3F));
      }
      if (i < off + len) {

        final PrintWriter writer = new PrintWriter(stringWriter);

        chatApiManager.sendSseEvent(writer, "chunk", Map.of("content", "Hello "));

        final String output = stringWriter.toString();
        assertTrue(output.contains("event: chunk"));
        assertTrue(output.contains("\"content\":\"Hello \""));
    }

    @Test
    public void test_sendSseEvent_error() {

        // Write 11MB of data
        try (FileOutputStream fos = new FileOutputStream(largeFile)) {
            final byte[] chunk = new byte[1024 * 1024]; // 1MB
            for (int i = 0; i < 11; i++) { // Write 11MB
                fos.write(chunk);
            }
        }

        try {
            FileUtil.readBytes(largeFile);
            fail("Expected IORuntimeException for large file");

	}

	total := 0
	err := gorm.G[User](DB).Where("name like ?", "GenericsFindBatch%").FindInBatches(ctx, 2, func(chunk []User, batch int) error {
		if len(chunk) > 2 {
			t.Errorf("batch size exceed 2: got %d", len(chunk))
		}

		total += len(chunk)
		return nil
	})
	if err != nil {
		t.Fatalf("FindInBatches failed: %v", err)
	}

	if total != len(users) {