assertNotNull(cryptographer);

        String plainText = "Hello, World!";
        String encrypted = cryptographer.encrypt(plainText);
        assertNotNull(encrypted);
        assertFalse(plainText.equals(encrypted));

        String decrypted = cryptographer.decrypt(encrypted);
        assertEquals(plainText, decrypted);
    }

    @Test

        // Test with very long password
        char[] plaintext = new char[10000];
        Arrays.fill(plaintext, 'X');

        byte[] encrypted = storage.encryptCredentials(plaintext);
        assertNotNull(encrypted, "Encrypted long password should not be null");
        assertTrue(encrypted.length > plaintext.length, "Encrypted data should be larger due to IV and auth tag");

    }

    public byte[] encryptCredentials(char[] plaintext) throws GeneralSecurityException {
        checkNotDestroyed();

        if (plaintext == null) {
            return null;
        }

        // Convert char[] to byte[] for encryption
        byte[] plaintextBytes = charsToBytes(plaintext);

        try {
            // Generate random IV

        // Verify transform header is present (first 52 bytes)
        assertTrue(encrypted.length >= 52, "Encrypted message should include transform header");

        // When - Decrypt
        byte[] decrypted = context.decryptMessage(encrypted);

        // Then - Verify decryption

var decryptTests = []struct {
	Key       []byte
	ETag      ETag
	Plaintext ETag
}{
	{ // 0
		Key:       make([]byte, 32),
		ETag:      must("3b83ef96387f14655fc854ddc3c6bd57"),
		Plaintext: must("3b83ef96387f14655fc854ddc3c6bd57"),
	},
	{ // 1
		Key:       make([]byte, 32),
		ETag:      must("7b976cc68452e003eec7cb0eb631a19a-1"),
		Plaintext: must("7b976cc68452e003eec7cb0eb631a19a-1"),
	},
	{ // 2

                len += cipher.doFinal(output, len);

                plaintext = new byte[ciphertext.length];
                System.arraycopy(output, 0, plaintext, 0, ciphertext.length);
            }

            return plaintext;
        } catch (final Exception e) {
            throw new CIFSException("Failed to decrypt message", e);
        }
    }

        private String subject;
        private String plainText;

        public void setSubject(String subject) {
            this.subject = subject;
        }

        public void setPlainText(String plainText) {
            this.plainText = plainText;
        }

        @Override
        public OptionalThing<String> getSavedSubject() {

	if !etag.IsEncrypted() {
		return etag, nil
	}
	mac := hmac.New(sha256.New, key)
	mac.Write([]byte(HMACContext))
	decryptionKey := mac.Sum(nil)

	plaintext := make([]byte, 0, 16)
	etag, err := sio.DecryptBuffer(plaintext, etag, sio.Config{
		Key: decryptionKey,
	})
	if err != nil {
		return nil, err
	}
	return etag, nil
}

// Parse parses s as an S3 ETag, returning the result.

```plaintext
/home/user/code/awesome-project/.venv/bin/python
```

and use that one.

////

//// tab | Windows

```plaintext
C:\Users\user\code\awesome-project\.venv\Scripts;C:\Windows\System32
```

That means that the system will now start looking first for programs in:

```plaintext
C:\Users\user\code\awesome-project\.venv\Scripts
```

        assertNull(permissionHelper.encode("(deny){group}"));
    }

    @Test
    public void test_passthroughValues() {
        assertEquals("plaintext", permissionHelper.encode("plaintext"));
        assertEquals("plaintext", permissionHelper.decode("plaintext"));

        assertEquals("abc", permissionHelper.encode("abc"));
        assertEquals("abc", permissionHelper.decode("abc"));