progress[0].details.message.startsWith("configure")
            }
        }
    }

    @ToBeFixedForIsolatedProjects(because = "Investigate")
    def "emits registration build ops when tasks not realized"() {
        given:
        stopBeforeTaskGraphCalculation()
        register('foo')

        when:
        runAndFail()

        then:

    @Requires(value = [IntegTestPreconditions.NotEmbeddedExecutor, IntegTestPreconditions.NotNoDaemonExecutor], reason = "Identity cache is off for embedded executor due to file locking issues")
    @LeaksFileHandles
    def "emits origin metadata for skipped transform executions"() {
        settingsFile << """
            include 'producer', 'consumer'
        """

        setupBuildWithColorTransform()

    }

    def "emits deprecation warning when convention mapping is used with Provider"() {
        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Inject abstract ProviderFactory getProviderFactory()

class ConfigurationCacheTaskRealizationBuildOperationIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def buildOperations = new BuildOperationsFixture(executer, testDirectoryProvider)

    def "load after store emits two realization operations with the same id"() {
        buildFile << """
            tasks.register("foo")
        """

        when:
        configurationCacheRun(":foo")
        then:

     * called except from Gradle internal code.
     *
     * <p>This constructor accepts a dummy parameter since we cannot call the constructor without it,
     * as that emits a deprecation warning. In 9.0, we can change the above constructor to protected
     * and remove this constructor.</p>
     *
     * @since 8.9
     */
    @Incubating

// license that can be found in the LICENSE file.

package raw

import (
	"encoding/binary"
	"fmt"
	"io"

	"internal/trace/event"
	"internal/trace/version"
)

// Writer emits the wire format of a trace.
//
// It may not produce a byte-for-byte compatible trace from what is
// produced by the runtime, because it may be missing extra padding

	if r.state == nil {
		r.state = <-r.prev
	}
	return r.state
}

// Warnf emits a warning message to the reporter's error stream,
// without changing its exit code.
func (r *reporter) Warnf(format string, args ...any) {
	fmt.Fprintf(r.getState().err, format, args...)
}

// Write emits a slice to the reporter's output stream.
//
// Any error is returned to the caller, and does not otherwise affect the

            .nagUser();

        rethrowFailure();

        // Disable deprecation, since the lenient configuration method also emits a deprecation warning
        return DeprecationLogger.whileDisabled(() -> configuration.getFirstLevelModuleDependencies(dependencySpec));
    }

    @Override

    def setup() {
        enableProblemsApiCheck()
    }


    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "emits deprecation warnings as build operation progress events with context"() {
        when:
        settingsFile "rootProject.name = 'root'"

        initScript  """

// Returns the builtin op code for the given MLIR operation on success; emits
// error and returns std::nullopt on failure.
std::optional<tflite::BuiltinOperator> GetBuiltinOpCode(Operation *mlir_op);

// Packs the given MLIR operation into a TFLite FlatBuffer operator object.
// Returns the FlatBuffer offset for the operator on success; emits error and
// returns std::nullopt on failure.