AttributeDescriber describer
    ) {
        ResolutionCandidateAssessor.AssessedCandidate assessedCandidate = failure.getCandidates().get(0);
        TreeFormatter formatter = new TreeFormatter();
        String candidateName = assessedCandidate.getDisplayName();

import org.gradle.internal.logging.text.TreeFormatter;

public class ToolChainAvailability implements ToolSearchResult {
    private ToolSearchResult reason;

    @Override
    public boolean isAvailable() {
        return reason == null;
    }

    public String getUnavailableMessage() {
        TreeFormatter formatter = new TreeFormatter();
        this.explain(formatter);

import org.gradle.internal.logging.text.TreeFormatter;

public abstract class RejectedVersion {
    private final ModuleComponentIdentifier id;

    public RejectedVersion(ModuleComponentIdentifier id) {
        this.id = id;
    }

    public ModuleComponentIdentifier getId() {
        return id;
    }

    public void describeTo(TreeFormatter builder) {
        builder.node(id.getVersion());
    }

package org.gradle.api.internal.artifacts.verification.verifier;

import org.gradle.internal.logging.text.TreeFormatter;

import java.io.File;

public class MissingChecksums extends AbstractVerificationFailure {
    public MissingChecksums(File file) {
        super(file);
    }

    @Override
    public void explainTo(TreeFormatter formatter) {
        formatter.append("checksum is missing from verification metadata.");
    }

import org.gradle.internal.logging.text.TreeFormatter;

import javax.annotation.Nullable;
import java.io.File;

public interface VerificationFailure {

    File getFilePath();

    @Nullable
    default File getSignatureFile() {
        return null;
    }

    default boolean isFatal() {
        return true;
    }

    default void explainTo(TreeFormatter formatter) {

    }

    }

    public Collection<Conflict> getConflicts() {
        return conflicts;
    }

    private static String buildMessage(Collection<Conflict> conflicts) {
        TreeFormatter formatter = new TreeFormatter();

        String plural = getPluralEnding(conflicts);
        formatter.node("Conflict" + plural + " found for the following module" + plural);
        formatter.startChildren();

    }

    private String buildMultipleMatchingVariantsFailureMsg(AmbiguousResolutionFailure failure, AttributeDescriber describer) {
        TreeFormatter formatter = new TreeFormatter();
        if (failure.getRequestedAttributes().isEmpty()) {
            formatter.node("More than one variant of " + failure.getRequestedName() + " matches the consumer attributes");
        } else {

 * limitations under the License.
 */
package org.gradle.api.internal.artifacts.verification.verifier;

import org.gradle.api.NonNullApi;
import org.gradle.internal.logging.text.TreeFormatter;

import java.io.File;

@NonNullApi
public class InvalidSignature extends AbstractVerificationFailure {
    private final File signatureFile;

        Attribute<?> attribute = e.getAttribute();
        TreeFormatter fmt = new TreeFormatter();
        fmt.node("Cannot select a variant of '" + module.getId());
        fmt.append("' because different values for attribute '");
        fmt.append(attribute.toString());
        fmt.append("' are requested");
        fmt.startChildren();

            register(registration, actionType, parameterObject);
        } catch (VariantTransformConfigurationException e) {
            throw e;
        } catch (Exception e) {
            TreeFormatter formatter = new TreeFormatter();
            formatter.node("Could not register artifact transform ");
            formatter.appendType(actionType);