protected GradleExecuter inDirectory(File directory) {
        return getExecuter().inDirectory(directory);
    }

    @Deprecated
    protected GradleExecuter usingBuildFile(File file) {
        return getExecuter().usingBuildScript(file);
    }

    protected GradleExecuter usingProjectDir(File projectDir) {
        return getExecuter().usingProjectDirectory(projectDir);
    }

import javax.inject.Inject

@SelfType(AbstractIntegrationSpec)
trait ToolingApiSpec {
    ToolingApiBackedGradleExecuter getToolingApiExecutor() {
        return (ToolingApiBackedGradleExecuter) getExecuter()
    }

    TestFile getProjectDir() {
        temporaryFolder.testDirectory
    }

    BuildTestFile singleProjectBuildInRootDir(String projectName, @DelegatesTo(BuildTestFile) Closure cl = {}) {

    private GradleExecuter executor
    private boolean ignoreCleanupAssertions

    private boolean enableProblemsApiCheck = false
    private BuildOperationsFixture buildOperationsFixture = null

    GradleExecuter getExecuter() {
        if (executor == null) {
            executor = createExecuter()
            if (ignoreCleanupAssertions) {
                executor.ignoreCleanupAssertions()
            }
        }

    test_util::PopulateDefaultDeviceFns(&device_fns_);
    test_util::PopulateDefaultStreamExecutor(&se_);
    test_util::PopulateDefaultTimerFns(&timer_fns_);
  }
  void TearDown() override {}

  StreamExecutor* GetExecutor(int ordinal) {
    if (!cplatform_) {
      cplatform_ = absl::make_unique<CPlatform>(
          platform_, test_util::DestroyPlatform, platform_fns_,
          test_util::DestroyPlatformFns, device_fns_, se_, timer_fns_);

     *
     * @param project The target project.
     * @param action The target action.
     */
    public static void afterEvaluateOrExecute(Project project, Action<Project> action) {
        if (project.getState().getExecuted()) {
            action.execute(project);
        } else {
            project.afterEvaluate(action);
        }
    }

    }

    def "can inject service using getter method"() {
        buildFile """
            class CustomPlugin implements Plugin<Project> {
                @Inject
                WorkerExecutor getExecutor() { }

                void apply(Project p) {
                    println(executor != null ? "got it" : "NOT IT")

                    // is generated but not extensible

    }

    @Override
    public boolean getRead() {
        return read;
    }

    @Override
    public boolean getWrite() {
        return write;
    }

    @Override
    public boolean getExecute() {
        return execute;
    }

            abstract class UsesWorker extends DefaultTask {
                @Input
                abstract ${type} getValue()

                @Inject
                abstract WorkerExecutor getExecutor()

                @TaskAction
                def go() {
                    def flag = value
                    executor.noIsolation().submit(SomeWorkAction) {
                        value = flag

     * returned value is equivalent to one of the three octal digits.
     */
    protected int toUnixNumeric() {
        return (getRead() ? 4 : 0) + (getWrite() ? 2 : 0) + (getExecute() ? 1 : 0);
    }

    protected static boolean isRead(int unixNumeric) {
        return (unixNumeric & 4) >> 2 == 1;
    }

    protected static boolean isRead(String unixSymbolic) {

     * doesn't really make sense, it's more like a traverse permission; for example, a user
     * must have 'execute' access to the 'bin' directory in order to execute the 'ls' or 'cd' commands.
     */
    boolean getExecute();