protected TermsQueryBuilder regTermsQ(String name, Collection<?> values) {
        checkEsInvalidQueryCollection(name, values);
        TermsQueryBuilder termsQuery = QueryBuilders.termsQuery(name, values);
        regQ(termsQuery);
        return termsQuery;
    }

    protected IdsQueryBuilder regIdsQ(Collection<String> values) {
        checkEsInvalidQueryCollection("_id", values);

 * demonstration – the real class behaviour is not required for
 * validating constants.
 */
public class SmbConstantsTest {

    /**
     * Verify that the hard‑coded default values are present.
     */
    @Test
    @DisplayName("Default constant values match expectations")
    void defaultValues() {
        assertEquals(445, SmbConstants.DEFAULT_PORT);
        assertEquals(10, SmbConstants.DEFAULT_MAX_MPX_COUNT);

   * distinct values for equality testing, use {@link #setDistinctValues} instead.
   */
  @CanIgnoreReturnValue
  public <T> ClassSanityTester setDefault(Class<T> type, T value) {
    nullPointerTester.setDefault(type, value);
    defaultValues.putInstance(type, value);
    return this;
  }

  /**

        }
    }

    protected void checkEsInvalidAggregationCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {
            String msg = "Cannot register null or empty query collection: name=" + name + " values=" + values;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

   * Returns a string containing the supplied {@code byte} values separated by {@code separator}.
   * For example, {@code join(":", (byte) 1, (byte) 2, (byte) 255)} returns the string {@code
   * "1:2:255"}.
   *
   * @param separator the text that should appear between consecutive values in the resulting string
   *     (but not at the start or end)
   * @param array an array of {@code byte} values, possibly empty
   */

        }
    }

    protected void checkEsInvalidAggregationCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {
            String msg = "Cannot register null or empty query collection: name=" + name + " values=" + values;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

    // FilteredCollection), which we want to avoid.
    if (values instanceof List || values instanceof ImmutableCollection) {
      return uniqueIndex(
          values.iterator(),
          keyFunction,
          ImmutableMap.builderWithExpectedSize(((Collection<?>) values).size()));
    }
    return uniqueIndex(values.iterator(), keyFunction);
  }

  /**

		"Environment can only accept `on` and `off` values. To disable Console access, set this value to `off`",
	)

	ErrInvalidFSOSyncValue = newErrFn(
		"Invalid O_SYNC value",
		"Please check the passed value",
		"Can only accept `on` and `off` values. To enable O_SYNC for fs backend, set this value to `on`",
	)

	ErrOverlappingDomainValue = newErrFn(
		"Overlapping domain values",
		"Please check the passed value",

// FromBytes creates a Value from a []byte
func FromBytes(b []byte) *Value {
	return &Value{value: b}
}

// FromArray creates a Value from an array of values.
func FromArray(a []Value) *Value {
	return &Value{value: a}
}

// ToFloat works for int and float values
func (v Value) ToFloat() (val float64, ok bool) {
	switch x := v.value.(type) {
	case float64:
		return x, true
	case int64:
		return float64(x), true

   * to {@link LoadingCache#get} if this method is not overridden.
   *
   * @param keys the unique, non-null keys whose values should be loaded
   * @return a map from each key in {@code keys} to the value associated with that key; <b>may not
   *     contain null values</b>
   * @throws Exception if unable to load the result
   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is