TestCoverage(20, TestType.configCache, Os.LINUX, JvmCategory.MIN_VERSION, DEFAULT_LINUX_FUNCTIONAL_TEST_BUCKET_SIZE)
            ),
            docsTests = listOf(
                DocsTestCoverage(Os.LINUX, JvmCategory.MAX_VERSION, listOf(CONFIG_CACHE_ENABLED, CONFIG_CACHE_DISABLED)),
                DocsTestCoverage(Os.WINDOWS, JvmCategory.MAX_VERSION, listOf(CONFIG_CACHE_DISABLED)),

   * @since 21.0
   */
  public static short constrainToRange(short value, short min, short max) {
    checkArgument(min <= max, "min (%s) must be less than or equal to max (%s)", min, max);
    return value < min ? min : value < max ? value : max;
  }

  /**
   * Returns the values from each provided array combined into a single array. For example, {@code

    }
  }

  public void testMax_noArgs() {
    try {
      SignedBytes.max();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMax() {
    assertThat(SignedBytes.max(LEAST)).isEqualTo(LEAST);
    assertThat(SignedBytes.max(GREATEST)).isEqualTo(GREATEST);
    assertThat(SignedBytes.max((byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1))
        .isEqualTo((byte) 127);

          .add(i)
          .add(Long.MAX_VALUE + i)
          .add(Long.MIN_VALUE + i)
          .add(Integer.MIN_VALUE + i)
          .add(Integer.MAX_VALUE + i)
          .add(floatConversionTest + i)
          .add(doubleConversionTest + i);
      BigInteger bigI = BigInteger.valueOf(i);
      testBigIntegersBuilder
          .add(bigI)
          .add(BigInteger.valueOf(Long.MAX_VALUE).add(bigI))

    val headerBlock = literalHeaders(sentHeaders)

    // Write the first headers frame.
    writeMedium(frame, Http2.INITIAL_MAX_FRAME_SIZE)
    frame.writeByte(Http2.TYPE_HEADERS)
    frame.writeByte(FLAG_NONE)
    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.write(headerBlock, Http2.INITIAL_MAX_FRAME_SIZE.toLong())

    // Write the continuation frame, specifying no more frames are expected.

    public String appValue;

    @Size(max = 1000)
    public String defaultLabelValue;

    @Size(max = 1000)
    public String defaultSortValue;

    @Size(max = 10000)
    public String virtualHostValue;

    @Size(max = 10)
    public String appendQueryParameter;

    @Size(max = 10)
    public String loginRequired;

    @Size(max = 10)
    public String resultCollapsed;

    @Size(max = 10)

        EnumSet<DialectVersion> vers = EnumSet.noneOf(DialectVersion.class);
        for ( DialectVersion ver : values() ) {

            if ( min != null && !ver.atLeast(min) ) {
                continue;
            }

            if ( max != null && !ver.atMost(max) ) {
                continue;
            }

            vers.add(ver);
        }

    for (int i = -3; i <= 3; i++) {
      testIntsBuilder
          .add(i)
          .add(force32(Integer.MIN_VALUE + i))
          .add(force32(Integer.MAX_VALUE + i));
      testLongsBuilder
          .add((long) i)
          .add((long) Integer.MIN_VALUE + i)
          .add((long) Integer.MAX_VALUE + i)
          .add((1L << 32) + i);
    }
    TEST_INTS = testIntsBuilder.build();
    TEST_LONGS = testLongsBuilder.build();
  }

static void*
goDummyCallbackThread(void* p)
{
	int i, max;

	max = *(int*)p;
	for(i=0; i<max; i++)
		goDummy();
	return NULL;
}

int
callGoInCThread(int max)
{
	pthread_t thread;

	if (pthread_create(&thread, NULL, goDummyCallbackThread, (void*)(&max)) != 0)
		return -1;
	if (pthread_join(thread, NULL) != 0)
		return -1;

	return max;

        ContiguousSet.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),
        ContiguousSet.create(Range.<Integer>all(), integers()));
    assertEquals(
        ContiguousSet.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),
        ContiguousSet.create(Range.atLeast(Integer.MIN_VALUE), integers()));
    assertEquals(
        ContiguousSet.closed(Integer.MIN_VALUE, Integer.MAX_VALUE),