this.buildOperationRunner = buildOperationRunner;
        this.specFactory = specFactory;
        IsolationScheme<WorkAction<?>, WorkParameters> isolationScheme = new IsolationScheme<>(Cast.uncheckedNonnullCast(WorkAction.class), WorkParameters.class, WorkParameters.None.class);

                public void run() {
                    // DO NOTHING
                }
            }
        """
        def workAction = """
            abstract public class TestWork implements WorkAction<WorkParameters.None> {
                public void execute() {
                    // DO NOTHING
                }
            }
        """

  if (!std::isfinite(double_multiplier) || double_multiplier <= 0) {
    return failure();
  }
  const double fraction = std::frexp(double_multiplier, &shift);
  quantized_fraction = static_cast<int32_t>(std::round(fraction * (1L << 15)));
  // Clip extreme values.  These are more than enough to overflow int8, the
  // storage type for quantized values, and the final values will be clamped

import org.gradle.api.file.FileSystemOperations
import org.gradle.api.provider.ProviderFactory
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.TaskAction
import org.gradle.workers.WorkAction
import org.gradle.workers.WorkParameters
import org.gradle.workers.WorkerExecutor
import org.gradle.tooling.provider.model.ToolingModelBuilder
import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry

import org.gradle.process.internal.worker.child.WorkerDirectoryProvider
import org.gradle.test.fixtures.concurrent.ConcurrentSpec
import org.gradle.util.UsesNativeServices
import org.gradle.workers.WorkAction
import org.gradle.workers.WorkParameters
import org.gradle.workers.WorkQueue
import org.gradle.workers.WorkerExecutionException
import spock.lang.TempDir

            import org.gradle.internal.operations.CurrentBuildOperationRef;

            import org.gradle.workers.WorkAction;

            import javax.inject.Inject;

            public abstract class ProblemWorkerTask implements WorkAction<ProblemsWorkerTaskParameter> {

                @Inject
                public abstract Problems getProblems();

                @Override

import org.gradle.api.tasks.Input
import org.gradle.api.tasks.TaskAction
import org.gradle.workers.WorkAction
import org.gradle.workers.WorkParameters
import org.gradle.workers.WorkerExecutor
import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
import org.gradle.tooling.provider.model.ToolingModelBuilder

plugins {
    id 'groovy'
}

repositories {
    mavenCentral()
}

// tag::object-factory[]

                }
            }

            interface SomeParams extends WorkParameters {
                ${type} getValue()
            }

            abstract class SomeWorkAction implements WorkAction<SomeParams> {
                void execute() {
                    println("value = \${parameters.value.get()}")
                }
            }

            task worker(type: UsesWorker) {

import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.gradle.util.UsesNativeServices
import org.gradle.util.internal.RedirectStdOutAndErr
import org.gradle.workers.WorkAction
import org.gradle.workers.WorkParameters
import org.gradle.workers.WorkerSpec
import org.junit.Rule
import spock.lang.Specification

@UsesNativeServices
class DefaultWorkerExecutorTest extends Specification {

 *     <li>Execution in isolated contexts such as an isolated classloader or even a separate process</li>
 *     <li>Safe execution of multiple tasks in parallel</li>
 * </ul>
 *
 * <p>Work should be submitted with a {@link WorkAction} class representing the implementation of the unit of work
 * and an action to configure the parameters of the unit of work (via {@link WorkParameters}).
 *
 * <pre>