}

    /**
     * Quotes a string value if it contains spaces.
     * Multi-word values are wrapped in double quotes with internal quotes replaced by spaces.
     *
     * @param value the string value to quote
     * @return the quoted string if it contains spaces, otherwise the original value
     */
    protected String quote(final String value) {
        if (value.split("\\s").length > 1) {

    }

    public void setEndTime(Long value) {
        registerModifiedProperty("endTime");
        this.endTime = value;
    }

    public String getJobName() {
        checkSpecifiedProperty("jobName");
        return convertEmptyToNull(jobName);
    }

    public void setJobName(String value) {
        registerModifiedProperty("jobName");
        this.jobName = value;
    }

        checkSpecifiedProperty("value");
        return convertEmptyToNull(value);
    }

    public void setValue(String value) {
        registerModifiedProperty("value");
        this.value = value;
    }

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

     *
     * @param array
     *            the array
     * @param value
     *            the value to search for
     * @return {@literal true} if the array contains the specified value
     */
    public static boolean contains(final long[] array, final long value) {
        return indexOf(array, value) > -1;
    }

    /**
     * Returns {@literal true} if the array contains the specified value.

    return generateListMultimap(key, value);
  }

  @Generates
  static <K, V> ImmutableMultimap<K, V> generateImmutableMultimap(K key, V value) {
    return ImmutableMultimap.of(key, value);
  }

  @Generates
  static <K, V> ListMultimap<K, V> generateListMultimap(@Nullable K key, @Nullable V value) {
    return generateArrayListMultimap(key, value);
  }

  @Generates

				}
			}
		}
	}

	switch value := updatingValue.Interface().(type) {
	case map[string]interface{}:
		set = make([]clause.Assignment, 0, len(value))

		keys := make([]string, 0, len(value))
		for k := range value {
			keys = append(keys, k)
		}
		sort.Strings(keys)

		for _, k := range keys {
			kv := value[k]
			if _, ok := kv.(*gorm.DB); ok {

            }
            json.append("}");
        } else if (value instanceof Number) {
            json.append(value);
        } else if (value instanceof Boolean) {
            json.append(value);
        } else {
            json.append("\"").append(escapeJson(String.valueOf(value))).append("\"");
        }
    }

    private String escapeJson(final String text) {

	builder.AddVar(builder, like.Value)
}

func (like Like) NegationBuild(builder Builder) {
	builder.WriteQuoted(like.Column)
	builder.WriteString(" NOT LIKE ")
	builder.AddVar(builder, like.Value)
}

func eqNil(value interface{}) bool {
	if valuer, ok := value.(driver.Valuer); ok && !eqNilReflect(valuer) {
		value, _ = valuer.Value()
	}

	return value == nil || eqNilReflect(value)
}

			Value: "auto",
		},
		config.KV{
			Key:   apiReplicationMaxWorkers,
			Value: "500",
		},
		config.KV{
			Key:   apiReplicationMaxLWorkers,
			Value: "10",
		},
		config.KV{
			Key:   apiTransitionWorkers,
			Value: "100",
		},
		config.KV{
			Key:   apiStaleUploadsCleanupInterval,
			Value: "6h",
		},
		config.KV{
			Key:   apiStaleUploadsExpiry,
			Value: "24h",
		},