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(

     */
    @Deprecated
    private void setSourceRootDirs(ProjectScope scope, Language language, List<String> roots) {
        sources.removeIf((source) -> scope.equals(source.scope()) && language.equals(source.language()));
        Path directory = getBaseDirectory();
        for (String root : roots) {
            addSourceRoot(new DefaultSourceRoot(scope, language, directory.resolve(root)));
        }
    }

                if (request != null) {
                    request.setPath(dunc);
                }

                if (!t.getShare().equals(dr.getShare())) {
                    // this should only happen for standalone roots or if the DC/domain root lookup failed
                    IOException last;
                    final DfsReferralData start = dr;
                    do {
                        if (log.isDebugEnabled()) {

        assertTrue(resourceAfter.getIncludes().contains("*.md"), "Should still contain *.md");
    }

    @Test
    void testSourceRootOrderingPreserved() {
        // Add multiple resource source roots
        project.addSourceRoot(
                new DefaultSourceRoot(ProjectScope.MAIN, Language.RESOURCES, Path.of("src/main/resources2")));
        project.addSourceRoot(

            # "-Wl,--undefined-version",
            # copybara:uncomment_end(google-only)
        ],
    }),
    linkstatic = 1,
    per_os_targets = True,
    roots = [
        "//tensorflow/c/experimental/filesystem:filesystem_interface",
        "//tensorflow/c/experimental/stream_executor:stream_executor",
        "//tensorflow/c:env",
        "//tensorflow/c:kernels",

    (For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

These requirements apply to the modified work as a whole.  If

    //         * Lookup a DC in the target domain
    //         * Ask the DC for a referral for the domain (e.g. "\example.com")
    //         * Do NetrDfsEnumEx on the server returned in the referral to
    //         * get roots in target domain
    //         */
    //
    //        UniAddress dc = UniAddress.getByName(domainName);
    //        SmbTransport trans = SmbTransport.getSmbTransport(dc, 0);

	}

	// Success.
	return objLayer, formattedDisks, nil
}

// removeRoots - Cleans up initialized directories during tests.
func removeRoots(roots []string) {
	for _, root := range roots {
		os.RemoveAll(root)
	}
}

// creates a bucket for the tests and returns the bucket name.
// initializes the specified API endpoints for the tests.

		_, err := certificate.Verify(x509.VerifyOptions{
			KeyUsages: []x509.ExtKeyUsage{
				x509.ExtKeyUsageClientAuth,
			},
			Intermediates: intermediates,
			Roots:         globalRootCAs,
		})
		if err != nil {
			writeSTSErrorResponse(ctx, w, ErrSTSInvalidClientCertificate, err)
			return
		}
	} else {