/**
     * Determines whether a stub model should be allowed when the POM is missing or unreadable.
     * A stub model contains only minimal information derived from the project's coordinates.
     *
     * @return true if a stub model should be allowed, false otherwise
     */
    boolean isAllowStubModel();

    /**
     * Determines whether the project builder should recursively build parent/child projects.

                .withTest(tempFile.toFile())
                .ignoreComments()
                .ignoreWhitespace()
                .build();
        assertFalse(diff.hasDifferences(), "XML files should be identical: " + diff.toString());
    }

    @Test
    void transformJarConsumerPom() throws Exception {
        RepositorySystemSession systemSessionMock = Mockito.mock(RepositorySystemSession.class);

          <description>
            Whether Maven should attempt to interact with the user for input.
          </description>
          <type>boolean</type>
          <defaultValue>true</defaultValue>
        </field>
        <field>
          <name>usePluginRegistry</name>
          <version>1.0.0+</version>
          <description>
            Whether Maven should use the {@code plugin-registry.xml} file to manage plugin versions.

    int initialSize = getList().size();
    assertTrue("remove(present) should return true", getList().remove(duplicate));
    assertTrue(
        "After remove(duplicate), a list should still contain the duplicate element",
        getList().contains(duplicate));
    assertFalse(
        "remove(duplicate) should remove the first instance of the "
            + "duplicate element in the list",

## Status

ACCEPTED

## Consequences

* The configuration cache serialization infrastructure should be used for all serialization.
* Existing usages of Serializer outside of this infrastructure should be migrated to use it.
* Existing usages of Java serialization should be migrated to use it.
* It is ok for Serializer to be used as a replacement for Java serialization as a migration step.

import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Explicitly specifies the types that should be used for dependency injection.
 * <p>
 * This annotation allows you to limit which types of a bean should be available
 * for injection. It can be used to prevent unintended automatic binding of implemented
 * interfaces or extended classes.
 * <p>
 * Example usage:

    int index = aValidIndex();
    E initialValue = getList().get(index);
    assertEquals(
        "set(i, x) should return the old element at position i.",
        initialValue,
        getList().set(index, newValue));
    assertEquals("After set(i, x), get(i) should return x", newValue, getList().get(index));
    assertEquals("set() should not change the size of a list.", getNumElements(), getList().size());
  }

  @ListFeature.Require(SUPPORTS_SET)

Maven Modifications

* DefaultPluginManager

  s/getMojoConfiguration()/getConfiguration()/g

  That should re-enable usage of mojo configuration. Ideally, we won't need any
  of the code that references this method, since the container should provide
  some way of recontextualizing the mojo, and all we would need to do is inject
  POM configuration via the lookup method or something.

* PluginDescriptorBuilder

   */
  /*
   * Just as Converter could implement `Function<@Nullable A, @Nullable B>` instead of `Function<A,
   * B>`, convertAll could accept and return iterables with nullable element types. In both cases,
   * we've chosen to instead use a signature that benefits existing users -- and is still safe.
   *
   * For convertAll, I haven't looked as closely at *how* much existing users benefit, so we should

      /*
       * FinalizableReference's class loader was reclaimed. While there's a chance that other
       * finalizable references could be enqueued subsequently (at which point the class loader
       * would be resurrected by virtue of us having a strong reference to it), we should pretty
       * much just shut down and make sure we don't keep it alive any longer than necessary.
       */
      return null;
    }
    try {