private String message;

    private String reference;

    private List<ExceptionSummary> children;

    public ExceptionSummary(Throwable exception, String message, String reference) {
        this(exception, message, reference, null);
    }

    public ExceptionSummary(Throwable exception, String message, String reference, List<ExceptionSummary> children) {
        this.exception = exception;

@Singleton
public class BuildListCalculator {
    public ProjectBuildList calculateProjectBuilds(MavenSession session, List<TaskSegment> taskSegments) {
        List<ProjectSegment> projectBuilds = new ArrayList<>();

        MavenProject rootProject = session.getTopLevelProject();

        for (TaskSegment taskSegment : taskSegments) {
            List<MavenProject> projects;

            if (taskSegment.isAggregating()) {

    public ExecutionPlanItem(MojoExecution mojoExecution) {
        this.mojoExecution = mojoExecution;
    }

    public static List<ExecutionPlanItem> createExecutionPlanItems(
            MavenProject mavenProject, List<MojoExecution> executions) {
        BuilderCommon.attachToThread(mavenProject);

        List<ExecutionPlanItem> result = new ArrayList<>();
        for (MojoExecution mojoExecution : executions) {

     */
    Optional<Boolean> yes();

    /**
     * Returns the list of encryption goals to be executed.
     * These goals can include operations like "init", "add-server", "delete-server", etc.
     *
     * @return an {@link Optional} containing the list of goals, or empty if not specified
     */
    @Nonnull
    Optional<List<String>> goals();

		t.Fatalf("List() Expected: 10, got %d", len(keys))
	}

	// Delete all
	for _, key := range keys {
		err := store.Del(key)
		if err != nil {
			t.Fatal(err)
		}
	}
	// Re-list
	keys = store.List()
	if len(keys) > 0 || err != nil {
		t.Fatalf("Expected List() to return empty list and no error, got %v err: %v", keys, err)
	}
}

func TestMultiplePutGetRaw(t *testing.T) {
	defer func() {

from typing import Annotated

from fastapi import FastAPI, File, UploadFile

app = FastAPI()


@app.post("/files/")
async def create_file(file: Annotated[bytes, File()]):
    return {"file_size": len(file)}


@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile):

    private DependencyNode root;

    private List<Dependency> dependencies = new ArrayList<>();

    private List<Dependency> resolvedDependencies = new ArrayList<>();

    private List<Dependency> unresolvedDependencies = new ArrayList<>();

    private List<Exception> collectionErrors = new ArrayList<>();

    private Map<Dependency, List<Exception>> resolutionErrors = new IdentityHashMap<>();

    @Override

    }

    @Override
    public boolean isUniqueVersion() {
        return true;
    }

    @Override
    public List<ArtifactRepository> getMirroredRepositories() {
        return mirroredRepositories;
    }

    @Override
    public void setMirroredRepositories(List<ArtifactRepository> mirroredRepositories) {
        if (mirroredRepositories != null) {

     *            be {@code null}.
     * @param request The project building request holding further settings like repository settings, must not be
     *            {@code null}.
     * @return The effective artifact repositories, never {@code null}.
     * @throws InvalidRepositoryException
     */
    List<ArtifactRepository> createArtifactRepositories(

        List<ProjectBuildingResult> results = projectBuilder.build(List.of(pom), true, configuration);
        assertEquals(2, results.size());
        MavenProject p1 = results.get(0).getProject();
        MavenProject p2 = results.get(1).getProject();
        MavenProject parent = p1.getArtifactId().equals("parent") ? p1 : p2;