mkParams := func(clientToken string, forceStart, forceStop bool) url.Values {
		v := url.Values{}
		if clientToken != "" {
			v.Add(mgmtClientToken, clientToken)
		}
		if forceStart {
			v.Add(mgmtForceStart, "")
		}
		if forceStop {
			v.Add(mgmtForceStop, "")
		}
		return v
	}
	qParamsArr := []url.Values{
		// Invalid cases
		mkParams("", true, true),
		mkParams("111", true, true),

    builder.put("key", "value");
    assertThat(builder.build().entries()).containsExactly(Maps.immutableEntry("key", "value"));
  }

  public void testBuilderWithExpectedKeysPositive() {
    ImmutableListMultimap.Builder<String, String> builder =
        ImmutableListMultimap.builderWithExpectedKeys(1);
    builder.put("key", "value");

// corresponding error value. NB When there is more than one error value that
// occurs maximum number of times, the error value returned depends on how
// golang's map orders keys. This doesn't affect correctness as long as quorum
// value is greater than or equal to simple majority, since none of the equally
// maximal values would occur quorum or more number of times.

	return fmt.Sprintf("%s\n Hint: error near line: %d, col: %d", b.msg, b.line, b.col)
}

// BatchJobKV is a key-value data type which supports wildcard matching
type BatchJobKV struct {
	line, col int
	Key       string `yaml:"key" json:"key"`
	Value     string `yaml:"value" json:"value"`
}

var _ yaml.Unmarshaler = &BatchJobKV{}

            else -> LinkedTags(this.key, this.value, nextMinusKey)
          }
        }
      }

    // Return a new `Tags` that maps `key` to `value`.
    return when {
      value != null -> LinkedTags(key, value, thisMinusKey)
      else -> thisMinusKey
    }
  }

  override fun <T : Any> get(key: KClass<T>): T? =
    when {
      key == this.key -> key.java.cast(value)
      else -> next[key]
    }

        ("param", "123"),
        ("param2", "456"),  # Pass a list of values as extra parameter
        ("param2", "789"),
    ]
    resp = client.get("/cookie")
    assert resp.status_code == 200
    resp_json = resp.json()
    assert "param2" in resp_json

     * combiner function to the corresponding values of the properties that are true.
     *
     * @param flags The map of boolean properties mapped to their values.
     * @param combiner The function to combine the values of the true properties.
     *
     * @return A provider of the reduced value. Non-present if no properties are true.
     */

It will perform the validation of the compound data, and will document it like that for the OpenAPI schema and automatic docs.

## Singular values in body { #singular-values-in-body }

The same way there is a `Query` and `Path` to define extra data for query and path parameters, **FastAPI** provides an equivalent `Body`.

 * Tests the batch limit configuration for various SMB commands.
 */
public class SmbConnectionTest {

    /**
     * Test that getBatchLimit returns correct values for different commands
     */
    @Test
    @DisplayName("getBatchLimit returns correct values for different SMB commands")
    public void testBatchLimitForDifferentCommands() throws CIFSException {
        Properties props = new Properties();

    /**
     * Returns true if this reference contains an active value, meaning one that is still considered
     * present in the cache. Active values consist of live values, which are returned by cache
     * lookups, and dead values, which have been evicted but awaiting removal. Non-active values
     * consist strictly of loading values, though during refresh a value may be both active and
     * loading.
     */
    boolean isActive();