Type1Message type1Message = new Type1Message(type1Token);
        // Type1Message ORs default flags with provided flags; ensure expected bits are present
        assertTrue((type1Message.getFlags() & context.ntlmsspFlags) == context.ntlmsspFlags);
        assertEquals(domain, type1Message.getSuppliedDomain());
    }

    @Test
    void testInitSecContext_state2_type3Message() throws Exception {

    }

    /**
     * Gets the compression flags.
     *
     * @return the compression flags
     */
    public int getFlags() {
        return this.flags;
    }

    /**
     * Checks if a specific compression algorithm is supported.
     *
     * @param algorithm the algorithm to check

                        Hexdump.hexdump(log, token, 0, token.length);
                    }
                }

                serverChallenge = msg2.getChallenge();
                ntlmsspFlags &= msg2.getFlags();

                //                  netbiosName = getNtlmsspListItem(token, 0x0001);

                final Type3Message msg3 =

    public boolean isAllow() {
        return this.allow;
    }

    @Override
    public boolean isInherited() {
        return (this.flags & FLAGS_INHERITED) != 0;
    }

    @Override
    public int getFlags() {
        return this.flags;
    }

    @Override
    public String getApplyToText() {
        switch (this.flags & (FLAGS_OBJECT_INHERIT | FLAGS_CONTAINER_INHERIT | FLAGS_INHERIT_ONLY)) {
        case 0x00:

     */
    public void setFlags(int flags) {
        this.flags = flags;
    }

    /**
     * Gets the registration flags.
     *
     * @return the registration flags
     */
    public int getFlags() {
        return flags;
    }

    /**
     * Sets the timeout value in seconds.
     *
     * @param timeout the timeout value
     */
    public void setTimeout(int timeout) {

            this.address = address;
            this.flags = address.getAddress().length == 4 ? IPV4 : IPV6;
        }
        
        public InetAddress getAddress() { return address; }
        public int getFlags() { return flags; }
        public boolean isIPv4() { return (flags & IPV4) != 0; }
        public boolean isIPv6() { return (flags & IPV6) != 0; }
    }
    
    public void addNewIPAddress(InetAddress address) {

            this.mic = new byte[16];
            int curFlags = 0;
            final AvFlags cur = (AvFlags) AvPairs.get(serverAvPairs, AvPair.MsvAvFlags);
            if (cur != null) {
                curFlags = cur.getFlags();
            }
            curFlags |= 0x2; // MAC present
            AvPairs.replace(serverAvPairs, new AvFlags(curFlags));
        }

        AvPairs.replace(serverAvPairs, new AvTimestamp(ts));

            CommonServerMessageBlockRequest result = testRequest.split();

            assertSame(nextRequest, result);
            assertNull(testRequest.getNext());
            assertEquals(0, nextRequest.getFlags() & SMB2_FLAGS_RELATED_OPERATIONS);
        }

        @Test
        @DisplayName("split should return null when no next request")
        void testSplitNoNext() {

    InetAddress client = InetAddresses.forString(clientStr);
    assertThat(teredo.getClient()).isEqualTo(client);

    assertEquals(port, teredo.getPort());
    assertEquals(flags, teredo.getFlags());
  }

  public void testTeredoAddress_nullServer() {
    InetAddresses.TeredoInfo info = new InetAddresses.TeredoInfo(null, null, 80, 1000);

                request.setShareName(shareName);
                request.setServerAddress(serverAddress.getHostAddress());
                request.setFlags(registration.getFlags());

                WitnessRegisterResponse response = rpcClient.register(request);

                if (response != null && response.isSuccess()) {