// Then - Verify keys are derived and different
        assertNotNull(signingKey300);
        assertNotNull(signingKey311);
        assertEquals(16, signingKey300.length);
        assertEquals(16, signingKey311.length);
        assertFalse(Arrays.equals(signingKey300, signingKey311));
    }

    @Test
    @DisplayName("Should handle different session key sizes")

                dstIndex += str.length() * 2;
                dst[dstIndex] = (byte) '\0';
                dstIndex++;
                dst[dstIndex++] = (byte) '\0';
            } else {
                final byte[] b = str.getBytes(OEM_ENCODING);
                System.arraycopy(b, 0, dst, dstIndex, b.length);
                dstIndex += b.length;

			if len(ei.Fields) != len(ai.Fields) {
				t.Errorf("expected index %q field length is %d but actual %d", ei.Name, len(ei.Fields), len(ai.Fields))
				return
			}
			for i, ef := range ei.Fields {
				af := ai.Fields[i]
				tests.AssertObjEqual(t, af, ef, "Name", "Unique", "UniqueIndex", "Expression", "Sort", "Collate", "Length", "NotNull")
			}
		})
	}

            out.write(testContent.getBytes("UTF-8"));
        }

        assertTrue(file.exists(), "File should exist after writing");
        assertEquals(testContent.length(), file.length(), "File length should match content length");

        // Read content back
        try (InputStream in = file.getInputStream()) {
            String readContent = new String(in.readAllBytes(), "UTF-8");

        // When
        String[] messages = NtStatus.NT_STATUS_MESSAGES;

        // Then
        assertNotNull(messages);
        assertTrue(messages.length > 0);
        // Should have same length as codes array
        assertEquals(NtStatus.NT_STATUS_CODES.length, messages.length);

        // First message should be for success
        assertNotNull(messages[0]);

    private long h1;
    private long h2;
    private int length;

    Murmur3_128Hasher(int seed) {
      super(CHUNK_SIZE);
      this.h1 = seed;
      this.h2 = seed;
      this.length = 0;
    }

    @Override
    protected void process(ByteBuffer bb) {
      long k1 = bb.getLong();
      long k2 = bb.getLong();
      bmix64(k1, k2);
      length += CHUNK_SIZE;
    }

        // Act
        byte[] result = NtlmUtil.computeResponse(key, serverChallenge, clientData, 0, clientData.length);

        // Assert: result = mac(16) + clientData
        assertEquals(16 + clientData.length, result.length);
        assertArrayEquals(clientData, Arrays.copyOfRange(result, 16, 16 + clientData.length));
    }

    @Test
    @DisplayName("getLMv2Response(byte[]): delegates to computeResponse")

        SMBUtil.writeInt4(messageLength, buffer, bufferIndex + 12);
        System.arraycopy(testData, 0, buffer, bufferIndex + 16, testData.length);

        // Decode
        int bytesDecoded = response.decode(buffer, bufferIndex, buffer.length);

        // Verify results
        assertEquals(namedPipeState, response.getNamedPipeState());
        assertEquals(readDataAvailable, response.getReadDataAvailable());

        // When pointer is non-zero, validate string length
        String testString = "TEST";
        short length = (short) (testString.length() * 2); // Unicode length
        PacUnicodeString unicodeString = new PacUnicodeString(length, length, 100);

        // Should validate string length
        String result = unicodeString.check(testString);
        assertEquals(testString, result);

        assertEquals(32, derived1.length, "Derived key should have correct length");
        assertEquals(32, derived2.length, "Derived key should have correct length");
        assertEquals(32, derived3.length, "Derived key should have correct length");

        assertFalse(Arrays.equals(derived1, derived2), "Different labels should produce different keys");