/**
     * Associates {@code key} with {@code value} in the built map. If the same key is put more than
     * once, {@link #buildOrThrow} will fail, while {@link #buildKeepingLast} will keep the last
     * value put for that key.
     */
    @CanIgnoreReturnValue
    public Builder<K, V> put(K key, V value) {
      ensureCapacity(size + 1);
      checkEntryNotNull(key, value);
      alternatingKeysAndValues[2 * size] = key;

            String key = (String) provide.getKey();
            String value = (String) provide.getValue();

            if (value == null) {
                throw new MisconfiguredToolchainException(
                        "Provides token '" + key + "' doesn't have any value configured.");
            }

            RequirementMatcher matcher;
            if ("version".equals(key)) {

    private boolean isStrict(Map<String, ?> options) {
        Object value = (options != null) ? options.get(IS_STRICT) : null;
        return value == null || Boolean.parseBoolean(value.toString());
    }

    private InputSource getSource(Map<String, ?> options) {
        Object value = (options != null) ? options.get(INPUT_SOURCE) : null;
        return (InputSource) value;
    }

                "value": {
                    "name": "Bar",
                    "price": "35.4",
                },
            },
            "invalid": {
                "summary": "Invalid data is rejected with an error",
                "value": {
                    "name": "Baz",
                    "price": "thirty five point four",

        server_name  localhost;

        # To allow special characters in headers
        ignore_invalid_headers off;
        # Allow any size file to be uploaded.
        # Set to a value such as 1000m; to restrict file size to a specific value
        client_max_body_size 0;
        # To disable buffering
        proxy_buffering off;
        proxy_request_buffering off;

        location / {

 */
class SMBUtilTest {

    @Test
    void testWriteInt2() {
        byte[] dst = new byte[10];

        // Test with simple value
        SMBUtil.writeInt2(0x1234L, dst, 0);
        assertEquals((byte) 0x34, dst[0]);
        assertEquals((byte) 0x12, dst[1]);

        // Test with max value for 2 bytes
        SMBUtil.writeInt2(0xFFFFL, dst, 2);
        assertEquals((byte) 0xFF, dst[2]);
        assertEquals((byte) 0xFF, dst[3]);

      assertThat(property.value()).isEqualTo(System.getProperty(property.key()));
    }
  }

  public void testToString() {
    for (StandardSystemProperty property : StandardSystemProperty.values()) {
      assertThat(property.toString()).isEqualTo(property.key() + "=" + property.value());
    }
  }

  public void testNoNullValues() {

        this.newPrefix = newPrefix;
        this.problems = problems;
    }

    @Override
    public Object getValue(String expression) {
        Object value = valueSource.getValue(expression);

        if (value != null && expression.startsWith(bannedPrefix)) {
            String msg = "The expression ${" + expression + "} is deprecated.";
            if (newPrefix != null && !newPrefix.isEmpty()) {

        result.add(element != null ? element.value : null);
      }
      return unmodifiableList(result);
    }
  }

  /** The result of a successful {@code Future}. */
  private static final class Present<V extends @Nullable Object> {
    @ParametricNullness final V value;

    Present(@ParametricNullness V value) {
      this.value = value;
    }
  }

        }

        val name = parameter.groups[1]?.value
        if (name == null) {
          s = parameter.range.last + 1
          continue
        }

        val token = parameter.groups[2]?.value
        val value =
          when {
            token == null -> {
              // Value is "double-quoted". That's valid and our regex group already strips the quotes.