/*
     * If someone called cancel(true), it is possible that the interrupted bit hasn't been set yet.
     * Wait for the interrupting thread to set DONE. (See interruptTask().) We want to wait so that
     * the interrupting thread doesn't interrupt the _next_ thing to run on this thread.
     *
     * Note: We don't reset the interrupted bit, just wait for it to be set. If this is a thread

If one or more drives are offline at the start of a PutObject or NewMultipartUpload operation the object will have additional data
protection bits added automatically to provide the regular safety for these objects up to 50% of the number of drives.
This will allow normal write operations to take place on systems that exceed the write tolerance.

		t.Fatalf("Creating a volume failed with %s expected to pass.", err)
	}

	// Stat to get permissions bits.
	st, err := os.Stat(path.Join(tmpPath, testCase.volName))
	if err != nil {
		t.Fatalf("Stat failed with %s expected to pass.", err)
	}

	// Get umask of the bits stored.
	currentUmask := 0o777 - uint32(st.Mode().Perm())

	// Verify if umask is correct.

import jcifs.BaseTest;

/**
 * Test class for Encdec utility functionality
 */
@DisplayName("Encdec Utility Tests")
class EncdecTest extends BaseTest {

    @Test
    @DisplayName("Should encode and decode 16-bit integers")
    void testInt16Operations() {
        // Given
        short value = 0x1234;
        byte[] buffer = new byte[2];

        // When - encode little endian
        Encdec.enc_uint16le(value, buffer, 0);

     */
    int NTLMSSP_NEGOTIATE_VERSION = 0x2000000;

    /**
     * Indicates that 128-bit encryption is supported.
     */
    int NTLMSSP_NEGOTIATE_128 = 0x20000000;

    /**
     * Request explicit key exchange
     */
    int NTLMSSP_NEGOTIATE_KEY_EXCH = 0x40000000;

    /**
     * Indicates that 56-bit encryption is supported.
     */
    int NTLMSSP_NEGOTIATE_56 = 0x80000000;

        bb.getInt();

        // LinkSpeed (8 bytes) - in bits per second
        long linkSpeedBps = bb.getLong();

        // Parse sockaddr structure (starts at offset + 24)
        InetAddress addr = parseSockaddr(data, offset + 24);

        if (addr == null) {
            return null;
        }

        // Convert bits per second to Mbps for internal use

    @DisplayName("setFlag true sets the bit")
    void testSetFlagTrue() {
        msg.setFlag(0x4, true);
        assertTrue(msg.getFlag(0x4), "Bit should be set after setFlag(true)");
    }

    @Test
    @DisplayName("setFlag false clears the bit")
    void testSetFlagFalse() {
        msg.setFlag(0x4, true);
        msg.setFlag(0x4, false);
        assertFalse(msg.getFlag(0x4), "Bit should be cleared after setFlag(false)");
    }

 * responses should be refused as their web socket extensions will not be understood.
 *
 * Note that [java.util.zip.Deflater] is hardcoded to use 15 bits (32 KiB) for
 * `client_max_window_bits` and [java.util.zip.Inflater] is hardcoded to use 15 bits (32 KiB) for
 * `server_max_window_bits`. This harms our ability to support these parameters:
 *

    // The values here look like 111...11101...010 in binary, where the initial 111...1110 takes
    // up exactly as many bits as can be represented in the significand (24 for float, 53 for
    // double). That final 0 should be rounded up to 1 because the remaining bits make that number
    // slightly nearer.
    long floatConversionTest = 0xfffffe8000000002L;
    long doubleConversionTest = 0xfffffffffffff402L;

        // Sequence number (64-bit)
        buf.enc_ndr_hyper(sequenceNumber);
    }

    @Override
    protected void decodeWitnessParameters(NdrBuffer buf) throws NdrException {
        // Decode output parameters for WitnessHeartbeat

        // Response sequence number (64-bit)
        responseSequenceNumber = buf.dec_ndr_hyper();

        // Heartbeat interval (64-bit, in 100-nanosecond intervals)