return nil, apierrors.NewBadRequest("no user present on request")
	}

	extra := user.GetExtra()

	selfSR := &authenticationapi.SelfSubjectReview{
		ObjectMeta: metav1.ObjectMeta{
			CreationTimestamp: metav1.NewTime(time.Now()),
		},
		Status: authenticationapi.SelfSubjectReviewStatus{
			UserInfo: authenticationapi.UserInfo{
				Username: user.GetName(),
				UID:      user.GetUID(),
				Groups:   user.GetGroups(),

		if containerName == kubetypes.PodInfraContainerName {
			// Special case for infrastructure container which is hidden from
			// the user and has network stats.
			podStats.StartTime = metav1.NewTime(cinfo.Spec.CreationTime)
		} else {
			podStats.Containers = append(podStats.Containers, *cadvisorInfoToContainerCPUAndMemoryStats(containerName, &cinfo))
		}
	}

	// Add each PodStats to the result.

		PersistentVolumeToSelectableFields(&api.PersistentVolume{}),
		map[string]string{"name": "metadata.name"},
	)
}

func TestStatusUpdate(t *testing.T) {
	now := metav1.Now()
	origin := metav1.NewTime(now.Add(time.Hour))
	later := metav1.NewTime(now.Add(time.Hour * 2))
	NowFunc = func() metav1.Time { return now }
	defer func() {
		NowFunc = metav1.Now
	}()
	tests := []struct {
		name        string
		fg          bool

		workingSetBytes := uint64(seed + offsetCRI + offsetMemWorkingSetBytes)
		podStats.CPU = &statsapi.CPUStats{
			Time:                 metav1.NewTime(timestamp),
			UsageCoreNanoSeconds: &usageCoreNanoSeconds,
		}
		podStats.Memory = &statsapi.MemoryStats{
			Time:            metav1.NewTime(timestamp),
			WorkingSetBytes: &workingSetBytes,
		}
	}

	return podStats
}

  }

  /** Advance the simulated clock, then runs tasks that are ready. Used by the test thread only. */
  fun advanceUntil(newTime: Long) {
    taskRunner.assertThreadDoesntHoldLock()

    taskRunner.lock.withLock {
      check(currentTask == TestThreadSerialTask)
      nanoTime = newTime
      yieldUntil(ResumePriority.AfterOtherTasks)
    }
  }

    }

    class FileTime {

        static long oldTime = 1000
        static long startTime = oldTime + 2000
        static long newTime = startTime + 2000

        static DefaultDeleter deleterWithDeletionAction(Function<File, DeletionAction> deletionAction) {
            new DefaultDeleter(
                { startTime },

	containerStats := getContainerStats()
	podStats := statsapi.PodStats{
		PodRef:     statsapi.PodReference{Name: "test-pod", Namespace: "test-namespace", UID: "UID_test-pod"},
		StartTime:  metav1.NewTime(time.Now()),
		Containers: []statsapi.ContainerStats{*containerStats},
		CPU:        containerStats.CPU,
		Memory:     containerStats.Memory,
	}

	return &podStats

		}))

		cst.c.Timeout = timeout

		_, err := cst.c.Get(cst.ts.URL)
		if err == nil {
			close(cancelHandler)
			t.Fatal("unexpected Get success")
		}

		tooSlow := time.NewTimer(timeout * 10)
		select {
		case <-tooSlow.C:
			// If we didn't get into the Handler, that probably means the builder was
			// just slow and the Get failed in that time but never made it to the

				t.Errorf("Failed equality test for '%v', '%v': expected %+v, got %+v", c.x, c.y, c.result, result)
			}
		})
	}
}

func TestMicroTimeEqualTime(t *testing.T) {
	t1 := NewMicroTime(time.Now())
	t2 := NewTime(t1.Time)
	cases := []struct {
		name   string
		x      *MicroTime
		y      *Time
		result bool
	}{
		{"nil =? nil", nil, nil, true},
		{"!nil =? !nil", &t1, &t2, true},

		{State: corev1.ContainerState{Running: &corev1.ContainerStateRunning{StartedAt: metav1.NewTime(frozenTime)}}},
	})
}

func buildPodWithStatus(cs []corev1.ContainerStatus) *corev1.Pod {
	return &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			UID:               types.UID(uid),
			CreationTimestamp: metav1.NewTime(frozenTime),
		},
		Status: corev1.PodStatus{
			ContainerStatuses: cs,
		},
	}