import org.gradle.model.internal.core.ModelPath
import org.gradle.model.internal.core.ModelReference
import org.gradle.model.internal.report.unbound.UnboundRule
import org.gradle.model.internal.report.unbound.UnboundRuleInput
import org.gradle.model.internal.report.unbound.UnboundRulesReporter
import org.gradle.util.internal.ConfigureUtil

import static org.gradle.util.internal.TextUtil.normaliseLineSeparators

import org.gradle.model.internal.report.unbound.UnboundRule;
import org.gradle.model.internal.report.unbound.UnboundRulesReporter;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.List;

public class UnboundModelRulesException extends GradleException {

    private static final String MESSAGE = "The following model rules could not be applied due to unbound inputs and/or subjects:";

import org.gradle.internal.deprecation.Documentation
import org.gradle.internal.operations.OperationIdentifier
import spock.lang.Specification

class DefaultProblemTest extends Specification {
    def "unbound builder result is equal to original"() {
        def additionalData = Mock(AdditionalData)
        def problem = createTestProblem(severity, additionalData)

        def newProblem = problem.toBuilder().build()

            include ":used", ":unused"
        """

        file("unused/build.gradle") << """
            class Rules extends RuleSource {
                @Mutate
                void unbound(ModelMap<Task> tasks, String unbound) {
                }
            }

            apply type: Rules
        """

        then:
        succeeds ":used:tasks"
    }

import org.gradle.model.internal.core.ModelNode;
import org.gradle.model.internal.core.ModelPath;
import org.gradle.model.internal.core.ModelReference;
import org.gradle.model.internal.report.unbound.UnboundRule;
import org.gradle.model.internal.report.unbound.UnboundRuleInput;
import org.gradle.util.internal.CollectionUtils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@ThreadSafe

 */

package org.gradle.model.internal.report.unbound

import org.gradle.util.internal.TextUtil
import spock.lang.Specification

class UnboundRulesReporterTest extends Specification {

    def output = new StringWriter()

    def reporter = new UnboundRulesReporter(new PrintWriter(output), "> ")

    def "reports on unbound rules"() {
        when:
        reporter.reportOn([

    }

    def "should not fire for unbound binders"() {
        setup:
        ModelNodeInternal modelNode = new TestNode(registration)
        def executionBinder = Mock(RuleBinder)
        executionBinder.isBound() >> false

        when:
        modelNode.notifyFired(executionBinder)

        then:
        AssertionError e = thrown()
        e.message == 'RuleBinder must be in a bound state'
    }

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

package org.gradle.model.internal.report.unbound;

import com.google.common.base.Joiner;
import javax.annotation.concurrent.NotThreadSafe;

import java.io.PrintWriter;

@NotThreadSafe
public class UnboundRulesReporter {

import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
import org.jetbrains.kotlin.resolve.source.PsiSourceFile
import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource

/**
 * Whether unbound IR symbols should be stubbed instead of linked.
 * This should be enabled if the compiled file could refer to symbols defined in another file of the same module.

    private final String type;
    private final boolean bound;
    private final String description;
    private final ImmutableList<String> suggestedPaths;
    private final String scope;

    public String getPath() {
        return path;
    }

    public String getType() {
        return type;
    }

    public boolean isBound() {
        return bound;
    }