wantRm      []indexPhase
		wantLeft    []indexPhase
		completions int32
	}{
		"all unique": {
			pods: []indexPhase{
				{noIndex, v1.PodPending},
				{"2", v1.PodPending},
				{"5", v1.PodRunning},
				{"6", v1.PodRunning},
			},
			wantRm: []indexPhase{
				{noIndex, v1.PodPending},
				{"6", v1.PodRunning},
			},
			wantLeft: []indexPhase{
				{"2", v1.PodPending},

		return false, nil
	}

	// How much will be left after adding the file.
	available -= uint64(size)

	// wantLeft is how much space there at least must be left.
	wantLeft := uint64(float64(total) * (1.0 - diskFillFraction))
	return available > wantLeft, nil

		wantText:   "inner error with added context",
		wantUnwrap: wrapped,
	}, {
		err:        fmt.Errorf("%s %w %v", "prefix", wrapped, "suffix"),
		wantText:   "prefix inner error suffix",
		wantUnwrap: wrapped,
	}, {
		err:        fmt.Errorf("%[2]s: %[1]w", wrapped, "positional verb"),
		wantText:   "positional verb: inner error",
		wantUnwrap: wrapped,
	}, {
		err:      fmt.Errorf("%v", wrapped),
		wantText: "inner error",

		"any enabled with volume ds": {
			dataSource: volumeDataSource,
			anyEnabled: true,
			want:       volumeDataSource,
			wantRef:    volumeDataSourceRef,
		},
		"any enabled with snapshot ds": {
			dataSource: snapshotDataSource,
			anyEnabled: true,
			want:       snapshotDataSource,
			wantRef:    snapshotDataSourceRef,
		},
		"any enabled with generic ds": {
			dataSource: genericDataSource,
			anyEnabled: true,

				}
				if (ss.ClusterSent != "") != wantSent {
					errorHandler("wanted ClusterSent set %v got %v for %v", wantSent, ss.ClusterSent, nodeID)
				}
				if (ss.ClusterAcked != "") != wantAcked {
					errorHandler("wanted ClusterAcked set %v got %v for %v", wantAcked, ss.ClusterAcked, nodeID)
				}
				if (ss.ListenerSent != "") != wantSent {

			want:    snapshotDataSource,
			wantRef: snapshotDataSourceRef,
		},
		"generic ds": {
			spec:    core.PersistentVolumeClaimSpec{DataSource: genericDataSource},
			want:    genericDataSource,
			wantRef: genericDataSourceRef,
		},
		"core ds": {
			spec:    core.PersistentVolumeClaimSpec{DataSource: coreDataSource},
			want:    coreDataSource,
			wantRef: coreDataSourceRef,
		},
		"volume ds ref": {

		t.Errorf("%s", diff.Diff("pkg.Markdown", b, "want", []byte(wantMarkdown)))
	}
	if b := pkg.Text(input); string(b) != wantText {
		t.Errorf("%s", diff.Diff("pkg.Text", b, "want", []byte(wantText)))
	}
	if b := pkg.Synopsis(input); b != wantSynopsis {
		t.Errorf("%s", diff.Diff("pkg.Synopsis", []byte(b), "want", []byte(wantText)))
	}

	var buf bytes.Buffer

	buf.Reset()
	ToHTML(&buf, input, map[string]string{"types": ""})

		name      string
		replace   func([]string, Attr) Attr
		addSource bool
		with      func(Handler) Handler
		preAttrs  []Attr
		attrs     []Attr
		wantText  string
		wantJSON  string
	}{
		{
			name:     "basic",
			attrs:    attrs,
			wantText: "time=2000-01-02T03:04:05.000Z level=INFO msg=message a=one b=2",
			wantJSON: `{"time":"2000-01-02T03:04:05Z","level":"INFO","msg":"message","a":"one","b":2}`,
		},
		{

			want:          true,
			wantRef:       true,
		},
		"any enabled with empty ds": {
			anyEnabled: true,
		},
		"any enabled with volume ds": {
			anyEnabled: true,
			dataSource: true,
			want:       true,
			wantRef:    true,
		},
		"any enabled with volume ds ref": {
			anyEnabled:    true,
			dataSourceRef: true,
			want:          true,
			wantRef:       true,
		},

	t.Run("text", func(t *testing.T) {
		var b bytes.Buffer
		h := newFastTextHandler(&b)
		if err := h.Handle(ctx, r); err != nil {
			t.Fatal(err)
		}
		got := b.String()
		if got != wantText {
			t.Errorf("\ngot  %q\nwant %q", got, wantText)
		}
	})
	t.Run("async", func(t *testing.T) {
		h := newAsyncHandler()
		if err := h.Handle(ctx, r); err != nil {
			t.Fatal(err)
		}
		got := h.ringBuffer[0]