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

func ConvertMapToValuesForCreate(stmt *gorm.Statement, mapValue map[string]interface{}) (values clause.Values) {
	values.Columns = make([]clause.Column, 0, len(mapValue))
	selectColumns, restricted := stmt.SelectAndOmitColumns(true, false)

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

	for _, k := range keys {
		value := mapValue[k]
		if stmt.Schema != nil {

            request.setPadding((byte) 0xFF);
            request.setReadFlags((byte) 0xFF);
            request.setReadLength(Integer.MAX_VALUE);
            request.setOffset(Long.MAX_VALUE);
            request.setMinimumCount(Integer.MAX_VALUE);
            request.setRemainingBytes(Integer.MAX_VALUE);

            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);

        void shouldHandleMaximumLongValues() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(Long.MAX_VALUE, Long.MAX_VALUE);

            // When & Then
            assertEquals(Long.MAX_VALUE, allocInfo.getCapacity());
            assertEquals(Long.MAX_VALUE, allocInfo.getFree());
        }

        @Test
        @DisplayName("Should handle minimum long values")

     */
    @Size(max = 10)
    public String webApiJson;

    /**
     * Application-specific value for custom configurations.
     * This field can be used to store custom application settings.
     */
    @Size(max = 10000)
    public String appValue;

    /**
     * Default label value to use when no specific label is selected.
     * This affects which documents are included in search results by default.

    longValues.addAll(Iterables.transform(POSITIVE_INTEGER_CANDIDATES, TO_LONG));
    // Add boundary values manually to avoid over/under flow (this covers 2^N for 31 and 63).
    longValues.add(Integer.MAX_VALUE + 1L, Long.MAX_VALUE - 1L, Long.MAX_VALUE);

    // Now add values near 2^N for lots of values of N.
    for (int exponent : asList(32, 33, 39, 40, 41, 47, 48, 49, 55, 56, 57)) {
      long x = 1L << exponent;

      if (value instanceof CharSequence) {
        return ((CharSequence) value).length() == 0;
      } else if (value instanceof Collection) {
        return ((Collection<?>) value).isEmpty();
      } else if (value instanceof Map) {
        return ((Map<?, ?>) value).isEmpty();
      } else if (value instanceof java.util.Optional) {
        return !((java.util.Optional<?>) value).isPresent();
      } else if (value instanceof OptionalInt) {

        searchRenderData.setAllRecordCount(Long.MAX_VALUE);
        searchRenderData.setCurrentStartRecordNumber(Long.MAX_VALUE - 10);
        searchRenderData.setCurrentEndRecordNumber(Long.MAX_VALUE);
        searchRenderData.setPageSize(Integer.MAX_VALUE);
        searchRenderData.setAllPageCount(Integer.MAX_VALUE);
        searchRenderData.setCurrentPageNumber(Integer.MAX_VALUE);

      }
    }
  }

  public void testSaturatedAbs() {
    assertEquals(Long.MAX_VALUE, LongMath.saturatedAbs(Long.MIN_VALUE));
    assertEquals(Long.MAX_VALUE, LongMath.saturatedAbs(Long.MAX_VALUE));
    assertEquals(Long.MAX_VALUE, LongMath.saturatedAbs(-Long.MAX_VALUE));
    assertEquals(0, LongMath.saturatedAbs(0));
    assertEquals(1, LongMath.saturatedAbs(1));

      int n = rand.nextInt(Integer.MAX_VALUE);
      assertEquals(LongMath.isPrime(n), IntMath.isPrime(n));
    }
  }

  public void testSaturatedAbs() {
    assertEquals(Integer.MAX_VALUE, IntMath.saturatedAbs(Integer.MIN_VALUE));
    assertEquals(Integer.MAX_VALUE, IntMath.saturatedAbs(Integer.MAX_VALUE));
    assertEquals(Integer.MAX_VALUE, IntMath.saturatedAbs(-Integer.MAX_VALUE));
    assertEquals(0, IntMath.saturatedAbs(0));