}

    /**
     * LSA close handle message.
     */
    public static class LsarClose extends DcerpcMessage {

        @Override
        public int getOpnum() {
            return 0x00;
        }

        /** Return value from the RPC call. */
        public int retval;
        /** Policy handle to be closed. */
        public rpc.policy_handle handle;

        /**

    protected static final Version BWC_BUGFIX_VERSION = Version.fromString("1.0.1");
    protected static final Version BWC_MAINTENANCE_VERSION = Version.fromString("0.90.1");

    protected static final BwcVersions BWC_MINOR = new BwcVersions(
        new TreeSet<>(Arrays.asList(BWC_BUGFIX_VERSION, BWC_MINOR_VERSION, BWC_MAJOR_VERSION)),
        BWC_MAJOR_VERSION
    );

export FESS_HEAP_SIZE
export SEARCH_ENGINE_HOME
export SEARCH_ENGINE_HTTP_URL
export FESS_JAVA_OPTS
export JAVA_HOME

lockfile=/var/lock/subsys/$prog

# backwards compatibility for old config sysconfig files, pre 0.90.1
if [ -n $USER ] && [ -z $FESS_USER ] ; then 
   FESS_USER=$USER
fi

checkJava() {
    if [ -x "$JAVA_HOME/bin/java" ]; then
        JAVA="$JAVA_HOME/bin/java"
    else
        JAVA=`which java`
    fi

	p.append(prog, "", true)
}

// asmData assembles a DATA pseudo-op.
// DATA masks<>+0x00(SB)/4, $0x00000000
func (p *Parser) asmData(operands [][]lex.Token) {
	if len(operands) != 2 {
		p.errorf("expect two operands for DATA")
		return
	}

	// Operand 0 has the general form foo<>+0x04(SB)/4.
	op := operands[0]
	n := len(op)
	if n < 3 || op[n-2].ScanToken != '/' || op[n-1].ScanToken != scanner.Int {

        assertEquals(2, written, "setup packet should write 2 bytes");
        assertEquals(SmbComTransaction.TRANS2_QUERY_FS_INFORMATION, buf[0], "first byte should be subCommand");
        assertEquals((byte) 0x00, buf[1], "second byte should be zero");
    }

    @Test
    @DisplayName("writeParametersWireFormat writes the information level as 2-byte little endian")
    void testWriteParametersWireFormat() {

        // 2 bytes for fileAttributes, 4 bytes for lastWriteTime, 4 bytes for fileSize
        byte[] buffer = new byte[20];
        // File Attributes: 0x0010 (Directory)
        buffer[0] = 0x10;
        buffer[1] = 0x00;
        // Last Write Time (UTime): A sample timestamp in milliseconds
        long sampleTimeMillis = 1672531200000L; // Represents a specific date in milliseconds

        subCommand = NET_SERVER_ENUM2; // not really true be used by upper logic
        name = "\\PIPE\\LANMAN";

        maxParameterCount = 8;
        maxDataCount = 16384;
        maxSetupCount = (byte) 0x00;
        setupCount = 0;
        timeout = 5000;
    }

    @Override
    void reset(final int key, final String lastName) {
        super.reset();
        this.lastName = lastName;
    }

    @Override

        byte[] bufferData = buf.getBuffer();
        assertEquals((byte) 0xCD, bufferData[startIndex + alignmentBytes], "Least significant byte should be first");
        assertEquals((byte) 0x00, bufferData[startIndex + alignmentBytes + 1], "Most significant byte should be second");
    }

    /**
     * When given a buffer with sufficient length, decode performs
     * the inverse of encode.
     */

        assertTrue(ratio >= 0.0 && ratio <= 1.0);

        double noneRatio = compressionService.estimateCompressionRatio(testData, CompressionService.COMPRESSION_NONE);
        assertEquals(1.0, noneRatio, 0.001);
    }

    @Test
    @DisplayName("Test configuration limits")
    public void testConfigurationLimits() {
        assertTrue(compressionService.getMinCompressionSize() > 0);

        void setup() throws GeneralSecurityException {
            digest = new Smb2SigningDigest(sessionKey, Smb2Constants.SMB2_DIALECT_0202, null);
            data = new byte[128];
            Arrays.fill(data, (byte) 0x00);

            // Set up mock messages
            request = mock(CommonServerMessageBlock.class);
            response = mock(CommonServerMessageBlock.class);
        }

        @Test