*
     * @see jcifs.DfsResolver#resolve(jcifs.CIFSContext, java.lang.String, java.lang.String, java.lang.String)
     */
    @Override
    public DfsReferralData resolve(final CIFSContext tf, final String domain, final String root, final String path)
            throws SmbAuthException {
        return resolve(tf, domain, root, path, 5);
    }

@Deprecated
class ProjectDependenciesResolverTest extends AbstractCoreMavenComponentTestCase {
    @Inject
    private ProjectDependenciesResolver resolver;

    @Override
    protected String getProjectsDirectory() {
        return "src/test/projects/project-dependencies-resolver";
    }

    @Test
    void testSystemScopeDependencies() throws Exception {
        MavenSession session = createMavenSession(null);

 * under the License.
 */
package org.apache.maven.artifact.resolver;

import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.wagon.events.TransferListener;

    /**
     * Create an instance of the exception with all required information.
     *
     * @param originatingArtifact the artifact that was being resolved
     * @param resolvedArtifacts   artifacts that could be resolved
     * @param missingArtifacts    artifacts that could not be resolved
     * @param remoteRepositories  remote repositories where the missing artifacts were not found
     */
    public MultipleArtifactsNotFoundException(

    // methods ----------------------------------------------------------------

    /**
     * Gets a conflict resolver of the specified type.
     *
     * @param type the type of conflict resolver to obtain
     * @return the conflict resolver
     * @throws ConflictResolverNotFoundException
     *          if the specified type was not found
     */

    /**
     * Sets whether to resolve this request path in DFS.
     *
     * @param resolve true to enable DFS resolution
     */
    void setResolveInDfs(boolean resolve);

    /**
     * Checks if this request should be resolved in DFS.
     *
     * @return whether to resolve the request path in DFS
     */
    boolean isResolveInDfs();

     * the analygous {@link jcifs.smb1.UniAddress} or {@link java.net.InetAddress}
     * <code>getByName</code> methods can be used for that.
     *
     * @param host hostname to resolve
     * @return the resolved NetBIOS address
     * @throws java.net.UnknownHostException if there is an error resolving the name
     */

    public static NbtAddress getByName(final String host) throws UnknownHostException {

* Allow secure access to apiserver from Admission Controllers ([#31491](https://github.com/kubernetes/kubernetes/pull/31491), [@dims](https://github.com/dims))
* Resolves x509 verification issue with masters dialing nodes when started with --kubelet-certificate-authority ([#33141](https://github.com/kubernetes/kubernetes/pull/33141), [@liggitt](https://github.com/liggitt))

            // for standalone DFS we could be checking for a referral here, too
            DfsReferralData dr = this.ctx.getDfs().resolve(this.ctx, loc.getServer(), loc.getShare(), loc.getUNCPath());
            if (dr != null) {
                if (log.isDebugEnabled()) {
                    log.debug("Resolved " + rfullpath + " -> " + dr);
                }

                final String dunc = loc.handleDFSReferral(dr, rpath);

        return session;
    }

    @Override
    protected String component() {
        return "resolver";
    }

    @Test
    void testResolutionOfASingleArtifactWhereTheArtifactIsPresentInTheLocalRepository() throws Exception {
        Artifact a = createLocalArtifact("a", "1.0");

        artifactResolver.resolve(a, remoteRepositories(), localRepository());

        assertLocalArtifactPresent(a);
    }

    @Test