SmbResourceLocatorImpl a = locator("smb://server/share/dir/file.txt");
        assertEquals("file.txt", a.getName());

        // share name with trailing slash when only share present
        SmbResourceLocatorImpl b = locator("smb://server/share/");
        assertEquals("share/", b.getName());

        // host when no path/share
        SmbResourceLocatorImpl c = locator("smb://server/");

            "share, " // empty service
    })
    void getSmbTree_invalid(String share, String service) {
        doThrow(new IllegalArgumentException("invalid share/service")).when(session).getSmbTree(eq(share), eq(service));

        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> session.getSmbTree(share, service));
        assertTrue(ex.getMessage().contains("invalid"));

                this.canon = "/" + this.share + "/" + StringUtil.join("/", remainParts) + (trailingSlash ? "/" : "");
            } else {
                this.unc = "\\";
                if (this.share != null) {
                    this.canon = "/" + this.share + (trailingSlash ? "/" : "");
                } else {
                    this.canon = "/";
                }

     */
    SmbTransport getTransport();

    /**
     * Connect to the logon share
     *
     * @throws SmbException if the connection fails
     */
    void treeConnectLogon() throws SmbException;

    /**
     * Gets or creates an SMB tree connection for the specified share and service.
     *
     * @param share the share name to connect to
     * @param service the service type for the connection

        assertDoesNotThrow(() -> new Trans2GetDfsReferral(mockConfig, "\\\\server\\share"));

        // Test forward slashes
        assertDoesNotThrow(() -> new Trans2GetDfsReferral(mockConfig, "//server/share"));

        // Test with spaces
        assertDoesNotThrow(() -> new Trans2GetDfsReferral(mockConfig, "\\\\server\\my share\\file.txt"));

        // Test with special characters

        void testGetShare() {
            // Act & Assert
            assertEquals("share", smbFile.getShare());
        }

        @Test
        void testGetUncPath() {
            // Arrange
            doReturn("\\localhost\share\file.txt").when(smbFile).getUncPath();

            // Act & Assert
            assertEquals("\\localhost\share\file.txt", smbFile.getUncPath());
        }
    }

    @Nested

    private int pathConsumed;
    private long ttl;
    private String server; // Server
    private String share; // Share
    private String link;
    private String path; // Path relative to tree from which this referral was thrown

    private long expiration;
    private int rflags;

    private boolean resolveHashes;

    private DfsReferralDataImpl next;

        }
    }

    /**
     * Validates share name
     *
     * @param share the share name to validate
     * @throws IllegalArgumentException if share name is invalid
     */
    public static void validateShareName(String share) {
        if (share == null || share.isEmpty()) {
            throw new IllegalArgumentException("Share name cannot be null or empty");
        }

            assertEquals("SERVER", concreteServer);
        }

        @Test
        @DisplayName("Should get share")
        void testGetShare() {
            String share = "share";

            // Test with mock
            when(mockReferralData.getShare()).thenReturn(share);
            assertEquals(share, mockReferralData.getShare());
            verify(mockReferralData, times(1)).getShare();

            assertEquals("smb1://server/share/", new SmbFile("smb1://server/share/file.txt").getParent());
            // Test parent of a directory
            assertEquals("smb1://server/share/", new SmbFile("smb1://server/share/dir/").getParent());
            // Test parent of a share
            assertEquals("smb1://server/", new SmbFile("smb1://server/share/").getParent());
            // Test parent of a server