Action<SslContextFactory.Server> configureServer = Actions.doNothing()
    ) {
        server.enableSsl(trustStore.path, trustStorePassword, null, null, configureServer)
    }

    void enableSslWithServerAndClientCerts(
        HttpServerFixture server,
        Action<SslContextFactory.Server> configureServer = Actions.doNothing()
    ) {

     *
     * A new action instance is created each time.
     *
     * @return An action object with an empty implementation
     */
    @SuppressWarnings("unchecked")
    public static <T> Action<T> doNothing() {
        return (Action<T>) DO_NOTHING;
    }

    private static class NullAction<T> implements Action<T>, Serializable {
        @Override
        public void execute(T t) {
        }
    }

    /**

        when:
        cachePolicy.eachArtifact(Actions.doNothing())
        then:
        1 * validator.validateMutation(STRATEGY)

        when:
        cachePolicy.eachDependency(Actions.doNothing())
        then:
        1 * validator.validateMutation(STRATEGY)

        when:
        cachePolicy.eachModule(Actions.doNothing())
        then:
        1 * validator.validateMutation(STRATEGY)
    }

                public SneakyTask() {
                    ${snippets.body}
                }

                @TaskAction
                public void doNothing() {}
            }
        """

        buildFile("""
            tasks.register("sneakyTask", SneakyTask) {}
        """)

        when:
        configurationCacheFails(":sneakyTask")

        then:

            6.times {
                start {
                    thread.blockUntil.allStarted
                    WorkQueue queue = workerExecutor."${isolationMode}" Actions.doNothing()
                    queue.submit(TestExecution.class, Actions.doNothing())
                }
            }
            instant.allStarted
        }

        then:
        6 * workerThreadRegistry.workerThread >> true

        create(name, elementType, Actions.doNothing());
    }

    @Override
    public void create(String name, Action<? super T> configAction) {
        create(name, elementType, configAction);
    }

    @Override
    public <S extends T> void create(String name, Class<S> type) {
        create(name, type, Actions.doNothing());
    }

    @Override

      new Runnable() {
        @Override
        public void run() {}
      };

  /** Returns a {@link Runnable} instance that does nothing when run. */
  public static Runnable doNothing() {
    return EMPTY_RUNNABLE;
  }

  private Runnables() {}

      new Runnable() {
        @Override
        public void run() {}
      };

  /** Returns a {@link Runnable} instance that does nothing when run. */
  public static Runnable doNothing() {
    return EMPTY_RUNNABLE;
  }

  private Runnables() {}

public interface DependencySubstitutionRules {
    DependencySubstitutionRules NO_OP = new DependencySubstitutionRules() {
        @Override
        public Action<DependencySubstitution> getRuleAction() {
            return Actions.doNothing();
        }

        @Override
        public boolean rulesMayAddProjectDependency() {
            return false;
        }
    };

    Action<DependencySubstitution> getRuleAction();

        })
        task.actions.size() == 1
    }

    def "doFirst() adds actions to the start of action list"() {
        given:
        Action<Task> action1 = Actions.doNothing()
        Action<Task> action2 = Actions.doNothing()

        expect:
        defaultTask.is(defaultTask.doFirst(action1))
        1 == defaultTask.actions.size()

        defaultTask.is(defaultTask.doFirst(action2))