class HappyPath {
        @Test
        void testBasicProperties() throws Exception {
            String url = "smb://server/share/path/file.txt";
            DummySmbResourceLocator loc = new DummySmbResourceLocator(url);
            assertEquals("file.txt", loc.getName());
            assertEquals("smb://server/share/path/", loc.getParent());
            assertEquals(url, loc.getPath());
            // canonicalisation simply removes '.' and '..'

    }

    @Test
    void testGetReferral_Success() throws IOException, SmbAuthException {
        String domain = "domain.com";
        String root = "share";
        String path = "\\folder";
        String fullPath = "\\" + domain + "\\" + root + path; // Should be "\domain.com\share\folder"

        lenient().when(smbTransport.getDfsReferrals(auth, fullPath, 0)).thenReturn(dfsReferral);

     * @throws CIFSException if an error occurs retrieving the domain name
     */
    String getOEMDomainName() throws CIFSException;

    /**
     * Gets the name of the share this tree is connected to
     * @return the share we are connected to
     */
    String getConnectedShare();

    /**
     * Checks if this tree handle refers to the same tree as another
     * @param th the tree handle to compare with

        CompletableFuture<WitnessRegistration> future = client.registerForNotifications("\\\\server\\share", serverAddress, listener);

        WitnessRegistration registration = future.get(5, TimeUnit.SECONDS);

        assertNotNull(registration);
        assertEquals(WitnessRegistrationState.REGISTERED, registration.getState());
        assertEquals("\\\\server\\share", registration.getShareName());

            throw new SmbException("Invalid server name in UNC path");
        }

        // Validate share name
        String share = parts[1];
        if (share.isEmpty() || share.endsWith("$") && share.length() == 1) {
            throw new SmbException("Invalid share name in UNC path");
        }
    }

    /**
     * Validate individual path components
     */

                () -> new SmbFileHandleImpl(cfg, new byte[] { 1, 2 }, null, "//server/share", 0, 0, 0, 0, 0L));
    }

    @Test
    @DisplayName("Constructor with null cfg throws NPE")
    void constructor_nullCfg_throwsNPE() {
        stubValidTree(7L, true, true);
        assertThrows(NullPointerException.class, () -> new SmbFileHandleImpl(null, 42, tree, "//server/share", 0, 0, 0, 0, 0L));
    }

    @Test

            p++;
        }
        while (p < len && pathInfo.charAt(p) == '/') {
            p++;
        }
        if (p < len) { /* then there must be a share */
            out[i] = '/';
            i++;
            do { /* collect the share name */
                out[i++] = ch = pathInfo.charAt(p++);
            } while (p < len && ch != '/');
        }
        return new String(out, 0, i);
    }

                            SmbTreeImpl uct = smbSession.getSmbTree(share, null).unwrap(SmbTreeImpl.class);
                            SmbTreeImpl ct = connectTree(loc, host, share, trans, uct, dr)) {

                        if (dr != null) {
                            ct.setTreeReferral(dr);
                            if (dr != start) {

import jcifs.internal.fscc.FileSystemInformation;

/**
 * Interface for file system allocation information providing capacity and free space details.
 * Used in SMB protocol operations to query disk space information from remote SMB shares.
 *
 * @author mbechler
 */
public interface AllocInfo extends FileSystemInformation {

    /**
     * Gets the total capacity of the allocation.
     *
     * @return total capacity
     */

        }

        /*
         * Subtract the server and share from the pathConsumed so that
         * it reflects the part of the relative path consumed and not
         * the entire path.
         */

        DfsReferralDataInternal next = dri;
        do {
            next.stripPathConsumed(1 + server.length() + 1 + share.length());
            next = next.next();
        } while (next != dri);