// Values should be within reasonable range for security flags
                assertTrue(value <= 0xFFFF, "Constant " + field.getName() + " value seems unusually large");
            }
        }
    }

    /**
     * Helper method to check if a number is a power of two
     */
    private boolean isPowerOfTwo(int n) {
        return n > 0 && (n & (n - 1)) == 0;
    }

to underlying data which may be shared by multiple values:
</p>

<ul>
<li>
	A pointer value is a reference to the variable holding
	the pointer base type value.
</li>
<li>
	A function value contains references to the (possibly
	<a href="#Function_literals">anonymous</a>) function
	and enclosed variables.
</li>
<li>

      add(value);
    }
  }

  /**
   * Adds the given values to the dataset.
   *
   * @param values a series of values
   */
  public void addAll(int... values) {
    for (int value : values) {
      add(value);
    }
  }

  /**
   * Adds the given values to the dataset.
   *
   * @param values a series of values, which will be converted to {@code double} values (this may

		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.
//

         * The value is split by pipe character (|) and each part is trimmed.
         *
         * @param value the configuration value string to parse
         */
        public Config(final String value) {
            values = StreamUtil.split(value, Pattern.quote("|")).get(stream -> stream.map(String::trim).toArray(n -> new String[n]));
        }

        /**

  // MultimapPutTester tests non-duplicate values, but ignores ordering

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAddsValueAtEnd() {
    for (K key : sampleKeys()) {
      for (V value : sampleValues()) {
        resetContainer();

        List<V> values = multimap().get(key);
        List<V> expectedValues = copyToList(values);

        assertTrue(multimap().put(key, value));
        expectedValues.add(value);

    protected void checkEsInvalidAggregation(String name, Object value) {
        if (value == null || (value instanceof String && ((String) value).isEmpty())) {
            String msg = "Cannot register null or empty aggregation: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

        private final String name;
        private final int value;

        public CustomTestObject(String name, int value) {
            this.name = name;
            this.value = value;
        }

        public String getName() {
            return name;
        }

        public int getValue() {
            return value;
        }

        @Override

  /**
   * Returns {@code true} if this multimap contains at least one key-value pair with the value
   * {@code value}.
   */
  boolean containsValue(@CompatibleWith("V") @Nullable Object value);

  /**
   * Returns {@code true} if this multimap contains at least one key-value pair with the key {@code
   * key} and the value {@code value}.
   */
  boolean containsEntry(

					values.Columns = append(values.Columns, clause.Column{Name: field.DBName})
					for idx := range values.Values {
						if vs[idx] == nil {
							values.Values[idx] = append(values.Values[idx], stmt.DefaultValueOf(field))
						} else {
							values.Values[idx] = append(values.Values[idx], vs[idx])
						}
					}
				}
			}
		case reflect.Struct: