NegTokenInit parsed = new NegTokenInit(bytes);
        assertNull(parsed.getMechanisms(), "Mechanisms should be null when absent");
        assertEquals(0, parsed.getContextFlags(), "Flags should be zero when absent");
        assertNull(parsed.getMechanismToken(), "Mechanism token should be null when absent");
        assertNull(parsed.getMechanismListMIC(), "MIC should be null when absent");
    }

    @Test

/**
 * Marks a method as an event subscriber.
 *
 * <p>The type of event will be indicated by the method's first (and only) parameter, which cannot
 * be primitive. If this annotation is applied to methods with zero parameters, or more than one
 * parameter, the object containing the method will not be able to register for event delivery from
 * the {@link EventBus}.
 *

										combineFilled[i] = 1
									}
								}
								combineFilledBlocks[block] = combineFilled
								combineSharedBlocks[block] = combineShared
								fmt.Println("Retrying with merged data")
								if addedFiles >= len(files[partIdx]) {
									attempt++
									goto nextAttempt
								}
							}
						}
					}
				}
				if m.blockOffset != len(combined) {

        // Assert
        assertEquals(expectedSize, size);
        verify(negotiationResponse).getTransactionBufferSize();
    }

    @Test
    @DisplayName("Test getTransactionBufferSize returns zero")
    void testGetTransactionBufferSizeZero() {
        // Arrange
        when(negotiationResponse.getTransactionBufferSize()).thenReturn(0);

        // Act

				isArrayKind = reflectValue.Kind() == reflect.Array
			)

			if !update || reflectValue.Len() == 0 {
				update = false
				if isArrayKind {
					db.Statement.ReflectValue.Set(reflect.Zero(reflectValue.Type()))
				} else {
					// if the slice cap is externally initialized, the externally initialized slice is directly used here
					if reflectValue.Cap() == 0 {

        void testGetResultSuccess() {
            message.result = 0;
            assertNull(message.getResult());
        }

        @Test
        @DisplayName("getResult should return DcerpcException for non-zero result")
        void testGetResultError() {
            message.result = 123; // Example error code
            DcerpcException exception = message.getResult();
            assertNotNull(exception);

        TransWaitNamedPipe pipe = new TransWaitNamedPipe("\\\\pipe\\testPipe");
        byte[] dst = new byte[10];

        // writeSetupWireFormat writes 4 bytes:
        // - subCommand byte
        // - 3 zero bytes (padding and no FID)
        int written = pipe.writeSetupWireFormat(dst, 0);

        assertEquals(4, written, "Setup should write 4 bytes");

        cfgMock = mock(Configuration.class);
        resp = new SmbComWriteResponse(cfgMock);
    }

    @Test
    public void testInitialCountIsZero() {
        assertEquals(0, resp.getCount(), "Initial count should be zero");
    }

    @Test
    public void testReadParameterWordsUpdatesCount() {
        // create a buffer with count = 0x1234 (4660 decimal)
        // Using little-endian byte order as per SMBUtil.readInt2

export MINIO_ROOT_PASSWORD=your-secret-key
minio server http://server{1...8}/mnt/hdd{1...16}
```

or

```sh
mc admin config set myminio/ api requests_max=1600
mc admin service restart myminio/
```

        assertEquals("Expected structureSize = 2", exception.getMessage());
    }

    @Test
    @DisplayName("Test readBytesWireFormat with zero structure size throws exception")
    void testReadBytesWireFormatZeroStructureSize() {
        byte[] buffer = new byte[1024];
        int bufferIndex = 0;

        // Set structure size to 0 (invalid)