buildFile << """
ext.prop = "value 1"
repositories {
    assert prop == "value 1"
    prop = "value 2"
    maven {
        assert prop == "value 2"
        prop = "value 3"
        1.times {
            assert prop == "value 3"
            prop = "value 4"
            authentication {
                assert prop == "value 4"
                prop = "value 5"
            }
        }

  for (int i = 0; i < n; ++i) result.push_back(ToOutput(output_tensors[i]));
  return result;
}

// The backprop loop counter and main backprop loop run in their own execution
// frame (conceptually, the main forward loop and forward loop counter run
// together in a frame, then the backprop loop counter and backprop loop run
// together in a different frame). This returns the frame name to use for the
// backprop while loops.

//     and grows, accordingly. This is stored in the state as the default
//     CPU set.
//
//   - RESERVED: A subset of the shared pool which is not exclusively
//     allocatable. The membership of this pool is static for the lifetime of
//     the Kubelet. The size of the reserved pool is
//     ceil(systemreserved.cpu + kubereserved.cpu).
//     Reserved CPUs are taken topologically starting with lowest-indexed

	// still has very poor throughput. We could instead keep a
	// running free-to-used budget and switch to fresh span
	// allocation if the budget runs low.
	spanBudget := 100

	var s *mspan
	var sl sweepLocker

	// Try partial swept spans first.
	sg := mheap_.sweepgen
	if s = c.partialSwept(sg).pop(); s != nil {
		goto havespan
	}

	sl = sweep.active.begin()

        1 * environment.propertiesFile(fromDir(settingsDir)) >> ["prop": "settings value"]

        when:
        def properties = loadAndMergePropertiesWith(emptyMap())

        then:
        "user value" == properties["prop"]
    }

    def userPropertiesFileHasPrecedenceOverProjectProperties() {
        given:

// CHECK-LABEL: func @preserve_unreachable_tpu_replicate_metadata
func.func @preserve_unreachable_tpu_replicate_metadata() {
  tf_executor.graph {
    %0 = tf_executor.ControlTrigger {}
    // CHECK: "tf.NoOp"
    %1 = tf_executor.island wraps "tf.NoOp"() : () -> ()
    // CHECK: "tf.TPUReplicateMetadata"

        code << [
                "id('noop')",
                "id 'noop'",
                "id('noop').version('bar')",
                "id 'noop' version 'bar'",
                "id('noop').\nversion 'bar'",
                "id('java');id('noop')",
                "id('java')\nid('noop')",
                "id('noop').version('bar');id('java')",
                "id('noop').version('bar')\nid('java')",

// Package loopclosure defines an Analyzer that checks for references to
// enclosing loop variables from within nested functions.
//
// # Analyzer loopclosure
//
// loopclosure: check references to loop variables from within nested functions
//
// This analyzer reports places where a function literal references the
// iteration variable of an enclosing loop, and the loop calls the function
// in such a way (e.g. with go or defer) that it may outlive the loop

package escape

var x bool

func f1() {
	var p *int
loop:
	if x {
		goto loop
	}
	// BAD: We should be able to recognize that there
	// aren't any more "goto loop" after here.
	p = new(int) // ERROR "escapes to heap"
	_ = p
}

func f2() {
	var p *int
	if x {
	loop:
		goto loop
	} else {
		p = new(int) // ERROR "does not escape"
	}
	_ = p
}

func f3() {

        1 * gradleProperties.mergeProperties([prop: 'childValue']) >> [prop: 'childValue']
        1 * rootProperties.set('prop', 'rootValue')
        1 * childProperties.set('prop', 'childValue')
    }

    def "defines project properties from Project class"() {
        given:
        2 * gradleProperties.mergeProperties([:]) >> [version: '1.0']

        when: