"k8s.io/client-go/informers"
	"k8s.io/kubernetes/pkg/controller"
)

func TestGetDefaultClass(t *testing.T) {

	var (
		t1 = time.Now()
		t2 = time.Now().Add(1 * time.Hour)

		sc1 = &storagev1.StorageClass{
			ObjectMeta: metav1.ObjectMeta{
				Name: "my-storage-class1",
				Annotations: map[string]string{
					"a": "b",
				},
			},
		}
		sc2 = &storagev1.StorageClass{

//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

)

// Default values of KeepAliveTime and KeepAliveInterval on Windows,
// check out https://learn.microsoft.com/en-us/windows/win32/winsock/sio-keepalive-vals#remarks for details.
const (
	defaultKeepAliveIdle     = 2 * time.Hour
	defaultKeepAliveInterval = time.Second
)

func setKeepAliveIdle(fd *netFD, d time.Duration) error {
	if !windows.SupportTCPKeepAliveIdle() {
		return setKeepAliveIdleAndInterval(fd, d, -1)
	}

	if d == 0 {

	}{
		{1, IntValue(1)},
		{1.5, Float64Value(1.5)},
		{float32(2.5), Float64Value(2.5)},
		{"s", StringValue("s")},
		{true, BoolValue(true)},
		{testTime, TimeValue(testTime)},
		{time.Hour, DurationValue(time.Hour)},
		{[]Attr{Int("i", 3)}, GroupValue(Int("i", 3))},
		{IntValue(4), IntValue(4)},
		{uint(2), Uint64Value(2)},
		{uint8(3), Uint64Value(3)},
		{uint16(4), Uint64Value(4)},
		{uint32(5), Uint64Value(5)},

	tracker.Set("k3", 59)
	expected := map[string]*timestampedCount{
		"k3": {
			count:         59,
			lastUpdatedAt: mostRecent,
		},
	}

	fakeClock.SetTime(now)
	if err := tracker.prune(time.Hour); err != nil {
		t.Fatalf("Expected no error, but got: %v", err)
	}

	// we expect only one entry in the map, so DeepEqual should work.
	if !reflect.DeepEqual(expected, tracker.counts) {

	if err != nil {
		return Cert{}, fmt.Errorf("creating citadel client: %v", err)
	}
	req := &pb.IstioCertificateRequest{
		Csr:              string(csrPEM),
		ValidityDuration: int64((time.Hour * 24 * 7).Seconds()),
	}
	rctx := metadata.NewOutgoingContext(context.Background(), metadata.Pairs("Authorization", "Bearer "+token, "ClusterID", constants.DefaultClusterName))
	resp, err := client.CreateCertificate(rctx, req)

		expectedExp time.Time
		expectedErr error
	}{
		"jwt with expiration time": {
			jwt:         thirdPartyJwt,
			expectedExp: time.Date(2020, time.April, 5, 10, 13, 54, 0, time.FixedZone("PDT", -int((7*time.Hour).Seconds()))),
			expectedErr: nil,
		},
		"jwt with no expiration time": {
			jwt:         firstPartyJwt,
			expectedExp: time.Time{},
			expectedErr: nil,
		},
		"invalid jwt": {

			withClientCert:         true,
			command:                "user",
			additionalFlags:        []string{"--validity-period=12h"},
			expectedValidityPeriod: 12 * time.Hour,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			buf := new(bytes.Buffer)

			// Get subcommands working in the temporary directory
			cmd := newCmdUserKubeConfig(buf)

			obj.RegistryBurst = 10
			obj.RegistryPullQPS = 5
			obj.ResolverConfig = kubetypes.ResolvConfDefault
			obj.SerializeImagePulls = true
			obj.StreamingConnectionIdleTimeout = metav1.Duration{Duration: 4 * time.Hour}
			obj.SyncFrequency = metav1.Duration{Duration: 1 * time.Minute}
			obj.ContentType = "application/vnd.kubernetes.protobuf"
			obj.KubeAPIQPS = 50
			obj.KubeAPIBurst = 100
			obj.HairpinMode = v1beta1.PromiscuousBridge

	}

	{
		t.Log("test sending log with specified time")

		// Clean up all the mssages, and log again. Check that buffer is cleaned up properly.
		srv.messages = make([]string, 0)
		yesterday := time.Now().Add(-time.Hour * 24).Truncate(time.Microsecond)
		defaultScope.LogWithTime(InfoLevel, "test3", yesterday)
		Sync()
		// There should only be one message in the buffer
		if got, want := len(srv.messages), 1; got != want {