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

     *
     * @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();

    }

    protected void beforeRead(@SuppressWarnings("unused") EvaluationContext.ScopeContext context) {
        provider.getProducer().visitContentProducerTasks(producer -> {
            if (!producer.getState().getExecuted()) {
                throw new InvalidUserCodeException(
                    String.format("Querying the filtered value of %s before %s has completed is not supported", provider, producer)
                );
            }

    }

    protected void beforeRead(EvaluationContext.ScopeContext context) {
        provider.getProducer().visitContentProducerTasks(producer -> {
            if (!producer.getState().getExecuted()) {
                throw new InvalidUserCodeException(
                    String.format("Querying the mapped value of %s before %s has completed is not supported", provider, producer)
                );
            }

  absl::StatusOr<std::unique_ptr<DeviceDescription>> DescriptionForDevice(
      int ordinal) const override;
  absl::StatusOr<StreamExecutor*> ExecutorForDevice(int ordinal) override;
  absl::StatusOr<StreamExecutor*> GetExecutor(
      const StreamExecutorConfig& config) override;
  absl::StatusOr<std::unique_ptr<StreamExecutor>> GetUncachedExecutor(
      const StreamExecutorConfig& config) override;