q[j-1] = 1 // difference is only found on the last byte
		for i := range b {
			idx := Index(b[i:], q[:j])
			if idx != -1 {
				t.Fatalf("Index(b[%d:], q[:%d])=%d, want -1\n", i, j, idx)
			}
		}
		q[j-1] = 0
	}

	// Test differing alignments and sizes of q which always end on a page boundary.
	q[len(q)-1] = 1 // difference is only found on the last byte
	for j := 0; j < len(q); j++ {
		for i := range b {

        // Arrange
        byte[] key14 = hex("01020304050607 11121314151617"); // two 7-byte chunks
        byte[] key7 = Arrays.copyOfRange(key14, 0, 7);
        byte[] data8 = NtlmUtil.S8;
        byte[] out14 = new byte[16];
        byte[] out7 = new byte[8];

        // Act
        NtlmUtil.E(key14, data8, out14);
        NtlmUtil.E(key7, data8, out7);

        // Assert: first block identical to single-chunk encryption

        return 0;
    }

    @Override
    protected int writeParametersWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override

        // Prepare test data with offset
        int offset = 10;
        String expectedFilename = "offsetfile.txt";
        byte[] buffer = new byte[200 + offset];
        byte[] dataBuffer = createValidBuffer(expectedFilename, "OFFSET~1.TXT", true);
        System.arraycopy(dataBuffer, 0, buffer, offset, dataBuffer.length);

        // Decode from offset

     */
    static Stream<Arguments> decodeProvider() {
        return Stream.of(Arguments.of("", new byte[0]), Arguments.of("QQ==", new byte[] { (byte) 0x41 }), // "A"
                Arguments.of("QUI=", new byte[] { (byte) 0x41, (byte) 0x42 }), // "AB"
                Arguments.of("TWFu", "Man".getBytes()), Arguments.of("AAAA", new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00 }), // all zeros

        // Protected constructor for abstract class
    }

    /**
     * The NTLMSSP "preamble".
     */
    protected static final byte[] NTLMSSP_SIGNATURE =
            { (byte) 'N', (byte) 'T', (byte) 'L', (byte) 'M', (byte) 'S', (byte) 'S', (byte) 'P', (byte) 0 };

    private static final String OEM_ENCODING = Config.DEFAULT_OEM_ENCODING;
    /**
     * Unicode encoding used for NTLM messages.
     */

        buffer[21] = 0x00;

        return buffer;
    }

    private byte[] createMockFileInternalInfoBuffer() {
        // Create a buffer that represents FileInternalInfo data
        // FileInternalInfo contains an 8-byte index number
        byte[] buffer = new byte[8];

        for (int i = 0; i < 8; i++) {
            buffer[i] = (byte) (0xFF - i);
        }

        return buffer;
    }

            // Given
            byte[] zeroKey = new byte[SOURCE_KEY_SIZE];
            byte[] maxKey = new byte[SOURCE_KEY_SIZE];
            Arrays.fill(maxKey, (byte) 0xFF);
            byte[] patternKey = new byte[SOURCE_KEY_SIZE];
            for (int i = 0; i < SOURCE_KEY_SIZE; i++) {
                patternKey[i] = (byte) i;
            }

            // When & Then

    public void testDifferentEncryptionsProduceDifferentCiphertexts() throws Exception {
        char[] plaintext = "SamePassword".toCharArray();

        // Encrypt twice
        byte[] encrypted1 = storage.encryptCredentials(plaintext.clone());
        byte[] encrypted2 = storage.encryptCredentials(plaintext.clone());

        // Should produce different ciphertexts due to random IV

        // Arrange
        byte[] largeData = new byte[1000];
        for (int i = 0; i < largeData.length; i++) {
            largeData[i] = (byte) (i % 256);
        }
        int offset = 990;
        int length = 10;

        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, largeData, offset, length);
        byte[] dst = new byte[100];

        // Act