*/
@NullMarked
@GwtCompatible
public final class OptionalTest extends TestCase {
  @SuppressWarnings("NullOptional")
  public void testToJavaUtil_static() {
    assertThat(Optional.toJavaUtil(null)).isNull();
    assertEquals(java.util.Optional.empty(), Optional.toJavaUtil(Optional.absent()));
    assertEquals(java.util.Optional.of("abc"), Optional.toJavaUtil(Optional.of("abc")));
  }

  public void testToJavaUtil_instance() {

 *
 */
package okhttp.android.test

import android.util.Log
import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.containsOnly
import assertk.assertions.isNull
import java.net.UnknownHostException
import okhttp3.ConnectionSpec
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.internal.platform.AndroidPlatform

    assertThat(fooReference1).isNotSameInstanceAs(fooReference2);

    assertThat(mapCache.put(fooReference1, "bar")).isNull();
    assertThat(mapCache.get(fooReference1)).isEqualTo("bar"); // ensure first reference is cached
    assertThat(mapCache.remove(fooReference2)).isEqualTo("bar");
    assertThat(mapCache.get(fooReference1)).isNull();
  }

package okhttp3.internal

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import java.util.concurrent.atomic.AtomicReference
import org.junit.jupiter.api.Test

class TagsTest {
  @Test
  fun emptyTags() {
    val tags = EmptyTags
    assertThat(tags[String::class]).isNull()
  }

  @Test
  fun singleElement() {
    val tags = EmptyTags.plus(String::class, "hello")

	}
	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.isEqualTo
import assertk.assertions.isInstanceOf
import assertk.assertions.isNotInstanceOf
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import assertk.assertions.isSameAs
import java.io.IOException
import java.net.CookieManager
import java.net.Proxy
import java.net.ProxySelector
import java.net.ResponseCache
import java.net.SocketAddress

@GwtCompatible
@NullMarked
public class FunctionsTest extends TestCase {

  public void testIdentity_same() {
    Function<@Nullable String, @Nullable String> identity = Functions.identity();
    assertThat(identity.apply(null)).isNull();
    assertSame("foo", identity.apply("foo"));
  }

  public void testIdentity_notSame() {
    Function<Long, Long> identity = Functions.identity();

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

import assertk.assertThat
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import java.util.concurrent.LinkedBlockingDeque
import java.util.concurrent.TimeUnit
import okhttp3.Response
import okhttp3.internal.platform.Platform
import okhttp3.internal.platform.Platform.Companion.get

  fun assertFailure(t: Throwable?) {
    val event = nextEvent() as Failure
    assertThat(event.response).isNull()
    assertThat(event.t).isSameAs(t)
  }

  fun assertFailure(
    cls: Class<out IOException?>?,
    vararg messages: String,
  ) {
    val event = nextEvent() as Failure
    assertThat(event.response).isNull()
    assertThat(event.t.javaClass).isEqualTo(cls)
    if (messages.isNotEmpty()) {

        // don't let the new entry get GCed
        warmed.add(entryOf(entry.getKey(), newValue));
        Object newKey = new Object();
        assertThat(cache.asMap().put(newKey, entry.getValue())).isNull();
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertThat(cache.getUnchecked(entry.getKey())).isEqualTo(newValue);
        assertThat(cache.getUnchecked(newKey)).isEqualTo(entry.getValue());