* 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

        executer.withArgument('--stacktrace')

        when:
        fails()

        then:
        assertCauseWithStacktrace('show stacktrace was ALWAYS')
    }

    def "emits actionable message when wrong configuration is used"() {
        setup:
        executer.requireDaemon().requireIsolatedDaemons()
        file('gradle.properties') << 'org.gradle.logging.stacktrace=suppress'

        when:

                }
            }
        """.stripIndent()

        expect:
        succeeds("test", "verifyTestOptions", "--warn")
    }

    def "setForkEvery null emits deprecation warning"() {
        given:
        buildFile << """
            tasks.withType(Test).configureEach {
                forkEvery = null
            }
        """

        when:

// 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

    ValuesConstraintSet& constraints, bool resolve = false,
    bool emit_remarks = false);

// Emits constraints remarks for all operations that use constrained values.
void EmitValueConstraintsRemarks(const ValuesConstraintSet& constraints);

// Emits constraints remarks for function inputs that are in the constraints
// set (entry block arguments have constraints).

// Create a test pass for the above with a "fake" session, for lit testing.
std::unique_ptr<OperationPass<ModuleOp>>
CreateInitializeVariablesInSessionInitializerTestPass();

// Create a test pass that emits remarks for each analysis result for resources.
// This pass is only used for lit testing.
std::unique_ptr<OperationPass<ModuleOp>> CreateResourceAnalyzerTestPass();

#define GEN_PASS_REGISTRATION

	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  """

    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    abstract boolean isEmitsTestClassOperations()
    abstract void writeTestSources()

    def "emits build operations for junit tests"() {
        given:
        buildFile << """
            apply plugin: 'java'
            repositories { mavenCentral() }
            dependencies {