var builder: HttpUrl.Builder = httpUrl.newBuilder()
    var resolveBuilder: HttpUrl.Builder? = httpUrl.newBuilder("")
    val topPrivateDomain: String? = httpUrl.topPrivateDomain()
    val resolve: HttpUrl? = httpUrl.resolve("")
    val getFromUrl: HttpUrl? = URL("").toHttpUrlOrNull()
    val getFromUri: HttpUrl? = URI("").toHttpUrlOrNull()
    val parse: HttpUrl? = "".toHttpUrlOrNull()
    val defaultPort: Int = HttpUrl.defaultPort("")
  }

	public final fun build ()Lokhttp3/HttpUrl;
	public final fun encodedFragment (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;
	public final fun encodedPassword (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;
	public final fun encodedPath (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;
	public final fun encodedQuery (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;
	public final fun encodedUsername (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;

import java.io.IOException
import java.net.Inet6Address
import java.net.ProtocolException
import mockwebserver3.RecordedRequest
import okhttp3.Headers
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import okio.ByteString

internal fun RecordedRequest(
  requestLine: RequestLine,
  headers: Headers,
  chunkSizes: List<Int>?,
  bodySize: Long,

    return KnownLengthSink()
  }

  private fun newFixedLengthSource(
    url: HttpUrl,
    length: Long,
  ): Source {
    check(state == STATE_OPEN_RESPONSE_BODY) { "state: $state" }
    state = STATE_READING_RESPONSE_BODY
    return FixedLengthSource(url, length)
  }

  private fun newChunkedSource(url: HttpUrl): Source {
    check(state == STATE_OPEN_RESPONSE_BODY) { "state: $state" }

 */
public final class Crawler {
  private final OkHttpClient client;
  private final Set<HttpUrl> fetchedUrls = Collections.synchronizedSet(new LinkedHashSet<>());
  private final BlockingQueue<HttpUrl> queue;
  private final ConcurrentHashMap<String, AtomicInteger> hostnames = new ConcurrentHashMap<>();
  private final int hostLimit;

) {
  @get:JvmName("url")
  val url: HttpUrl = checkNotNull(builder.url) { "url == null" }

  @get:JvmName("method")
  val method: String = builder.method

  @get:JvmName("headers")
  val headers: Headers = builder.headers.build()

  @get:JvmName("body")
  val body: RequestBody? = builder.body

  @get:JvmName("cacheUrlOverride")
  val cacheUrlOverride: HttpUrl? = builder.cacheUrlOverride

	public final fun build ()Lokhttp3/HttpUrl;
	public final fun encodedFragment (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;
	public final fun encodedPassword (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;
	public final fun encodedPath (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;
	public final fun encodedQuery (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;
	public final fun encodedUsername (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;

 */

package okhttp3.modules;

import okhttp3.Call;
import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.logging.HttpLoggingInterceptor;
import okhttp3.logging.LoggingEventListener;

/**
 * Just checking compilation works
 */
public class OkHttpCaller {
  public static Call callOkHttp(HttpUrl url) {
    OkHttpClient client = new OkHttpClient
      .Builder()

    Platform.resetForTests()
    PlatformRegistry.applicationContext = null
  }

  @Test
  fun testWithoutContext() {
    val httpUrl = "https://www.google.co.uk".toHttpUrl()
    assertFailure { httpUrl.topPrivateDomain() }.all {
      hasMessage("Unable to load PublicSuffixDatabase.list resource.")
      cause().isNotNull().all {
        hasMessage(

  }

  override fun proxySelectStart(
    call: Call,
    url: HttpUrl,
  ) {
    logWithTime("proxySelectStart: $url")
  }

  override fun proxySelectEnd(
    call: Call,
    url: HttpUrl,
    proxies: List<Proxy>,
  ) {
    logWithTime("proxySelectEnd: $proxies")
  }

  override fun dnsStart(
    call: Call,