/**
 * DFS (Distributed File System) referral response buffer parser.
 * Decodes server responses to DFS referral requests, extracting information about
 * available DFS targets, path consumption details, and referral flags.
 *
 * @author mbechler
 */
public class DfsReferralResponseBuffer implements Decodable {

    /**
     * Default constructor for DfsReferralResponseBuffer.

        assertEquals(0x4000, SmbConstants.FLAGS2_STATUS32);
        assertEquals(0x8000, SmbConstants.FLAGS2_UNICODE);
    }

    /**
     * Test capability flags.
     */
    @Test
    @DisplayName("Capability flags are correct")
    void capabilityFlagsTest() {
        // Test individual capability values
        assertEquals(0x0004, SmbConstants.CAP_UNICODE);

  @RegisterExtension
  val clientTestRule = configureClientTestRule()

  @RegisterExtension
  val testLogHandler: TestLogHandler = TestLogHandler(Http2::class.java)

  // Flaky https://github.com/square/okhttp/issues/4632
  // Flaky https://github.com/square/okhttp/issues/4633
  private val handshakeCertificates: HandshakeCertificates =
    platform.localhostHandshakeCertificates()

  @StartStop

    - [Container Images](#container-images-1)
  - [Changelog since v1.33.2](#changelog-since-v1332)
  - [Changes by Kind](#changes-by-kind-1)
    - [Bug or Regression](#bug-or-regression-1)
    - [Other (Cleanup or Flake)](#other-cleanup-or-flake)
  - [Dependencies](#dependencies-1)
    - [Added](#added-1)
    - [Changed](#changed-1)
    - [Removed](#removed-1)
- [v1.33.2](#v1332)
  - [Downloads for v1.33.2](#downloads-for-v1332)

        assertEquals(smb.flags, readSmb.flags);
        assertEquals(smb.flags2, readSmb.flags2);
        assertEquals(smb.tid, readSmb.tid);
        assertEquals(smb.pid, readSmb.pid);
        assertEquals(smb.uid, readSmb.uid);
        assertEquals(smb.mid, readSmb.mid);
    }

    @Test
    void testIsResponse() {
        smb.flags = (byte) ServerMessageBlock.FLAGS_RESPONSE;

    }

    /**
     * Gets the SMB message flags
     * @return the flags
     */
    public final byte getFlags() {
        return this.flags;
    }

    /**
     * Sets the SMB message flags
     * @param flags
     *            the flags to set
     */
    public final void setFlags(final byte flags) {
        this.flags = flags;
    }

    /**

    close(ErrorCode.PROTOCOL_ERROR, ErrorCode.PROTOCOL_ERROR, e)
  }

  /**
   * Sends any initial frames and starts reading frames from the remote peer. This should be called
   * after [Builder.build] for all new connections.
   *
   * @param sendConnectionPreface true to send connection preface frames. This should always be true
   *     except for in tests that don't check for a connection preface.

    String path;
    SigningDigest digest = null;
    ServerMessageBlock response;

    ServerMessageBlock() {
        flags = (byte) (FLAGS_PATH_NAMES_CASELESS | FLAGS_PATH_NAMES_CANONICALIZED);
        pid = PID;
        batchLevel = 0;
    }

    void reset() {
        flags = (byte) (FLAGS_PATH_NAMES_CASELESS | FLAGS_PATH_NAMES_CANONICALIZED);
        flags2 = 0;
        errorCode = 0;
        received = false;

            assertEquals(100L, t.delay, "Default delay should be 100");
        }

        @Test
        @DisplayName("Multiple flags are parsed correctly")
        void multipleFlags() {
            TestLocking t = new TestLocking();

            // Parse multiple flags
            String[] args = { "-t", "3", "-i", "7", "-d", "200", "smb://test/file.txt" };
            for (int ai = 0; ai < args.length; ai++) {

        assertEquals(null, bothNullResponse.getFileName());
    }

    @Test
    @DisplayName("Test multiple close flags combinations")
    void testMultipleCloseFlagsCombinations() {
        // Test combining multiple flags
        int combinedFlags = 0x0003; // Multiple flags set
        request.setCloseFlags(combinedFlags);

        byte[] buffer = new byte[256];