}
		return nil
	}
	return res, testCancel, nil
}

// UpdateAndWait updates the given object in the test, or creates it if it doesn't exist
// Depending upon object type, waits afterward until the object is synced
// by the policy source
//
// Be aware the UpdateAndWait will modify the ResourceVersion of the
// provided objects.

    api(libs.testng)
    api(libs.bsh) {
        because("""We need to create a capability conflict between "org.beanshell:bsh", and "org.beanshell:beanshell" by explicitly including this lib
            version of bsh, instead of depending on the transitive version contributed by testng.  This lib contributes the "beanshell" capability,
            and the conflict resolution rules from capabilities.json ensures this is the version that is resolved.

@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface Supplier<T extends @Nullable Object> {
  /**
   * Retrieves an instance of the appropriate type. The returned object may or may not be a new
   * instance, depending on the implementation.
   *
   * @return an instance of the appropriate type
   */
  @ParametricNullness
  T get();

		if !data.DryRun() {
			fmt.Println("[preflight] Pulling images required for setting up a Kubernetes cluster")
			fmt.Println("[preflight] This might take a minute or two, depending on the speed of your internet connection")
			fmt.Println("[preflight] You can also perform this action beforehand using 'kubeadm config images pull'")

                sourcePath = "${productFlavorName}/${buildTypeName}"
            }
            val testTaskName = "test${sourceName.capitalize()}UnitTest"
            // Create coverage task of form("testFlavorTypeCoverage" depending on("testFlavorTypeUnitTest"
            tasks.register<JacocoReport>("${testTaskName}Coverage") {
                dependsOn(testTaskName)
                group = "Reporting"

=== Verification of downloaded Gradle distributions

The Gradle Wrapper allows for verification of the downloaded Gradle distribution via SHA-256 hash sum comparison.
This increases security against targeted attacks by preventing a man-in-the-middle attacker from tampering with the downloaded Gradle distribution.

To enable this feature, download the `.sha256` file associated with the Gradle distribution you want to verify.

func asGoVersion(v string) goVersion {
	return goVersion(version.Lang(v))
}

// isValid reports whether v is a valid Go version.
func (v goVersion) isValid() bool {
	return v != ""
}

// cmp returns -1, 0, or +1 depending on whether x < y, x == y, or x > y,
// interpreted as Go versions.
func (x goVersion) cmp(y goVersion) int {
	return version.Compare(string(x), string(y))
}

var (
	// Go versions that introduced language changes

	}
)

// TODO: getActualWildcardAndLocalHost would be removed once the dual stack support in Istio
// getActualWildcardAndLocalHost will return corresponding Wildcard and LocalHost
// depending on value of proxy's IPAddresses.
func getActualWildcardAndLocalHost(node *model.Proxy) (string, string) {
	if node.SupportsIPv4() {
		return WildcardAddress, LocalhostAddress
	}

 - only the version you are interested in is used as a reference
 - only the test you are interested in is executed
 - tighten the regression limits to get significant results
 - only search for memory/execution time regressions depending on what you are interested in
 
For our example, let's assume we want to track down a performance regression for `native build medium header file change`. 

				Status: v1.PodStatus{
					Phase: v1.PodPending,
				},
			},
			result: nil,
		},
		{
			name:   "simple pod not running but have podIP",
			inputs: []any{},
			pod: &v1.Pod{
				TypeMeta: metav1.TypeMeta{},
				ObjectMeta: metav1.ObjectMeta{
					Name:      "name",
					Namespace: "ns",
				},
				Spec: v1.PodSpec{},
				Status: v1.PodStatus{
					Phase: v1.PodPending,
					PodIP: "1.2.3.4",
				},
			},