private static final int WITNESS_INTERFACE_VERSION = 1;

    // RPC connection parameters
    private static final int WITNESS_RPC_PORT = 135;
    private static final int WITNESS_RPC_TIMEOUT_MS = 5000;

    // RPC operation numbers
    private static final int WITNESS_REGISTER = 0;
    private static final int WITNESS_UNREGISTER = 1;
    private static final int WITNESS_ASYNC_NOTIFY = 2;

     * The pipe should be opened read-only.
     */

    public static final int PIPE_TYPE_RDONLY = O_RDONLY;

    /**
     * The pipe should be opened only for writing.
     */

    public static final int PIPE_TYPE_WRONLY = O_WRONLY;

    /**
     * The pipe should be opened for both reading and writing.
     */

    public static final int PIPE_TYPE_RDWR = O_RDWR;

    /**

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

  @GwtIncompatible // BlockingQueue
  public static <E> int drain(
      BlockingQueue<E> q, Collection<? super E> buffer, int numElements, Duration timeout)
      throws InterruptedException {
    return drain(q, buffer, numElements, toNanosSaturated(timeout), NANOSECONDS);
  }

  /**
   * Drains the queue as {@link BlockingQueue#drainTo(Collection, int)}, but if the requested {@code

    assertTrue(sleeper.completed);
  }

  private static class SleepingRunnable implements Runnable {
    final int millis;
    volatile boolean completed;

    SleepingRunnable(int millis) {
      this.millis = millis;
    }

    @Override
    public void run() {
      try {
        Thread.sleep(millis);

	if err := feedTokens(1); err != nil {
		return nil, err
	}
	numEntries, err := strconv.ParseInt(nextToken(), 10, 0) // Intentionally parse as native int
	if err != nil || numEntries < 0 || int(2*numEntries) < int(numEntries) {
		return nil, ErrHeader
	}

	// Parse for all member entries.
	// numEntries is trusted after this since feedTokens limits the number of

        assertNotNull(testValue);
        assertEquals("test", testValue);
    }

    // Additional test for coverage
    @Test
    public void test_additionalCoverage() {
        int a = 5;
        int b = 10;
        int sum = a + b;
        assertEquals(15, sum);

        String str = "Hello";
        assertTrue(str.startsWith("H"));
        assertTrue(str.endsWith("o"));
        assertEquals(5, str.length());

        assertNotNull(testValue);
        assertEquals("test", testValue);
    }

    // Additional test for coverage
    @Test
    public void test_additionalCoverage() {
        int a = 5;
        int b = 10;
        int sum = a + b;
        assertEquals(15, sum);

        String str = "Hello";
        assertTrue(str.startsWith("H"));
        assertTrue(str.endsWith("o"));
        assertEquals(5, str.length());

        assertNotNull(testValue);
        assertEquals("test", testValue);
    }

    // Additional test for coverage
    @Test
    public void test_additionalCoverage() {
        int a = 5;
        int b = 10;
        int sum = a + b;
        assertEquals(15, sum);

        String str = "Hello";
        assertTrue(str.startsWith("H"));
        assertTrue(str.endsWith("o"));
        assertEquals(5, str.length());