</entry>
        <entry key="$PROJECT_DIR$/compiler/testData/codegen/boxInline">
          <value>
            <array>
              <option value="$PROJECT_DIR$/js/js.tests/build/node/{out,out-min,out-per-module,out-per-module-min}/codegen/{boxInline,irBoxInline,firBoxInline,firEs6BoxInline}/$TEST_DATA_FILE$_v5.js" />
            </array>
          </value>
        </entry>
        <entry key="$PROJECT_DIR$/compiler/testData/debug">

        'exact match'                                    | [key: 'something']              | 'foo'
        'exact match'                                    | [key: 'something else']         | 'bar'
        'partial match on key but attribute is optional' | [key: 'something', extra: 'no'] | 'foo'
    }

    def "revalidates default configuration if it has attributes"() {

						resp.Envs = make(map[string]string)
						for _, dev := range devs {
							switch dev {
							case "dev3":
								resp.Envs["key2"] = "val2"

							case "dev4":
								resp.Envs["key2"] = "val3"
							}
						}
						resps := new(pluginapi.AllocateResponse)
						resps.ContainerResponses = append(resps.ContainerResponses, resp)
						return resps, nil
					},

				Type:        []string{"object"},
				Properties: map[string]spec.Schema{
					"key": {
						SchemaProps: spec.SchemaProps{

	res, err := c.Exists(
		index,
		key,
		c.Exists.WithContext(ctx),
	)
	if err != nil {
		return false, err
	}
	xhttp.DrainBody(res.Body)
	return !res.IsError(), nil
}

func (c *esClientV7) removeEntry(ctx context.Context, index string, key string) error {
	exists, err := c.entryExists(ctx, index, key)
	if err == nil && exists {

        then:
        failure.assertHasDescription("Error loading encryption key from GRADLE_ENCRYPTION_KEY environment variable")
        failure.assertHasCause("Encryption key length is 8 bytes, but must be at least 16 bytes long")
    }

    def "new configuration cache entry if env var key changes"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

		return "", "", err
	}

	return certPath, keyPath, nil
}

// createCertAndKeyFilesUsingRename creates cert and key files under a parent dir `identity` as
// <certDir>/identity/kubelet.cert, <certDir>/identity/kubelet.key
func createCertAndKeyFilesUsingRename(certDir string) (string, string, error) {
	cert, key, err := cert.GenerateSelfSignedCertKey("k8s.io", nil, nil)

     * of the property to its current convention value, if set, or an empty map.
     * </p>
     *
     * @param key the key
     * @param value the value
     */
    @Incubating
    void insert(K key, V value);

    /**
     * Adds a map entry to the property value.
     *
     * <p>The given provider will be queried when the value of this property is queried.
     * <p>

        }

        public void put(K key, V value) {
            Preconditions.checkNotNull(key, NULL_KEY_FORBIDDEN_MESSAGE);
            Preconditions.checkNotNull(value, NULL_VALUE_FORBIDDEN_MESSAGE);
            addCollector(new SingleEntry<>(key, value));
        }

        public void put(K key, Provider<? extends V> providerOfValue) {
            Preconditions.checkNotNull(key, NULL_KEY_FORBIDDEN_MESSAGE);

	}
	if x.XIntOrString {
		ret.VendorExtensible.AddExtension("x-kubernetes-int-or-string", true)
	}
	if len(x.XListMapKeys) > 0 {
		ret.VendorExtensible.AddExtension("x-kubernetes-list-map-keys", x.XListMapKeys)
	}
	if x.XListType != nil {
		ret.VendorExtensible.AddExtension("x-kubernetes-list-type", *x.XListType)
	}
	if x.XMapType != nil {
		ret.VendorExtensible.AddExtension("x-kubernetes-map-type", *x.XMapType)