systemNetworkInternodeCollectorPath collectorPath = "/system/network/internode"
	systemDriveCollectorPath            collectorPath = "/system/drive"
	systemMemoryCollectorPath           collectorPath = "/system/memory"
	systemCPUCollectorPath              collectorPath = "/system/cpu"
	systemProcessCollectorPath          collectorPath = "/system/process"

	debugGoCollectorPath collectorPath = "/debug/go"

	fs.On("AddPodToMesh",
		ctx,
		mock.IsType(pod),
		util.GetPodIPsIfPresent(pod),
		"",
	).Return(nil)

	server := getFakeDP(fs, client.Kube())

	handlers := setupHandlers(ctx, client, server, "istio-system")
	client.RunAndWait(ctx.Done())
	go handlers.Start()

	// label the namespace
	labelsPatch := []byte(fmt.Sprintf(`{"metadata":{"labels":{"%s":"%s"}}}`,
		label.IoIstioDataplaneMode.Name, constants.DataplaneModeAmbient))

    streamPrimesToSinkAsynchronously(pipeBody.sink());

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

  private void streamPrimesToSinkAsynchronously(final BufferedSink sink) {
    Thread thread = new Thread("writer") {
      @Override public void run() {
        try {

        final List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();
        for (int i = 0; i < numTasks; i++) {
            tasks.add(testCallable);
        }

        // 時間取得
        final long time = System.nanoTime();

        // Callableタスク(複数)を実行する
        final ExecutorService executor = Executors.newFixedThreadPool(numTasks);
        try {
            final List<Future<Integer>> futures = executor.invokeAll(tasks);

        this.numberOfNames = src[ srcIndex++ ] & 0xFF;
        // gotta read the mac first so we can populate addressArray with it
        System.arraycopy(src, srcIndex + namesLength, this.macAddress, 0, 6);
        srcIndex += readNodeNameArray(src, srcIndex);
        this.stats = new byte[statsLength];
        System.arraycopy(src, srcIndex, this.stats, 0, statsLength);
        srcIndex += statsLength;
        return srcIndex - start;
    }

  return Client(
    userAgent = "OkHttp",
    version = version,
    enabled = enabled,
  )
}

fun currentVm(ianaSuites: IanaSuites): Client {
  return systemDefault(
    name = System.getProperty("java.vm.name"),
    version = System.getProperty("java.version"),
    ianaSuites = ianaSuites,
  )
}

fun conscrypt(ianaSuites: IanaSuites): Client {
  val version = Conscrypt.version()
  return systemDefault(

      assertEquals(expected, property.key());
    }
  }

  public void testGetValue() {
    for (StandardSystemProperty property : StandardSystemProperty.values()) {
      assertEquals(System.getProperty(property.key()), property.value());
    }
  }

  public void testToString() {
    for (StandardSystemProperty property : StandardSystemProperty.values()) {

    <expression>
      <syntax>settings.offline</syntax>
      <configuration>
        <![CDATA[
    <offline>true</offline>
    ]]></configuration>
      <description>
        <![CDATA[
      Flags the system as offline, to prevent accessing the network to resolve artifacts or execute plugins.

      NOTE: It's also possible to switch to offline mode on a per-build basis, using the '-o' command-line option.
    ]]></description>

* the data from the client to be sent through the network
* the data sent by your program to be received by the client through the network
* the contents of a file in the disk to be read by the system and given to your program
* the contents your program gave to the system to be written to disk
* a remote API operation
* a database operation to finish
* a database query to return the results
* etc.

Call call = client.newCall(new Request.Builder()
    .url(server.url("/"))
    .build());
Response response = call.execute();
System.out.println(response.handshake().peerPrincipal());
RecordedRequest recordedRequest = server.takeRequest();
System.out.println(recordedRequest.getHandshake().peerPrincipal());
```

This handshake is successful because each party has prearranged to trust the root certificate that