import spock.lang.Specification

class DefaultProblemsTestReport extends Specification {

    def "using org.gradle core namespace is not allowed on the public API"() {
        def emitter = Mock(ProblemEmitter)

        given:
        def p = new DefaultProblems(emitter)

        when:
        p.forNamespace(DefaultProblemCategory.GRADLE_CORE_NAMESPACE)

        then:
        thrown(IllegalStateException)
    }

        "details"     | { it.details("details") }
    }


    def "unbound builder result with a change and check report"() {
        given:
        def emitter = Mock(ProblemEmitter)
        def problemReporter = new DefaultProblemReporter(emitter, null, org.gradle.internal.operations.CurrentBuildOperationRef.instance(), HashMultimap.create())
        def problem = createTestProblem(Severity.WARNING)

 * Listeners must be sure to remove themselves if they want to only listen for a single build.
 *
 * Listeners are notified in registration order.
 * Started and progress notifications are emitted in registration order,
 * while finished notifications are emitted in reverse registration order.
 *
 * Listeners will not receive progress notifications for events before they have received

## Emitting a problem

Problems can be emitted via an injected `Problems` service.
Here's an example on how to report a problem from a plugin.

====
include::sample[dir="groovy",files="reporters/standard-plugin/src/main/java/reporters/StandardPlugin.java[tags=problems-api-report]"]
====


## Receiving a problem report

        BuildOperationProgressEventEmitter buildOperationProgressEventEmitter,
        ProblemStream problemStream
    ) {
        BuildOperationBasedProblemEmitter emitter = new BuildOperationBasedProblemEmitter(buildOperationProgressEventEmitter);
        return new DefaultProblems(emitter, problemStream, CurrentBuildOperationRef.instance());
    }

    def "emitsBuildOperationsForJUnitTests"() {
        given:
        executer.withRepositoryMirrors()

        when:
        run "test"

        then: "test build operations are emitted in expected hierarchy"
        def rootTestOp = operations.first(ExecuteTestBuildOperationType)
        rootTestOp.details.testDescriptor.name.startsWith("Gradle Test Run :test")

executable: gradle
args: tasks
# Do not fail for deprecation warnings: Project.getConvention emitted by the shadow plugin

  // protobuf instance from the corresponding static data emitted into the
  // object file.
  struct CPPShim {
    // `expression` is a C++ expression that creates an instance of said
    // protocol buffer when executed.
    string expression;

    // `variable_decl` is an "extern C" array declaration that is used in
    // `expression`.  It must be visible wherever `expression` is emitted.
    string variable_decl;
  };

namespace mlir {
namespace TF {

// A function that determines which op to emit next in the case of ties.
// The predecessor (which can be null) is the last op we emitted,
// and op is the candidate we're considering. A larger returned integer
// means the op has a higher chance of being emitted first.
typedef int (*PriorityFunction)(Operation *predecessor, Operation *op);

// A function that returns extra dependencies for each op. These might

(){function t(e){o(this,t),this.resolveOptions(e),this.initSelection()}return a(t,[{key:"resolveOptions",value:function t(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};this.action=e.action,this.container=e.container,this.emitter=e.emitter,this.target=e.target,this.text=e.text,this.trigger=e.trigger,this.selectedText=""}},{key:"initSelection",value:function t(){this.text?this.selectFake():this.target&&this.selectTarget()}},{key:"selectFake",value:function t(){var e=this,n="rtl...