*
     * @param type1 the Type-1 message to respond to
     * @return An <code>int</code> containing the default flags.
     */
    public static int getDefaultFlags(final Type1Message type1) {
        if (type1 == null) {
            return DEFAULT_FLAGS;
        }
        int flags = NTLMSSP_NEGOTIATE_NTLM;
        final int type1Flags = type1.getFlags();

     */
    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + 32 + (this.fileName != null ? 2 * this.fileName.length() : 0));
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {

    void testSetCloseFlags() throws Exception {
        int testFlags = 0x00000001; // SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB
        request.setCloseFlags(testFlags);

        Field closeFlagsField = Smb2CloseRequest.class.getDeclaredField("closeFlags");
        closeFlagsField.setAccessible(true);
        int storedFlags = (int) closeFlagsField.get(request);
        assertEquals(testFlags, storedFlags);
    }

        long readFlags = 0;
        for (int i = 0; i < 8; i++) {
            readFlags |= ((long) (buffer[8 + i] & 0xFF)) << (i * 8);
        }
        assertEquals(flags, readFlags);
    }

    @Test
    @DisplayName("Test desired access setter")
    void testSetDesiredAccess() {
        request = new Smb2CreateRequest(mockConfig, "test.txt");

        int access = 0x12345678;

        dstIndex++;

        return dstIndex - start;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

    void testWriteSetupWireFormat() {
        // Arrange
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, testPipeName);
        byte[] dst = new byte[10];
        int dstIndex = 0;

        // Act
        int bytesWritten = transWaitNamedPipe.writeSetupWireFormat(dst, dstIndex);

        // Assert
        assertEquals(4, bytesWritten);
        assertEquals(SmbComTransaction.TRANS_WAIT_NAMED_PIPE, dst[0]);

     * The packet type of this DCERPC message
     */
    protected int ptype = -1;
    /**
     * The flags for this DCERPC message
     */
    protected int flags = 0;
    /**
     * The total length of this DCERPC message
     */
    protected int length = 0;
    /**
     * The call ID for matching requests and responses
     */
    protected int call_id = 0;
    /**
     * The allocation hint for buffer sizing

        FileEndOfFileInformation info = new FileEndOfFileInformation(endOfFile);

        // Create buffer with offset
        byte[] buffer = new byte[20];
        int offset = 5;
        int bytesWritten = info.encode(buffer, offset);

        assertEquals(8, bytesWritten);

        // Verify encoded value at offset
        long decodedValue = SMBUtil.readInt8(buffer, offset);

pkg reflect, func Swapper(interface{}) func(int, int)
pkg runtime, func MutexProfile([]BlockProfileRecord) (int, bool)
pkg runtime, func SetMutexProfileFraction(int) int
pkg runtime, type MemStats struct, NumForcedGC uint32
pkg sort, func Slice(interface{}, func(int, int) bool)
pkg sort, func SliceIsSorted(interface{}, func(int, int) bool) bool
pkg sort, func SliceStable(interface{}, func(int, int) bool)

    }

    @Test
    @DisplayName("Test haveCapability with multiple capability flags")
    void testHaveCapabilityMultipleFlags() {
        // Arrange
        int cap1 = 0x00000001;
        int cap2 = 0x00000002;
        int cap3 = 0x00000004;
        when(negotiationResponse.haveCapabilitiy(cap1)).thenReturn(true);
        when(negotiationResponse.haveCapabilitiy(cap2)).thenReturn(false);