}
            }
        }

        private void mergePluginContainerPlugins(PluginContainer target, PluginContainer source) {
            List<Plugin> src = source.getPlugins();
            if (!src.isEmpty()) {
                List<Plugin> tgt = target.getPlugins();

                Map<Object, Plugin> managedPlugins = new LinkedHashMap<>(src.size() * 2);

        project.addAttachedArtifact(artifact);
    }

    @Override
    public void addResource(
            MavenProject project, String resourceDirectory, List<String> includes, List<String> excludes) {
        Resource resource = new Resource();
        resource.setDirectory(resourceDirectory);
        resource.setIncludes(includes);
        resource.setExcludes(excludes);

     * @param requirements Key-value pairs specifying toolchain requirements (e.g., "version": "11")
     * @return List of matching toolchains, never null
     * @throws ToolchainManagerException if toolchain retrieval fails
     */
    @Nonnull
    List<Toolchain> getToolchains(@Nonnull Session session, String type, Map<String, String> requirements);

    /**

    public Settings effectiveSettings;
    public PersistedToolchains effectiveToolchains;

    public final List<AutoCloseable> closeables = new ArrayList<>();

    @Override
    public void close() throws InvokerException {
        List<Exception> causes = null;
        List<AutoCloseable> cs = new ArrayList<>(closeables);
        Collections.reverse(cs);
        for (AutoCloseable c : cs) {

    sponsorEntity: SponsorEntity
    tier: Tier


class SponsorshipAsMaintainerEdge(BaseModel):
    cursor: str
    node: SponsorshipAsMaintainerNode


class SponsorshipAsMaintainer(BaseModel):
    edges: list[SponsorshipAsMaintainerEdge]


class SponsorsUser(BaseModel):
    sponsorshipsAsMaintainer: SponsorshipAsMaintainer


class SponsorsResponseData(BaseModel):
    user: SponsorsUser

    }

    /**
     * Checks if the list is empty.
     *
     * @return true if the list is empty, false otherwise
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * Checks if an element is contained in the list.
     *
     * @param element the element
     * @return true if the element is contained in the list, false otherwise
     */

        return multimap.asMap().entrySet().iterator();
      }

      @Override
      protected void verify(List<Entry<String, Collection<Integer>>> elements) {
        assertEquals(new HashSet<>(elements), multimap.asMap().entrySet());
      }
    }.test();
  }

  public void testKeysSpliterator() {
    List<Entry<String, Integer>> expectedEntries =
        asList(
            immutableEntry("foo", 2),

        // Given
        String hint = "hint";
        Throwable error = new Exception();
        when(mockContext.renewCredentials(hint, error)).thenReturn(true);

        // When
        boolean renewed = mockContext.renewCredentials(hint, error);

        // Then
        assertTrue(renewed);
        verify(mockContext).renewCredentials(hint, error);
    }

```

### List all batch jobs
```
mc batch list alias/
ID                      TYPE            USER            STARTED
E24HH4nNMcgY5taynaPfxu  replicate       minioadmin      1 minute ago
```

### List all 'replicate' batch jobs
```
mc batch list alias/ --type replicate
ID                      TYPE            USER            STARTED

import org.apache.maven.project.Graph.Vertex;

/**
 * ProjectSorter
 */
public class ProjectSorter {
    private Graph graph;

    private List<MavenProject> sortedProjects;

    private Map<String, MavenProject> projectMap;

    /**
     * Sort a list of projects.
     * <ul>
     * <li>collect all the vertices for the projects that we want to build.</li>