}
        return Optional.of(new DefaultPackaging(id, type, getPlugins(lifecycleMapping)));
    }

    private Map<String, PluginContainer> getPlugins(LifecycleMapping lifecycleMapping) {
        Map<String, PluginContainer> lfs = new HashMap<>();
        lifecycleMapping.getLifecycles().forEach((id, lifecycle) -> {
            Map<String, Plugin> plugins = new HashMap<>();
            lifecycle

    private boolean dryRun;

    @Inject
    public PruneChangelogsTask(Project project, ObjectFactory objectFactory, ExecOperations execOperations) {
        changelogs = objectFactory.fileCollection();
        gitWrapper = new GitWrapper(execOperations);
        rootDir = project.getRootDir().toPath();
    }

    @Internal
    public FileCollection getChangelogs() {
        return changelogs;
    }

* **Proper nouns and quotes**: Names of organizations, products, or quoted text that use different conventions

## Consequences

### Positive Consequences

* **Improved consistency**: The codebase has a uniform language standard
* **Easier onboarding**: New contributors have clear guidance on which spelling to use

)

// BytePoolCap implements a leaky pool of []byte in the form of a bounded channel.
type BytePoolCap struct {
	c    chan []byte
	w    int
	wcap int
}

// NewBytePoolCap creates a new BytePool bounded to the given maxSize, with new
// byte arrays sized based on width.
func NewBytePoolCap(maxSize uint64, width int, capwidth int) (bp *BytePoolCap) {
	if capwidth <= 0 {
		panic("total buffer capacity must be provided")
	}

 */
@GwtCompatible
public abstract class AbstractSequentialIterator<T> extends UnmodifiableIterator<T> {
  private @Nullable T nextOrNull;

  /**
   * Creates a new iterator with the given first element, or, if {@code firstOrNull} is null,
   * creates a new empty iterator.
   */
  protected AbstractSequentialIterator(@Nullable T firstOrNull) {
    this.nextOrNull = firstOrNull;
  }

  /**

    private final List<Problem> problems;

    /**
     * Creates a new exception with the specified problems.
     *
     * @param problems The problems that cause this exception, must not be {@code null}.
     */
    public ToolchainsBuildingException(List<Problem> problems) {
        super(toMessage(problems));

        this.problems = new ArrayList<>();
        if (problems != null) {

    @SuppressWarnings("unchecked")
    public ArrayMap(int initialCapacity) {
        if (initialCapacity <= 0) {
            initialCapacity = INITIAL_CAPACITY;
        }
        mapTable = new Entry[initialCapacity];
        listTable = new Entry[initialCapacity];
        threshold = (int) (initialCapacity * LOAD_FACTOR);
    }

    /**
     * Constructs an instance with the same mappings as the specified {@link Map}.
     *

        TransferListener delegate;
        if (quiet || noTransferProgress || quietCI) {
            delegate = new QuietMavenTransferListener();
        } else if (context.interactive && !logFile) {
            if (context.simplexTransferListener == null) {
                SimplexTransferListener simplex = new SimplexTransferListener(new ConsoleMavenTransferListener(
                        context.invokerRequest.messageBuilderFactory(),

 * @author Hayward Chan
 */
@NullUnmarked
public class ForwardingMultimapTest extends TestCase {

  @SuppressWarnings("rawtypes")
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Multimap.class,
            new Function<Multimap, Multimap<?, ?>>() {
              @Override
              public Multimap<?, ?> apply(Multimap delegate) {
                return wrap((Multimap<?, ?>) delegate);

 * @author Gregory Kick
 */
@NullUnmarked
public class ForwardingTableTest extends TestCase {

  @SuppressWarnings("rawtypes")
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Table.class,
            new Function<Table, Table<?, ?, ?>>() {
              @Override
              public Table<?, ?, ?> apply(Table delegate) {
                return wrap((Table<?, ?, ?>) delegate);