* limitations under the License.
 */
package org.gradle.internal.buildevents;

import com.google.common.collect.ImmutableList;
import org.apache.commons.lang.StringUtils;
import org.gradle.BuildResult;
import org.gradle.api.Action;
import org.gradle.api.internal.DocumentationRegistry;
import org.gradle.api.logging.LogLevel;
import org.gradle.api.logging.configuration.LoggingConfiguration;

 * limitations under the License.
 */

package org.gradle.invocation;

import com.google.common.collect.ImmutableList;
import groovy.lang.Closure;
import org.gradle.BuildListener;
import org.gradle.BuildResult;
import org.gradle.StartParameter;
import org.gradle.api.Action;
import org.gradle.api.IsolatedAction;
import org.gradle.api.Project;
import org.gradle.api.ProjectEvaluationListener;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.buildevents

import org.gradle.BuildResult
import org.gradle.StartParameter
import org.gradle.api.GradleException
import org.gradle.api.internal.artifacts.ivyservice.TypedResolveException
import org.gradle.api.invocation.Gradle
import org.gradle.api.logging.LogLevel

    fun `can use Closure only APIs`() {

        withBuildScript(
            """
            gradle.buildFinished(closureOf<org.gradle.BuildResult> {
                println("*" + action + "*") // <- BuildResult.getAction()
            })
            """
        )

        assert(
            build("build").output.contains("*Build*")
        )
    }

    @Test

                }
                void projectsEvaluated(Gradle gradle) {
                    println 'gradle.addListener(ComboListener) from $source'
                }
                void buildFinished(BuildResult result) {
                    println 'gradle.addListener(ComboListener) from $source'
                }
                void beforeEvaluate(Project project) {

            }
            task build2(type: GradleBuild) {
                tasks = ['checkOpId']
                startParameter.projectProperties = [resultFile: 'build2result.txt']
                buildName = 'changed'
            }
        """
        succeeds "build1", "build2"

        then:
        file("build1result.txt").text != file("build2result.txt").text

- Method link:{javadocPath}/org/gradle/api/invocation/Gradle.html#buildFinished-org.gradle.api.Action-[Gradle.buildFinished()]
- Method link:{javadocPath}/org/gradle/BuildListener.html#buildFinished-org.gradle.BuildResult-[BuildListener.buildFinished()]

    void assertFasterThanMaven() {
        builds.groupBy { it.displayName - 'Gradle ' - 'Maven ' }.each { scenario, infos ->
            def gradle = buildResults[infos.find { it.displayName.startsWith 'Gradle ' }]
            def maven = buildResults[infos.find { it.displayName.startsWith 'Maven ' }]
            def baselineVersion = new BaselineVersion("Maven")
            baselineVersion.results.addAll(maven)

    }

    def 'can sort scenarios correctly'() {
        when:
        List buildResults = [
            createLowConfidenceRegressedData(),
            createLowConfidenceImprovedData(),
            createHighConfidenceImprovedData(),
            createHighConfidenceRegressedData(),
            createFailedData()
        ]
        buildResults.sort(DefaultPerformanceExecutionDataProvider.SCENARIO_COMPARATOR)

        then:

  auto build_result = BuildHloFromGraph(*graph, /*use_output_shapes=*/false);
  TF_ASSERT_OK(build_result);
}

TEST(CompileMlirUtil, UsesIncorrectOutputShapesWhenPresent) {
  TF_ASSERT_OK_AND_ASSIGN(auto graph, BuildOpGraphWithOutputShapes());

  auto build_result = BuildHloFromGraph(*graph, /*use_output_shapes=*/true);
  ASSERT_FALSE(build_result.ok());
  EXPECT_THAT(build_result.message(),