setting up your local repository for Bazel build. For this you will need to
create bazel workspace and build files:

```sh
LLVM_SRC=... # this the path to the LLVM local source directory you intend to use.
touch ${LLVM_SRC}/BUILD.bazel ${LLVM_SRC}/WORKSPACE
```

You can then use this overlay to build TensorFlow:

```
bazel build --override_repository="llvm-raw=${LLVM_SRC}" \
  -c opt tensorflow/compiler/mlir:tf-opt

    if [ -n "$PID_DIR" ] && [ ! -e "$PID_DIR" ]; then
        mkdir -p "$PID_DIR" && chown "$FESS_USER":"$FESS_GROUP" "$PID_DIR"
    fi
    if [ -n "$pidfile" ] && [ ! -e "$pidfile" ]; then
        touch "$pidfile" && chown "$FESS_USER":"$FESS_GROUP" "$pidfile"
    fi

    echo -n $"Starting $prog: "
    # if not running, start it up here, usually something like "daemon $exec"

            // java.lang.AssertionError(String) is private, so explicit cast to Object is needed here
            // to call public AssertionError(Object)
            new AssertionError((Object) "ouch").tap { stackTrace = createCauseTrace() }
        ]
        expect:
        formatter.format(testDescriptor, exceptions) == """\
    java.io.IOException at FileName1.java:11
    java.lang.AssertionError at FileName0.java:1

        then:
        with(taskSuccessResult(':incrementalTask')) {
            !incremental
            executionReasons[0].contains("No history")
        }

        when:
        file('src/a').touch()
        file('src/b').touch()

        and:
        runBuild('incrementalTask')

        then:
        with(taskSuccessResult(':incrementalTask')) {
            incremental

        }
        includedBuilds << buildB

        def staleFiles = [
            file("buildA/build/classes/java/main/stale"),
            file("buildB/build/classes/java/main/stale")]
        staleFiles*.touch()

        when:
        execute(buildA, 'build')
        then:
        staleFiles*.assertDoesNotExist()
    }

    metadata:
      labels:
        app: liveness
    spec:
      containers:
      - name: liveness
        image: registry.k8s.io/busybox
        args:
        - /bin/sh
        - -c
        - touch /tmp/healthy; sleep 3600
        livenessProbe:
          exec:
            command:
            - cat
            - /tmp/healthy
          initialDelaySeconds: 5

            apply from: 'shared.gradle'
            println 'build.gradle'
        """

        succeeds "help"

        when: // already compiled shared script
        file('otherBuild/settings.gradle').touch()
        file('otherBuild/build.gradle') << "apply from: '../shared.gradle'"
        executer.usingProjectDirectory(file('otherBuild'))
        succeeds 'help'

# All commands run relative to this directory
cd "$(dirname "${BASH_SOURCE[0]}")"

mv BUILD.bazel BUILD

SUPPORTED_VERSIONS=("3_9" "3_10" "3_11" "3_12")

for VERSION in "${SUPPORTED_VERSIONS[@]}"
do
  touch "requirements_lock_$VERSION.txt"
  bazel run \
    --experimental_convenience_symlinks=ignore \
    --enable_bzlmod=false \
    //:requirements_"$VERSION".update
  sed -i '/^#/d' requirements_lock_"$VERSION".txt

	}
	vals := make(map[string]interface{})
	s := string(data)
	items := strings.Split(s, " ")
	var err error
	for _, item := range items {
		vals[item] = s
		if item == "error" {
			err = errors.New("ouch")
		}
	}
	*v = vals
	return err

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification

class DaemonJvmCompatibilityCrossVersionSpec extends ToolingApiSpecification {
    def setup() {
        buildFile.touch()
        settingsFile << """
            rootProject.name = "root"
        """
    }

    @TargetGradleVersion(">=8.8")
    def "can run a build with Java 21 followed by another build with a different version"() {