/**
     * 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();

      val extensions =
        try {
          X509TrustManagerExtensions(trustManager)
        } catch (iae: IllegalArgumentException) {
          // X509TrustManagerExtensions checks for checkServerTrusted(X509Certificate[], String, String)
          null
        }

      return when {
        extensions != null -> AndroidCertificateChainCleaner(trustManager, extensions)
        else -> null

    /**
     * Adds a Throwable to the list of failures.
     *
     * @param t the Throwable to add
     */
    public void addFailure(final Throwable t) {
        failures.add(t);
    }

    /**
     * Checks if there are any failures recorded.
     *
     * @return true if there is at least one failure, false otherwise
     */
    public boolean hasFailure() {
        return !failures.isEmpty();
    }

    /**

import static com.google.common.truth.Truth.assertWithMessage;

import com.google.common.testing.AbstractPackageSanityTests;
import org.jspecify.annotations.NullUnmarked;

/**
 * Covers basic sanity checks for the entire package.
 *
 * @author Kurt Alfred Kluever
 */

@NullUnmarked
public class PackageSanityTests extends AbstractPackageSanityTests {

  private static final AbstractGraphBuilder<?> graphBuilderA =

import static com.google.common.base.Preconditions.checkState;

import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;

/** Precondition checks useful in collection implementations. */
@GwtCompatible
final class CollectPreconditions {

  static void checkEntryNotNull(Object key, Object value) {
    if (key == null) {

    for (String entry : Splitter.on(PATH_SEPARATOR.value()).split(JAVA_CLASS_PATH.value())) {
      try {
        try {
          urls.add(new File(entry).toURI().toURL());
        } catch (SecurityException e) { // File.toURI checks to see if the file is a directory
          urls.add(new URL("file", null, new File(entry).getAbsolutePath()));
        }
      } catch (MalformedURLException e) {

        ArtifactRepository rr2 = repositorySystem.createDefaultRemoteRepository();
        a2.setDependencyFilter(new ExcludesArtifactFilter(Arrays.asList("foo")));

        // sanity checks
        assertNotSame(a1, a2);
        assertNotSame(lr1, lr2);
        assertNotSame(rr1, rr2);

        DefaultMavenMetadataCache.CacheKey k1 =

                    "clean",
                    "performance:${testProject}PerformanceAdHocTest",
                    tests.map { """--tests "$it"""" }.joinToString(" "),
                    """--warmups 2 --runs 2 --checks none""",
                    "-PtestJavaVersion=${os.perfTestJavaVersion.major}",
                    "-PtestJavaVendor=${os.perfTestJavaVendor.name.lowercase()}",
                    "-PautoDownloadAndroidStudio=true",

        return destroyProcess(sessionId, jobProcess);
    }

    /**
     * Checks if any processes are currently running.
     *
     * @return true if at least one process is running, false otherwise
     */
    public boolean isProcessRunning() {
        return !runningProcessMap.isEmpty();
    }

    /**
     * Checks if the process with the given session ID is currently running.
     *

     * @throws VersionParserException if the range specification violates the syntax rules of this scheme
     */
    @Nonnull
    VersionConstraint parseVersionConstraint(@Nonnull String constraint);

    /**
     * Checks whether a given artifact version is considered a {@code SNAPSHOT} or not.
     */
    boolean isSnapshot(@Nonnull String version);