https://github.com/tensorflow/tensorflow/blob/master/tensorflow/tools/tf_sig_build_dockerfiles/devel.usertools/code_check_full.bats
Here are the affected tests:
EOF
    while read dep; do
      echo "For dependency $dep:"
      # For every missing dependency, find the tests which directly depend on
      # it, and print that list for debugging. Not really clear if this is
      # helpful since the only examples I've seen are enormous.

// license that can be found in the LICENSE file.

package main

import (
	"cmd/go/internal/base"
	"os"
	"strings"
	"testing"
)

func TestChdir(t *testing.T) {
	// We want -C to apply to every go subcommand.
	// Test that every command either has a -C flag registered
	// or has CustomFlags set. In the latter case, the command
	// must be explicitly tested in TestScript/chdir.
	script, err := os.ReadFile("testdata/script/chdir.txt")

      for (PerListenerQueue<L> queue : listeners) {
        queue.add(event, label);
      }
    }
  }

  /**
   * Dispatches all events enqueued prior to this call, serially and in order, for every listener.
   *
   * <p>Note: this method is idempotent and safe to call from any thread
   */
  public void dispatch() {
    // iterate by index to avoid concurrent modification exceptions

=== Only apply plugins where they're needed

Every plugin and script that you apply to a project adds to the overall configuration time.
Some plugins have a greater impact than others.
That doesn’t mean you should avoid using plugins, but you should take care to only apply them where they’re needed.
For example, it’s easy to apply plugins to all subprojects via `allprojects {}` or `subprojects {}` even if not every project needs them.

package internal

import (
	"sync"
	"time"
)

// AtMostEvery will never run the method more than once every specified
// duration.
type AtMostEvery struct {
	delay    time.Duration
	lastCall time.Time
	mutex    sync.Mutex
}

// NewAtMostEvery creates a new AtMostEvery, that will run the method at
// most every given duration.
func NewAtMostEvery(delay time.Duration) *AtMostEvery {
	return &AtMostEvery{
		delay: delay,

                .withTasks(":sub1:exec", ":sub2:exec")
                .run()
        }

        then: "invalid JVM installation warning should be printed in every build"
        results.size() == 2
        results.every { result ->
            def expectedErrorMessages = [invalidJdkHome1, invalidJdkHome2].collect {

			ctx.Fatal(err)
		}
	}
}

func (t *T) hasSourceSetup() bool {
	return len(t.sourceDeploymentSetup) > 0
}

// SetupForPair runs the given function for every source instance in every cluster in combination with every
// destination service.
//
// Example of how long this setup lasts before the given context is cleaned up:
//   - a/to_b/from_cluster-1
//   - a/to_b/from_cluster-2
//   - cleanup...

        when:
        BuildInvocations model = withConnection { connection ->
            connection.getModel(BuildInvocations)
        }

        then:
        model.tasks.every { Task t -> publicTasks.contains(t.name) == t.public }
        model.taskSelectors.every { TaskSelector ts -> publicSelectors.contains(ts.name) == ts.public }
    }

# Test required and embedded body parameters with no bodies sent
def test_post_body_example():
    response = client.put(
        "/items/5",
        json={
            "name": "Foo",
            "description": "A very nice Item",
            "price": 35.4,
            "tax": 3.2,
        },
    )
    assert response.status_code == 200


def test_openapi_schema():
    response = client.get("/openapi.json")

	// Start tracing.
	//
	// Set trace.enabled. This is *very* subtle. We need to maintain the invariant that if
	// trace.gen != 0, then trace.enabled is always observed as true. Simultaneously, for
	// performance, we need trace.enabled to be read without any synchronization.
	//
	// We ensure this is safe by stopping the world, which acts a global barrier on almost