expect:
        pathNotationParser.parseNotation(file) == file.path
    }

    def "with Number"() {
        expect:
        expected == pathNotationParser.parseNotation(input);
        where:
        input << [1, 1.5, -1]
        expected << ["1", "1.5", "-1"]
    }

    def "with Boolean"() {
        expect:
        expected == pathNotationParser.parseNotation(input);
        where:

        expect:
        TestEnum.ENUM1 == parser.parseNotation("ENUM1")
        TestEnum.ENUM1 == parser.parseNotation("enum1")
        TestEnum.ENUM1 == parser.parseNotation("EnUm1")
        TestEnum.ENUM2 == parser.parseNotation("enum2")
        TestEnum.ENUM3 == parser.parseNotation("enum3")
        TestEnum.ENUM_4_1 == parser.parseNotation("enum_4_1")
    }

        when:
        parser.parseNotation([group: 'aGroup', invalidKey1:"invalidValue"]);
        then:
        thrown(MissingPropertyException)
    }

    def "checkValidExcludeRuleMap is true if group or module is defined"() {
        expect:
        parser.parseNotation(WrapUtil.toMap(ExcludeRule.GROUP_KEY, "aGroup"));
        parser.parseNotation(WrapUtil.toMap(ExcludeRule.MODULE_KEY, "aModule"));

        when:
        artifactHandler.someConf("someNotation", "someNotation2")

        then:
        1 * artifactFactoryStub.parseNotation("someNotation") >> artifactDummy1
        1 * artifactFactoryStub.parseNotation("someNotation2") >> artifactDummy2
        1 * artifactsMock.add(artifactDummy1)
        1 * artifactsMock.add(artifactDummy2)

    }

    void failsWhenNoParameters() {
        when:

    }

    def "parse string notation"() {
        expect:
        MemoryAmount.parseNotation(null) == -1
        MemoryAmount.parseNotation('') == -1
        MemoryAmount.parseNotation(' ') == -1
        MemoryAmount.parseNotation('23') == 23
    }

    def "parse invalid string notation"() {
        when:
        MemoryAmount.parseNotation('invalid')

        then:
        thrown IllegalArgumentException
    }

        injectServices(dependencyConstraint);
        return dependencyConstraint;
    }

    @Override
    public DependencyConstraint create(ProjectDependency project) {
        DependencyConstraint dependencyConstraint = dependencyConstraintNotationParser.getProjectDependencyNotationParser().parseNotation(project);
        injectServices(dependencyConstraint);

        when:
        def capability = lenientParser.parseNotation("foo:bar")

        then:
        capability.group == 'foo'
        capability.name == 'bar'
        capability.version == null
    }

    def "invalid string notation #notation is reported for strict parser"() {
        when:
        strictParser.parseNotation(notation)

        then:
        InvalidUserDataException ex = thrown()

        expect:
        parser.parseNotation(12) == "12"
    }

    def "can convert to null value"() {
        given:
        converter.convert(12, _) >> { Object notation, NotationConvertResult result -> result.converted(null) }

        expect:
        parser.parseNotation(12) == null
    }

    def "fails when the notation cannot be converted"() {
        given:

    def "parses module identifier notation"() {
        expect:
        parser.parseNotation("org.gradle:gradle-core") == newId("org.gradle", "gradle-core")
        parser.parseNotation(" foo:bar ") == newId("foo", "bar")
    }

    def "reports invalid notation"() {
        when: parser.parseNotation(notation)
        then: thrown(UnsupportedNotationException)

            resolve(_) >> { Object path -> fileNotationParser.parseNotation(path) }
        }
        parser = new MavenArtifactNotationParserFactory(instantiator, fileResolver, TestFiles.taskDependencyFactory()).create()
    }

    def "directly returns MavenArtifact input"() {
        when:
        MavenArtifact mavenArtifact = Mock()
        def output = parser.parseNotation(mavenArtifact)

        then:
        output == mavenArtifact