}
			checkOriginalSrcIP(t, apps.A[0], apps.Tproxy[0], srcIps)
		})
}

func checkOriginalSrcIP(t framework.TestContext, from echo.Caller, to echo.Target, expected []string) {
	t.Helper()
	checker := func(result echo.CallResult, inErr error) error {
		// Check that each response saw one of the workload IPs for the src echo instance
		for _, r := range result.Responses {
			found := false
			for _, ip := range expected {

// is allowed to use version v. If the position is unknown, the specified
// module version (Config.GoVersion) is used. If that version is invalid,
// allowVersion returns true.
func (check *Checker) allowVersion(at poser, v goVersion) bool {
	fileVersion := check.conf.GoVersion
	if pos := at.Pos(); pos.IsKnown() {
		fileVersion = check.versions[pos.FileBase()]
	}

`org.gradle.integtests.fixtures.executer.DefaultGradleDistribution.worksWith(org.gradle.internal.jvm.Jvm)` is the method that checks this.
This is used by `AbstractCompatibilityTestInterceptor` to filter out incompatible Gradle Versions.
Also, all TestPrecondition annotations are checked in an interceptor (e.g. TestPrecondition.NOT_MAC_OS_X). 

        withReadOnlyCache()
        other.allowAll()
        parent.allowAll()
        succeeds ':checkDeps'

        then:
        noExceptionThrown()
    }


    @Override
    List<MavenHttpModule> getModulesInReadOnlyCache(MavenHttpRepository repo) {

        """

        when:
        module.pom.expectGet()
        module.moduleMetadata.expectGet()

        fails ':checkDeps'

        then:
        failure.assertHasErrorOutput('''> Could not resolve all files for configuration ':compileClasspath'.
   > Could not resolve org:producer:1.0.
     Required by:
         project :

- Version-specific caches in all `caches/<GRADLE_VERSION>/` directories are checked for whether they are still in use.
+
If not, directories for release versions are deleted after 30 days of inactivity, and snapshot versions after 7 days.
- Shared caches in `caches/` (e.g., `jars-*`) are checked for whether they are still in use.
+
If no Gradle version still uses them, they are deleted.

        when:
        buildFile << """
configurations.compile.withDependencies {
    throw new RuntimeException("Bad user code")
}
"""

        then:
        resolve.prepare()
        fails ":checkDeps"

        failure.assertHasCause("Bad user code")
    }

    @ToBeFixedForConfigurationCache(because = "task uses Configuration API")
    def "cannot add withDependencies rule after configuration has been used"() {

      - master

permissions:
  contents: read
    
jobs:
  build:
    name: runner / shfmt
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: luizm/action-sh-checker@master
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SHFMT_OPTS: "-s"
        with:

  const Function* func = bef_file_->GetFunction("_tfrt_fallback_init");
  CHECK(func) << "TFRT initialization function was not found";
  CHECK_EQ(func->argument_types().size(), 1);

  llvm::SmallVector<RCReference<AsyncValue>, 1> results;
  results.resize(func->result_types().size());
  CHECK_EQ(results.size(), 1);

  func->Execute(*exec_ctx_, tfrt::GetReadyChain().GetAsyncValue(), results);

  host_context_->Await(results);

import com.google.common.annotations.GwtCompatible;
import java.util.AbstractCollection;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A simplistic collection which implements only the bare minimum allowed by the spec, and throws
 * exceptions whenever it can.
 *
 * @author Kevin Bourrillion