function create-linux-node-instance-template {
  local template_name="$1"
  local machine_type="${2:-$NODE_SIZE}"

  ensure-gci-metadata-files
  # shellcheck disable=2154 # 'scope_flags' is assigned by upstream
  create-node-template "${template_name}" "${scope_flags[*]}" "$(get-node-instance-metadata-from-file)" "" "linux" "${machine_type}"

     * returned.
     */
    @Override
    void stop();

    /**
     * Stops any pending or asynchronous processing immediately
     *
     * Any test class assigned to this processor, but not yet run will not have results in the output.  The processor should
     * not use the result processor provided to {@link #startProcessing(TestResultProcessor)} after this method has
     * returned.

    call: Call,
  ) {}

  /**
   * Invoked when a connection is released as no longer required.
   */
  open fun connectionClosed(connection: Connection) {}

  /**
   * Invoked when a call is assigned a particular connection.
   */
  open fun connectionAcquired(
    connection: Connection,
    call: Call,
  ) {}

  /**
   * Invoked when a call no longer uses a connection.
   */

It's a subset of the compile classpath of the producer: this is strong encapsulation of dependencies.

The consequence is that a dependency which is assigned to the `implementation` configuration of a library _does not end up on the compile classpath of the consumer_.
On the other hand, a dependency which is assigned to the `api` configuration of a library _would end up on the compile classpath of the consumer_.
At _runtime_, however, all dependencies are required.

import org.gradle.internal.declarativedsl.analysis.getDataType
import org.gradle.internal.declarativedsl.language.DataTypeInternal
import org.gradle.internal.declarativedsl.objectGraph.AssignmentResolver.AssignmentResolutionResult.Assigned
import org.gradle.internal.declarativedsl.objectGraph.AssignmentResolver.AssignmentResolutionResult.Unassigned
import org.gradle.internal.declarativedsl.objectGraph.AssignmentResolver.ExpressionResolutionProgress.Ok

*   Ops that require SparseTensor or IndexSlices (currently only in python)
    cannot yet be implemented.

*   Maybe more.

    }

    @Rule
    public final ScopeIdsFixture scopeIds = new ScopeIdsFixture(delegatingExecuter, temporaryFolder)

    void afterBuild() {
        afterExecute*.execute(executer)
    }

    def "ids are assigned for each invocation"() {
        given:
        def i1 = file("i1")
        def i2 = file("i2")

        when:
        i1.text = "1"
        i2.text = "1"

        buildFile << """
            task t1 {

		},
		CustomSerializerString: "world",
	}

	// first time insert record
	out := SerializerStruct{}
	if err := DB.Assign(data).FirstOrCreate(&out).Error; err != nil {
		t.Fatalf("failed to FirstOrCreate Assigned data, got error %v", err)
	}

	var result SerializerStruct
	if err := DB.First(&result, out.ID).Error; err != nil {
		t.Fatalf("failed to query data, got error %v", err)
	}
	AssertEqual(t, result, out)

                     org.junit.Assert.assertEquals(1, 1);
                }
            }
        """
    }

    def "build fails if debugger is not ready"() {
        setup:
        // port is assigned but not connected
        def port = jdwpClient.port

        when:
        withConnection { connection ->
            connection.newTestLauncher()
                .withJvmTestClasses("example.MyTest")

// fields will be same with `deprecated_builtin_code'.
//
// - Supporting builtin operator codes beyonds 127
//
// New builtin operators, whose operator code is larger than 127, can not be
// assigned to the `deprecated_builtin_code` field. In such cases, the
// value of the `builtin_code` field should be used for the builtin operator
// code. In the case, the maximum value of the two fields will be the value of