settingsFile << """
            rootProject.name = 'root'
            $includeFunction $projectNamesCommaSeparated
        """

        // The failure here emits a stacktrace because it's at compilation time
        executer.withStackTraceChecksDisabled()

        expect:
        def result = fails("projects")

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package raw

import (
	"fmt"
	"io"

	"internal/trace/version"
)

// TextWriter emits the text format of a trace.
type TextWriter struct {
	w io.Writer
	v version.Version
}

// NewTextWriter creates a new write for the trace text format.

                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()

import java.util.Collections;

/**
 * An {@link AbstractRoleBasedConfigurationCreationRequest} that does not provide any additional contextual
 * information about the request, and emits generic error messages.
 */
public final class NoContextRoleBasedConfigurationCreationRequest extends AbstractRoleBasedConfigurationCreationRequest {

}

const (
	Separator = '/'
)

// String returns the general purpose string representation
func (n NamespacedName) String() string {
	return n.Namespace + string(Separator) + n.Name
}

// MarshalLog emits a struct containing required key/value pair
func (n NamespacedName) MarshalLog() interface{} {
	return struct {
		Name      string `json:"name"`
		Namespace string `json:"namespace,omitempty"`
	}{
		Name:      n.Name,

    void afterBuild() {
        afterExecute*.execute(executer)
    }

    def setup() {
        executer.withRepositoryMirrors()
    }

    def "emits test operations for continuous builds"() {
        given:
        resources.maybeCopy('TestExecutionBuildOperationsIntegrationTest/emitsBuildOperationsForJUnitTests')
        succeeds("test")

        when:

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:

    // This shouldn't happen, returning an error instead of asserting so it
    // doesn't go unnoticed if it ever happens.
    target_op.emitError("no path to target op found, cannot emit warnings");
    return;
  }

  // Emit warnings for path.
  int node_idx = 0;
  for (auto iter = path.rbegin(); iter != path.rend(); ++iter) {
    Operation* op = *iter;
    std::string pos_str;
    if (node_idx == 0) {