* @param action The action to execute for each element becomes known.
     */
    <S> void whenElementKnown(Class<S> type, Action<? super S> action);

    /**
     * Registers an action to execute when an element is finalized. The action is only executed for those elements that are required. Fails if any element has already been finalized.
     *
     * @param action The action to execute for each element when finalized.
     */

        (0..10).each { count ->
            assert events.statusMatches("${count} tests? completed(,.*)*")
        }

        and:
        (1..3).each { count ->
            assert events.statusMatches("\\d+ tests? completed, ${count} failed(,.*)?")
        }

        and:
        (1..2).each { count ->
            assert events.statusMatches("\\d+ tests? completed,( \\d failed,)? ${count} skipped")
        }
    }

            });
        } else {
            row.find("td,th").each(function(index){
                $(this).addClass(slices[index]);
            })
        }
    });

    // Add alternate row styles for tables
    $("table").each(function () {
        var counter = 0;
        var rows = $(this).find("tr");
        if (rows.length != 1) {
            rows.each(function () {
                var e = $(this);

    + row.withPanels([
      panels.timeSeries.base('Ztunnel Versions', queries.istioBuild, 'Version number of each running instance'),
      panels.timeSeries.bytes('Memory Usage', queries.memUsage, 'Memory usage of each running instance'),
      panels.timeSeries.base('CPU Usage', queries.cpuUsage, 'CPU usage of each running instance'),
    ]),
    row.new('Network')
    + row.withPanels([

        }
    }
    components {
        all {
            targetPlatform "x86"
        }
    }
    components {
<%
components.each { component ->
    out.println """
        ${component.name}(${component.type}) {
            binaries.all {"""
    component.deps.each { dep ->
        out.println """
                lib project: '${dep.project}', library: '${dep.library}', linkage: '${dep.linkage}'"""
    }

    void setProjects(List<VisualStudioProjectMetadata> projects) {
        projects.each { VisualStudioProjectMetadata project ->
            this.projects[project.file] = project.name
            if (!this.projectConfigurations.containsKey(project.file)) {
                this.projectConfigurations[project.file] = new HashSet<>()
            }
            project.configurations.each { configuration ->

    /**
     * Applies given action for each dependency.
     * An instance of {@link DependencyResult} is passed as parameter to the action.
     *
     * @param action - action that is applied for each dependency
     */
    void allDependencies(Action<? super DependencyResult> action);

    /**
     * Applies given closure for each dependency.

     * @return this
     */
    ManifestMergeSpec from(Object... mergePaths);

    /**
     * Adds an action to be applied to each key-value tuple in a merge operation. If multiple merge paths are specified,
     * the action is called for each key-value tuple of each merge operation. The given action is called with a
     * {@link org.gradle.api.java.archives.ManifestMergeDetails} as its parameter. Actions are executed

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'


<% if (binding.hasVariable("manyPlugins")) { (1..25).findAll { it % 3 == 0 }.each { %>
    apply plugin: "org.gradle.build.gen${it}"
    <% } %>
    <% } %>


<% if (binding.hasVariable("manyScripts")) { (1..30).findAll { it % 5 == 0 }.each { %>
    apply from: "\${rootProject.projectDir.absolutePath}/gradle/script-plugin${it}.gradle"
    <% } %>
    <% } %>

repositories {

            boolean annotatedWithEach = hasAnnotation(annotations, Each.class);
            if (paramIndex == subjectParamIndex) {
                if (annotatedWithEach && hasAnnotation(annotations, Path.class)) {
                    problems.add(ruleDefinition, "Rule subject must not be annotated with both @Path and @Each.");
                }
                result = annotatedWithEach ? DESCENDANTS : SELF;