* limitations under the License.
 */

package org.gradle.internal.time;

public class MockClock implements Clock {

    long current;

    public MockClock() {
        this(System.currentTimeMillis());
    }

    public MockClock(long startTime) {
        current = startTime;
    }

    public void increment(long diff) {
        current += diff;
    }

import org.gradle.internal.time.MockClock

@CompileStatic
class ToStringLogger extends OutputEventListenerBackedLogger {

    private final StringBuilder log = new StringBuilder()

    ToStringLogger() {
        super("ToStringLogger", new OutputEventListenerBackedLoggerContext(new MockClock()), new MockClock())
    }

    @Override
    void lifecycle(String message) {

import org.gradle.launcher.daemon.registry.DaemonRegistry
import org.gradle.launcher.daemon.registry.EmbeddedDaemonRegistry
import org.gradle.launcher.daemon.server.api.DaemonStateControl
import org.gradle.internal.time.MockClock
import spock.lang.Specification

import static org.gradle.launcher.daemon.server.api.DaemonStateControl.State.Busy

abstract class DaemonExpirationStrategyTest extends Specification {
    DaemonRegistry registry

import org.gradle.internal.time.Clock
import org.gradle.internal.time.MockClock
import org.gradle.util.internal.MockExecutor
import spock.lang.Subject

class ThrottlingOutputEventListenerTest extends OutputSpecification {
    def listener = Mock(OutputEventListener)
    def clock = new MockClock()
    def executor = new MockExecutor()

        task.state.rethrowFailure() >> { throw failure }
    }

    private static class MockLock implements ResourceLock {
        final Thread owner = Thread.currentThread()
        final ProjectInternal project
        boolean locked
        final Collection<MockLock> locks

        MockLock(ProjectInternal project, Collection<MockLock> locks) {
            this.locks = locks
            this.project = project
        }