file("included/src/main/java/com/example/TestWorkAction.java") << """
            package com.example;

            import org.gradle.workers.WorkAction;
            import org.gradle.workers.WorkParameters;
            import javax.inject.Inject;

            abstract class TestWorkAction implements WorkAction<WorkParameters.None> {
                @Inject
                public TestWorkAction() {}
                @Override

    }

    def spec() {
        return new IsolatedParametersActionExecutionSpec(TestWorkAction, "action", "impl", null, null, null, null, false)
    }

    static abstract class TestWorkAction implements WorkAction<WorkParameters.None> {
        @Override
        void execute() {}
    }

        return """
            import org.gradle.api.file.ProjectLayout
            import org.gradle.workers.WorkParameters
            import org.gradle.workers.internal.WorkerDaemonFactory

            abstract class TestWorkAction implements WorkAction<WorkParameters.None> {
                void execute() {
                    println "Runnable executed..."
                }
            }

        then:
        def operation = buildOperations.only(ExecuteWorkItemBuildOperationType)
        operation.displayName == "org.gradle.test.TestWorkAction"
        with (operation.details) {
            className == "org.gradle.test.TestWorkAction"
            displayName == "org.gradle.test.TestWorkAction"
        }

        where:
        isolationMode << ISOLATION_MODES
    }

        testParameterType.fields += [
            "files": "List<String>",
            "outputDir": "File",
            "bar": "Foo"
        ]

        workActionThatCreatesFiles = getWorkActionThatCreatesFiles("TestWorkAction")

        workActionThatFails = getWorkActionThatFails(RuntimeException.class, "Failure from work action")
    }

    def prepareTaskTypeUsingWorker() {
        withParameterClassInBuildSrc()

                @TaskAction
                void doWork() {
                    workerExecutor.processIsolation().submit(TestWorkAction) { }
                    ${server.callFromBuild("waiting")}
                }
            }
            abstract class TestWorkAction implements WorkAction<WorkParameters.None> { void execute() { } }
        """

        when:

            interface TestParameters : WorkParameters {
                @get:Input
                val workInput: $propertyType
            }

            abstract class TestWorkAction : WorkAction<TestParameters> {
                override fun execute() {
                    println(parameters.workInput.get().let { $toString })
                }

        """
    }

    private defineGradleWorkAction() {
        """
        interface WorkActionParams extends WorkParameters {
            Property<String> getName()
        }
        abstract class TestWorkAction implements WorkAction<WorkActionParams> {
            public void execute() {
                ${server.callFromBuildUsingExpression('parameters.name.get()')}
            }
        }

        expect:
        fails("runInWorker")

        and:
        failure.assertHasDescription("Execution failed for task ':runInWorker'.")
        failure.assertHasCause("Could not create an instance of type TestWorkAction.")
        failure.assertHasCause("Unable to determine constructor argument #1: missing parameter of type $forbiddenType.simpleName, or no service of type $forbiddenType.simpleName")

        where: