Fields: map[string]*structpb.Value{
								"req1": {Kind: &structpb.Value_StringValue{StringValue: "%REQ_WITHOUT_QUERY(key1:val1)%"}},
								"req2": {Kind: &structpb.Value_StringValue{StringValue: "%REQ_WITHOUT_QUERY(key2:val1)%"}},
								"key1": {Kind: &structpb.Value_StringValue{StringValue: "%METADATA(CLUSTER:istio)%"}},
								"key2": {Kind: &structpb.Value_StringValue{StringValue: "%METADATA(UPSTREAM_HOST:istio)%"}},
							},
						},
					},

8vGvziOgS1A3qTGvMwNpkd1vg/n/B3wPBZC124wx/yHl4YM19b+xsvp3SQARAQAB
tB1KZXNzZSBXaWxzb24gPGplc3NlQHN3YW5rLmNhPg==
=owuM
-----END PGP PUBLIC KEY BLOCK-----

pub    86FDC7E2A11262CB
uid    Gary David Gregory (Code signing key) <******@****.***>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: BCPG v1.68

mQENBE2kzuwBCACYV+G9yxNkSjAKSji0B5ipMGM74JAL1Ogtcu+993pLHHYsdXri

        val entryPoint2 = Any()
        val key1 = Any()
        val key2 = Any()

        reporting.enterDynamicCall(entryPoint1)
        assertTrue(reporting.unreportedProblemInCurrentCall(key1))
        assertFalse(reporting.unreportedProblemInCurrentCall(key1))
        assertTrue(reporting.unreportedProblemInCurrentCall(key2))
        assertFalse(reporting.unreportedProblemInCurrentCall(key2))

		},
		{
			Expression: "('group1' in request.groups)",
		},
		{
			Expression: "('key1' in request.extra)",
		},
		{
			Expression: "!('key2' in request.extra)",
		},
		{
			Expression: "('a' in request.extra['key1'])",
		},
		{
			Expression: "!('z' in request.extra['key1'])",
		},
		{

	}
	if e := c.Err(); e != Canceled {
		t.Errorf("c.Err() == %v want %v", e, Canceled)
	}
}

type key1 int
type key2 int

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

  XlaSerializedCacheEntry entry;
  TF_ASSERT_OK(ReadTextOrBinaryProto(
      Env::Default(), GetFilePath(key1, persistor.persistent_cache_directory()),
      &entry));
  // Change the entry's key to key2.
  *entry.mutable_key() = key2;
  // Write the modified entry to file corresponding to key2.
  TF_ASSERT_OK(WriteBinaryProto(

    public void test_register() {
        RenderData data = new RenderData();

        RenderDataUtil.register(data, "key1", null);
        assertNull(data.getDataMap().get("key1"));

        RenderDataUtil.register(data, "key5", "");
        assertEquals(data.getDataMap().get("key5"), "");

    }

		},
		{
			name: "@request.auth.claims.key1-key2",
			in:   &networking.StringMatch{MatchType: &networking.StringMatch_Exact{Exact: "exact"}},
			want: authz.MetadataMatcherForJWTClaims([]string{"key1-key2"}, authzmatcher.StringMatcher("exact"), false),
		},
		{
			name: "@request.auth.claims.prefix",

      values: ["valueC"]
  - to:
    - operation:
        paths: ["/nested-2-key1"]
        methods: ["GET"]
    when:
    - key: request.auth.claims[nested][nested-2][key1]
      values: ["valueA"]
  - to:
    - operation:
        paths: ["/valid-jwt"]
    when:
    - key: request.auth.principal
      values: ["*"]
  - to:
    - operation:
        paths: ["*/presenter"]
    when:

 * For example, to create a key of type Map<String, List<Integer>>, you can just use
 * this syntax: <code>new Key&lt;Map&lt;String, List&lt;Integer&gt;&gt;&gt;(){}</code>.
 * <p>
 * If your types are not known at compile time, you can use {@link Types#parameterizedType} to make a
 * parameterized type and give it to a {@link #ofType Key.ofType} constructor.
 *
 * @param <T> binding type
 */
public abstract class Key<T> {