* domain-based DFS root shares to links for each
                 */
                final Map<String, CacheEntry<DfsReferralDataInternal>> roots = domains.get(domain);
                if (roots != null) {
                    dr = getLinkReferral(tf, domain, root, path, now, roots);
                }

                if (tf.getConfig().isDfsConvertToFQDN() && dr instanceof DfsReferralDataImpl) {

/**
 * MSRPC implementation for enumerating DFS roots.
 * This class provides functionality to enumerate Distributed File System (DFS)
 * roots on a server using the NetDFS RPC interface.
 */
public class MsrpcDfsRootEnum extends netdfs.NetrDfsEnumEx {

    /**
     * Creates a new DFS root enumeration request for the specified server.
     *
     * @param server the server name to enumerate DFS roots from
     */

/**
 * MSRPC implementation for enumerating DFS roots.
 * This class provides functionality to enumerate Distributed File System (DFS)
 * roots on a server using the NetDFS RPC interface.
 */
public class MsrpcDfsRootEnum extends netdfs.NetrDfsEnumEx {

    /**
     * Creates a new DFS root enumeration request for the specified server.
     *
     * @param server the server name to enumerate DFS roots from
     */

        /* domains that can contain DFS points to maps of roots for each
         */
        final HashMap domains = getTrustedDomains(auth);
        if (domains != null) {
            domain = domain.toLowerCase();
            /* domain-based DFS root shares to links for each
             */
            final HashMap roots = (HashMap) domains.get(domain);
            if (roots != null) {
                SmbTransport trans = null;

        // Verify totalentries is initialized
        assertNotNull(dfsRootEnum.totalentries);
    }

    @Test
    @DisplayName("getEntries should return empty array when no DFS roots exist")
    void testGetEntries_emptyArray() throws Exception {
        // Create empty DfsEnumArray200
        netdfs.DfsEnumArray200 emptyArray = new netdfs.DfsEnumArray200();
        emptyArray.count = 0;

        sourceRoots.asSequence()
            .map { it.resolve(sourceFilePath) to it }
            .firstOrNull { it.first.isFile }
            ?: error("Source file '$sourceFilePath' not found, searched in source roots:\n  - ${sourceRoots.joinToString("\n  - ")}")

    private
    val KtFile.normalizedPath: String?
        get() = virtualFile.canonicalPath?.let { normaliseFileSeparators(it) }

    private

a client and a client that authenticates a server.

```java
// Create the root for client and server to trust. We could also use different roots for each!
HeldCertificate rootCertificate = new HeldCertificate.Builder()
    .certificateAuthority(0)
    .build();

// Create a server certificate and a server that uses it.

 *    will be used to authenticate the client's certificate chain. Typically this is not the same
 *    set of root certificates used in server authentication. Instead it will be a small set of
 *    roots private to an organization or service.
 */
class HandshakeCertificates private constructor(
  @get:JvmName("keyManager") val keyManager: X509KeyManager,
  @get:JvmName("trustManager") val trustManager: X509TrustManager,
) {

        if (tc.getDfs().isTrustedDomain(tc, locator.getServer())) {
            /*
             * The server name is actually the name of a trusted
             * domain. Add DFS roots to the list.
             */
            try {
                entries = doDfsRootEnum(tc, locator, locator.getAddress());
                for (final FileEntry e : entries) {

                    message += String.format(
                            "  Hint: The artifactId '%s' does not match the project artifactId '%s' "
                                    + "nor any declared module name in source roots.",
                            a2, a1);
                }
            } else {
                // Non-modular project: artifactId must match exactly
                message = String.format(