// To properly test UNC rejection, we would need to fix the normalization logic
        // to preserve the leading double backslash for UNC paths
    }

    @Test
    public void testInvalidUncPath() throws Exception {
        // Due to normalization removing duplicate backslashes, true UNC validation doesn't work
        // These tests validate current behavior where problematic paths are caught by other checks

            return Pattern.quote(s.substring(0, s.length() - 1)) + "$";
        }
        return Pattern.quote(s);
    }

    /**
     * Unescapes double backslashes in regex patterns.
     * Converts escaped backslashes (\\) back to single backslashes (\).
     *
     * @param s the string to unescape
     * @return the unescaped string
     */
    protected String unescape(final String s) {

            assertEquals(buffer.size(), bytesEncoded);
            assertEquals(4 + 2 * path.length(), bytesEncoded);
        }

        @Test
        @DisplayName("Should handle path with only backslashes")
        void testPathWithOnlyBackslashes() {
            String path = "\\\\\\\\\\\\";
            buffer = new DfsReferralRequestBuffer(path, 2);

            byte[] dst = new byte[buffer.size()];

        request.setPath("third\\path\\");
        assertEquals("\\third\\path", request.getPath());

        // Multiple leading backslashes - only first one gets stripped, then trailing ones get stripped
        // But getPath() adds a backslash at the beginning, so \\fourth\path\\ becomes \fourth\path\
        request.setPath("\\\\fourth\\path\\\\");
        assertEquals("\\\\fourth\\path\\", request.getPath());

        MsrpcShareEnum shareEnum = new MsrpcShareEnum(TEST_SERVER_NAME);
        assertNotNull(shareEnum);

        // Verify the server name is properly formatted with double backslashes
        try {
            Field servernameField = srvsvc.ShareEnumAll.class.getDeclaredField("servername");
            servernameField.setAccessible(true);

            assertEquals(expectedPath.isEmpty() ? "" : expectedPath, result.getPath());
        }

        @Test
        @DisplayName("Should handle path with multiple backslashes")
        void testPathWithMultipleBackslashes() {
            when(mockReferral.getTtl()).thenReturn(300);
            when(mockReferral.getRFlags()).thenReturn(0);

        when(dr.getPathConsumed()).thenReturn(2); // consume leading \\ from UNC

        String newUnc = l.handleDFSReferral(dr, "\\req\\");
        // dunc is "\\" + path + remaining  - note: path may not have leading backslashes
        assertTrue(newUnc.contains("dfs/path") || newUnc.contains("dfs\\path"));
        assertEquals(dr, l.getDfsReferral());
        assertEquals("dfs-server", l.getServerWithDfs());

            }
        }

        return false;
    }

    /**
     * Normalize a path
     */
    private String normalizePath(String path) {
        // Replace forward slashes with backslashes for consistency
        String normalized = path.replace('/', '\\');

        // Remove duplicate slashes
        normalized = normalized.replaceAll("\\\\+", "\\\\");

     */

    public String getPath() {
        return this.fileLocator.getPath();
    }

    /**
     * Returns the Windows UNC style path with backslashes instead of forward slashes.
     *
     * @return The UNC path.
     */
    public String getCanonicalUncPath() {
        return this.fileLocator.getCanonicalURL();
    }

    /**

        assertEquals("\\test\\path\\", trans2FindFirst2.getPath());
    }

    @Test
    @DisplayName("Test constructor with path ending in backslash")
    void testConstructorWithPathEndingInBackslash() {
        // Test path already ending with backslash
        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test\\path\\", "*.doc", 0x16, 20, 2048);

        assertEquals("\\test\\path\\", trans2FindFirst2.getPath());