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)

     *
     * @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

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

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

        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.
     * @param challenge The challenge from the domain controller/server.
     * @param target The authentication target.
     */

        assertEquals(type1, type2);

        Map<String, Object> source1 = event.toSource();
        Map<String, Object> source2 = event.toSource();
        assertSame(source1, source2);
    }

    // Test edge cases for version numbers
    public void test_versionNumberEdgeCases() {
        TestSearchLogEvent event = new TestSearchLogEvent("id", 0L, "type");

        // Test minimum value

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

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

                }
                final Type3Message type3 = (Type3Message) attemptNegotiation(response);
                if (type3 == null) {
                    return;
                }
                connection.setRequestProperty(authProperty, authMethod + ' ' + Base64.encode(type3.toByteArray()));
                connection.connect(); // send type 3
                if (cachedOutput != null && doOutput) {

                }
                final NtlmMessage type3 = attemptNegotiation(response);
                if (type3 == null) {
                    return;
                }
                this.connection.setRequestProperty(this.authProperty, this.authMethod + ' ' + Base64.toBase64String(type3.toByteArray()));
                this.connection.connect(); // send type 3
                if (this.cachedOutput != null && this.doOutput) {