assertArrayEquals(originalBuffer, buffer);
        }
    }

    @Nested
    @DisplayName("ToString Tests")
    class ToStringTests {

        @Test
        @DisplayName("Should generate correct string representation")
        void testToString() throws Exception {
            // Set up notification with known values
            byte oplockLevel = 0x02;
            byte[] fileId = new byte[16];

        // Should write FileInformation data + 6 bytes padding
        assertEquals(36, written); // 30 + 6

        // Verify encode was called with correct offset
        verify(mockFileInfo).encode(buffer, offset);
    }

    @Test
    @DisplayName("Test readSetupWireFormat returns 0")
    void testReadSetupWireFormat() {

<img src="/img/deployment/https/https07.drawio.svg">

The client (browser) will know that the response comes from the correct server because it is using the cryptography they agreed using the **HTTPS certificate** before.

### Multiple Applications { #multiple-applications }

            msg.decode_header(fragBuf);
            final int stub_frag_len = msg.length - 24;
            if (off + stub_frag_len > in.length) {
                // shouldn't happen if alloc_hint is correct or greater
                final byte[] tmp = new byte[off + stub_frag_len];
                System.arraycopy(in, 0, tmp, 0, off);
                in = tmp;
            }

        for (int i = 0; i < result1.size(); i++) {
            assertEquals(result1.get(i), result2.get(i));
            assertEquals(result2.get(i), result3.get(i));
        }

        // Verify content is correct
        assertEquals(2, result1.size());
        assertEquals(mockNotifyInfo1, result1.get(0));
        assertEquals(mockNotifyInfo2, result1.get(1));
    }

// or last read lock)
// UID and optionally owner must match for entries to be deleted.
func (l *localLocker) removeEntry(name string, args dsync.LockArgs, lri *[]lockRequesterInfo) bool {
	// Find correct entry to remove based on uid.
	for index, entry := range *lri {
		if entry.UID == args.UID && (args.Owner == "" || entry.Owner == args.Owner) {
			if len(*lri) == 1 {
				// Remove the write lock.

This package does not support disk spanning.

A note about ZIP64:

To be backwards compatible the FileHeader has both 32 and 64 bit Size
fields. The 64 bit fields will always contain the correct value and
for normal archives both fields will be the same. For files requiring
the ZIP64 format the 32 bit fields will be 0xffffffff and the 64 bit
fields must be used instead.

            assertEquals(4096, response.getChunkBytesWritten());
            assertEquals(12288, response.getTotalBytesWritten());
        }

        @Test
        @DisplayName("Should return correct bytes consumed")
        void testReturnBytesConsumed() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[100];
            byte[] responseData = createValidCopyChunkResponse(8, 16384, 131072);

        Model model = new Model(org.apache.maven.api.model.Model.newBuilder()
                .build(org.apache.maven.api.model.Build.newBuilder()
                        .sourceDirectory("correct")
                        .resources(List.of(org.apache.maven.api.model.Resource.newBuilder()
                                .directory("${project.build.sourceDirectory}")
                                .build()))

		if setDriveCount == 1 {
			cfg.RRS.Parity = 0
		}
	}

	// Validation is done after parsing both the storage classes. This is needed because we need one
	// storage class value to deduce the correct value of the other storage class.
	if err = validateParity(cfg.Standard.Parity, cfg.RRS.Parity, setDriveCount); err != nil {
		return Config{}, err
	}

	cfg.Optimize = env.Get(OptimizeEnv, kvs.Get(Optimize))