Client(
    userAgent = "OkHttp",
    version = OkHttp.VERSION,
    enabled =
      ConnectionSpec.MODERN_TLS.cipherSuites!!.map {
        ianaSuites.fromJavaName(it.javaName)
      },
    supported =
      ConnectionSpec.COMPATIBLE_TLS.cipherSuites!!.map {
        ianaSuites.fromJavaName(it.javaName)
      },
  )

fun historicOkHttp(version: String): Client {
  val enabled =

import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.testing.EqualsTester;
import com.google.common.testing.SerializableTester;
import java.util.Map;
import org.junit.Ignore;

/**
 * Basic serialization test for maps.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")

        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(1), eq(new byte[] { 0x01 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData1));
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(2), eq(new byte[] { 0x02 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData2));

	ReplicationFailedCountV1 uint64 `json:"objectsFailedReplicationCount"`

	ObjectsCount            uint64                           `json:"objectsCount"`
	ObjectSizesHistogram    map[string]uint64                `json:"objectsSizesHistogram"`
	ObjectVersionsHistogram map[string]uint64                `json:"objectsVersionsHistogram"`
	VersionsCount           uint64                           `json:"versionsCount"`

            assertNotNull(e);
        }
    }

    public void test_getQueryMap_exists() {
        Map<String, List<Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>>>> result = keyMatchHelper.getQueryMap("");
        assertNotNull(result);
    }

    public void test_getQueryMap_notExists() {
        Map<String, List<Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>>>> result = keyMatchHelper.getQueryMap("nonexistent");

    private final int rank;

    private final String key;

    private static Map<String, ArtifactStatus> map;

    private ArtifactStatus(String key, int rank) {
        this.rank = rank;
        this.key = key;

        if (map == null) {
            map = new HashMap<>();
        }
        map.put(key, this);
    }

    public static ArtifactStatus valueOf(String status) {

    return Platform.getEnumIfPresent(enumClass, value);
  }

  private static final Map<Class<? extends Enum<?>>, Map<String, WeakReference<? extends Enum<?>>>>
      enumConstantCache = new WeakHashMap<>();

  private static <T extends Enum<T>> Map<String, WeakReference<? extends Enum<?>>> populateCache(
      Class<T> enumClass) {
    Map<String, WeakReference<? extends Enum<?>>> result = new HashMap<>();

      // '!' represents an interior node that represents a REGISTRY entry in the map.
      // '?' represents a leaf node, which represents a REGISTRY entry in map.
      // ':' represents an interior node that represents a private entry in the map
      // ',' represents a leaf node, which represents a private entry in the map.
      String domain = DIRECT_JOINER.join(stack);

      if (domain.length() > 0) {

    LocalCache<?, ?> map = CacheTesting.toLocalCache(cache);

    assertThat(map.segments).hasLength(4);
    assertEquals(2, map.segments[0].table.length());
    assertEquals(2, map.segments[1].table.length());
    assertEquals(2, map.segments[2].table.length());
    assertEquals(2, map.segments[3].table.length());
  }

  @GwtIncompatible // CacheTesting

    LocalCache<?, ?> map = CacheTesting.toLocalCache(cache);

    assertThat(map.segments).hasLength(4);
    assertEquals(2, map.segments[0].table.length());
    assertEquals(2, map.segments[1].table.length());
    assertEquals(2, map.segments[2].table.length());
    assertEquals(2, map.segments[3].table.length());
  }

  @GwtIncompatible // CacheTesting