+ timeSeries.standardOptions.withUnit('s'),

    connections(title, targets, desc=''):
      self.base(title, targets, desc)
      + timeSeries.standardOptions.withUnit('cps'),

    dns(title, targets, desc=''):
      self.base(title, targets, desc)
      + timeSeries.standardOptions.withUnit('qps'),

    bytes(title, targets, desc=''):
      self.base(title, targets, desc)

      .assertHeader("", "ef")
  }

  @Test
  fun customDns() {
    // Configure a DNS that returns our local MockWebServer for android.com.
    val dns = FakeDns()
    dns["android.com"] = Dns.SYSTEM.lookup(server.url("/").host)
    client =
      client.newBuilder()
        .dns(dns)
        .build()
    server.enqueue(MockResponse())

        if ( ro == null || ro.length() == 0 ) {
            /*
             * No resolveOrder has been specified, use the
             * default which is LMHOSTS,DNS,WINS,BCAST or just
             * LMHOSTS,DNS,BCAST if jcifs.netbios.wins has not
             * been specified.
             */
            if ( this.winsServer.length == 0 ) {

  private var authenticator = JavaNetAuthenticator()
  private val fakeDns = FakeDns()
  private val recordingAuthenticator = RecordingAuthenticator()
  private val factory =
    TestValueFactory()
      .apply {
        dns = fakeDns
      }

  @BeforeEach
  fun setup() {
    Authenticator.setDefault(recordingAuthenticator)
  }

  @AfterEach
  fun tearDown() {
    Authenticator.setDefault(null)
    factory.close()
  }

        if( RO == null || RO.length() == 0 ) {

            /* No resolveOrder has been specified, use the
             * default which is LMHOSTS,DNS,WINS,BCAST
             * LMHOSTS,BCAST,DNS if jcifs.smb1.netbios.wins has not
             * been specified.
             */

            if( NbtAddress.getWINSAddress() == null ) {
                resolveOrder = new int[2];

           "typed_config": {
            "@type": "type.googleapis.com/envoy.extensions.filters.network.tcp_proxy.v3.TcpProxy",
            "stat_prefix": "outbound|53||kube-dns.kube-system.svc.cluster.local",
            "cluster": "outbound|53||kube-dns.kube-system.svc.cluster.local"
           }
          }
         ]
        }
       ],
       "traffic_direction": "OUTBOUND",
       "bind_to_port": false
      },

	public final fun setMaxRequestsPerHost (I)V
}

public abstract interface class okhttp3/Dns {
	public static final field Companion Lokhttp3/Dns$Companion;
	public static final field SYSTEM Lokhttp3/Dns;
	public abstract fun lookup (Ljava/lang/String;)Ljava/util/List;
}

public final class okhttp3/Dns$Companion {
}

public abstract class okhttp3/EventListener {

package okhttp3.dnsoverhttps

import java.io.EOFException
import java.net.InetAddress
import java.net.UnknownHostException
import okio.Buffer
import okio.ByteString
import okio.utf8Size

/**
 * Trivial Dns Encoder/Decoder, basically ripped from Netty full implementation.
 */
internal object DnsRecordCodec {
  private const val SERVFAIL = 2
  private const val NXDOMAIN = 3
  const val TYPE_A = 0x0001

          listOf(InetAddress.getByName(socketHost))
        } else {
          connectionUser.dnsStart(socketHost)

          val result = address.dns.lookup(socketHost)
          if (result.isEmpty()) {
            throw UnknownHostException("${address.dns} returned no addresses for $socketHost")
          }

          connectionUser.dnsEnd(socketHost, result)
          result
        }

		},
		{
			name:        "DNS",
			annotations: map[string]string{annotation.SidecarStatus.Name: "true"},
			proxyEnv:    []corev1.EnvVar{{Name: options.DNSCaptureByAgent.Name, Value: "true"}},
			golden:      filepath.Join(env.IstioSrc, "cni/pkg/plugin/testdata/dns.txt.golden"),
		},
		{
			name:        "invalid-drop",