import org.gradle.platform.base.internal.VariantAspect;
import org.gradle.reporting.ReportRenderer;
import org.gradle.util.internal.GUtil;

import java.util.Map;
import java.util.TreeMap;

// TODO - bust up this hierarchy and compose using interfaces instead
public abstract class AbstractBinaryRenderer<T extends BinarySpec> extends ReportRenderer<BinarySpec, TextReportBuilder> {
    private final ModelSchemaStore schemaStore;

            "",
            "buildscript { $repositoriesBlock }"
        )
    }

    def "sourcePath includes kotlin-stdlib sources resolved against project hierarchy"() {

        expect:
        assertSourcePathIncludesKotlinStdlibSourcesGiven(
            "buildscript { $repositoriesBlock }",
            ""
        )
    }

            case INSTRUMENTATION_MARKER:
                // We don't need to do anything with the marker file
                return;
            case TYPE_HIERARCHY_ANALYSIS_DATA:
                // Type hierarchy analysis should never be an input to this transform
            default:
                throw new IllegalStateException("Unexpected input type: " + inputType);
        }
    }

    precisely control parts of the extension and dependencies to expose in the API class loader.
    Maven uses Plexus Classworlds to build the class loader hierarchy, therefore some concepts used in this extensions
    stem from Plexus Classworlds originally.
    <p><i>Notice:</i> this documentation is generated from a Modello model but the code executed is not generated

			name.EgressComponentName,
		},
		name.IstioBaseComponentName: {
			name.PilotComponentName,
		},
		name.CNIComponentName: {
			name.ZtunnelComponentName,
		},
	}

	// InstallTree is a top down hierarchy tree of dependencies where children must wait for the parent to complete
	// before starting installation.
	InstallTree = make(ComponentTree)
)

        then:
        eclipseModel.projectNatures.collect { it.id } == ['nature.a', 'nature.b']
    }

    def "nature list independent from project hierarchy"() {
        setup:
        project.eclipse.project.natures = ['nature.for.root']
        child1.eclipse.project.natures = ['nature.for.child1']
        child2.eclipse.project.natures = ['nature.for.child2']

        when:
        loader.load(settings, gradle)

        then:
        1 * target.load(settings, gradle)
        0 * target._
    }

    def "sets project properties on each project in hierarchy"() {
        given:
        2 * gradleProperties.mergeProperties([:]) >> [prop: 'value']

        when:
        loader.load(settings, gradle)

        then:
        1 * rootProperties.set('prop', 'value')

        when:
        def op = ops.start("compile", null, new OperationIdentifier(1), null)

        then:
        op.parent == null
        op.operationId.id == 1L
    }

    def "maintains operation hierarchy"() {
        when:
        def op1 = ops.start("compile", null, new OperationIdentifier(1), null)
        def op2 = ops.start("resolve", null, new OperationIdentifier(2), new OperationIdentifier(1))

        then:

     *
     * A path is contained in the set if it or one of its ancestors has
     * been added to the set.
     */
    public abstract boolean contains(String path);

    /**
     * Whether this hierarchy is empty, i.e. contains no directories.
     */
    public abstract boolean isEmpty();

    /**

    /**
     * Finds the parent symbol of the given [KaSymbol] by traversing back up the symbol hierarchy a certain number of steps,
     * or until the containing class or object symbol is found.
     *
     * @param symbol The [KaSymbol] whose parent symbol needs to be found.
     * @param goBackSteps The number of steps to go back up the symbol hierarchy.
     * @param selectedFqName The fully qualified name of the selected package.