}

    /**
     * Converts value to lowercase if lowercase wildcard is enabled.
     *
     * @param value the value to convert
     * @return the converted value
     */
    protected String toLowercaseWildcard(final String value) {
        if (lowercaseWildcard) {
            return value.toLowerCase(Locale.ROOT);
        }
        return value;
    }

    /**

    Set<List<Integer>> degenerate = cartesianProduct();
    checkHashCode(degenerate);

    checkHashCode(cartesianProduct(set(1, 2)));

    int num = Integer.MAX_VALUE / 3 * 2; // tickle overflow-related problems
    checkHashCode(cartesianProduct(set(1, 2, num)));

    Set<Integer> mt = emptySet();
    checkHashCode(cartesianProduct(mt, mt));

		panic("not all labels were given values")
	}

	v, ok := m.values[name]
	if !ok {
		v = make([]metricValue, 0, 1)
	}
	// If valid non zero value set the metrics
	if value > 0 {
		m.values[name] = append(v, metricValue{
			Labels: labelMap,
			Value:  value,
		})
	}
}

// SetHistogram - sets values for the given MetricName using the provided
// histogram.
//

        Map<String, Object> value = new LinkedHashMap<>();
        DocMap docMap = new DocMap(value);
        assertTrue(docMap.isEmpty());
        value.clear();

        List<String> keys = Arrays.asList("test_2", "test_0", "lang", "test_1");
        value.put(keys.get(0), true);
        value.put(keys.get(1), 1000);
        value.put(keys.get(2), "ja");
        value.put(keys.get(3), "str");

    }

    // Read 1 or more decimal digits for a value in 0..255.
    var value = 0
    val groupOffset = i
    while (i < limit) {
      val c = input[i]
      if (c < '0' || c > '9') break
      if (value == 0 && groupOffset != i) return false // Reject unnecessary leading '0's.
      value = value * 10 + c.code - '0'.code
      if (value > 255) return false // Value out of range.
      i++
    }

    }

    /**
     * Encodes the specified value using the character encoding.
     *
     * @param value the value to encode
     * @return the encoded value
     * @throws CurlException if the encoding is unsupported
     */
    protected String encode(final String value) {
        try {
            return URLEncoder.encode(value, encoding);
        } catch (final UnsupportedEncodingException e) {

    }

    static <K, V> Map<K, V> singletonMap(K key, V value) {
        return new Map1<>(key, value);
    }

    private static class Map1<K, V> extends AbstractImmutableMap<K, V> {
        private final Entry<K, V> entry;

        private Map1(K key, V value) {
            this.entry = new SimpleImmutableEntry<>(key, value);
        }

        @Override
        public Set<Entry<K, V>> entrySet() {

            // Given
            byte[] maxKey = new byte[SOURCE_KEY_SIZE];
            Arrays.fill(maxKey, (byte) 0xFF);
            SrvCopychunk chunk = new SrvCopychunk(Long.MAX_VALUE, Long.MAX_VALUE, Integer.MAX_VALUE);
            SrvCopychunkCopy copy = new SrvCopychunkCopy(maxKey, chunk);
            byte[] buffer = new byte[100];

            // When
            int bytesWritten = copy.encode(buffer, 0);

```Python
old_dict = {
    "old key": "old value",
    "second old key": "second old value",
}
new_dict = {**old_dict, "new key": "new value"}
```

Hier wird `new_dict` alle Schlüssel-Wert-Paare von `old_dict` plus das neue Schlüssel-Wert-Paar enthalten:

```Python
{
    "old key": "old value",
    "second old key": "second old value",
    "new key": "new value",
}
```

```Python
old_dict = {
    "old key": "old value",
    "second old key": "second old value",
}
new_dict = {**old_dict, "new key": "new value"}
```

Aquí, `new_dict` contendrá todos los pares clave-valor de `old_dict` más el nuevo par clave-valor:

```Python
{
    "old key": "old value",
    "second old key": "second old value",
    "new key": "new value",
}
```