} else {
          fail(
              rootLocaleFormat(
                  "Feature enum %s contains a class named "
                      + "'Require' but it is not an annotation.",
                  featureEnumClass));
        }
        return;
      }
    }
    fail(
        rootLocaleFormat(
            "Feature enum %s should contain an annotation named 'Require'.", featureEnumClass));
  }

        int num = random.nextInt(10);
        for (int i = 0; i < num; i++) {
          list.add(counter.getAndIncrement());
        }
        builder.addAll(list);
      }
    },
    ADD_ITERABLE {
      @Override
      void doIt(ImmutableIntArray.Builder builder, AtomicInteger counter) {
        List<Integer> list = new ArrayList<>();
        int num = random.nextInt(10);

import java.util.ListIterator;
import java.util.Set;

/**
 * A method supported by implementations of the {@link Iterator} or {@link ListIterator} interface.
 *
 * <p>This enum is GWT compatible.
 *
 * @author Chris Povirk
 */
@GwtCompatible
public enum IteratorFeature {
  /** Support for {@link Iterator#remove()}. */
  SUPPORTS_REMOVE,
  /**
   * Support for {@link ListIterator#add(Object)}; ignored for plain {@link Iterator}

        wildcardBoundUsesImplicitlyRecursiveBoundedWildcard(UseList<? extends List<Enum<?>>> arg) {
      return isSubtype(arg);
    }

    @TestSubtype(suppressGetSupertype = true, suppressGetSubtype = true)
    public UseList<? extends List<Enum<? extends Enum<?>>>>
        wildcardBoundHasImplicitBoundAtsInvariantPosition(UseList<? extends List<Enum<?>>> arg) {
      return isSubtype(arg);

      enumConstantCache = new WeakHashMap<>();

  private static <T extends Enum<T>> Map<String, WeakReference<? extends Enum<?>>> populateCache(
      Class<T> enumClass) {
    Map<String, WeakReference<? extends Enum<?>>> result = new HashMap<>();
    for (T enumInstance : EnumSet.allOf(enumClass)) {
      result.put(enumInstance.name(), new WeakReference<Enum<?>>(enumInstance));

    },
    ADD_COLLECTION {
      @Override
      void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
        List<Double> list = new ArrayList<>();
        double num = random.nextInt(10);
        for (int i = 0; i < num; i++) {
          list.add((double) counter.getAndIncrement());
        }
        builder.addAll(list);
      }
    },
    ADD_ITERABLE {
      @Override

 * limitations under the License.
 */

package common

enum class Arch(
    val suffix: String,
    val nameOnLinuxWindows: String,
    val nameOnMac: String,
) {
    AMD64("64bit", "amd64", "x86_64"),
    AARCH64("aarch64", "aarch64", "aarch64"),
    ;

    fun asName() = name.lowercase().toCapitalized()
}

enum class Os(
    val agentRequirement: String,
    val androidHome: String,

    },
    ADD_COLLECTION {
      @Override
      void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
        List<Double> list = new ArrayList<>();
        double num = random.nextInt(10);
        for (int i = 0; i < num; i++) {
          list.add((double) counter.getAndIncrement());
        }
        builder.addAll(list);
      }
    },
    ADD_ITERABLE {
      @Override

 */
// These benchmarks allocate a lot of data so use a large heap
@VmOptions({"-Xms12g", "-Xmx12g", "-d64"})
@NullUnmarked
public class CharStreamsCopyBenchmark {
  enum CopyStrategy {
    OLD {
      @Override
      long copy(Readable from, Appendable to) throws IOException {
        CharBuffer buf = CharStreams.createBuffer();
        long total = 0;

import org.junit.jupiter.api.Test;

/**
 * Tests for the {@link ResolverType} enum.
 * This class ensures that the enum constants are defined as expected.
 */
class ResolverTypeTest {

    /**
     * Tests that all expected enum constants exist.
     */
    @Test
    void testEnumConstants() {
        // Verify that each enum constant exists and can be referenced