handle.close();
        CIFSException ex1 = assertThrows(CIFSException.class, handle::getInput, "getInput after close must throw");
        assertTrue(ex1.getMessage().contains("Already closed"));
        CIFSException ex2 = assertThrows(CIFSException.class, handle::getOutput, "getOutput after close must throw");
        assertTrue(ex2.getMessage().contains("Already closed"));
    }

    @Test

        NegTokenInit init = new NegTokenInit(mechs, 0, null, null);

        NegTokenInit parsed = new NegTokenInit(init.toByteArray());
        assertArrayEquals(mechs, parsed.getMechanisms(), "Mechanism order must be preserved");
    }

    @Test
    @DisplayName("setContextFlag toggles bits correctly")
    void testSetAndGetContextFlags() {
        NegTokenInit init = new NegTokenInit();

        BoolQueryBuilder builder;
        if (queryBuilder instanceof MatchAllQueryBuilder) {
            builder = QueryBuilders.boolQuery();
        } else {
            builder = QueryBuilders.boolQuery().must(queryBuilder);
        }
        boolQuery.accept(builder);
        if (builder.hasClauses()) {
            queryBuilder = builder;
        }
    }

    /**

     */
    public String name;
    /**
     * Scope id
     */
    public String scope;
    /**
     * Type
     */
    public int hexCode;
    int srcHashCode; /*
                      * srcHashCode must be set by name resolution
                      * routines before entry into addressCache
                      */
    private final Configuration config;

    Name(final Configuration cfg) {
        this.config = cfg;

    }

    public void filtered(FilteredCall<WebAuthenticationCQ, WebAuthenticationCQ> filteredLambda,
            ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<WebAuthenticationCQ> notLambda) {
        not(notLambda, null);
    }

        URLConnection connection = handler.openConnection(url);

        assertNotNull(connection, "The resulting connection should not be null.");
        assertTrue(connection instanceof NtlmHttpURLConnection, "Connection must be wrapped in NtlmHttpURLConnection.");

        // Verify that our custom factory was indeed used.
        verify(mockFactory).createURLStreamHandler("http");
    }

    @Test

    public String name;
    /** The NetBIOS scope identifier */
    public String scope;
    /** The NetBIOS name type/suffix (hexadecimal code) */
    public int hexCode;
    int srcHashCode; /* srcHashCode must be set by name resolution
                      * routines before entry into addressCache
                      */

    Name() {
    }

    /**
     * Creates a NetBIOS name with the specified attributes.

                resumeKey = e.fileIndex;
            }

            bufferIndex += e.nextEntryOffset;
        }

        /* last nextEntryOffset for NT 4(but not 98) is 0 so we must
         * use dataCount or our accounting will report an error for NT :~(
         */

        //return bufferIndex - start;

        return dataCount;
    }

    @Override

    protected final Set<String> invalidPropertyNames = newHashSet();

    /**
     * Creates a {@link BeanDescImpl}.
     *
     * @param beanClass
     *            the class of the bean. Must not be {@literal null}
     */
    public BeanDescImpl(final Class<?> beanClass) {
        assertArgumentNotNull("beanClass", beanClass);

        this.beanClass = beanClass;

        }

        /*
         * The message provided to batch has a batchLimit that is
         * higher than the current batchLevel so we will now encode
         * that chained message. Before doing so we must increment
         * the batchLevel of the andx message in case it itself is an
         * andx message and needs to perform the same check as above.
         */

        this.andx.batchLevel = this.batchLevel + 1;