// Validate parameter bytes using reflection since fields are private
        assertEquals(getField(cmd, "fid"), SMBUtil.readInt2(buffer, 0));
        assertEquals(getField(cmd, "typeOfLock"), buffer[2]);
        assertEquals(getField(cmd, "newOpLockLevel"), buffer[3]);
        assertEquals(getField(cmd, "timeout"), (long) SMBUtil.readInt4(buffer, 4));
        assertEquals(1, SMBUtil.readInt2(buffer, 8));

        String accountName = (String) getField(obj, "accountName");
        String primaryDomain = (String) getField(obj, "primaryDomain");

        // The actual implementation keeps lowercase for guest when Unicode is not enabled
        assertEquals("guest", accountName);
        assertEquals("DOM", primaryDomain);

        byte[] lm = (byte[]) getField(obj, "lmHash");
        byte[] nt = (byte[]) getField(obj, "ntHash");

            assertNotNull(resource, "Should create resource for URL: " + url);
        }
    }

    @Test
    @DisplayName("getPipe method should create SmbPipeResource")
    void testGetPipeResource() throws CIFSException {
        // When
        SmbPipeResource pipe = context.getPipe("smb://server/IPC$/pipe", 0);

        // Then
        assertNotNull(pipe, "Should create pipe resource");

        assertNotNull(cifsContextWrapper.getPipe(url, pipeType));
    }

    @Test
    void testGetPipe_MalformedURLException() {
        // Test getPipe(String url, int pipeType) with a malformed URL
        String malformedUrl = "invalid-pipe-url";
        int pipeType = 1;
        CIFSException thrown = assertThrows(CIFSException.class, () -> {
            cifsContextWrapper.getPipe(malformedUrl, pipeType);
        });

        // We need to set the file here or the resolver will fail with an NPE, not fully equipped to deal
        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        return artifact;
    }

    @Override
    public String getId() {
        return localRepository.getId();
    }

    @Override

        void testGetEndOfFile() {
            assertEquals(0, response.getEndOfFile());
        }

        @Test
        @DisplayName("getSize should return same as getEndOfFile")
        void testGetSize() {
            assertEquals(response.getEndOfFile(), response.getSize());
        }

        @Test
        @DisplayName("getFileAttributes should return initial value of 0")
        void testGetFileAttributes() {

        String existingContent = "";

        // Try to read existing content
        try {
            FileObject inputFile = processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT, "", path);
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputFile.openInputStream()))) {
                String line;

        when(mockTreeHandle.getSendBufferSize()).thenReturn(65536);
        when(mockFileHandle.isValid()).thenReturn(false, true); // First false to trigger ensureOpen, then true
        when(mockFileHandle.getFileId()).thenReturn(new byte[16]);
        when(mockFileHandle.acquire()).thenReturn(mockFileHandle);

        // Mock for ensureOpen to reopen file

    @Mock
    SmbFileHandleImpl fileHandle;

    private SmbPipeOutputStream newStream() throws CIFSException {
        // Arrange common constructor collaborators to avoid touching network/state
        when(handle.getPipe()).thenReturn(pipe);
        when(tree.isSMB2()).thenReturn(true);
        when(tree.getSendBufferSize()).thenReturn(4096);
        // Act
        return new SmbPipeOutputStream(handle, tree);
    }

        SmbInfoAllocation info = (SmbInfoAllocation) response.getInfo();
        assertEquals(8L * 1000000L * 512L, info.getCapacity());
        assertEquals(8L * 500000L * 512L, info.getFree());
    }

    @Test
    void testReadDataWireFormat_FileFsSizeInformation() throws Exception {
        // Test reading FS_SIZE_INFO data