@Test
    @DisplayName("readSecurityBuffer correctly extracts data")
    void testReadSecurityBuffer() {
        byte[] buf = new byte[8 + 4];
        byte[] payload = { 0x11, 0x22, 0x33, 0x44 };
        NtlmMessage.writeSecurityBuffer(buf, 0, 8, payload);
        byte[] extracted = NtlmMessage.readSecurityBuffer(buf, 0);
        assertArrayEquals(payload, extracted, "Payload should match original");
    }

    @Test

            }
            return new byte[bufferSize];
        }

        @Override
        public synchronized void releaseBuffer(byte[] buf) {
            if (buf != null && cache.size() < maxBuffers) {
                cache.add(buf);
            }
        }
    }

//
// Go stdlib doesn't support parsing JSON with duplicate
// keys, so we need to use this technique to merge the
// keys.
func sanitizePolicy(r io.Reader) (io.Reader, error) {
	var buf bytes.Buffer
	e := json.NewEncoder(&buf)
	d := jstream.NewDecoder(r, 0).ObjectAsKVS().MaxDepth(10)
	sset := set.NewStringSet()
	for mv := range d.Stream() {
		if mv.ValueType == jstream.Object {

        final StringBuilder buf = new StringBuilder();
        updateConfigListenerMap.entrySet().stream().forEach(e -> {
            buf.append(e.getKey()).append(": ");
            try {
                buf.append(e.getValue().get());
            } catch (final Exception ex) {
                logger.warn("Failed to process {} task.", e.getKey(), ex);
                buf.append(ex.getMessage());
            }

		_, err := f.w.Write(b[:match[0]])
		f.buf.Next(match[0])
		if err != nil {
			return n, err
		}
	}
	return n, nil
}

func (f *exitCodeFilter) Finish() (int, error) {
	// f.buf could be empty, contain a partial match of exitRe, or
	// contain a full match.
	b := f.buf.Bytes()
	defer f.buf.Reset()
	match := f.exitRe.FindSubmatch(b)
	if len(match) < 2 || match[1] == nil {
		// Not a full match. Flush.

        setField(cmd, "largeFile", false);
        byte[] buf = new byte[12]; // Buffer needs to be at least 12 bytes for the parameter words
        cmd.writeParameterWordsWireFormat(buf, 0);
        // The flag must be present so the command recognises largeFile
        SmbComLockingAndX copy = new SmbComLockingAndX(cfg);
        copy.readParameterWordsWireFormat(buf, 0);
        assertTrue((boolean) getField(copy, "largeFile"));
    }

		w.Write(b)
	}
	w.Flush()
	// Output: 1 2 3 4
}

// ExampleWriter_ReadFrom demonstrates how to use the ReadFrom method of Writer.
func ExampleWriter_ReadFrom() {
	var buf bytes.Buffer
	writer := bufio.NewWriter(&buf)

	data := "Hello, world!\nThis is a ReadFrom example."
	reader := strings.NewReader(data)

	n, err := writer.ReadFrom(reader)
	if err != nil {
		fmt.Println("ReadFrom Error:", err)
		return

2. **Code Quality**:
   - Check adherence to MinIO’s Go standards (e.g., error handling, documentation).
   - Ensure tests cover new code and pass CI.
   - Flag bugs or critical issues for immediate fixes; suggest non-blocking improvements as follow-up issues.

3. **Flow**:
   - Review promptly to avoid blocking progress.

best used in bulk, on the order of MiB of memory allocated on each use.

Note that by allowing for this limited form of manual memory allocation
that use-after-free bugs are possible with regular Go values. This package
limits the impact of these use-after-free bugs by preventing reuse of freed
memory regions until the garbage collector is able to determine that it is
safe. Typically, a use-after-free bug will result in a fault and a helpful

            final StringBuilder buf = new StringBuilder(100);
            buf.append("Processing ");
            if (totalHits > 0) {
                buf.append(arList.size()).append('/').append(totalHits).append(" docs (Doc:{access ");
            } else {
                buf.append("no docs in indexing queue (Doc:{access ");
            }
            buf.append(systemHelper.getCurrentTimeAsLong() - execTime).append("ms");