)

func TestNodeStartupLatencyNoEvents(t *testing.T) {
	t.Run("metrics registered; no incoming events", func(t *testing.T) {
		metrics.Register()
		defer clearMetrics()

		tracker := &basicNodeStartupLatencyTracker{
			bootTime:         frozenTime.Add(-100 * time.Millisecond),
			kubeletStartTime: frozenTime,
			clock:            clock.RealClock{},
		}

		wants := `

)

const imagePullDurationKey = "kubelet_" + ImagePullDurationKey

func TestImagePullDurationMetric(t *testing.T) {
	t.Run("register image pull duration", func(t *testing.T) {
		Register()
		defer clearMetrics()

		// Pairs of image size in bytes and pull duration in seconds
		dataPoints := [][]float64{
			// 0 byets, 0 seconds
			{0, 0},
			// 5MB, 10 seconds
			{5 * 1024 * 1024, 10},
			// 15MB, 20 seconds

	return r.item, r.err
}

func (r *mockRangeRegistry) CreateOrUpdate(alloc *api.RangeAllocation) error {
	r.updateCalled = true
	r.updated = alloc
	return r.updateErr
}

func TestRepair(t *testing.T) {
	clearMetrics()
	fakeClient := fake.NewSimpleClientset()
	registry := &mockRangeRegistry{
		item: &api.RangeAllocation{Range: "100-200"},
	}
	pr, _ := net.ParsePortRange(registry.item.Range)

	if err := r.runOnce(); !strings.Contains(err.Error(), ": test error") {
		t.Fatal(err)
	}
}

func TestRepairLeak(t *testing.T) {
	clearMetrics()

	_, cidr, _ := netutils.ParseCIDRSloppy("192.168.1.0/24")
	previous, err := ipallocator.NewInMemory(cidr)
	if err != nil {
		t.Fatal(err)
	}
	previous.Allocate(netutils.ParseIPSloppy("192.168.1.10"))

			if got := calculateRangeOffset(tt.args.pr); got != tt.want {
				t.Errorf("calculateRangeOffset() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestNodePortMetrics(t *testing.T) {
	clearMetrics()
	// create node port allocator
	portRange := "30000-32767"
	pr, err := net.ParsePortRange(portRange)
	if err != nil {
		t.Fatal(err)
	}

	a, err := NewInMemory(*pr)
	if err != nil {