import java.util.Collection;
import java.util.Collections;
import java.util.Formatter;

public class UnsupportedNotationException extends TypeConversionException {
    private final Object notation;
    private final Collection<String> candidates;

    public UnsupportedNotationException(Object notation) {
        super("Could not convert " + notation);
        this.notation = notation;

        then:
        thrown(UnsupportedNotationException)
    }

    def "with closure of unsupported return value"() {
        def customObj = new DefaultExcludeRule()

        when:
        pathNotationParser.parseNotation({ customObj });

        then:
        thrown(UnsupportedNotationException)
    }

    def "with Provider of String"() {

        when: parser.parseNotation(notation)
        then: thrown(UnsupportedNotationException)
        where: notation << [null, "", ":", "foo", "foo:", "foo:bar:x:2", "  :", ":  ", "  :  "]
    }

    def "reports notation with invalid character for module"() {
        when: parser.parseNotation("group:module${character}")
        then: thrown(UnsupportedNotationException)
        where: character << ["+", "*", "[", "]", "(", ")", ","]
    }

        when: parser.parseNotation(notation)
        then: thrown(UnsupportedNotationException)
        where: notation << [null, "", ":", "foo:", "bar:", "foo:bar:baz", "  :", ":  ", "  :  "]
    }

    def "reports notation with invalid character"() {
        when: parser.parseNotation("group:module${character}")
        then: thrown(UnsupportedNotationException)
        where: character << ["*", "[", "]", "(", ")", ","]
    }

    public static String validate(String part, String notation) {
        if (!GUtil.isTrue(part)) {
            throw new UnsupportedNotationException(notation);
        }
        for (char c : INVALID_SPEC_CHARS) {
            if (part.indexOf(c) != -1) {
                throw new UnsupportedNotationException(notation);
            }
        }
        return part;
    }

    public static String validate(String part) {

    }

    def "does not accept empty Strings"() {
        when:
        parser.parseNotation('')
        then:
        thrown(UnsupportedNotationException)

        when:
        parser.parseNotation(' ')
        then:
        thrown(UnsupportedNotationException)
    }

        given:
        target.parseNotation("bad") >> { throw new UnsupportedNotationException("broken-part") }
        target.describe(!null) >> { DiagnosticsVisitor visitor -> visitor.candidate("format 1"); visitor.candidate("format 2") }

        when:
        parser.parseNotation("bad")

        then:
        UnsupportedNotationException e = thrown()

        then:
        parsed instanceof URI
    }

    @Issue("GRADLE-2072")
    def "parsing unknown types causes UnsupportedNotationException"() {
        when:
        parse(12)

        then:
        UnsupportedNotationException e = thrown()
        e.message == toPlatformLineSeparators("""Cannot convert the provided notation to a File or URI: 12.
The following types/formats are supported:

import org.gradle.internal.typeconversion.NotationConverter;
import org.gradle.internal.typeconversion.TypeConversionException;
import org.gradle.internal.typeconversion.UnsupportedNotationException;

import static org.gradle.api.internal.notations.ModuleNotationValidation.validate;

public class ModuleIdentifierNotationConverter implements NotationConverter<String, ModuleIdentifier> {

    }

    def "does not allow null target"() {
        when:
        details.useTarget(null)

        then:
        thrown(UnsupportedNotationException)

        when:
        details.useTarget(null, SELECTED_BY_RULE)

        then:
        thrown(UnsupportedNotationException)
    }

    def "can specify target module"() {
        when:
        details.useTarget("org:bar:2.0")

        then: