}
            if (terminateAfter > 0) {
                builder.setTerminateAfter(terminateAfter);
            }
        }

        public void setExplain(boolean explain) {
            this.explain = explain;
        }

        public void setMinScore(float minScore) {
            this.minScore = minScore;
        }

        public void setPreference(String preference) {

        windowsKitLookup.component >> null
        windowsKitLookup.explain(_) >> { args -> args[0].node("fail") }

        when:
        def result = locator.locateComponent(null)

        then:
        !result.available
        result.component == null

        when:
        result.explain(visitor)

        then:
        1 * visitor.node("fail")
    }

        expect:
        def formatter = new TreeFormatter()
        provider.explain(formatter)
        formatter.toString() == "don't know how to build this thing"
    }

    def "tool lookup returns same failure"() {

To provide the missing information to Gradle, you can define <<component_metadata_rules.adoc#sec:component_metadata_rules,component metadata rules>> as explained in the following.

[[sec:align_bom_platform]]
=== Align versions of modules using a published BOM

.A dependency version alignment rule
====

        public boolean isAvailable() {
            return windowsKitSearchResult.isAvailable() || legacySearchResult.isAvailable();
        }

        @Override
        public void explain(DiagnosticsVisitor visitor) {
            windowsKitSearchResult.explain(visitor);
        }
    }

    }

    @Override
    public ActionFuture<ExplainResponse> explain(final ExplainRequest request) {
        return client.explain(request);
    }

    @Override
    public void explain(final ExplainRequest request, final ActionListener<ExplainResponse> listener) {
        client.explain(request, listener);
    }

    @Override
    public ClearScrollRequestBuilder prepareClearScroll() {

            this.candidates = candidates;
        }

        @Override
        public boolean isAvailable() {
            return false;
        }

        @Override
        public void explain(DiagnosticsVisitor visitor) {
            String verb = sourceLanguage == NativeLanguage.ANY ? "build" : "build " + sourceLanguage;

    private static final String NO_MATCHING_VARIANTS_PREFIX = "No matching variant errors are explained in more detail at ";
    private static final String NO_MATCHING_VARIANTS_SECTION = "sub:variant-no-match";
    private static final String NO_VARIANTS_EXIST_PREFIX = "Creating consumable variants is explained in more detail at ";
    private static final String NO_VARIANTS_EXIST_SECTION = "sec:resolvable-consumable-configs";

    }

    def "handles output that cannot be parsed"() {
        def visitor = new TreeFormatter()

        expect:
        def result = output(out)
        !result.available

        when:
        result.explain(visitor)

        then:
        visitor.toString() == "Could not determine SwiftC metadata: swiftc produced unexpected output."

        where:
        out << ["not sure about this", ""]
    }

func (ageFloat) String() string {
	return "age"
}

func TestExplainSQL(t *testing.T) {
	user := *GetUser("explain-sql", Config{})
	dryRunDB := DB.Session(&gorm.Session{DryRun: true})

	stmt := dryRunDB.Model(&user).Where("id = ?", 1).Updates(map[string]interface{}{"age": ageInt(8)}).Statement
	sql := DB.Dialector.Explain(stmt.SQL.String(), stmt.Vars...)
	if !regexp.MustCompile(`.*age.*=8,`).MatchString(sql) {