Laura Kassovic <******@****.***> 1701107622 -0800

}

// Configurations to declare dependencies
def aggregate = configurations.create('aggregate') {
    visible = false
    canBeResolved = false
    canBeConsumed = false
}

// Resolvable configuration to resolve the classes of all dependencies
def classesPath = configurations.create('classesPath') {
    visible = false
    canBeConsumed = false
    extendsFrom(aggregate)
    attributes {

}

// Configurations to declare dependencies
val aggregate by configurations.creating {
    isVisible = false
    isCanBeResolved = false
    isCanBeConsumed = false
}

// Resolvable configuration to resolve the classes of all dependencies
val classesPath by configurations.creating {
    isVisible = false
    isCanBeConsumed = false
    extendsFrom(aggregate)
    attributes {

			aggregate{fmt.Errorf("abc"), fmt.Errorf("ghi")},
		},
		{
			aggregate{aggregate{fmt.Errorf("abc")}},
			[]Matcher{},
			aggregate{aggregate{fmt.Errorf("abc")}},
		},
		{
			aggregate{aggregate{fmt.Errorf("abc"), aggregate{fmt.Errorf("def")}}},
			[]Matcher{},
			aggregate{aggregate{fmt.Errorf("abc"), aggregate{fmt.Errorf("def")}}},
		},
		{

		}
	}
	return result
}

// Flatten takes an Aggregate, which may hold other Aggregates in arbitrary
// nesting, and flattens them all into a single Aggregate, recursively.
func Flatten(agg Aggregate) Aggregate {
	result := []error{}
	if agg == nil {
		return nil
	}
	for _, err := range agg.Errors() {
		if a, ok := err.(Aggregate); ok {
			r := Flatten(a)
			if r != nil {

<1> Apply the `jacoco-report-aggregation` plugin
<2> Optional: make JaCoCo aggregate report generation part of the 'check' lifecycle phase

		return e.aggregate.runningSum, err

	case aggFnMin:
		if !e.aggregate.seen {
			// No rows were seen by MIN
			return FromNull(), nil
		}
		return e.aggregate.runningMin, nil

	case aggFnMax:
		if !e.aggregate.seen {
			// No rows were seen by MAX
			return FromNull(), nil
		}
		return e.aggregate.runningMax, nil

	case aggFnSum:
		// TODO: check if returning 0 when no rows were seen

// of the aggregate controller. It does so by
// creating a controller with a pseudo-random
// Options{} and create pseudo-random service
// registries and deleting them.
func FuzzAggregateController(data []byte) int {
	ops := map[int]string{
		0: "AddRegistry",
		1: "DeleteRegistry",
	}
	maxOps := 2
	f := fuzz.NewConsumer(data)
	opts := aggregate.Options{}
	err := f.GenerateStruct(&opts)

        def subject = new GradleApiSpecAggregator(classLoader, DirectInstantiator.INSTANCE)

        when:
        def aggregate = subject.aggregate()

        then:
        aggregate.exportedResourcePrefixes == setOf("META-INF/gradle-plugins")
        aggregate.exportedPackages == setOf("kotlin", "org.gradle", "groovy")
    }

    static class SpecProvider1 implements GradleApiSpecProvider {
        @Override

<2> Define a report of type `AggregateTestReport` which collects test data from unit test suites
<3> Optional: make aggregate test report generation part of the 'check' lifecycle phase