// RUN: tf-opt %s -split-input-file -tf-xla-broadcast | FileCheck %s

    public static int parseMajorVersion(String fullVersion) {
        int firstNonVersionCharIndex = findFirstNonVersionCharIndex(fullVersion);

        String[] versionStrings = fullVersion.substring(0, firstNonVersionCharIndex).split("\\.");
        List<Integer> versions = convertToNumber(fullVersion, versionStrings);

        if (isLegacyVersion(versions)) {
            assertTrue(fullVersion, versions.get(1) > 0);
            return versions.get(1);

}

description = "Gradle Tooling API - the programmatic API to invoke Gradle"

gradlebuildJava.usedInToolingApi()

tasks.named<Jar>("sourcesJar") {
    // duplicate package-info.java because of split packages
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

shadedJar {
    shadedConfiguration.exclude(mapOf("group" to "org.slf4j", "module" to "slf4j-api"))
    keepPackages = listOf("org.gradle.tooling")

  // There should be two ops: the split and add in the original model.
  EXPECT_THAT(*readonly_subgraph->operators(), SizeIs(2));
  EXPECT_THAT(subgraph->operators, SizeIs(2));
  const auto& split = subgraph->operators[0];
  const auto& add = subgraph->operators[1];
  EXPECT_THAT(GetBuiltinCode(model_.operator_codes[split->opcode_index].get()),
              Eq(BuiltinOperator_SPLIT));

    api(project(":time"))
    api(project(":toolchains-jvm-shared"))
    api(project(":tooling-api"))

    // This project contains the Gradle client, daemon and tooling API provider implementations.
    // It should be split up, but for now, add dependencies on both the client and daemon pieces
    api(project(":client-services"))
    api(project(":daemon-services"))

    api(libs.guava)
    api(libs.jsr305)

def TPUColocateSplitsPass : Pass<"tf-tpu-colocate-splits", "mlir::func::FuncOp"> {
  let summary = "Colocates each Split op with its predecessor";
  let constructor = "TFTPU::CreateTPUColocateSplitsPass()";
  let description = [{
    It is beneficial for performance to assign a `Split` op to the same device
    as its predecessor. This is because the weight of cut edges is always
    minimized when the `Split` is with its predecessor. This colocation

                }
            };
        }

        List<Spec<GradleVersion>> specs = new ArrayList<Spec<GradleVersion>>();
        String[] patterns = trimmed.split("\\s+");
        for (String value : patterns) {
            if (value.startsWith(">=")) {
                final GradleVersion minVersion = getVersion(value, 2);

  helm3 template grafana grafana \
    --namespace istio-system \
    --version "${GRAFANA_VERSION}" \
    --repo https://grafana.github.io/helm-charts \
    -f "${WD}/values-grafana.yaml"

  # Set up grafana dashboards. Split into 2 and compress to single line json to avoid Kubernetes size limits
  compressDashboard "pilot-dashboard.gen.json"
  compressDashboard "istio-performance-dashboard.json"
  compressDashboard "istio-workload-dashboard.json"

		if labelValue == "none" || labelValue == "~" || strings.HasSuffix(labelValue, "/none") {
			return nil, true
		}
		namespacedName := strings.Split(labelValue, "/")
		switch len(namespacedName) {
		case 1:
			return &krt.Named{
				Name:      namespacedName[0],
				Namespace: defaultNamespace,
			}, false
		case 2:
			return &krt.Named{

    // Note that all tests use a relative path to the script because its absolute path may contain
    // spaces and it breaks logic String.execute which splits the given string at spaces without
    // any options to escape the space.
    ShellScript baseScript = ShellScript.builder().printEnvironmentVariable('FOOBAR').printWorkingDir().writeTo(testDirectory, "test")

    def setup() {