}

    @Test
    void testGetMid() {
        long mid = 54321L;
        when(mockResponse.getMid()).thenReturn(mid);
        assertEquals(mid, mockResponse.getMid());

        // Verify the method was called
        verify(mockResponse, times(1)).getMid();
    }

    @Test
    void testVerifySignature() {
        byte[] buffer = new byte[] { 1, 2, 3 };
        int offset = 0;

import org.elasticsearch.gradle.internal.info.JavaHome;
import org.gradle.api.GradleException;

import java.util.List;
import java.util.Optional;

public class JavaUtil {

    /** A convenience method for getting java home for a version of java and requiring that version for the given task to execute */
    public static String getJavaHome(final int version) {
        List<JavaHome> javaHomes = BuildParams.getJavaVersions();

            this.andx.setFlags(getFlags());
            this.andx.setFlags2(getFlags2());
            this.andx.setTid(getTid());
            this.andx.setPid(getPid());
            this.andx.setUid(getUid());
            this.andx.setMid(getMid());
            this.andx.setUseUnicode(this.isUseUnicode());

            if (this.andx instanceof AndXServerMessageBlock) {

package jcifs.smb1.smb1;

import jcifs.smb1.Config;

class SmbComWriteAndX extends AndXServerMessageBlock {

    private static final int READ_ANDX_BATCH_LIMIT = Config.getInt("jcifs.smb1.smb.client.WriteAndX.ReadAndX", 1);
    private static final int CLOSE_BATCH_LIMIT = Config.getInt("jcifs.smb1.smb.client.WriteAndX.Close", 1);

    private int fid, remaining, dataLength, dataOffset, off;
    private byte[] b;
    private long offset;

    static final int SMB_FILE_NAMES_INFO = 0x103;
    static final int SMB_FILE_BOTH_DIRECTORY_INFO = 0x104;

    static final int LIST_SIZE = Config.getInt("jcifs.smb1.smb.client.listSize", DEFAULT_LIST_SIZE);
    static final int LIST_COUNT = Config.getInt("jcifs.smb1.smb.client.listCount", DEFAULT_LIST_COUNT);

    Trans2FindFirst2(final String filename, final String wildcard, final int searchAttributes) {

        // Test at various positions in the buffer
        int[] positions = { 0, 10, 50, 100, 150 };

        for (int pos : positions) {
            when(mockConfig.getPid()).thenReturn(1234); // Mock getPid for each new instance
            response = new TestSmbComNtTransactionResponse(mockConfig); // Reset response

            // Fill buffer at position
            for (int i = 0; i < 37; i++) {

    }

    private static final SID USER_SID = new SID() {

        @Override
        public SID getDomainSid() {
            return null;
        }

        @Override
        public int getRid() {
            return 0;
        }

        @Override
        public String toDisplayString() {
            return getDomainName() + "\\" + getAccountName();
        }

        @Override

        FieldUtil.set(field, this, Integer.valueOf(testData));
        assertThat(FieldUtil.getInt(field, this), is(testData));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetIntFieldObject() throws Exception {
        final Field field = getClass().getField("INT_DATA");
        assertThat(FieldUtil.getInt(field), is(INT_DATA));
    }

    /**
     * @throws Exception
     */
    @Test

            final Response response = checkMethodBase(requestBody).put("/api/admin/scheduler/" + schedulerId + "/start");
            if (response.getBody().jsonPath().getInt("response.status") == 0) {
                logger.info("Start scheduler \"{}\"", schedulerId);
                return;
            }
            ThreadUtil.sleep(100L);
        }
        fail("could not start job.");

        Set<Integer> values = new HashSet<>();

        for (Field field : fields) {
            if (field.getType() == int.class) {
                int value = field.getInt(null);
                assertTrue(values.add(value), "Duplicate value found for field: " + field.getName());
            }
        }
    }

    @Test
    @DisplayName("Test constant values follow bit flag pattern")