import org.gradle.internal.logging.events.OutputEventListener;
import org.gradle.internal.time.Clock;

import java.io.PrintStream;

public class DefaultStdOutLoggingSystem extends PrintStreamLoggingSystem implements StdOutLoggingSystem {

    public DefaultStdOutLoggingSystem(OutputEventListener listener, Clock clock) {
        super(listener, "system.out", clock);
    }

    @Override
    protected PrintStream get() {

        this.suiteFiles = suiteFiles;
    }

    @Override
    public TestClassProcessor create(IdGenerator<?> idGenerator, ActorFactory actorFactory, Clock clock) {
        return new TestNGTestClassProcessor(testReportDir, options, suiteFiles, idGenerator, clock, actorFactory);
    }

        this.spec = spec;
    }

    @Override
    public TestClassProcessor create(IdGenerator<?> idGenerator, ActorFactory actorFactory, Clock clock) {
        return new JUnitTestClassProcessor(spec, idGenerator, actorFactory, clock);
    }

	}

	clock := clock.RealClock{}

	return &pluginProvider{
		clock:                clock,
		matchImages:          provider.MatchImages,
		cache:                cache.NewExpirationStore(cacheKeyFunc, &cacheExpirationPolicy{clock: clock}),
		defaultCacheDuration: provider.DefaultCacheDuration.Duration,
		lastCachePurge:       clock.Now(),
		plugin: &execPlugin{

	ShutdownGracePeriodCriticalPods  time.Duration
	ShutdownGracePeriodByPodPriority []kubeletconfig.ShutdownGracePeriodByPodPriority
	StateDirectory                   string
	Clock                            clock.Clock
}

// managerStub is a fake node shutdown managerImpl .
type managerStub struct{}

// Admit returns a fake Pod admission which always returns true

	cache      map[string]*authenticationv1.TokenRequest

	// mocked for testing
	getToken func(name, namespace string, tr *authenticationv1.TokenRequest) (*authenticationv1.TokenRequest, error)
	clock    clock.Clock
}

// GetServiceAccountToken gets a service account token for a pod from cache or
// from the TokenRequest API. This process is as follows:
// * Check the cache for the current token request.

	timeout := &subs[0]
	eventtype := timeout.u.eventtype()
	*eventtype = eventtypeClock
	clock := timeout.u.subscriptionClock()
	clock.id = clockMonotonic
	clock.precision = 1e3
}

func netpollIsPollDescriptor(fd uintptr) bool {
	return false
}

func netpollopen(fd uintptr, pd *pollDesc) int32 {
	lock(&mtx)

	// We don't worry about pd.fdseq here,
	// as mtx protects us from stale pollDescs.

	pds = append(pds, pd)

	fakeRecorder := &record.FakeRecorder{}
	fakeClock := testingclock.NewFakeClock(time.Now())

	testCases := []struct {
		podStatusProvider status.PodStatusProvider
		recorder          record.EventRecorder
		clock             clock.Clock
	}{
		{podStatusProvider, fakeRecorder, fakeClock},
		{podStatusProvider, fakeRecorder, nil},
		{podStatusProvider, nil, fakeClock},
		{podStatusProvider, nil, nil},
		{nil, fakeRecorder, fakeClock},

limitations under the License.
*/

package eventclock

import (
	"time"

	baseclock "k8s.io/utils/clock"
)

// EventFunc does some work that needs to be done at or after the
// given time.
type EventFunc func(time.Time)

// EventClock is an active clock abstraction for use in code that is
// testable with a fake clock that itself determines how time may be
// advanced.  The timing paradigm is invoking EventFuncs rather than

// StorageObjectCountTracker interface that can be used to
// keep track of the total number of objects for each resource.
func NewStorageObjectCountTracker() StorageObjectCountTracker {
	return &objectCountTracker{
		clock:  &clock.RealClock{},
		counts: map[string]*timestampedCount{},
	}
}

// timestampedCount stores the count of a given resource with a last updated
// timestamp so we can prune it after it goes stale for certain threshold.