0x19a4c116, 0, 1, 2, 3, 4, 5, 6, 7) SHA256ROUND1(49, 0x1e376c08, 7, 0, 1, 2, 3, 4, 5, 6) SHA256ROUND1(50, 0x2748774c, 6, 7, 0, 1, 2, 3, 4, 5) SHA256ROUND1(51, 0x34b0bcb5, 5, 6, 7, 0, 1, 2, 3, 4) SHA256ROUND1(52, 0x391c0cb3, 4, 5, 6, 7, 0, 1, 2, 3) SHA256ROUND1(53, 0x4ed8aa4a, 3, 4, 5, 6, 7, 0, 1, 2) SHA256ROUND1(54, 0x5b9cca4f, 2, 3, 4, 5, 6, 7, 0, 1) SHA256ROUND1(55, 0x682e6ff3, 1, 2, 3, 4, 5, 6, 7, 0) SHA256ROUND1(56, 0x748f82ee, 0, 1, 2, 3, 4, 5, 6, 7) SHA256ROUND1(57, 0x78a5636f, 7, 0, 1, 2, 3, 4, 5,...

import jcifs.internal.util.SMBUtil;

/**
 * Test class for ValidateNegotiateInfoRequest
 */
class ValidateNegotiateInfoRequestTest {

    private static final int DEFAULT_CAPABILITIES = 0x12345678;
    private static final int DEFAULT_SECURITY_MODE = 0x0003;
    private byte[] defaultClientGuid;
    private int[] defaultDialects;

    @BeforeEach
    void setUp() {

</p>

<p>
Examples:
</p>

<pre>
var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
var s = make([]int, 6)
var b = make([]byte, 5)
n1 := copy(s, a[0:])            // n1 == 6, s is []int{0, 1, 2, 3, 4, 5}
n2 := copy(s, s[2:])            // n2 == 4, s is []int{2, 3, 4, 5, 4, 5}
n3 := copy(b, "Hello, World!")  // n3 == 5, b is []byte("Hello")
</pre>

        void testConstructorAndOpnum() {
            // When: Creating open alias message
            samr.SamrOpenAlias message = new samr.SamrOpenAlias(mockPolicyHandle, 123, 456, mockPolicyHandle);

            // Then: Should have correct values
            assertEquals(0x1b, message.getOpnum());
            assertEquals(mockPolicyHandle, message.domain_handle);

    }

    @Test
    @DisplayName("Test readParametersWireFormat reads length correctly")
    void testReadParametersWireFormat() throws Exception {
        byte[] buffer = new byte[100];
        int expectedLength = 0x12345678;

        // Write length in little-endian format
        SMBUtil.writeInt4(expectedLength, buffer, 0);

        int result = response.readParametersWireFormat(buffer, 0, buffer.length);

        @DisplayName("Should encode basic lock structure correctly")
        void testBasicEncoding() {
            long offset = 0x1234567890ABCDEFL;
            long length = 0xFEDCBA0987654321L;
            int flags = 0x12345678;

            lock = new Smb2Lock(offset, length, flags);
            int encoded = lock.encode(buffer, 0);

            assertEquals(24, encoded);

            // Verify offset (8 bytes)

}

func benchmarkCompareBytesBigUnaligned(b *testing.B, offset int) {
	b.StopTimer()
	b1 := make([]byte, 0, 1<<20)
	for len(b1) < 1<<20 {
		b1 = append(b1, "Hello Gophers!"...)
	}
	b2 := append([]byte("12345678")[:offset], b1...)
	b.StartTimer()
	for j := 0; j < b.N; j++ {
		if Compare(b1, b2[offset:]) != 0 {
			b.Fatal("b1 != b2")
		}
	}
	b.SetBytes(int64(len(b1)))
}

    }

    @Test
    @DisplayName("Test desired access setter")
    void testSetDesiredAccess() {
        request = new Smb2CreateRequest(mockConfig, "test.txt");

        int access = 0x12345678;
        request.setDesiredAccess(access);

        byte[] buffer = new byte[1024];
        request.writeBytesWireFormat(buffer, 0);

        when(response.getDigest()).thenReturn(digest);
        response.setDigest(digest);
        assertEquals(digest, response.getDigest());

        // Test mid methods
        long mid = 123456L;
        doNothing().when(response).setMid(mid);
        when(response.getMid()).thenReturn(mid);
        response.setMid(mid);
        assertEquals(mid, response.getMid());

        // Test command methods

        // Maximum practical length (avoid OutOfMemoryError)
        StringBuilder maxName = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            maxName.append("0123456789");
        }
        testTransformer.setName(maxName.toString());
        assertEquals(10000, testTransformer.getName().length());
        assertEquals(maxName.toString(), testTransformer.getName());
    }