setTime(51243)

        then:
        timer.getElapsed() == "51.243 secs"
    }

    def testOnlySecondsEvenMs() {
        when:
        setTime(4000)

        then:
        timer.getElapsed() == "4.0 secs"
    }

    def testMinutesAndSeconds() {
        when:
        setTime(0, 32, 40, 322)

        then:
        timer.getElapsed() == "32 mins 40.322 secs"
    }

        if (recompilationSpec.isFullRebuildNeeded()) {
            LOG.info("Full recompilation is required because {}. Analysis took {}.", recompilationSpec.getFullRebuildCause(), clock.getElapsed());
            return rebuildAllCompiler.execute(spec);
        }

        CompileTransaction transaction = recompilationSpecProvider.initCompilationSpecAndTransaction(spec, recompilationSpec);

        Timer clock = Time.startTimer();
        ClassSetAnalysisData snapshot = classSetAnalyzer.analyzeOutputFolder(outputFolder);
        LOG.info("Class dependency analysis for incremental compilation took {}.", clock.getElapsed());
        return snapshot;
    }


    public ClassSetAnalysisData getClasspathSnapshot(final Iterable<File> entries) {
        if (classpathSnapshot == null) {
            Timer clock = Time.startTimer();

 * limitations under the License.
 */

package org.gradle.internal.time;

public interface Timer {

    /**
     * @return A human-consumable description of the elapsed time.
     */
    String getElapsed();

    /**
     * Return the elapsed time in ms. Returned value is always >= 0.
     * @return The elapsed time, in ms.
     */
    long getElapsedMillis();

    /**

    private final TimeSource timeSource;
    private long startTime;

    DefaultTimer(TimeSource timeSource) {
        this.timeSource = timeSource;
        reset();
    }

    @Override
    public String getElapsed() {
        long elapsedMillis = getElapsedMillis();
        return TimeFormatting.formatDurationVerbose(elapsedMillis);
    }

    @Override
    public long getElapsedMillis() {

    private int buildCount;
    private long allBuildsTime;

    public int getBuildCount() {
        return buildCount;
    }

    public String getPrettyUpTime() {
        return daemonTimer.getElapsed();
    }

    public long getStartTime() {
        return startTime;
    }

    public long getAllBuildsTime() {
        return allBuildsTime;
    }

            project.getOwner().applyToMutableState(configurer::apply);
        } finally {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Timing: Running the build script took {}", clock.getElapsed());
            }
        }
    }

        settings.getCaches().finalizeConfiguration(gradle);
        applySettingsScript(settingsScript, settings);
        LOGGER.debug("Timing: Processing settings took: {}", settingsProcessingClock.getElapsed());
        return state;
    }

    private void applySettingsScript(TextResourceScriptSource settingsScript, final SettingsInternal settings) {

        context.setTaskExecutionMode(taskExecutionMode);
        LOGGER.debug("Putting task artifact state for {} into context took {}.", task, clock.getElapsed());
        try {
            return executer.execute(task, state, context);
        } finally {
            context.setTaskExecutionMode(null);

                            ResolvedComponentResult root = builder.getRoot(rootId);
                            LOG.debug("Loaded resolution results ({}) from {}", clock.getElapsed(), data);
                            return root;
                        case COMPONENT:
                            componentResultSerializer.readInto(decoder, builder);
                            break;