// any pointer.
type uintptr uintptr

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8

// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
type rune = int32

    assertEquals(a, b);
  }

  @SuppressWarnings("TestExceptionChecker") // see comment below
  public <T> void testVariableTypeTokenNotAllowed() {
    /*
     * We'd use assertThrows here, but that causes no exception to be thrown under Java 8,
     * presumably because the ThrowingRunnable lambda triggers some kind of bug in Java 8's
     * reflection implementation.
     */
    try {
      new TypeToken<T>() {};

        for (E e : contents) {
          E unused = interner.intern(e);
        }
        return interner;
      }
    },
    StrongInternerImpl {
      @Override
      public <E> Interner<E> create(Collection<E> contents) {
        Interner<E> interner = Interners.newStrongInterner();
        for (E e : contents) {
          E unused = interner.intern(e);
        }
        return interner;

        /* Samba has a tendency to return referral paths and pathConsumed values
         * in such a way that there can be a slash at the end of the path. This
         * causes problems matching keys in resolve() where an extra slash causes
         * a mismatch. This strips trailing slashes from all keys to eliminate
         * this problem.
         */
        int ki = key.length();

    thread2.join();
    assertEquals(1, runCalled.get());
  }

  public void testAddAfterRun() throws Exception {
    // Run the previous test
    testRunOnPopulatedList();

    // If it passed, then verify an Add will be executed without calling run
    CountDownLatch countDownLatch = new CountDownLatch(1);
    list.add(new MockRunnable(countDownLatch), newCachedThreadPool());

            // Act & Assert
            assertThrows(NullPointerException.class, () -> resp.readBytesWireFormat(null, 0));
        }

        @Test
        @DisplayName("Insufficient buffer causes ArrayIndexOutOfBoundsException")
        void shortBuffer_throwsAIOOBE() {
            // Arrange: length 1 means readInt2 will access index 1 and fail
            byte[] buffer = new byte[1];

    }

    void write(@Nonnull XmlWriterRequest<T> request) throws XmlWriterException;

    /**
     * Simply parse the given xml string.
     *
     * @param xml the input xml string
     * @return the parsed object
     * @throws XmlReaderException if an error occurs during the parsing
     * @see #toXmlString(Object)
     */
    @Nonnull
    default T fromXmlString(@Nonnull String xml) throws XmlReaderException {

    /**
     * Constructs a new CrawlingAccessException with the specified detail message and cause.
     *
     * @param message the detail message
     * @param cause the cause
     */
    public CrawlingAccessException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new CrawlingAccessException with the specified detail message.
     *

   * relying on this, as we have made incompatible changes to serialized forms in the past and
   * expect to do so again, as discussed in https://github.com/google/guava#important-warnings.
   */
  @SuppressWarnings("unused")
  private static final class SerializedForm<V> implements Serializable {
    final ImmutableMap<?, V> map;

    SerializedForm(ImmutableMap<?, V> map) {
      this.map = map;
    }

    thread2.join();
    assertEquals(1, runCalled.get());
  }

  public void testAddAfterRun() throws Exception {
    // Run the previous test
    testRunOnPopulatedList();

    // If it passed, then verify an Add will be executed without calling run
    CountDownLatch countDownLatch = new CountDownLatch(1);
    list.add(new MockRunnable(countDownLatch), newCachedThreadPool());