}
            });
            run.setClasspath(runtimeClasspath);
            run.getMainModule().set(pluginExtension.getMainModule());
            run.getMainClass().set(pluginExtension.getMainClass());
            run.getJvmArguments().convention(project.provider(pluginExtension::getApplicationDefaultJvmArgs));

    public void copyTo(JavaExecSpec targetSpec) {
        // JavaExecSpec
        targetSpec.setArgs(getArgs());
        targetSpec.getArgumentProviders().addAll(getArgumentProviders());
        targetSpec.getMainClass().set(getMainClass());
        targetSpec.getMainModule().set(getMainModule());
        targetSpec.getModularity().getInferModulePath().set(getModularity().getInferModulePath());
        targetSpec.classpath(getClasspath());

    )
    Property<String> getMainClass();

    /**
     * Sets the fully qualified name of the main class to be executed.
     *
     * @param main the fully qualified name of the main class to be executed.
     *
     * @return this
     *
     * @deprecated Use {@link #getMainClass()}.set(main) instead. This method will be removed in Gradle 9.0.
     */
    @Deprecated

    @Override
    default Property<String> getMainModule() {
        return getDelegate().getMainModule();
    }

    @Override
    default Property<String> getMainClass() {
        return getDelegate().getMainClass();
    }

    @Nullable
    @Override
    default List<String> getArgs() {
        return getDelegate().getArgs();
    }

    @Override

    }

    @Override
    public Property<String> getMainModule() {
        return mainModule;
    }

    @Override
    public Property<String> getMainClass() {
        return mainClass;
    }

    @Override
    public Iterable<String> getApplicationDefaultJvmArgs() {
        return DeprecationLogger.whileDisabled(convention::getApplicationDefaultJvmArgs);
    }

            JavaExecHandleBuilder builder = getExecActionFactory().newJavaExec();
            builder.setExecutable(Jvm.current().getJavaExecutable());
            builder.setClasspath(classpath);
            builder.getMainClass().set(mainClassName);
            builder.setArgs(arguments);
            registry.start(getPath(), changeBehavior, JavaApplicationHandle.class, builder);
        }
    }

    @Inject

     *
     * @since 6.4
     */
    Property<String> getMainModule();

    /**
     * The fully qualified name of the application's main class.
     *
     * @since 6.4
     */
    Property<String> getMainClass();

    /**
     * Array of string arguments to pass to the JVM when running the application
     */
    Iterable<String> getApplicationDefaultJvmArgs();

    /**

        ByteArrayOutputStream output = new ByteArrayOutputStream()

        ExecResult result = execOperations.javaexec(new Action<JavaExecSpec>() {
            void execute(JavaExecSpec spec) {
                spec.getMainClass().set(reportGeneratorClass)
                spec.args(reportDir.path, projectName)
                spec.args(resultJsons*.path)
                spec.systemProperties(databaseParameters)

                it.setStandardOutput(baos);
            """
    }

    private String getJavaJavaexecSpec() {
        return """
                it.getMainClass().set("${TestJavaMain.class.name}");
                it.classpath("${TextUtil.escapeString(TestJavaMain.classLocation)}");
                it.args("Hello", "from", "Java");
                it.setStandardOutput(baos);

        jvmArguments = objectFactory.listProperty(String.class).convention(jvmArgumentsConvention);

        javaExecSpec.getMainClass().convention(mainClass);
        javaExecSpec.getMainModule().convention(mainModule);
        javaExecSpec.getModularity().getInferModulePath().convention(modularity.getInferModulePath());