String password = "testpassword";

        // When
        Type3Message type3 = new Type3Message(createMockContext(), type2, null, password, "DOMAIN", "user", "WORKSTATION",
                NtlmFlags.NTLMSSP_NEGOTIATE_NTLM);

        // Then
        assertNotNull(type3.getLMResponse());
        assertNotNull(type3.getNTResponse());
        assertTrue(type3.getLMResponse().length > 0);

     *
     * @param tc
     *            context to use
     * @param type1
     *            The Type-1 message which this represents a response to.
     */
    public Type2Message(final CIFSContext tc, final Type1Message type1) {
        this(tc, type1, null, null);
    }

    /**
     * Creates a Type-2 message in response to the given Type-1 message.
     *
     * @param tc
     *            context to use

    assertThat(buffer.readByteString()).isEqualTo("A20743054A6F6E6573".decodeHex())
  }

  @Test fun `decode implicit tagged implicit prefixed type`() {
    // Type1 ::= VisibleString
    // Type2 ::= [APPLICATION 3] IMPLICIT Type1
    // Type3 ::= [2] Type2
    // Type4 ::= [APPLICATION 7] IMPLICIT Type3
    val buffer =
      Buffer()
        .write("670743054A6F6E6573".decodeHex())

    val derReader = DerReader(buffer)

        // Test with another type and empty raw data
        int type2 = AvPair.MsvAvEOL;
        byte[] raw2 = new byte[] {};
        AvPair avPair2 = new AvPair(type2, raw2);

        assertEquals(type2, avPair2.getType(), "Type should match the constructor argument for empty raw data.");
        assertArrayEquals(raw2, avPair2.getRaw(), "Raw data should match the constructor argument for empty raw data.");

                final Type1Message type1 = new Type1Message(src);
                final Type2Message type2 = new Type2Message(tc, type1, challenge, null);
                msg = new String(Base64.encode(type2.toByteArray()), "US-ASCII");
                resp.setHeader("WWW-Authenticate", "NTLM " + msg);
            } else if (src[8] == 3) {
                final Type3Message type3 = new Type3Message(src);

        scriptEngineFactory.add("type1", engine1);
        scriptEngineFactory.add("type2", engine2);

        // Execute with first engine
        Object result1 = scriptExecutor.execute("type1", "script for engine1");
        assertEquals("engine1:processed: script for engine1", result1);

        // Execute with second engine
        Object result2 = scriptExecutor.execute("type2", "script for engine2");

    static Stream<Arguments> intGetterProvider() {
        return Stream.of(Arguments.of((IntGetter) FileEntry::getType, -1, "negative type"),
                Arguments.of((IntGetter) FileEntry::getType, 0, "zero type"),
                Arguments.of((IntGetter) FileEntry::getType, Integer.MAX_VALUE, "max type"),

                Arguments.of((IntGetter) FileEntry::getAttributes, 0, "no attributes"),

        CURRENT = JAVA6;
      }
    }

    abstract Type newArrayType(Type componentType);

    abstract Type usedInGenericType(Type type);

    final ImmutableList<Type> usedInGenericType(Type[] types) {
      ImmutableList.Builder<Type> builder = ImmutableList.builder();
      for (Type type : types) {
        builder.add(usedInGenericType(type));
      }
      return builder.build();
    }

 * <p>
 * Example usage:
 * <pre>
 * {@literal @}Typed(ServiceImpl.class)
 * public class ServiceImpl implements Service {
 *     // Implementation
 * }
 * </pre>
 *
 * @since 4.0.0
 */
@Target({FIELD, METHOD, TYPE})
@Retention(RUNTIME)
@Documented
public @interface Typed {
    /**
     * Specifies the types that should be considered for dependency injection.
     * <p>

        CURRENT = JAVA6;
      }
    }

    abstract Type newArrayType(Type componentType);

    abstract Type usedInGenericType(Type type);

    final ImmutableList<Type> usedInGenericType(Type[] types) {
      ImmutableList.Builder<Type> builder = ImmutableList.builder();
      for (Type type : types) {
        builder.add(usedInGenericType(type));
      }
      return builder.build();
    }