func (bto *BootstrapTokenOptions) AddTTLFlagWithName(fs *pflag.FlagSet, flagName string) {
	fs.DurationVar(
		&bto.TTL.Duration, flagName, bto.TTL.Duration,
		"The duration before the token is automatically deleted (e.g. 1s, 2m, 3h). If set to '0', the token will never expire",
	)
}

// AddUsagesFlag adds the --usages flag to the given flagset
func (bto *BootstrapTokenOptions) AddUsagesFlag(fs *pflag.FlagSet) {
	fs.StringSliceVar(

		{d: -2*time.Second + 1, want: "0s"},
		{d: 0, want: "0s"},
		{d: time.Second - time.Millisecond, want: "0s"},
		{d: 2*time.Minute - time.Millisecond, want: "119s"},
		{d: 2 * time.Minute, want: "2m"},
		{d: 2*time.Minute + time.Second, want: "2m1s"},
		{d: 10*time.Minute - time.Millisecond, want: "9m59s"},
		{d: 10 * time.Minute, want: "10m"},
		{d: 10*time.Minute + time.Second, want: "10m"},

		{resource.Quantity{}, resource.MustParse("1m"), false},
		{
			resource.NewQuantity(5, resource.BinarySI),
			resource.NewQuantity(5, resource.DecimalSI),
			true,
		},
		{resource.MustParse("2m"), resource.MustParse("1m"), false},
	}

	for index, item := range table {
		if e, a := item.shouldEqual, Semantic.DeepEqual(item.a, item.b); e != a {
			t.Errorf("case[%d], expected %v, got %v.", index, e, a)
		}
	}

	// practice, we will have one dynamic table per HTTP/2 connection. If we
	// assume a very powerful server that handles 1M QPS per connection and each
	// request adds (then evicts) 100 entries from the table, it would still take
	// 2M years for evictCount to overflow.
	ents       []HeaderField
	evictCount uint64

	// byName maps a HeaderField name to the unique id of the newest entry with
	// the same name. See above for a definition of "unique id".

  istioctl experimental metrics productpage-v1

  # Retrieve workload metrics for various services with custom duration
  istioctl experimental metrics productpage-v1 -d 2m

  # Retrieve workload metrics for various services in the different namespaces
  istioctl experimental metrics productpage-v1.foo reviews-v1.bar ratings-v1.baz`,
		// nolint: goimports
		Aliases: []string{"m"},

000002d0  4d 5e f1 10 1f ed 70 d1  88 7a 22 79 6e 5c c9 4c  |M^....p..z"yn\.L|
000002e0  e3 e7 a2 bd f4 3d f4 75  dc a3 85 5e f1 af 55 6f  |.....=.u...^..Uo|
000002f0  e3 36 21 c6 8a 44 e9 58  29 89 32 4d 14 90 9d 1b  |.6!..D.X).2M....|
00000300  bd 0e fa c3 eb 40 5d 05  5d ba 58 55 3e f9 30 b8  |.....@].].XU>.0.|
00000310  8f 56 35 71 12 33 92 0e  14 f9 90 2c ee 36 03 50  |.V5q.3.....,.6.P|

		"--tracing-config-file=/var/run/kubernetes/tracing_config.yaml",
		"--proxy-client-cert-file=/var/run/kubernetes/proxy.crt",
		"--proxy-client-key-file=/var/run/kubernetes/proxy.key",
		"--request-timeout=2m",
		"--storage-backend=etcd3",
		"--lease-reuse-duration-seconds=100",
	}
	fs.Parse(args)

	// This is a snapshot of expected options parsed by args.
	expected := &Options{

	args := []string{
		"-bool",
		"-bool2=true",
		"--int", "22",
		"--int64", "0x23",
		"-uint", "24",
		"--uint64", "25",
		"-string", "hello",
		"-float64", "2718e28",
		"-duration", "2m",
		extra,
	}
	if err := f.Parse(args); err != nil {
		t.Fatal(err)
	}
	if !f.Parsed() {
		t.Error("f.Parse() = false after Parse")
	}
	if *boolFlag != true {

		"--tracing-config-file=/var/run/kubernetes/tracing_config.yaml",
		"--proxy-client-cert-file=/var/run/kubernetes/proxy.crt",
		"--proxy-client-key-file=/var/run/kubernetes/proxy.key",
		"--request-timeout=2m",
		"--storage-backend=etcd3",
		"--service-cluster-ip-range=192.168.128.0/17",
		"--lease-reuse-duration-seconds=100",
	}
	fs.Parse(args)

	// This is a snapshot of expected options parsed by args.

	}

	// construct a log string that contains 128 characters
	line := ""
	for i := 0; i < 8; i++ {
		line += "0123456789ABCDEF" // 16 characters
	}

	// make sure that all log outputs is much larger than 2M
	wg := sync.WaitGroup{}
	for i := 0; i < 4; i++ {
		wg.Add(1)
		go func() {
			for ii := 0; ii < 1024; ii++ {
				for j := 0; j < 8; j++ {
					log.Println(line)
				}
			}
			wg.Done()
		}()