if: steps.cache.outputs.cache-hit != 'true'
        run: pip install -r requirements-docs.txt
      # Install MkDocs Material Insiders here just to put it in the cache for the rest of the steps
      - name: Install Material for MkDocs Insiders
        if: ( github.event_name != 'pull_request' || github.secret_source == 'Actions' ) && steps.cache.outputs.cache-hit != 'true'
        run: |

    def setup() {
        file("settings.gradle") << 'rootProject.name="hello-world"'
    }

    def "models are streamed on build action cache hit"() {
        def listener1 = new TestStreamedValueListener()
        def listener2 = new TestStreamedValueListener()

        when:
        withIsolatedProjects()

      - name: Install Dependencies
        if: steps.cache.outputs.cache-hit != 'true'
        run: pip install -r requirements-tests.txt
      - name: Install Pydantic v2
        run: pip install "pydantic>=2.0.2,<3.0.0"
      - name: Lint
        run: bash scripts/lint.sh

  test:

When using the https://gradle.com/build-cache[Develocity build cache backend] you should pay close attention to the hit rate in the admin UI.
A rise in the hit rate there probably indicates better usage by developers:

[.screenshot]
image::build-cache/cache-admin-hit-rate.png[build cache hit rate]

== Analyzing performance in build scans

          {{if .Instructions -}}
            {{/* instructions for this source line */ -}}
            <span class=asm>{{"" -}}
            {{range .Instructions -}}
              {{/* separate when we hit a new basic block */ -}}
              {{if .NewBlock -}}{{printf " %8s %28s\n" "" "⋮"}}{{end -}}

              {{/* inlined calls leading to this instruction */ -}}
              {{range .InlinedCalls -}}

        then:
        isolatedProjectsEvents().enabled == [enabled]
        configurationCacheEvents().enabled == [GradleContextualExecuter.configCache || enabled]

        // Ensure events are produced on CC hit as well
        when:
        succeeds("help", "-Dorg.gradle.unsafe.isolated-projects=$enabled")
        then:
        isolatedProjectsEvents().enabled == [enabled]

					namespace: namespace.NewOrFail(t, t, namespace.Config{
						Prefix:   fmt.Sprintf("revision-%s", rev),
						Inject:   true,
						Revision: rev,
					}),
				})
			}
			// Allow all namespaces so we do not hit passthrough cluster
			t.ConfigIstio().YAML(apps.Namespace.Name(), `apiVersion: networking.istio.io/v1alpha3
kind: Sidecar
metadata:
  name: allow-cross-namespaces
spec:
  workloadSelector:
    labels:
      app: a

		params: append([]string{"-I", chain, fmt.Sprint(position)}, rules...),
	})
	idx := indexOf("-j", params)
	// We have identified the type of command this is and logging is enabled. Insert a rule to log this chain was hit.
	// Since this is insert we do this *after* the real chain, which will result in it bumping it forward
	if rb.cfg.TraceLogging && idx >= 0 && command != log.UndefinedCommand {
		match := params[:idx]

		if file, _ := u.fileLine(uf); file == "?" {
			// We're probably in the trailing function padding, where findfunc
			// still returns f but there's no symbolic information. Just keep
			// going until we definitely hit the end. If we see a "?" in the
			// middle of unwinding, that's a real problem.
			//
			// TODO: If we ever have function end information, use that to make
			// this robust.
			continue
		}

// nice to have.
//
// Hitting this target resolution is easy in the nanotime case: just pick a
// division of 64. In the cputicks case it's a bit more complex.
//
// For x86, on a 3 GHz machine, we'd want to divide by 3*64 to hit our target.
// To keep the division operation efficient, we round that up to 4*64, or 256.
// Given what cputicks represents, we use this on all other platforms except
// for PowerPC.