assertThat(base.newBuilder("")!!.build()).isEqualTo(parse("http://host/a/b"))
    assertThat(base.newBuilder("ftp://b")).isNull()
    assertThat(base.newBuilder("ht+tp://b")).isNull()
    assertThat(base.newBuilder("ht-tp://b")).isNull()
    assertThat(base.newBuilder("ht.tp://b")).isNull()
  }

  @Test
  fun redactedUrl() {
    val baseWithPasswordAndUsername = parse("http://username:password@host/a/b#fragment")

    return suite;
  }

  public void testAllocArraysDefault() {
    CompactHashSet<Integer> set = CompactHashSet.create();
    assertThat(set.needsAllocArrays()).isTrue();
    assertThat(set.elements).isNull();

    set.add(1);
    assertThat(set.needsAllocArrays()).isFalse();
    assertThat(set.elements).hasLength(CompactHashing.DEFAULT_SIZE);
  }

  public void testAllocArraysExpectedSize() {

    assertThat(Longs.tryParse("")).isNull();
    assertThat(Longs.tryParse("-")).isNull();
    assertThat(Longs.tryParse("+1")).isNull();
    assertThat(Longs.tryParse("999999999999999999999999")).isNull();
    assertWithMessage("Max long + 1")
        .that(Longs.tryParse(BigInteger.valueOf(MAX_VALUE).add(BigInteger.ONE).toString()))
        .isNull();
    assertWithMessage("Max long * 10")

    assertThat(Longs.tryParse("")).isNull();
    assertThat(Longs.tryParse("-")).isNull();
    assertThat(Longs.tryParse("+1")).isNull();
    assertThat(Longs.tryParse("999999999999999999999999")).isNull();
    assertWithMessage("Max long + 1")
        .that(Longs.tryParse(BigInteger.valueOf(MAX_VALUE).add(BigInteger.ONE).toString()))
        .isNull();
    assertWithMessage("Max long * 10")

    assumeNetwork()

    val (allAddresses, exception) = dnsQuery("google.com")

    assertThat(exception).isNull()
    assertThat(allAddresses).isNotEmpty()
  }

  @Test
  fun testDnsRequestInvalid() {
    val (allAddresses, exception) = dnsQuery("google.invalid")

    assertThat(exception).isNull()
    assertThat(allAddresses).isEmpty()
  }

  @Test
  fun testRequestOnNetwork() {

 * limitations under the License.
 */
package okhttp3.internal.cache2

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNull
import assertk.assertions.isTrue
import java.io.File
import java.io.IOException
import java.util.concurrent.Callable
import java.util.concurrent.Executors
import kotlin.test.assertFailsWith

package okhttp3

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.hasMessage
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import java.io.IOException
import java.security.cert.Certificate
import kotlin.test.assertFailsWith
import okhttp3.Handshake.Companion.handshake
import okhttp3.tls.HeldCertificate
import org.junit.jupiter.api.Test

    val page2 = server.takeRequest()
    assertThat(page2.requestLine).isEqualTo("GET /page2 HTTP/1.1")
    assertThat(page2.headers["Content-Length"]).isNull()
    assertThat(page2.headers["Content-Type"]).isNull()
    assertThat(page2.headers["Transfer-Encoding"]).isNull()
  }

  @Test
  fun response305UseProxy() {
    server.enqueue(
      MockResponse(
        code = HttpURLConnection.HTTP_USE_PROXY,

	}
	return false
}

// HasExpiry returns 'true' if lifecycle document has Expiry enabled.
func (lc Lifecycle) HasExpiry() bool {
	for _, rule := range lc.Rules {
		if !rule.Expiration.IsNull() || !rule.NoncurrentVersionExpiration.IsNull() {
			return true
		}
	}
	return false
}

// UnmarshalXML - decodes XML data.
func (lc *Lifecycle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {

import assertk.assertions.containsExactly
import assertk.assertions.containsExactlyInAnyOrder
import assertk.assertions.hasMessage
import assertk.assertions.isEqualTo
import assertk.assertions.isInstanceOf
import assertk.assertions.isNull
import java.io.EOFException
import java.io.File
import java.io.IOException
import java.net.InetAddress
import java.net.UnknownHostException
import java.util.concurrent.TimeUnit
import mockwebserver3.MockResponse