* @see org.gradle.api.plugins.ExtensionAware
 */
@Deprecated
public interface HasConvention {
    org.gradle.api.plugins.Convention getConvention();

        conventionAware.map("list1", TestUtil.toClosure("{ convention, object -> [convention, object] }"));
        assertThat(conventionAware.getConventionValue(null, "list1", false), equalTo((Object) toList(conventionAware.getConvention(), testTask)));
    }

    @Test
    public void canMapPropertiesUsingCallable() {

    @SuppressWarnings("deprecation")
    public ConventionMapping getConventionMapping() {
        if (conventionMapping == null) {
            org.gradle.api.plugins.Convention convention = DeprecationLogger.whileDisabled(this::getConvention);
            conventionMapping = new ConventionAwareHelper(this, convention);
        }
        return conventionMapping;
    }

            getBuildDirectory() >> projectDirProperty.fileValue(new File(testRootDir, "build"))
            getProjectDirectory() >> projectDirProperty.fileValue(testRootDir).get()
        }
        getConvention() >> Stub(Convention) {
            findPlugin(_) >> null
        }
        getExtensions() >> Stub(ExtensionContainerInternal) {
            getByType(JavaPluginExtension) >> Mock(JavaPluginExtension)
        }

        DeprecationLogger.whileDisabled(new Runnable() {
            @Override
            @SuppressWarnings("deprecation")
            public void run() {
                project.getConvention().getPlugins().put("projectReports", convention);
            }
        });

        project.getTasks().register(TASK_REPORT, TaskReportTask.class, taskReportTask -> {

        BasePluginConvention convention = project.getObjects().newInstance(org.gradle.api.plugins.internal.DefaultBasePluginConvention.class, baseExtension);
        DeprecationLogger.whileDisabled(() -> {
            project.getConvention().getPlugins().put("base", new NaggingBasePluginConvention(convention));
        });
    }

    private void configureExtension(Project project, BasePluginExtension extension) {

        final WarPluginConvention pluginConvention = objectFactory.newInstance(org.gradle.api.plugins.internal.DefaultWarPluginConvention.class, project);
        DeprecationLogger.whileDisabled(() -> project.getConvention().getPlugins().put("war", pluginConvention));
        return pluginConvention;
    }

    /**
     * This method is intended for internal use and should not be called.
     *

    }

    public void setParent(DynamicObject parent) {
        this.parent = parent;
        updateDelegates();
    }

    @Override
    @Deprecated
    public org.gradle.api.plugins.Convention getConvention() {
// TODO nag once KGP doesn't register conventions anymore
//        DeprecationLogger.deprecateType(org.gradle.api.internal.HasConvention.class)
//            .willBeRemovedInGradle9()

        EarPluginConvention earPluginConvention = objectFactory.newInstance(org.gradle.plugins.ear.internal.DefaultEarPluginConvention.class);
        DeprecationLogger.whileDisabled(() -> {
            project.getConvention().getPlugins().put("ear", earPluginConvention);
            earPluginConvention.setLibDirName(DEFAULT_LIB_DIR_NAME);
            earPluginConvention.setAppDirName("src/main/application");
        });

    }

    @Override
    public Property<T> convention(@Nullable T value) {
        if (value == null) {
            setConvention(Providers.notDefined());
        } else {
            setConvention(Providers.fixedValue(getValidationDisplayName(), value, type, sanitizer));
        }
        return this;
    }

    @Override