result instanceof Cancel
    }

    def "can serialize BuildStarted message"() {
        expect:
        def diagnostics = new DaemonDiagnostics(new File("log"), 1234L)
        def message = new BuildStarted(diagnostics)
        def result = serialize(message, serializer)
        result instanceof BuildStarted
        result.diagnostics.daemonLog == message.diagnostics.daemonLog

        return startTime;
    }

    public long getAllBuildsTime() {
        return allBuildsTime;
    }

    // TODO: these should be moved off to a separate type

    public void buildStarted() {
        ++buildCount;
        currentBuildTimer.reset();
    }

    public void buildFinished() {
        long buildTime = Math.max(currentBuildTimer.getElapsedMillis(), 1);
        allBuildsTime += buildTime;

        LOGGER.debug("Received result {} from daemon {} (build should be starting).", result, connection.getDaemon());

        DaemonDiagnostics diagnostics = null;
        if (result instanceof BuildStarted) {
            diagnostics = ((BuildStarted) result).getDiagnostics();
            result = monitorBuild(build, diagnostics, connection, cancellationToken, buildEventConsumer);
        }

        return !locationsWrittenByCurrentBuild.get().contains(location);
    }

    public FileHierarchySet getImmutableLocations() {
        return immutableLocations;
    }

    public void buildStarted() {
        resetLocationsWritten();
        buildRunning = true;
    }

    public void buildFinished() {
        resetLocationsWritten();
        buildRunning = false;
    }

        then:
        profile.buildDescription.contains(" (no tasks specified)")
    }

    def "provides start time description"() {
        when:
        profile.buildStarted = new GregorianCalendar(2010, 1, 1, 12, 25).getTimeInMillis()

        then:
        profile.buildStartedDescription == "Started on: 2010/02/01 - 12:25:00"
    }

        LOGGER.debug(DaemonMessages.STARTED_BUILD);
        LOGGER.debug("Executing build with daemon context: {}", execution.getDaemonContext());
        runningStats.buildStarted();
        DaemonConnectionBackedEventConsumer buildEventConsumer = new DaemonConnectionBackedEventConsumer(execution);
        try {

    public void setEmacsMode(boolean emacsMode) {
        // ignore
    }

    @Override
    public void setErrorPrintStream(PrintStream err) {
        // ignore
    }

    @Override
    public void buildStarted(BuildEvent event) {
        // ignore
    }

    @Override
    public void buildFinished(BuildEvent event) {
        // ignore
    }

    @Override
    public void targetStarted(BuildEvent event) {

        then:
        0 * _

        when:
        buildFinished()
        then:
        0 * _

        when:
        buildStarted()
        then:
        0 * _

        when:
        registerWatchableHierarchies([directoryWithinFirst, secondDir])
        then:
        0 * _

        when:

    def "renders report"() {
        def model = new BuildProfile(new StartParameter(), new BuildStartedTime(0))
        def file = temp.file("report.html")

        model.profilingStarted   = time(12, 20, 0)
        model.buildStarted       = time(12, 20, 0, 700)
        model.settingsEvaluated  = time(12, 20, 3)
        model.projectsLoaded     = time(12, 20, 6)

        model.buildFinished      = time(12, 35, 30)

            listenerManager.addListener(new RootBuildLifecycleListener() {
                @Override
                public void afterStart() {
                    fileWatchingFilter.buildStarted();
                }

                @Override
                public void beforeComplete() {
                    fileWatchingFilter.buildFinished();
                }
            });