getConventionMapping().map(property, mapping);
        return this;
    }

    public Task conventionMapping(String property, Closure mapping) {
        getConventionMapping().map(property, mapping);
        return this;
    }

    @Override
    @Internal
    @SuppressWarnings("deprecation")
    public ConventionMapping getConventionMapping() {
        if (conventionMapping == null) {

        assertTrue(bean instanceof IConventionAware);

        IConventionAware conventionAware = (IConventionAware) bean;
        assertThat(conventionAware.getConventionMapping(), instanceOf(ConventionAwareHelper.class));
        conventionAware.getConventionMapping().map("prop", TEST_CLOSURE);
    }

    @Test
    public void mixesInDynamicObjectAwareInterface() throws Exception {
        Bean bean = newInstance(Bean.class);

                ((IConventionAware) component).getConventionMapping().map("libDeployPath", new Callable<String>() {
                    @Override
                    public String call() throws Exception {
                        return "../";
                    }
                });
                ((IConventionAware) component).getConventionMapping().map("sourceDirs", new Callable<Set<File>>() {

    public abstract ConventionTask getTask();

    def "is aware of conventions"() {

        expect:
        task.getConventionMapping() instanceof ConventionAwareHelper

        when:
        ConventionAwareHelper conventionMapping = (ConventionAwareHelper) task.getConventionMapping();

        then:
        conventionMapping.getConvention().is(task.getConvention())
    }

            testSuite.getTargets().all(target -> {
                target.getTestTask().configure(test -> {
                    test.getConventionMapping().map("testClassesDirs", () -> testSuite.getSources().getOutput().getClassesDirs());
                    test.getConventionMapping().map("classpath", () -> testSuite.getSources().getRuntimeClasspath());
                });
            });
        });

            });
            groovydoc.getConventionMapping().map("destinationDir", () -> javaPluginExtension(project).getDocsDir().dir("groovydoc").get().getAsFile());
            groovydoc.getConventionMapping().map("docTitle", () -> extensionOf(project, ReportingExtension.class).getApiDocTitle());

        }
        return extensionContainer;
    }

    @Override
    public ConventionMapping getConventionMapping() {
        if (conventionMapping == null) {
            this.conventionMapping = DeprecationLogger.whileDisabled(() ->
                toType(object, IConventionAware.class).getConventionMapping()
            );
        }
        return conventionMapping;
    }

    public Class<?> getDeclaredType() {

     * manage the mapping for individual properties.
     *
     * @return The mapping. Never returns null.
     */
    ConventionMapping getConventionMapping();

        compileTask.getConventionMapping().map("classpath", () -> classpath);
    }

    public static void configureAnnotationProcessorPath(final SourceSet sourceSet, SourceDirectorySet sourceDirectorySet, CompileOptions options, final Project target) {
        final ConventionMapping conventionMapping = new DslObject(options).getConventionMapping();

            task.getConventionMapping().map("libDirName", new Callable<String>() {
                @Override
                public String call() throws Exception {
                    return DeprecationLogger.whileDisabled(() -> earConvention.getLibDirName());
                }
            });
            task.getConventionMapping().map("deploymentDescriptor", new Callable<DeploymentDescriptor>() {