if (isQualifiedForInterpolation) {
                    for (Field currentField : clazz.getDeclaredFields()) {
                        Class<?> type = currentField.getType();
                        if (isQualifiedForInterpolation(currentField, type)) {
                            if (String.class == type) {
                                if (!Modifier.isFinal(currentField.getModifiers())) {

  private boolean outputStreamOpened;
  private boolean outputStreamClosed;

  public TestByteSink(TestOption... options) {
    this.options = ImmutableSet.copyOf(options);
  }

  byte[] getBytes() {
    return bytes.toByteArray();
  }

  @Override
  public boolean wasStreamOpened() {
    return outputStreamOpened;
  }

  @Override
  public boolean wasStreamClosed() {

            ByteBuffer bb = ByteBuffer.wrap(dst).order(ByteOrder.LITTLE_ENDIAN);
            assertEquals(maxReferralLevel, bb.getShort());

            // Verify path encoding (UTF-16LE)
            byte[] pathBytes = path.getBytes(StandardCharsets.UTF_16LE);
            byte[] encodedPath = new byte[pathBytes.length];
            bb.get(encodedPath);
            assertArrayEquals(pathBytes, encodedPath);

            // Verify null terminator

        String domain = "DOMAIN";
        byte[] domainBytes = domain.getBytes();
        for (int i = 0; i < domainBytes.length; i++) {
            message[112 + i * 2] = domainBytes[i];
            message[112 + i * 2 + 1] = 0;
        }

        // Add User "user" in Unicode at offset 124
        String user = "user";
        byte[] userBytes = user.getBytes();
        for (int i = 0; i < userBytes.length; i++) {

            for (ToolchainModel model : toolchains.getToolchains()) {
                if (!groupedToolchains.containsKey(model.getType())) {
                    groupedToolchains.put(model.getType(), new ArrayList<>());
                }

                groupedToolchains.get(model.getType()).add(model);
            }

            request.setToolchains(groupedToolchains);
        }
        return request;
    }

  private final TestByteSource byteSource;

  public TestCharSource(String content, TestOption... options) {
    this.byteSource = new TestByteSource(content.getBytes(UTF_8), options);
  }

  @Override
  public boolean wasStreamOpened() {
    return byteSource.wasStreamOpened();
  }

  @Override
  public boolean wasStreamClosed() {

    void testType1MessageCreation() {
        // When
        Type1Message type1 = new Type1Message(mockContext);

        // Then
        assertNotNull(type1);
        // Note: getType() method does not exist in Type1Message
        assertTrue(type1.getFlags() != 0); // Should have some flags set
    }

    @Test
    @DisplayName("Should create Type 1 message with custom flags")

 * </ul>
 *
 * <p>Example usage:</p>
 * <pre>
 * Toolchain toolchain = ...; // Obtain a Toolchain instance
 * String type = toolchain.getType(); // Get the type of the toolchain
 * String version = toolchain.getVersion(); // Get the version of the toolchain
 * </pre>
 *
 *
 * @since 4.0.0
 * @see JavaToolchain

            return true;
        }

        return Objects.equals(a1.getGroupId(), a2.getGroupId())
                && Objects.equals(a1.getArtifactId(), a2.getArtifactId())
                && Objects.equals(a1.getType(), a2.getType())
                && Objects.equals(a1.getVersion(), a2.getVersion())
                && Objects.equals(a1.getClassifier(), a2.getClassifier())
                && Objects.equals(a1.getScope(), a2.getScope())

    @Test
    public void testEncryptDecryptBytes() {
        final CachedCipher cipher = new CachedCipher();
        cipher.setKey("mySecretKey");

        final byte[] original = "Hello World".getBytes();
        final byte[] encrypted = cipher.encrypt(original);
        final byte[] decrypted = cipher.decrypt(encrypted);

        assertThat(encrypted, is(not(original)));
        assertArrayEquals(original, decrypted);