final TaskProvider<JavaCompile> compileTask = project.getTasks().register(sourceSet.getCompileJavaTaskName(), JavaCompile.class, javaCompile -> {
            ConventionMapping conventionMapping = javaCompile.getConventionMapping();
            conventionMapping.map("classpath", sourceSet::getCompileClasspath);

            JvmPluginsHelper.configureAnnotationProcessorPath(sourceSet, javaSource, javaCompile.getOptions(), project);

                @TaskAction
                public void runAction0() {}
            }
        """
        buildFile << """
            task myTask(type: MyTask) {
                conventionMapping.someProperty = {"Foo"}
            }
        """

        expect:
        for(int i = 0; i < 35; i++) {
            myTask.text = myTask.text.replace("runAction$i", "runAction${i + 1}")

                    } ?: fieldValue
            }
        }

    private
    fun getConventionValue(bean: Any, field: Field, fieldValue: Any?) =
        bean.uncheckedCast<IConventionAware>()
            .conventionMapping
            .getConventionValue<Any?>(fieldValue, field.name, false)

    private
    fun Field.debugFrameName() =
        "${declaringClass.typeName}.$name"

    private

import com.google.common.collect.Lists;
import org.gradle.api.Action;
import org.gradle.api.JavaVersion;
import org.gradle.api.Project;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.internal.ConventionMapping;
import org.gradle.api.internal.IConventionAware;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.plugins.JavaPluginExtension;
import org.gradle.api.plugins.WarPlugin;

        ConventionMapping conventionMapping = new DslObject(bean).getConventionMapping();
        conventionMapping.map("prop", new Callable<String>() {
            public String call() {
                return "conventionValue";
            }
        });
        conventionMapping.map("number", new Callable<Integer>() {
            public Integer call() {

                @TaskAction
                void doIt() {
                    assert archiveFileName.get() == "something"
                }
            }

            task myTask(type: MyTask) {
                conventionMapping('archiveName') { 'not something' }
                archiveFileName.convention("something")
            }
        """

        expect: 'convention mapping is ignored'
        configurationCacheRun 'myTask'

        @Override
        public void mixInConventionAware() {
            // GENERATE private ConventionMapping mapping
            addField(ACC_PRIVATE | ACC_TRANSIENT, MAPPING_FIELD, CONVENTION_MAPPING_FIELD_DESCRIPTOR);
            hasMappingField = true;
            // END

            // GENERATE public ConventionMapping getConventionMapping() {
            //     if (mapping == null) {

                @Input
                def String prop
                void doStuff(Action<Task> action) { action.execute(this) }
            }
            tasks.withType(GroovyTask) { conventionMapping.prop = { '[default]' } }
            task test(type: GroovyTask)
            assert test.prop == '[default]'
            test {
                description 'does something'
                prop 'value'

        def readOnlyBean = create(HasReadOnlyProperty, Describables.of("<display name>"))
        def readOnlyBeanWithMapping = create(HasReadOnlyProperty, Describables.of("<display name>"))
        readOnlyBeanWithMapping.conventionMapping.map("other") { "ignore" }
        def finalBeanWithOverloads = create(HasReadOnlyFinalBooleanPropertyWithOverloads, Describables.of("<display name>"))

                        }
                    }
                    hasExtensionAwareImplementation = true;
                    return true;
                }
                if (property.getName().equals("conventionMapping") || property.getName().equals("convention")) {
                    return true;
                }
            }

            return false;
        }

        @Override