public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));
      return charactersOf(String.copyValueOf(chars));
    }
  }

  public static class CharactersOfCharSequenceGenerator extends TestCharacterListGenerator {
    @Override
    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));

    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));
      return charactersOf(String.copyValueOf(chars));
    }
  }

  public static class CharactersOfCharSequenceGenerator extends TestCharacterListGenerator {
    @Override
    public List<Character> create(Character[] elements) {
      char[] chars = Chars.toArray(asList(elements));

    }

    /**
     * Convert char array to byte array (UTF-8)
     */
    private byte[] charsToBytes(char[] chars) {
        if (chars == null) {
            return null;
        }

        // Use UTF-8 encoding
        byte[] bytes = new byte[chars.length * 3]; // Max 3 bytes per char in UTF-8
        int byteIndex = 0;

        for (char c : chars) {
            if (c < 0x80) {

  }

  static CharMatcher from(BitSet chars, String description) {
    // Compute the filter.
    long filter = 0;
    int size = chars.cardinality();
    boolean containsZero = chars.get(0);
    // Compute the hash table.
    char[] table = new char[chooseTableSize(size)];
    int mask = table.length - 1;
    for (int c = chars.nextSetBit(0); c != -1; c = chars.nextSetBit(c + 1)) {

        assertTrue(result.contains("field1field2"));
        assertTrue(result.contains("exclude1exclude2"));

        // Count separators
        long separatorCount = result.chars().filter(ch -> ch == '\n').count();
        assertEquals(4, separatorCount);
    }

    @Test
    public void test_getCacheKey_nullParameters() {
        String seed = "test_seed";
        String[] tags = null;

      }

      @Override
      public Hasher putChar(char c) {
        for (Hasher hasher : hashers) {
          hasher.putChar(c);
        }
        return this;
      }

      @Override
      public Hasher putUnencodedChars(CharSequence chars) {
        for (Hasher hasher : hashers) {
          hasher.putUnencodedChars(chars);
        }
        return this;
      }

      @Override

        // Pattern with single backslash (14 chars): should match
        String singleBackslash = "image/svg" + "\\" + "+xml";
        assertEquals("Single backslash pattern should be 14 chars", 14, singleBackslash.length());
        assertTrue(svgMimetype.matches(singleBackslash));

        // Pattern with double backslash (15 chars): should NOT match
        String doubleBackslash = "image/svg" + "\\\\" + "+xml";

... alors, comme `description` a une valeur par défaut, si vous ne retournez rien pour ce champ, il aura tout de même cette **valeur par défaut**.

### Modèle pour les données de réponse en sortie { #model-for-output-response-data }

Si vous interagissez avec les documents et vérifiez la réponse, même si le code n'a rien ajouté dans l'un des champs `description`, la réponse JSON contient la valeur par défaut (`null`) :

<div class="screenshot">

      HashFunction hashFunction, Random random) {
    int size = random.nextInt(8) + 1;
    char[] chars = new char[size];
    for (int i = 0; i < chars.length; i++) {
      chars[i] = random.nextBoolean() ? randomLowSurrogate(random) : randomHighSurrogate(random);
    }
    String string = new String(chars);
    assertEquals(
        hashFunction.hashUnencodedChars(string),

// code points in chars. It returns -1 if chars is empty or if there is no code
// point in common.
func IndexAny(s []byte, chars string) int {
	if chars == "" {
		// Avoid scanning all of s.
		return -1
	}
	if len(s) == 1 {
		r := rune(s[0])
		if r >= utf8.RuneSelf {
			// search utf8.RuneError.
			for _, r = range chars {
				if r == utf8.RuneError {
					return 0
				}