import org.gradle.internal.service.scopes.Scope;

/**
 * <p>A {@code BuildListener} is notified of the major lifecycle events as a build is executed.</p>
 *
 * @see org.gradle.api.invocation.Gradle#addListener(Object)
 */
@EventScope(Scope.Build.class)
@DeprecatedInGradleScope
public interface BuildListener {

    /**
     * Called when the build settings are about to be loaded and evaluated.
     *

        execute()

        then:
        events(16)
        loggedOncePerBuild('buildListener.settingsEvaluated')
        loggedOncePerBuild('buildListener.projectsLoaded')
        loggedOncePerBuild('buildListener.projectsEvaluated')
        loggedOncePerBuild('gradle.taskGraphReady', [':'])
        loggedOncePerBuild('buildListener.buildFinished failure=null')
        loggedOncePerBuild('gradle.buildFinished failure=null')
    }

        }
        1 * listenerManager.addListener({ it instanceof BuildListener }) >> { BuildListener listener ->
            buildListener = listener
        }

        when:
        buildListener.buildFinished(Stub(BuildResult))

        then:
        1 * listenerManager.removeListener(daemonExpirationListener)
        1 * listenerManager.removeListener(buildListener)
    }

        def buildListener = new InternalBuildAdapter()
        def projectEvaluationListener = Mock(InternalProjectEvaluationListener)
        def graphListener = Mock(InternalTaskExecutionGraphListener)

        expect:
        decorator.decorate('foo', action) is action

        and:
        decorator.decorate('foo', BuildListener, buildListener) is buildListener

import org.gradle.util.TestUtil
import spock.lang.Specification

import java.util.function.Consumer
import java.util.function.Function

class DefaultBuildLifecycleControllerTest extends Specification {
    def buildListener = Mock(BuildListener)
    def buildModelLifecycleListener = Mock(BuildModelLifecycleListener)
    def workExecutor = Mock(BuildWorkExecutor)
    def workPreparer = Mock(BuildWorkPreparer)

    @Suppress("DEPRECATION")
    override fun buildFinished(action: Action<in BuildResult>) =
        delegate.buildFinished(action)

    override fun addBuildListener(buildListener: BuildListener) =
        delegate.addBuildListener(buildListener)

    override fun addListener(listener: Any) =
        delegate.addListener(listener)

    override fun removeListener(listener: Any) =

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal;

import org.gradle.BuildListener;

public interface InternalBuildListener extends BuildListener, InternalListener {

import org.gradle.api.initialization.Settings;
import org.gradle.api.invocation.Gradle;

/**
 * A {@link BuildListener} adapter class for receiving build events. The methods in this class are empty. This class
 * exists as convenience for creating listener objects.
 */
public class BuildAdapter implements BuildListener {

    @Override
    public void beforeSettings(Settings settings) {
    }

    @Override

    private static final ImmutableList<State> CONFIGURATION_STATES = ImmutableList.of(State.Configure, State.TaskSchedule, State.ReadyToRun);

    private final ExceptionAnalyser exceptionAnalyser;
    private final BuildListener buildListener;
    private final BuildModelLifecycleListener buildModelLifecycleListener;
    private final BuildWorkPreparer workPreparer;
    private final BuildWorkExecutor workExecutor;

 * limitations under the License.
 */

package org.gradle.api

import org.apache.tools.ant.BuildEvent
import org.apache.tools.ant.BuildListener

class RecordingAntBuildListener implements BuildListener {

    List<BuildEvent> buildStarted = []
    List<BuildEvent> buildFinished = []
    List<BuildEvent> targetStarted = []
    List<BuildEvent> targetFinished = []