output.contains '''
            lib - Components that depend on native library 'lib'
            +--- lib:sharedLibrary NOT BUILDABLE
            |    \\--- main:executable
            \\--- lib:staticLibrary NOT BUILDABLE

            main - Components that depend on native executable 'main'
            \\--- main:executable

            util - Components that depend on native library 'util'
            +--- util:sharedLibrary

//
// This function's execution time does not depend on the inputs.
func RotateLeft8(x uint8, k int) uint8 {
	const n = 8
	s := uint(k) & (n - 1)
	return x<<s | x>>(n-s)
}

// RotateLeft16 returns the value of x rotated left by (k mod 16) bits.
// To rotate x right by k bits, call RotateLeft16(x, -k).
//
// This function's execution time does not depend on the inputs.
func RotateLeft16(x uint16, k int) uint16 {

        """

        then:
        fails "foo"

        and:
        failure.assertHasCause("Cannot add task 'foo' as a task with that name already exists.")
    }

    def "a non-rule-source task can depend on a rule-source task"() {
        given:
        buildFile << """
        ${ruleBasedTasks()}

        class Rules extends RuleSource {
            @Mutate
            void addTasks(ModelMap<Task> tasks) {

     * <p>
     *     With a wide hierarchy, each group of libraries depend only on each other. There's a limited depth (~7) and
     *     several projects.  This tries to replicate a project with many subgroups of interconnected components.
     * <p>
     *     With a deep and wide hierarchy, each subproject is formed as above, except each group of libraries depend on

                    t.doFirst { throw new RuntimeException("broken")}
                }
            }
        '''
    }

    @Issue("https://github.com/gradle/gradle/issues/21542")
    def "finalizer can depend on a task that it finalizes"() {
        given:
        buildFile '''
            task finalizer(type: BreakingTask) {
              dependsOn "finalizerDep"
            }

      # it, and print that list for debugging. Not really clear if this is
      # helpful since the only examples I've seen are enormous.
      bazel query "rdeps(kind(py_test, $(cat $BATS_TEST_TMPDIR/deps)), $dep, 1)"
    done < $BATS_TEST_TMPDIR/missing_deps
    exit 1
  fi
}

# The Python package is not allowed to depend on any CUDA packages.

      # it, and print that list for debugging. Not really clear if this is
      # helpful since the only examples I've seen are enormous.
      bazel cquery "rdeps(kind(py_test, $(cat $BATS_TEST_TMPDIR/deps)), $dep, 1)"
    done < $BATS_TEST_TMPDIR/missing_deps
    exit 1
  fi
}

# The Python package is not allowed to depend on any CUDA packages.

  return %0#0, %0#1 : tensor<i32>, tensor<i32>
}

// -----

// Check that `tf.ReadVariableOp` is hoisted because the variable is readonly.
// The following ops that depend on `tf.ReadVariableOp` and satisfy hoisting
// conditions are also hoisted (i.e., `tf.Add` and `tf.Mul`).

// CHECK-LABEL: readvariableop_is_hoisted_if_readonly
// CHECK:       [[CST_0:%.*]] = "tf.Const"

		if !features.EnableK8SServiceSelectWorkloadEntries {
			fo = append(fo, krt.FilterGeneric(func(a any) bool {
				return a.(model.ServiceInfo).Source == kind.ServiceEntry
			}))
		}
		services := krt.Fetch(ctx, WorkloadServices, fo...)
		a.networkUpdateTrigger.MarkDependant(ctx) // Mark we depend on out of band a.Network
		network := a.Network(wle.Spec.Address, wle.Labels).String()

 4. Updating task dependencies.
+
`compileJava` must depend on `prepare`, `package` must depend on `compileJava` rather than `ant_build`, and `assemble` must depend on `package` rather than the standard Gradle `jar` task.