}

    def "keySet() containsAll(#key1, #key2) is tracked"() {
        when:
        def result = getMapUnderTestToRead().keySet().containsAll(Arrays.asList(key1, key2))

        then:
        result == expectedResult
        1 * onAccess.accept(key1, reportedValue1)
        1 * onAccess.accept(key2, reportedValue2)
        0 * onAccess._

        where:

        expect:
        MavenDependencyKey key1 = new MavenDependencyKey('group-one', 'artifact-one', 'jar', 'sources')
        MavenDependencyKey key2 = new MavenDependencyKey(groupId, artifactId, type, classifier)
        strictlyEquals(key1, key2) == equality
        (key1.hashCode() == key2.hashCode()) == hashCode
        (key1.toString() == key2.toString()) == stringRepresentation

        where:

        then:
        tempFile.text == toPlatformLineSeparators("""-key1 'value1'
-key2 'value2'
-key3 'value3'
""")
        when:
        optionsMap.put("locale", new StringJavadocOptionFileOption("locale", "alocale"));
        and:
        javadocOptionFileWriter.write(tempFile)
        then:
        tempFile.text == toPlatformLineSeparators("""-locale 'alocale'
-key1 'value1'
-key2 'value2'
-key3 'value3'
""")
    }

        def object = parser.parseNotation([name: 'name', version: 'version'])
        object.key1 == 'name'
        object.key2 == 'version'
        object.prop1 == null
    }

    def "parses map with required and optional keys"() {
        expect:
        def object = parser.parseNotation([name: 'name', version: 'version', optional: '1.2'])
        object.key1 == 'name'
        object.key2 == 'version'
        object.optional == '1.2'

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

  ASSERT_EQ(error::INVALID_ARGUMENT, another_cc_status.code());
  // Ensure the payloads are not lost during conversions
  ASSERT_EQ(cc_status.GetPayload("key1"), another_cc_status.GetPayload("key1"));
  ASSERT_EQ(cc_status.GetPayload("key2"), another_cc_status.GetPayload("key2"));
  TSL_DeleteStatus(s);
}

}  // namespace

			external: v1beta1.Endpoint{
				Topology: map[string]string{
					"key1": "val1",
				},
			},
			internal: discovery.Endpoint{
				DeprecatedTopology: map[string]string{
					"key1": "val1",
				},
			},
		},
		{
			desc: "non empty topology map, with zone",
			external: v1beta1.Endpoint{
				Topology: map[string]string{
					"key1":                   "val1",
					corev1.LabelTopologyZone: "zone1",
				},

    signature {
      name: "custom_embedding_matmul"
    }
    attr {
      key: "_implements"
      value {
        func {
          name: "tensorflow.embedding_matmul"
          attr {
            key: "key1"
            value {
              i: 2
            }
          }
          attr {
            key: "key2"
            value {
              b: false
            }
          }
        }
      }

        methods: ["GET"]
    when:
    - key: request.auth.claims[permission]
      values: ["write", "append"]
  - to:
    - operation:
        paths: ["/nested-key1"]
        methods: ["GET"]
    when:
    - key: request.auth.claims[nested][key1]
      values: ["valueB"]
  - to:
    - operation:
        paths: ["/nested-non-exist"]
        methods: ["GET"]
    when:
    - key: request.auth.claims[nested][non-exist]

                expected = ['key1': 'value1', 'key2': 'value2']
            }
            """.stripIndent()

        expect:
        succeeds('verify')

        where:
        value                                                         | _
        "['key1': 'value1', 'key2': 'value2']"                        | _
        "new LinkedHashMap(['key1': 'value1', 'key2': 'value2'])"     | _