for (int i = 0; i < len; i++) {
            assertEquals(src[off + i], dst[dstIndex + i], "Byte mismatch at " + i);
        }

        // Assert: bytes before and after region remain unchanged.
        for (int i = 0; i < dstIndex; i++) {
            assertEquals((byte) 0x55, dst[i], "Unexpected change before copy region at " + i);
        }
        for (int i = dstIndex + len; i < dst.length; i++) {

// For each call, unfreezeServices must be called once.
func freezeServices() {
	// Use atomics for globalServiceFreeze, so we can read without locking.
	// We need a lock since we are need the 2 atomic values to remain in sync.
	globalServiceFreezeMu.Lock()
	// If multiple calls, first one creates channel.
	globalServiceFreezeCnt++
	if globalServiceFreezeCnt == 1 {
		globalServiceFreeze.Store(make(chan struct{}))
	}

import org.jspecify.annotations.Nullable;

/**
 * A {@code UnicodeEscaper} that escapes some set of Java characters using a UTF-8 based percent
 * encoding scheme. The set of safe characters (those which remain unescaped) can be specified on
 * construction.
 *
 * <p>This class is primarily used for creating URI escapers in {@link UrlEscapers} but can be used

   * <ul>
   *   <li>It is <i>consistent</i>: for any reference {@code x}, multiple invocations of {@code
   *       hash(x}} consistently return the same value provided {@code x} remains unchanged
   *       according to the definition of the equivalence. The hash need not remain consistent from
   *       one execution of an application to another execution of the same application.

        // Verify encoded length
        assertEquals(0, encodedLen, "Encoded length should be zero for zero length encodable");
        assertArrayEquals(new byte[] { 0x00, 0x00, 0x00 }, dest, "Destination array should remain unchanged for zero length encoding");
    }

    @Test
    void testEncodeEmptySourceArray() {
        // Test with an empty source array
        byte[] data = {};

## Origine { #origin }

Une origine est la combinaison du protocole (`http`, `https`), du domaine (`myapp.com`, `localhost`, `localhost.tiangolo.com`) et du port (`80`, `443`, `8080`).

Ainsi, toutes celles-ci sont des origines différentes :

* `http://localhost`
* `https://localhost`
* `http://localhost:8080`

		}

		buf = buf[:nr]
		var (
			n  int
			un int
			nw int64
		)

		remain := len(buf) % DirectioAlignSize
		if remain == 0 {
			// buf is aligned for directio write()
			n, err = w.Write(buf)
			nw = int64(n)
		} else {
			if remain < len(buf) {
				n, err = w.Write(buf[:len(buf)-remain])
				if err != nil {
					return written, err
				}
				nw = int64(n)
			}

            assertTrue(result.success(), "Compatibility fix should succeed");
            assertTrue(result.modifiedCount() > 0, "Should have removed duplicate dependency");

            // Verify only one dependency remains
            Editor editor = new Editor(document);
            Element root = editor.root();
            Element dependencyManagement = DomUtils.findChildElement(root, "dependencyManagement");

        assertNotNull(deleteResponse);
        assertFalse(deleteResponse.hasError());

        suggester.refresh();

        // Document-only should be deleted, Query-only should remain, Both should remain but as Query only
        assertEquals(2, suggester.getAllWordsNum());
        assertEquals(0, suggester.getDocumentWordsNum());
        assertEquals(2, suggester.getQueryWordsNum());
    }

    @Test

   - Reference related issues (e.g., “Closes #1234”).
   - Notify team members via GitHub `@mentions` if urgent or complex.

## Reviewing PRs

Reviewers ensure MinIO’s commit history remains a clear, reliable record. Responsibilities include:

1. **Commit Quality**:
   - Verify each commit explains *why* the change was made (e.g., “So that…”).