fileSystem.createDirectories(workspaceDir)
  }

  /**
   * Resolve the OSGi metadata of the all okhttp3 modules. If required modules do not have OSGi
   * metadata this will fail with an exception.
   */
  @Test
  fun testMainModuleWithSiblings() {
    createWorkspace().use { workspace ->
      createBndRun(workspace).use { bndRun ->
        bndRun.resolve(
          false,
          false,
        )
      }
    }

     *
     * @return resolveHashes
     */
    boolean isResolveHashes();

    /**
     * Check if this referral needs to be resolved further
     *
     * @return whether this refrral needs to be resolved further
     */
    boolean isIntermediate();

    /**
     * Combine this referral with another to form a chain
     *
     * @param next the referral to combine with

      - uses: dessant/lock-threads@v3
        with:
          github-token: ${{ github.token }}
          issue-inactive-days: '365'
          exclude-any-issue-labels: 'do-not-close'
          issue-lock-reason: 'resolved'

    }

    @Test
    void testInitLoadsJcifsPropertiesFile(@TempDir Path tempDir) throws IOException, CIFSException {
        // Test that jcifs.properties file is loaded
        Path jcifsPropertiesPath = tempDir.resolve("jcifs.properties");
        Files.writeString(jcifsPropertiesPath, "jcifs.smb.client.nativeOs=FileOS");
        System.setProperty("jcifs.properties", jcifsPropertiesPath.toString());

        SingletonContext.init(null);

     *
     * @param url the SMB URL of the named pipe
     * @param pipeType the type of the pipe
     * @throws MalformedURLException if the URL is malformed
     * @throws UnknownHostException if the host cannot be resolved
     */
    public SmbNamedPipe(final String url, final int pipeType) throws MalformedURLException, UnknownHostException {
        super(url);
        this.pipeType = pipeType;
        type = TYPE_NAMED_PIPE;
    }

    }
    val multimap = mapOf("Set-Cookie" to cookieStrings)
    try {
      cookieHandler.put(url.toUri(), multimap)
    } catch (e: IOException) {
      Platform.get().log("Saving cookies failed for " + url.resolve("/...")!!, WARN, e)
    }
  }

  override fun loadForRequest(url: HttpUrl): List<Cookie> {
    val cookieHeaders =
      try {
        // The RI passes all headers. We don't have 'em, so we don't pass 'em!

     * Implementation may override with absolute path instead.
     */
    default Path directory() {
        Path src = Path.of("src");
        return module().map(src::resolve)
                .orElse(src)
                .resolve(scope().id())
                .resolve(language().id());
    }

    /**
     * {@return the list of patterns for the files to include}.
     * The path separator is {@code /} on all platforms, including Windows.

nvidia-cudnn-cu12>=9.3.0.75,<10.0
nvidia-cufft-cu12>=11.2.3.61,<12.0
nvidia-curand-cu12>=10.3.6.82,<11.0
nvidia-cusolver-cu12>=11.6.3.83,<12.0
nvidia-cusparse-cu12>=12.5.1.3,<13.0
nvidia-nccl-cu12>=2.27.7,<3.0
nvidia-nvjitlink-cu12>=12.5.82,<13.0

        }

        @Override
        public synchronized DfsReferral resolve(String domain, String root, String path, NtlmPasswordAuthentication auth)
                throws SmbAuthException {
            if (disabled || root.equals("IPC$")) {
                return null;
            }
            return super.resolve(domain, root, path, auth);
        }
    }

    @BeforeEach
    void setUp() {

            this.domain = domain;
            this.server = server;
            this.fullUNCPath = fullPath;
        }

        @Override
        public void setResolveInDfs(boolean resolve) {
            this.resolveInDfs = resolve;
        }

        @Override
        public boolean isResolveInDfs() {
            return resolveInDfs;
        }