* is queried frequently and exceptions would be rather costly to
     * throw on a regular basis here.
     *
     * @param host the hostname to resolve
     * @param tc the CIFS context
     * @return resolved name, null if not found
     */
    public synchronized NbtAddress getByName(final String host, final CIFSContext tc) {
        return getByName(new Name(tc.getConfig(), host, 0x20, null), tc);

      val privateHost = isPrivateHost(hostname)

      if (privateHost && !resolvePrivateAddresses) {
        throw UnknownHostException("private hosts not resolved")
      }

      if (!privateHost && !resolvePublicAddresses) {
        throw UnknownHostException("public hosts not resolved")
      }
    }

    return lookupHttps(hostname)
  }

  @Throws(UnknownHostException::class)

#   DefaultVersionResolverRequest    - Version resolution results (session/soft, less critical than artifacts)
#   RgavCacheKey                     - BOM import caching (session/soft, typically resolved once)
#   DefaultModelBuilderRequest       - Model building operations (none, ensures fresh dynamic builds)
#   *                                - Fallback for all other requests (request/soft for temporary child request caching)
#

    assertThat(response.body.string()).isEqualTo("abc")
    assertThat(socksProxy.connectionCount()).isEqualTo(1)
  }

  @Test
  fun checkRemoteDNSResolve() {
    // This testcase will fail if the target is resolved locally instead of through the proxy.
    server.enqueue(MockResponse.Builder().body("abc").build())
    val client =
      clientTestRule
        .newClientBuilder()
        .proxy(socksProxy.proxy())

public interface SmbTreeHandleInternal extends SmbTreeHandle {

    /**
     * Releases this tree handle back to the pool for reuse
     */
    void release();

    /**
     * Ensures that DFS referrals have been resolved for this tree
     * @throws SmbException if an SMB-specific error occurs
     * @throws CIFSException if a general CIFS error occurs
     */
    void ensureDFSResolved() throws CIFSException;

    /**

    TypeResolver typeResolver = TypeResolver.covariantly(parameterized.getClass());
    ParameterizedType resolved =
        (ParameterizedType) typeResolver.resolveType(parameterized.parameterizedType());
    assertEquals(TypeTokenResolutionTest.class, resolved.getOwnerType());
    assertEquals(Bar.class, resolved.getRawType());
    assertThat(resolved.getActualTypeArguments()).asList().contains(String.class);
  }

    TypeResolver typeResolver = TypeResolver.covariantly(parameterized.getClass());
    ParameterizedType resolved =
        (ParameterizedType) typeResolver.resolveType(parameterized.parameterizedType());
    assertEquals(TypeTokenResolutionTest.class, resolved.getOwnerType());
    assertEquals(Bar.class, resolved.getRawType());
    assertThat(resolved.getActualTypeArguments()).asList().contains(String.class);
  }

    }

    /**
     * Resolves the runtime dependencies needed to build a SearchLog.
     *
     * @param params The search request parameters.
     * @param fessConfig The Fess configuration.
     * @return The resolved search log context.
     */

     *   <li>Both file and directory targets</li>
     * </ul>
     *
     * @param relative path to resolve relative to this source
     * @return the resolved source, or null if resolution not possible
     * @throws NullPointerException if relative is null
     */
    @Nullable
    Source resolve(@Nonnull String relative);

    /**
     * Retrieve an <code>InetAddress</code>. If the address is not
     * an IP address and cannot be resolved <code>null</code> will
     * be returned.
     *
     * @param key the property key to look up
     * @param def the default InetAddress to return if the property is not found or cannot be resolved
     * @return the property value as an InetAddress, or the default value
     */