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

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

import java.io.File;

public class DeletedArtifact extends AbstractVerificationFailure {
    public DeletedArtifact(File file) {
        super(file);

    }

    @Override
    public void explainTo(TreeFormatter formatter) {

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

import java.io.File;

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

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

    @Override
    public void explainTo(TreeFormatter formatter) {

        assert distinguishingAttribute != null;

        AttributeDescriber describer = AttributeDescriberSelector.selectDescriber(failure.getRequestedAttributes(), schema);
        TreeFormatter formatter = new TreeFormatter();
        summarizeAmbiguousVariants(failure, describer, formatter, false);
        buildSpecificAttributeSuggestionMsg(failure, distinguishingAttribute, formatter);
        return formatter.toString();
    }

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

package org.gradle.nativeplatform.toolchain.internal.swift.metadata

import org.gradle.internal.logging.text.TreeFormatter
import org.gradle.platform.base.internal.toolchain.SearchResult
import org.gradle.process.ExecResult
import org.gradle.process.internal.ExecAction
import org.gradle.process.internal.ExecActionFactory

import org.gradle.internal.component.resolution.failure.type.ResolutionFailure;
import org.gradle.internal.logging.text.StyledTextOutput;
import org.gradle.internal.logging.text.TreeFormatter;

import javax.inject.Inject;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

                }
                visitor.endChildren();
            }
        }

        @Override
        public File getTool() {
            TreeFormatter formatter = new TreeFormatter();
            explain(formatter);
            throw new GradleException(formatter.toString());
        }

        @Override
        public boolean isAvailable() {
            return false;

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.verification.RepositoryAwareVerificationFailure;
import org.gradle.internal.component.external.model.ModuleComponentArtifactIdentifier;
import org.gradle.internal.logging.text.TreeFormatter;

import java.nio.file.Path;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * A text report renderer, which is <i>not</i> cumulative and is used to report failures in

import org.gradle.api.artifacts.component.ModuleComponentIdentifier;
import org.gradle.api.internal.attributes.AttributeValue;
import org.gradle.internal.component.model.AttributeMatcher;
import org.gradle.internal.logging.text.TreeFormatter;

import java.util.Comparator;
import java.util.List;

public class RejectedByAttributesVersion extends RejectedVersion {

            return build(explanation);
        }

        private WorkValidationException build(@Nullable String explanation) {
            TreeFormatter formatter = new TreeFormatter();
            formatter.node(summary);
            formatter.startChildren();
            for (String problem : problems) {
                formatter.node(problem);
            }

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

import org.gradle.api.internal.artifacts.verification.model.ChecksumKind;
import org.gradle.internal.logging.text.TreeFormatter;

import java.io.File;

public class ChecksumVerificationFailure extends AbstractVerificationFailure {

    private final ChecksumKind kind;
    private final String expected;
    private final String actual;