select(.Replace.Version != null) |
  select(.Version != .Replace.Version) |
  select(.Path) |
  \"\(.Path)
    pinned:    \(.Replace.Version)
    preferred: \(.Version)
    hack/pin-dependency.sh \(.Path) \(.Version)\"
")
if [[ -n "${outdated}" ]]; then
  echo "These modules are pinned to versions different than the minimal preferred version."

        val result = build("buildEnvironment")

        assertThat(result.output, containsString("No dependencies"))
    }

    @Test
    fun `embedded kotlin dependencies are pinned to the embedded version`() {

        withBuildScript(
            """
            buildscript {
                $repositoriesBlock
                dependencies {

	}
	return p.pinSlow()
}

func (p *Pool) pinSlow() (*poolLocal, int) {
	// Retry under the mutex.
	// Can not lock the mutex while pinned.
	runtime_procUnpin()
	allPoolsMu.Lock()
	defer allPoolsMu.Unlock()
	pid := runtime_procPin()
	// poolCleanup won't be called while we are pinned.
	s := p.localSize
	l := p.local
	if uintptr(pid) < s {
		return indexLocal(l, pid), pid
	}
	if p.local == nil {

			ID:          img.Id,
			Size:        int64(img.Size_),
			RepoTags:    img.RepoTags,
			RepoDigests: img.RepoDigests,
			Spec:        toKubeContainerImageSpec(img),
			Pinned:      img.Pinned,
		})
	}

	return images, nil
}

// RemoveImage removes the specified image.
func (m *kubeGenericRuntimeManager) RemoveImage(ctx context.Context, image kubecontainer.ImageSpec) error {

// CHECK: "tf.opA"
// CHECK: "tf_device.launch"
// CHECK: device = "/GPU:1"
// CHECK: "tf.opA"


// Tests replicate with control dependency output has each expanded replica
// control pinned to a sink island.
// CHECK-LABEL: func @replicate_control
func.func @replicate_control() {
  tf_executor.graph {
    %1 = tf_executor.island {
      tf_device.replicate {n = 2 : i32} {
        tf_device.return

        .dispatcher(Dispatcher(newVirtualThreadPerTaskExecutor()))
        .build()

    executor = newVirtualThreadPerTaskExecutor()

    // Capture non-deterministic but probable sysout warnings of pinned threads
    // https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html
    System.setOut(PrintStream(capturedOut))
  }

  @AfterEach
  fun checkForPinning() {

GCS_BUCKET=${GCS_BUCKET:-istio-build/dev}

# Enable emulation required for cross compiling a few images (VMs)
docker run --rm --privileged "${DOCKER_HUB}/qemu-user-static" --reset -p yes
export ISTIO_DOCKER_QEMU=true

# Use a pinned version in case breaking changes are needed
BUILDER_SHA=159efd4a18a7325192c4f7cb0acbe5648bfb8658

# Reference to the next minor version of Istio
# This will create a version like 1.4-alpha.sha

     */
    val santaGitUri = "https://github.com/gradle/santa-tracker-android.git"

    val santaTracker by registering(RemoteProject::class) {
        remoteUri = santaGitUri
        // Pinned from branch main
        ref = "e9419cad3583427caca97958301ff98fc8e9a1c3"
    }

    val gradleBuildCurrent by registering(RemoteProject::class) {
        remoteUri = rootDir.absolutePath
        ref = buildCommitId

# Add the replace directive
if [ "${replacement}" != "${dep}" ]; then
  echo "Running: go mod edit -replace ${dep}=${replacement}@${rev}"
  go mod edit -replace "${dep}=${replacement}@${rev}"
fi

# Propagate pinned version to staging repos
for repo in $(kube::util::list_staging_repos); do
  pushd "staging/src/k8s.io/${repo}" >/dev/null 2>&1
    go mod edit -require "${dep}@${rev}"

    echo "${_out}" > vendordiff.patch
    echo "If you're seeing this locally, run the below command to fix your directories:" >&2
    echo "hack/update-vendor.sh" >&2
    ret=1
  fi

  # Verify we are pinned to matching levels
  hack/lint-dependencies.sh >&2
popd > /dev/null 2>&1

if [[ ${ret} -gt 0 ]]; then
  exit ${ret}
fi

# Ensure we can tidy every repo using only its recorded versions