setLMResponse(getLMv2Response(type2, domain, user, password, clientChallenge));
            /*
            setNTResponse(getNTLMv2Response(type2, domain, user, password,
                    clientChallenge));
            */
            break;
        default:
            setLMResponse(getLMResponse(type2, password));
            setNTResponse(getNTResponse(type2, password));
        }
    }

    /**

     *
     * @param tc
     *            context to use
     * @param type2
     *            The Type-2 message.
     * @return An <code>int</code> containing the default flags.
     */
    public static int getDefaultFlags(final CIFSContext tc, final Type2Message type2) {
        if (type2 == null) {
            return getDefaultFlags(tc);
        }

                data += 8;
            }
            final byte[] type2 = new byte[data + target.length + (targetInformation != null ? targetInformation.length : 0)];
            System.arraycopy(NTLMSSP_SIGNATURE, 0, type2, 0, 8);
            writeULong(type2, 8, 2);
            writeSecurityBuffer(type2, 12, data, target);
            writeULong(type2, 20, flags);

    void testType3MessageFromBytes() throws Exception {
        // Given - Create a Type 3 message and convert to bytes
        Type2Message type2 = createMockType2Message();
        Type3Message original = new Type3Message(createMockContext(), type2, null, "password", "DOMAIN", "user", "WORKSTATION", 0);
        byte[] messageBytes = original.toByteArray();

        // When

        }

        final byte[] type2 = new byte[size];
        int pos = 0;

        System.arraycopy(NTLMSSP_SIGNATURE, 0, type2, pos, NTLMSSP_SIGNATURE.length);
        pos += NTLMSSP_SIGNATURE.length;

        writeULong(type2, pos, NTLMSSP_TYPE2);
        pos += 4;

        // TargetNameFields
        final int targetNameOff = writeSecurityBuffer(type2, pos, targetBytes);
        pos += 8;

    assertThat(buffer.readByteString()).isEqualTo("43054A6F6E6573".decodeHex())
  }

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

    val derReader = DerReader(buffer)

    derReader.read("test") { header ->

        // 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.");

            if (src[8] == 1) {
                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) {

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

        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");