: xla_compiler_(options) {}

  // Compiles a Tensorflow `function` into an HloModuleProto stored in the
  // XlaCompilationResult pointed to by `result` by calling
  // XlaCompiler::CompileFunction.
  Status Compile(const XlaCompiler::CompileOptions& options,
                 const NameAttrList& function,
                 absl::Span<const XlaArgument> args,

# Test that running a fuzz target that returns without failing or calling
# f.Fuzz fails and causes a non-zero exit status.
! go test noop_fuzz_test.go
! stdout ^ok
stdout FAIL

# Test that fuzzing a fuzz target that returns without failing or calling
# f.Fuzz fails and causes a non-zero exit status.
! go test -fuzz=Fuzz -fuzztime=1x noop_fuzz_test.go
! stdout ^ok
stdout FAIL

        succeeds(":test:unitTestClasses")
        file("main/build/classes/java/main").assertHasDescendants("Main.class")
        file("tests/build/classes/java/unitTest").assertHasDescendants("Test.class")
    }

    def "calling withSourcesJar is deprecated when the java plugin is not applied"() {
        given:
        buildFile << """
            plugins {
                id 'java-base'
            }

            sourceSets {

 */
public interface ResolutionAccess {

    /**
     * Get the owner of the resolution.
     */
    ResolutionHost getHost();

    /**
     * Get the request attributes for this resolution. Calling this method will lock-in the
     * request attributes from further mutation but will not perform resolution.
     */
    ImmutableAttributes getAttributes();

    /**

    /**
     * {@inheritDoc}
     *
     * <p>
     * This is similar to calling {@link #value(Iterable)} with a <code>null</code> argument.
     * </p>
     */
    @Override
    ListProperty<T> unset();

    /**
     * {@inheritDoc}
     *
     * <p>
     * This is similar to calling {@link #convention(Iterable)} with a <code>null</code> argument.
     * </p>
     */
    @Override

    /**
     * Updates the current value. The function is passed the current value or {@code null} if there is no value, and the function's return value is
     * used as the new value.
     *
     * <p>The calling thread must own the mutable state from which the value is calculated (via {@link ModelContainer#fromMutableState(Function)}). At most a single thread

var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
	return []interface{}{
		func(obj *certificates.CertificateSigningRequestSpec, c fuzz.Continue) {
			c.FuzzNoCustom(obj) // fuzz self without calling this function again
			obj.Usages = []certificates.KeyUsage{certificates.UsageKeyEncipherment}
			obj.SignerName = "example.com/custom-sample-signer"

     */
    Set<ComponentResult> getComponents();

    /**
     * <p>Return a set of {@link ComponentResult} instances representing all successfully resolved components.
     *
     * <p>Calling this method is the same as calling {@link #getComponents()} and filtering the resulting set for elements of type {@link ComponentArtifactsResult}.
     *
     * @return the set of all successfully resolved components
     */

@Subject(DefaultMutationGuard)
class DefaultMutationGuardTest extends Specification {
    final MutationGuard guard = new DefaultMutationGuard()

    def target = new Object()

    def "does not throw exception when calling a disallowed method when allowed using #methodUnderTest(#callableClass.type)"() {
        def callable = callableClass.newInstance(this)

        when:
        ensureExecuted(guard."${methodUnderTest}"(callable))

	nodeID string,
	maxVolumePerNode int64,
	accessibleTopology map[string]string,
	err error) {
	klog.V(4).InfoS(log("calling NodeGetInfo rpc"))

	var getNodeInfoError error
	nodeID, maxVolumePerNode, accessibleTopology, getNodeInfoError = c.nodeGetInfoV1(ctx)
	if getNodeInfoError != nil {
		klog.InfoS("Error calling CSI NodeGetInfo()", "err", getNodeInfoError.Error())
	}
	return nodeID, maxVolumePerNode, accessibleTopology, getNodeInfoError