name := apiservercel.NewField(1, "name")
	name.Ref = testValue(t, 2, "test-instance")
	nestedVal := apiservercel.NewMapValue()
	flags := apiservercel.NewField(5, "flags")
	flagsVal := apiservercel.NewMapValue()
	myFlag := apiservercel.NewField(6, "my_flag")
	myFlag.Ref = testValue(t, 7, true)
	flagsVal.AddField(myFlag)
	flags.Ref = testValue(t, 8, flagsVal)
	dates := apiservercel.NewField(9, "dates")

        0 * writerContextMock._
    }

    def testWriteNoneNullValue() throws IOException {
        final String testValue = "testValue"
        stringOption.setValue(testValue)

        when:
        stringOption.write(writerContextMock)

        then:
        1 * writerContextMock.writeValueOption(optionName, testValue)
    }

    }

    def testWriteNonNullValue() throws IOException {
        final File testValue = new File("dummyTestFileValue")
        fileOption.setValue(testValue)

        when:
        fileOption.write(writerContextMock)

        then:
        1 * writerContextMock.writeValueOption(optionName, testValue.absolutePath)
    }

package main

func main() {
	One[TextValue]()
}

func One[V Value]() { Two[Node[V]]() }

func Two[V interface{ contentLen() int }]() {
	var v V
	v.contentLen()
}

type Value interface {
	Len() int
}

type Node[V Value] struct{}

func (Node[V]) contentLen() int {
	var value V
	return value.Len()
}

type TextValue struct{}

			}
		}
	}(Environ())

	if err := Setenv(testKey, testValue); err != nil {
		t.Fatalf("Setenv(%q, %q) failed: %v", testKey, testValue, err)
	}
	if _, ok := LookupEnv(testKey); !ok {
		t.Errorf("Setenv(%q, %q) didn't set $%s", testKey, testValue, testKey)
	}
	Clearenv()
	if val, ok := LookupEnv(testKey); ok {

	for _, t := range types {
		for _, n := range t.testvalues() {
			fmt.Printf("var %s_%s %s = %d\n", t.name, valname(n), t.name, n)
		}
	}

	fmt.Println("func main() {")

	for _, t := range types {
		// test binary ops
		for _, op := range binops {
			for _, x := range t.testvalues() {
				for _, y := range t.testvalues() {
					if (op.name == "/" || op.name == "%") && y.Sign() == 0 {

    // CHECK-NEXT:     %[[IF:.*]]:2 = "tf.IfRegion"(%[[HAS_VALUE]])
    // CHECK-NEXT:       %[[GET_VALUE:[0-9]*]]:2 = "tf.OptionalGetValue"(%[[GET_NEXT]])
    // CHECK-NEXT:       %[[FUNC_CALL:[0-9]*]]:2 = func.call @__reduce_func_3(%[[ARG_11]], %[[ARG_12]], %[[GET_VALUE]]#0, %[[GET_VALUE]]#1, %[[ARG_13]], %[[ARG_14]])
    // CHECK-SAME:       _xla_compile_device_type = "TPU"

		return fmt.Errorf("couldn't find %v field in %T", fieldName, v.Interface())
	}
	destValue, err := conversion.EnforcePtr(dest)
	if err != nil {
		return err
	}
	if field.Type().AssignableTo(destValue.Type()) {
		destValue.Set(field)
		return nil
	}
	if field.Type().ConvertibleTo(destValue.Type()) {
		destValue.Set(field.Convert(destValue.Type()))
		return nil
	}

        } else {
            assert value(fixture.antProperty) == fixture.defaultValue
        }
        when:
        testObject."${fixture.fieldName}" = fixture.testValue
        then:
        value(fixture.antProperty) == fixture.testValue
        where:
        fixture << stringProperties()
    }

            for (String key : present) {
                if (!testValue(expectedPayload[key], actualPayload[key])) {
                    return false
                }
            }
            true
        } as Predicate
    }

    private static boolean testValue(expectedValue, actualValue) {
        if (expectedValue instanceof Closure) {
            expectedValue.call(actualValue)