cache.edit(key)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("keys must match regex [a-z0-9_-]{1,120}: \"$key\"")
    }
    assertFailsWith<IllegalArgumentException> {
      key = "has_CR\r"
      cache.edit(key)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("keys must match regex [a-z0-9_-]{1,120}: \"$key\"")
    }
    assertFailsWith<IllegalArgumentException> {

But then we get a `dict` in the parameter `commons` of the *path operation function*.

And we know that editors can't provide a lot of support (like completion) for `dict`s, because they can't know their keys and value types.

We can do better...

## What makes a dependency { #what-makes-a-dependency }

Up to now you have seen dependencies declared as functions.

 * and field configuration handling during the document transformation process.
 */
public interface FessTransformer {

    /**
     * Synchronized LRU cache for storing parent URL encodings.
     * Maps session+parent URL keys to their corresponding character encodings.
     */
    Map<String, String> parentEncodingMap = Collections.synchronizedMap(new LruHashMap<>(1000));

    /**
     * Gets the Fess configuration instance.
     *

    //                                                                           =========
    // keeping parsed request parameters, normal texts or uploaded files
    // keys are requested parameter names (treated as field name here)
    protected Map<String, Object> elementsAll; // lazy-loaded, then after not null
    protected Map<String, MultipartFormFile> elementsFile; // me too

    }
    try {
      decode(pkcs8Pem + certificatePem + pkcs8Pem)
      fail<Any>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo("string includes multiple private keys")
    }
  }

  @Test
  fun decodeWrongType() {
    try {
      decode(
        """
        |-----BEGIN CERTIFICATE-----
        |MIIBmjCCAQOgAwIBAgIBATANBgkqhkiG9w0BAQsFADATMREwDwYDVQQDEwhjYXNo

	if schema.PrioritizedPrimaryField == nil {
		if len(schema.PrimaryFields) == 1 {
			schema.PrioritizedPrimaryField = schema.PrimaryFields[0]
		} else if len(schema.PrimaryFields) > 1 {
			// If there are multiple primary keys, the AUTOINCREMENT field is prioritized
			for _, field := range schema.PrimaryFields {
				if field.AutoIncrement {
					schema.PrioritizedPrimaryField = field
					break
				}
			}
		}
	}

                checkNotNull(key);
                return map.put(key, value);
              }
            };
          }
        },
        "HashMap w/out null keys",
        ALLOWS_NULL_VALUES);
  }

  private static Test testsForHashMapNullValuesForbidden() {
    return wrappedHashMapTests(
        new WrappedHashMapGenerator() {
          @Override

            }
            this.closed = true;
        } finally {
            this.signingLock.unlock();
        }
    }

    /**
     * Close the signing digest and securely wipe keys
     */
    @Override
    public void close() {
        secureWipeKey();
    }

	response, err := s.client.Do(request)
	c.Assert(err, nil)
	c.Assert(response.StatusCode, http.StatusOK)

	// create listObjectsV1 request with invalid value of max-keys parameter. max-keys is set to -2.
	request, err = newTestSignedRequest(http.MethodGet, getListObjectsV1URL(s.endPoint, bucketName, "", "-2", ""),
		0, nil, s.accessKey, s.secretKey, s.signer)
	c.Assert(err, nil)

      for (Object o : entries) {
        @SuppressWarnings("unchecked")
        Multiset.Entry<E> entry = (Entry<E>) o;
        checkArgument(
            elements.add(entry.getElement()), "Duplicate keys not allowed in EntrySetGenerator");
        for (int i = 0; i < entry.getCount(); i++) {
          contents.add(entry.getElement());
        }
      }