configurations { compile }
                task jar {
                    def jar1 = file("${project.name}-1.jar")
                    def jar2 = file("${project.name}-2.jar")
                    doLast {
                        jar1.text = 'content'
                        jar2.text = 'content'
                    }
                }
            }
            dependencies {

module example.prog

-- testdata/another.go --

package main

import "fmt"

func main() {
  fmt.Println("Hi dad")
}

-- tiny/tiny.go --

package tiny

var Tvar int

-- tiny/tiny2.go --

package tiny

		}
		if v1.UnsafePointer() == v2.UnsafePointer() {
			return true
		}
		iter := v1.MapRange()
		for iter.Next() {
			val1 := iter.Value()
			val2 := v2.MapIndex(iter.Key())
			if !val1.IsValid() || !val2.IsValid() || !deepValueEqual(val1, val2, visited) {
				return false
			}
		}
		return true
	case Func:
		if v1.IsNil() && v2.IsNil() {
			return true
		}
		// Can't do better than this:

				simpleEndpointSlice("bar1", "10.2.3.4", discovery.AddressTypeIPv4),
				simpleEndpointSlice("bar2", "10.3.4.5", discovery.AddressTypeIPv4),
			},
		},
		expectedSlices: &slicesByAction{
			toUpdate: []*discovery.EndpointSlice{simpleEndpointSlice("bar1", "10.1.2.3", discovery.AddressTypeIPv4)},
			toDelete: []*discovery.EndpointSlice{simpleEndpointSlice("bar2", "10.3.4.5", discovery.AddressTypeIPv4)},
		},
	}, {

                }
                task jar2(type: Jar) {
                    archiveFileName = 'lib2.jar'
                }
                tasks.withType(Jar) {
                    destinationDirectory = buildDir
                }
                artifacts {
                    compile jar1
                    compile jar2
                }
            }

            project(':util') {

	if value.(string) != testObj.val {
		t.Errorf("Expected to get cached value: %#v, but got: %s", testObj.val, value.(string))
	}

}

func TestExpirationBasic(t *testing.T) {
	unexpectedVal := "bar"
	expectedVal := "bar2"

	testObj := testObject{
		key: "foo",
		val: unexpectedVal,
	}

	fakeClock := testingclock.NewFakeClock(time.Now())

	objectCache := NewFakeObjectCache(func() (interface{}, error) {

            .add(new TestMethodResult(1, "foo"))

        def barTest = new TestClassResult(2, 'BarTest', 100)
            .add(new TestMethodResult(2, "bar"))
            .add(new TestMethodResult(3, "bar2"))

        resultsProvider.visitClasses(_) >> { Action action ->
            action.execute(fooTest)
            action.execute(barTest)
        }

        when:
        generator.generate()

        then:

class PropertiesAsMapTest {

    @Test
    void testPropertiesAsMap() {
        Properties props = new Properties();
        props.setProperty("foo1", "bar1");
        props.setProperty("foo2", "bar2");
        PropertiesAsMap pam = new PropertiesAsMap(props);
        assertEquals(2, pam.size());
        Set<Entry<String, String>> set = pam.entrySet();
        assertNotNull(set);
        assertEquals(2, set.size());

    %val0 = "tf.ReadVariableOp"(%arg0) : (tensor<!tf_type.resource<tensor<f32>>>) -> tensor<f32>
    %val1 = "tf.ReadVariableOp"(%arg1) : (tensor<!tf_type.resource<tensor<f32>>>) -> tensor<f32>
    %val2 = "tf.ReadVariableOp"(%arg2) : (tensor<!tf_type.resource<tensor<f32>>>) -> tensor<f32>
    %val3 = "tf.ReadVariableOp"(%arg3) : (tensor<!tf_type.resource<tensor<f32>>>) -> tensor<f32>

    - five
    - six
    - seven
    - eight
    - nine
    env:
    - name: VAR_3
      valueFrom:
        secretKeyRef:
          key: some-other-key
          name: some-oher-name
    - name: VAR_2
      valueFrom:
        secretKeyRef:
          key: other-key
          name: other-name
    - name: VAR_1
      valueFrom:
        secretKeyRef:
          key: some-key
          name: some-name