a.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, Category.DOCUMENTATION));
            a.attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named(DocsType.class, "gradle-source-folders"));
        });
        sourcesPath.setCanBeConsumed(false);
        sourcesPath.setCanBeResolved(true);
        sourcesPath.extendsFrom(runtimeClasspath);

        extension.getClasspath().from(runtimeClasspath);

  }

  public void testMutableValues() {
    IntHolder holderA = new IntHolder(1);
    IntHolder holderB = new IntHolder(2);
    Map<String, IntHolder> map = ImmutableSortedMap.of("a", holderA, "b", holderB);
    holderA.value = 3;
    assertTrue(map.entrySet().contains(immutableEntry("a", new IntHolder(3))));

   * it can fail here.
   */
  public void testAnonymous() {
    AtomicReference<String> holder = new AtomicReference<>();
    AtomicInteger deliveries = new AtomicInteger();
    EventBus bus = new EventBus();
    bus.register(
        new Object() {
          @Subscribe
          public void accept(String str) {
            holder.set(str);
            deliveries.incrementAndGet();
          }
        });

                  () -> {
                    holder.count++;
                    return Thread.currentThread().getStackTrace().length;
                  },
                  directExecutor()));
        } else {
          // Otherwise, schedule a task on directExecutor
          unused =
              serializer.submit(
                  () -> {
                    holder.count++;
                    return null;

    ImmutableMultimap.Builder<String, Integer> builder = new Builder<>();
    StringHolder holder = new StringHolder();
    holder.string = "one";
    Entry<String, Integer> entry =
        new AbstractMapEntry<String, Integer>() {
          @Override
          public String getKey() {
            return holder.string;
          }

          @Override
          public Integer getValue() {

 * </ul>
 *
 * To force selection of our fallback strategies we load {@link AggregateFutureState} (and all of
 * {@code com.google.common.util.concurrent}) in degenerate class loaders which make certain
 * platform classes unavailable. Then we construct a test suite so we can run the normal FuturesTest
 * test methods in these degenerate classloaders.
 */

@NullUnmarked
@GwtIncompatible

      }
    }
  }

  /**
   * Iterates through the given loaders until it finds one that will load Finalizer.
   *
   * @return a {@link Class} for {@link Finalizer} or {@code null} if none of the loaders load it
   */
  private static @Nullable Class<?> loadFinalizer(FinalizerLoader... loaders) {
    for (FinalizerLoader loader : loaders) {
      Class<?> finalizer = loader.loadFinalizer();
      if (finalizer != null) {

  @GwtIncompatible // SerializableTester
  public void testSerializationIndirectSelfReference() {
    Multiset<MultisetHolder> multiset = HashMultiset.create();
    MultisetHolder holder = new MultisetHolder(multiset);
    multiset.add(holder, 2);
    Multiset<MultisetHolder> copy = SerializableTester.reserialize(multiset);
    assertEquals(2, copy.size());
    assertThat(copy.iterator().next().member).isSameInstanceAs(copy);
  }

                  () -> {
                    holder.count++;
                    return Thread.currentThread().getStackTrace().length;
                  },
                  directExecutor()));
        } else {
          // Otherwise, schedule a task on directExecutor
          unused =
              serializer.submit(
                  () -> {
                    holder.count++;
                    return null;

 *
 * <p>To force selection of our fallback strategies, we load {@link AbstractFuture} (and all of
 * {@code com.google.common.util.concurrent}) in degenerate class loaders which make certain
 * platform classes unavailable. Then we construct a test suite so we can run the normal
 * AbstractFutureTest test methods in these degenerate classloaders.
 */

@NullUnmarked
@GwtIncompatible