@TaskAction
                void customAction() {
                    println("Hello from custom task")
                    println("- mapValues['alma'] = \${mapValues['alma']}")
                }
            }
        """

        expect:
        succeeds(":compileGroovy")
    }

    def "can compile Kotlin code against public API"() {

        when:
        modelMap.create("alma")

        then:
        1 * instantiator.create("alma", SomeType) >>  { new SomeType(name: "alma") }
        1 * backingCollection.add({ item -> item.name == "alma" })
        1 * backingCollection.iterator() >> { Collections.emptyIterator() }
        0 * _
    }

    def "cannot register output file with same property name"() {
        outputs.file("a").withPropertyName("alma")
        outputs.file("b").withPropertyName("alma")
        when:
        outputs.fileProperties
        then:
        def ex = thrown IllegalArgumentException
        ex.message == "Multiple output file properties with name 'alma'"
    }

    def "can register unnamed output files"() {
        when:

                    return Collections.singletonMap("alma", new Options());
                }

                @Nested
                public Iterable<Map<String, Iterable<Options>>> getIterableMappedOptions() {
                    return Arrays.asList(Collections.singletonMap("alma", Arrays.asList(new Options())));
                }

                @Nested

        inputs.files.files == files(inputFilePath)
    }

    def "cannot register input file with same property name"() {
        inputs.file("a").withPropertyName("alma")
        inputs.file("b").withPropertyName("alma")
        def visitor = new GetInputFilesVisitor(task.toString(), fileCollectionFactory)
        when:
        TaskPropertyUtils.visitProperties(walker, task, visitor)
        visitor.getFileProperties()

import spock.lang.Specification

class TrieTest extends Specification {

    def "empty trie is empty"() {
        def empty = Trie.from()
        expect:
        !empty.find("")
        !empty.find("alma")
    }

    def "can find exact match"() {
        def trie = Trie.from("aaa", "bbb")
        expect:
        trie.find("aaa")
        trie.find("bbb")
        !trie.find("ccc")
    }

            task producer {
                outputs.cacheIf { true }
                outputs.file("build/outputs/producer.txt")
                doLast {
                    file("build/outputs/producer.txt").text = "alma"
                }
            }

            task consumer {
                dependsOn producer
                outputs.cacheIf { true }
                inputs.file("build/outputs/producer.txt")

                    return Collections.singletonMap("alma", new Options());
                }

                @Nested
                public Iterable<Map<String, Iterable<Options>>> getIterableMappedOptions() {
                    return Arrays.asList(Collections.singletonMap("alma", Arrays.asList(new Options())));
                }

                @Nested

     *     some/path     == some/other
     *     some1/path    <  some2/other
     *     some/path     >  some1/other
     *     some/same     == some/same/more
     *     some/one/alma == some/two/bela
     *     a/some        <  b/other
     *
     * @return 0 if the two paths have a common prefix, and the comparison of the first segment of each path if not.
     */

    def "local load does not stores to local"() {
        given:
        1 * local.loadLocally(key, _) >> { BuildCacheKey key, Consumer<File> action ->
            def file = tmpDir.file("file")
            file.text = "alma"
            action.accept(file)
        }

        when:
        controller.load(key, cacheableEntity)

        then:
        0 * local.storeLocally(key, _)
    }