public static void main(String[] args) {
        if (!"${testValue}".equals(System.getProperty("testValue"))) {
            throw new RuntimeException("Unexpected value: testValue=" + System.getProperty("testValue"));
        }
        if (!"${testValue2}".equals(System.getProperty("testValue2"))) {
            throw new RuntimeException("Unexpected value: testValue2=" + System.getProperty("testValue2"));
        }

func (k key2) String() string { return fmt.Sprintf("%[1]T(%[1]d)", k) }

var k1 = key1(1)
var k2 = key2(1) // same int as k1, different type
var k3 = key2(3) // same type as k2, different int

func TestValues(t *testing.T) {
	check := func(c Context, nm, v1, v2, v3 string) {
		if v, ok := c.Value(k1).(string); ok == (len(v1) == 0) || v != v1 {
			t.Errorf(`%s.Value(k1).(string) = %q, %t want %q, %t`, nm, v, ok, v1, len(v1) != 0)

      } catch (UnsupportedOperationException | NullPointerException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }

  public void testValues() {
    Map<K, V> map;
    Collection<V> valueCollection;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    assertInvariants(map);

      } catch (UnsupportedOperationException | NullPointerException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }

  public void testValues() {
    Map<K, V> map;
    Collection<V> valueCollection;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    assertInvariants(map);

			podTolerations:            []api.Toleration{{Key: "testKey", Operator: "Equal", Value: "testValue1", Effect: "NoSchedule"}},
			mergedTolerations:         []api.Toleration{{Key: "testKey", Operator: "Equal", Value: "testValue", Effect: "NoSchedule"}, {Key: "testKey", Operator: "Equal", Value: "testValue1", Effect: "NoSchedule"}},
			admit:                     true,

	}
}

func TestListValueContainsNestedList(t *testing.T) {
	lvA := NewListValue()
	lvA.Append(testValue(t, 1, int64(1)))
	lvA.Append(testValue(t, 2, int64(2)))

	lvB := NewListValue()
	lvB.Append(testValue(t, 3, int64(3)))

	elemA, elemB := testValue(t, 4, lvA), testValue(t, 5, lvB)
	lv := NewListValue()
	lv.Append(elemA)
	lv.Append(elemB)

	contained := lv.Contains(elemA.ExprValue())

			}
		}
	}(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 {

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

	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")

    }

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

        when:
        fileOption.write(writerContextMock)

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