private Smb2SetInfoRequest request;
    private byte[] testFileId;

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);

        testFileId = new byte[16];
        for (int i = 0; i < 16; i++) {
            testFileId[i] = (byte) i;
        }
    }

    @Test

    private byte[] testFileId;
    private String testFileName;
    private Smb2CloseRequest request;

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);

        // Create a test file ID (16 bytes)
        testFileId = new byte[16];

    @Mock
    private Smb2Lock mockLock;

    private byte[] testFileId;
    private Smb2Lock[] testLocks;
    private Smb2LockRequest request;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockContext.getConfig()).thenReturn(mockConfig);

        testFileId = new byte[16];
        new SecureRandom().nextBytes(testFileId);

        // Initial state
        assertNull(testRule.getRuleId());

        // Set rule ID
        testRule.setRuleId("testRule1");
        assertEquals("testRule1", testRule.getRuleId());

        // Change rule ID
        testRule.setRuleId("changedRule");
        assertEquals("changedRule", testRule.getRuleId());

        // Set null rule ID
        testRule.setRuleId(null);

            }
        };

        File tempFile = ResponseDataUtil.createResponseBodyFile(responseData);

        assertNotNull(tempFile);
        assertTrue(tempFile.exists());

        // Verify file permissions (readable and writable by owner)
        assertTrue(tempFile.canRead());
        assertTrue(tempFile.canWrite());

        // Clean up
        tempFile.delete();
    }

        // Create a temporary file with test data
        File tempFile = File.createTempFile("test-", ".tmp");
        try (FileOutputStream fos = new FileOutputStream(tempFile)) {
            fos.write("Test data".getBytes());
        }

        // Read from TemporaryFileInputStream
        try (TemporaryFileInputStream stream = new TemporaryFileInputStream(tempFile)) {
            assertEquals('T', stream.read());

	}

	return x509Certs, nil
}

// LoadX509KeyPair - load an X509 key pair (private key , certificate)
// from the provided paths. The private key may be encrypted and is
// decrypted using the ENV_VAR: MINIO_CERT_PASSWD.
func LoadX509KeyPair(certFile, keyFile string) (tls.Certificate, error) {
	certPEMBlock, err := os.ReadFile(certFile)
	if err != nil {

        root.documentElement
    }

    Node emptyDoc() {
        root = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()
    }

    void write(File destFile, boolean indent = false) {
        destFile.withOutputStream { OutputStream stream ->
            TransformerFactory factory = TransformerFactory.newInstance()
            Transformer transformer = factory.newTransformer()
            if (indent) {

        File tempFile = null;
        try (final InputStream is = responseData.getResponseBody()) {
            tempFile = File.createTempFile("crawler-", ".tmp");
            tempFile.setReadable(false, false);
            tempFile.setReadable(true, true);
            tempFile.setWritable(false, false);
            tempFile.setWritable(true, true);

                final File tempFile = ComponentUtil.getSystemHelper().createTempFile("tmp-adminplugin-", ".jar");
                try (final InputStream is = form.jarFile.getInputStream(); final OutputStream os = new FileOutputStream(tempFile)) {
                    CopyUtil.copy(is, os);
                } catch (final Exception e) {
                    if (tempFile.exists() && !tempFile.delete()) {