}
TEST(CAPI, RemoteExecuteSilentCopiesLocalAsyncFuncOrdering) {
  // A remote input may be not ready when we start running a function. Test that
  // the function execution should wait until the remote input is ready.
  TestRemoteExecuteSilentCopiesFunc(/*async=*/true, /*remote=*/false,
                                    /*heavy_load_on_streaming_rpc=*/true);
}

      "description": "JDK 11 requirement"
    },
    {
      "matchPackageNames": ["gradle"],
      "allowedVersions": "<8.0",
      "description": "Recent release, not compatible with pinned AGP and Kotlin versions yet. Wait for AGP 8?"
    },
    {
      "matchPackageNames": ["com.android.tools.build:gradle"],
      "allowedVersions": "<7.4",
      "description": "Recent release, no compatible Intellij stable release (2023.1)"
    }
  ]

				return err
			}
		}

		header, err := tarReader.Next()
		switch {

		// if no more files are found return
		case err == io.EOF:
			wg.Wait()
			return asyncErr

		// return any other error
		case err != nil:
			wg.Wait()
			extra := ""
			if n > 0 {
				extra = fmt.Sprintf(" after %d successful object(s)", n)
			}
			return fmt.Errorf("tar file error: %w%s", err, extra)

                        case SmbComTransaction.NET_SERVER_ENUM3:
                        case SmbComTransaction.TRANS_PEEK_NAMED_PIPE:
                        case SmbComTransaction.TRANS_WAIT_NAMED_PIPE:
                        case SmbComTransaction.TRANS_CALL_NAMED_PIPE:
                        case SmbComTransaction.TRANS_TRANSACT_NAMED_PIPE:
                        case SmbComTransaction.TRANS2_GET_DFS_REFERRAL:

			return
		}
		received := string(b)
		if received != "message one\n" {
			t.Errorf(`server: expected: "message one\n", got: %v`, received)
			return
		}

		// Wait for more than read timeout to simulate processing.
		time.Sleep(3 * time.Second)

		_, terr = deadlineconn.Read(b)
		if terr != nil {
			t.Errorf("failed to read from client. %v", terr)
			return
		}

	// while counting the number of concurrent connections
	return int(globalHTTPListen.Subscribers()) + int(globalTrace.Subscribers())
}

func waitForLowIO(maxIO int, maxWait time.Duration, currentIO func() int) {
	// No need to wait run at full speed.
	if maxIO <= 0 {
		return
	}

	const waitTick = 100 * time.Millisecond

	tmpMaxWait := maxWait

	for currentIO() >= maxIO {
		if tmpMaxWait > 0 {
			if tmpMaxWait < waitTick {

              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: OPERATOR_NAME
              value: {{.Release.Namespace | quote}}
            - name: WAIT_FOR_RESOURCES_TIMEOUT
              value: {{.Values.waitForResourcesTimeout | quote}}
            - name: REVISION
              value: {{.Values.revision | quote}}
      {{- with .Values.nodeSelector }}
      nodeSelector:

          connectResult = launchTcpConnect()
          nextTcpConnectAtNanos = now + connectDelayNanos
          awaitTimeoutNanos = connectDelayNanos
        }

        // Wait for an in-flight connect to complete or fail.
        if (connectResult == null) {
          connectResult = awaitTcpConnect(awaitTimeoutNanos, TimeUnit.NANOSECONDS) ?: continue
        }

	for i := 0; i < numReaders; i++ {
		go parallelReader(context.Background(), m, clocked, cunlock, cdone)
	}
	// Wait for all parallel RLock()s to succeed.
	for i := 0; i < numReaders; i++ {
		<-clocked
	}
	for i := 0; i < numReaders; i++ {
		cunlock <- true
	}
	// Wait for the goroutines to finish.
	for i := 0; i < numReaders; i++ {
		<-cdone
	}
}

// Borrowed from rwmutex_test.go

import okhttp3.ExperimentalOkHttpApi

/** Handler for mock server requests. */
@ExperimentalOkHttpApi
abstract class Dispatcher {
  /**
   * Returns a response to satisfy `request`. This method may block (for instance, to wait on
   * a CountdownLatch).
   */
  @Throws(InterruptedException::class)
  abstract fun dispatch(request: RecordedRequest): MockResponse

  /**