// When
        Type1Message type1 = new Type1Message(mockContext, flags, domain, workstation);

        // Then
        assertEquals(domain, type1.getSuppliedDomain());
        assertEquals(workstation, type1.getSuppliedWorkstation());
        assertTrue((type1.getFlags() & NtlmFlags.NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED) != 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.
     *

    }

    assertThat(buffer.readByteString()).isEqualTo("1A054A6F6E6573".decodeHex())
  }

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

    val derReader = DerReader(buffer)

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

            // Given
            CIFSContext mockContext = createMockContext();
            Type1Message type1 = new Type1Message(mockContext);
            type1.setFlags(Type1Message.NTLMSSP_NEGOTIATE_UNICODE | Type1Message.NTLMSSP_REQUEST_TARGET);

            // When
            Type2Message message = new Type2Message(mockContext, type1);

            // Then
            assertNotNull(message);

     * using default values from the current environment.
     *
     * @param type1 The Type-1 message which this represents a response to.
     */
    public Type2Message(final Type1Message type1) {
        this(type1, null, null);
    }

    /**
     * Creates a Type-2 message in response to the given Type-1 message.
     *
     * @param type1 The Type-1 message which this represents a response to.

                return;
            }
            final Type1Message type1 = (Type1Message) attemptNegotiation(response);
            if (type1 == null) {
                return; // no NTLM
            }
            int attempt = 0;
            while (attempt < MAX_REDIRECTS) {
                connection.setRequestProperty(authProperty, authMethod + ' ' + Base64.encode(type1.toByteArray()));
                connection.connect(); // send type 1

        when(mockEntry.lastAccess()).thenReturn(300L);
        when(mockEntry.length()).thenReturn(12345L);

        // Act: call methods, some multiple times
        String name = mockEntry.getName();
        int type1 = mockEntry.getType();
        int type2 = mockEntry.getType(); // called twice for interaction verification
        int attributes = mockEntry.getAttributes();
        long createTime = mockEntry.createTime();

            }
            final NtlmMessage type1 = attemptNegotiation(response);
            if (type1 == null) {
                return; // no NTLM
            }
            int attempt = 0;
            while (attempt < MAX_REDIRECTS) {
                this.connection.setRequestProperty(this.authProperty, this.authMethod + ' ' + Base64.toBase64String(type1.toByteArray()));

// for any Go type, but represents the same type for any given function
// invocation.
type Type int

// Type1 is here for the purposes of documentation only. It is a stand-in
// for any Go type, but represents the same type for any given function
// invocation.
type Type1 int

// IntegerType is here for the purposes of documentation only. It is a stand-in
// for any integer type: int, uint, int8 etc.

    }

    /**
     * Sets the MIC
     *
     * @param type1 the Type-1 message bytes
     * @param type2 the Type-2 message bytes
     * @throws GeneralSecurityException if a cryptographic error occurs
     * @throws IOException if an I/O error occurs
     */
    public void setupMIC(final byte[] type1, final byte[] type2) throws GeneralSecurityException, IOException {