Convention conv = new ExtensibleDynamicObject(this, DynamicObjectAwareBean.class, TestUtil.instantiatorFactory().decorateLenient()).getConvention();

        public Convention getConvention() {
            return conv;
        }

        public ExtensionContainer getExtensions() {
            return conv;
        }

            }
        }
        return returnValue;
    }

    @Deprecated
    @Override
    public org.gradle.api.plugins.Convention getConvention() {
        DeprecationLogger.deprecateType(org.gradle.api.internal.HasConvention.class)
            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(8, "deprecated_access_to_conventions")

    }

    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");
        });

        assertDynamicObject();
        if (disableDeprecationForConventionAccess) {
            return DeprecationLogger.whileDisabled(() -> extensibleDynamicObject.getConvention());
        }
        return extensibleDynamicObject.getConvention();
    }

    @Internal
    @Override
    public DynamicObject getAsDynamicObject() {
        assertDynamicObject();
        return extensibleDynamicObject;
    }

        DeprecationLogger.whileDisabled(() ->
            new DslObject(sourceSet).getConvention().getPlugins().put("groovy", groovySourceSet)
        );
        return groovySourceSet.getGroovy();
    }

        DeprecationLogger.whileDisabled(() -> pluginConvention.setApplicationName(project.getName()));
        DeprecationLogger.whileDisabled(() -> project.getConvention().getPlugins().put("application", pluginConvention));
        return project.getExtensions().create(JavaApplication.class, "application", DefaultJavaApplication.class, pluginConvention);
    }

    @Override
    public abstract RoleBasedConfigurationContainerInternal getConfigurations();

    @Deprecated
    @Override
    public org.gradle.api.plugins.Convention getConvention() {
        return extensibleDynamicObject.getConvention();
    }

    @Override
    public String getPath() {
        return owner.getProjectPath().toString();
    }

    @Override
    public String getBuildTreePath() {

    override fun getDefaultTasks(): MutableList<String> =
        delegate.defaultTasks

    @Deprecated("The concept of conventions is deprecated. Use extensions instead.")
    override fun getConvention(): @Suppress("deprecation") org.gradle.api.plugins.Convention =
        @Suppress("deprecation")
        delegate.convention

    override fun getLogger(): Logger =
        delegate.logger

            """
        )

        val convention = mock<org.gradle.api.plugins.Convention>()
        val receiver = mock<org.gradle.api.internal.HasConvention>(extraInterfaces = arrayOf(T::class)) {
            on { getConvention() } doReturn convention
        }

        instantiatePrecompiledScriptOf(
            receiver as T,
            scriptClassNameForFile(fileName)
        )

        verify(convention).add(