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

[
 {
	 "key_1": "value",
	 "key_2": "value"
 }
]
[
	{
		"key_1": "value2",
		"key_2": "value3"
	}

         * 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]));
        }

        /**

{{- if eq .Values.mode "distributed" }}
{{ $poolCount := .Values.pools | int }}
{{ $nodeCount := .Values.replicas | int }}
{{ $replicas := mul $poolCount $nodeCount }}
{{ $drivesPerNode := .Values.drivesPerNode | int }}
{{ $scheme := .Values.tls.enabled | ternary "https" "http" }}
{{ $mountPath := .Values.mountPath }}
{{ $bucketRoot := or ($.Values.bucketRoot) ($.Values.mountPath) }}
{{ $subPath := .Values.persistence.subPath }}

   */
  public void testUpdateAndGetWithSubtract() {
    for (double x : VALUES) {
      for (double y : VALUES) {
        AtomicDouble a = new AtomicDouble(x);
        double z = a.updateAndGet(value -> value - y);
        assertBitEquals(x - y, z);
        assertBitEquals(x - y, a.get());
      }
    }
  }

  /** a deserialized serialized atomic holds same value */

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>

					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:

  /**
   * 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(

}

// AutoMigrate auto migrate values
func (m Migrator) AutoMigrate(values ...interface{}) error {
	for _, value := range m.ReorderModels(values, true) {
		queryTx, execTx := m.GetQueryAndExecTx()
		if !queryTx.Migrator().HasTable(value) {
			if err := execTx.Migrator().CreateTable(value); err != nil {
				return err
			}
		} else {
			if err := m.RunWithValue(value, func(stmt *gorm.Statement) error {

        final SuppressErrorReportValve valve1 = new SuppressErrorReportValve();
        final SuppressErrorReportValve valve2 = new SuppressErrorReportValve();

        valve1.setShowReport(true);
        valve1.setShowServerInfo(true);

        // valve2 should still have default values
        assertFalse("valve2 should have independent ShowReport setting", valve2.isShowReport());