override fun select(uri: URI) = listOf(socksProxy.proxy())

        override fun connectFailed(
          uri: URI,
          socketAddress: SocketAddress,
          e: IOException,
        ) = error("unexpected call")
      }
    val client =
      clientTestRule.newClientBuilder()
        .proxySelector(proxySelector)
        .build()
    val request = Request.Builder().url(server.url("/")).build()

	if err == nil {
		return nil
	}
	switch err {
	case context.DeadlineExceeded:
		return fmt.Errorf("%w %s", errEtcdUnreachable, etcdEndpoints)
	default:
		return fmt.Errorf("unexpected error %w from etcd, please check your endpoints %s", err, etcdEndpoints)
	}
}

func saveKeyEtcdWithTTL(ctx context.Context, client *etcd.Client, key string, data []byte, ttl int64) error {

			rds = formatStatus(config)
		case xdsresource.EndpointType:
			eds = formatStatus(config)
		case xdsresource.ExtensionConfigurationType:
			ecds = formatStatus(config)
		default:
			log.Infof("GenericXdsConfig unexpected type %s\n", xdsresource.GetShortType(cfgType))
		}
	}
	return
}

func handleAndGetXdsConfigs(clientConfig *xdsstatus.ClientConfig) []*xdsstatus.ClientConfig_GenericXdsConfig {

		t.Run(fmt.Sprintf("Test_%d", i+1), func(t *testing.T) {
			cfg, err := ParseConfig(bytes.NewReader([]byte(tc.inputConfig)))
			if err != nil {
				t.Fatalf("Got unexpected error: %v", err)
			}
			if got := cfg.Rules[0].MetadataReplicate(tc.opts); got != tc.expectedResult {
				t.Fatalf("Expected result with recursive set to false: `%v`, got: `%v`", tc.expectedResult, got)
			}
		})

	}

## Version 3.9.1

_2017-11-18_

 *  New: Recover gracefully when Android's DNS crashes with an unexpected
    `NullPointerException`.
 *  New: Recover gracefully when Android's socket connections crash with an
    unexpected `ClassCastException`.
 *  Fix: Don't include the URL's fragment in `encodedQuery()` when the query
    itself is empty.

## Version 3.9.0

		}
	}
	t.Run("uint32max-2_NoZip64", func(t *testing.T) {
		t.Parallel()
		if generatesZip64(t, gen(0xfffffffe)) {
			t.Error("unexpected zip64")
		}
	})
	t.Run("uint32max-1_Zip64", func(t *testing.T) {
		t.Parallel()
		if !generatesZip64(t, gen(0xffffffff)) {
			t.Error("expected zip64")
		}
	})
}

// At 16k records, we need to generate a zip64 file.
func TestZip64ManyRecords(t *testing.T) {

            pkcs8Base64 = match.groups[2]!!.value // Include the contents only for PKCS8.
          }
          else -> {
            throw IllegalArgumentException("unexpected type: $label")
          }
        }
      }
      require(certificatePem != null) { "string does not include a certificate" }
      require(pkcs8Base64 != null) { "string does not include a private key" }

        int ftag = in.read();
        int tag = readTagNumber(in, ftag);
        if ( tag != expectTag ) {
            throw new IOException("Unexpected tag " + tag);
        }
        int length = readLength(in, limit, false);
        byte[] content = new byte[length];
        in.read(content);
        return content;
    }

      TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()).apply {
        init(null as KeyStore?)
      }.trustManagers!!
    check(trustManagers.size == 1 && trustManagers[0] is X509TrustManager) {
      "Unexpected default trust managers: ${trustManagers.contentToString()}"
    }
    val x509TrustManager = trustManagers[0] as X509TrustManager
    // Disabled because OkHttp will run anyway

    }
    public void decode(NdrBuffer buf) throws NdrException {
        decode_header(buf);

        if (ptype != 12 && ptype != 2 && ptype != 3 && ptype != 13)
            throw new NdrException("Unexpected ptype: " + ptype);

        if (ptype == 2 || ptype == 3) { /* Response or Fault */
            alloc_hint = buf.dec_ndr_long();
            buf.dec_ndr_short();        /* context id */