Any("a", nil),
			`a`, `<nil>`,
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			for _, opts := range []struct {
				name       string
				opts       HandlerOptions
				wantPrefix string
				modKey     func(string) string
			}{
				{
					"none",
					HandlerOptions{},
					`time=2000-01-02T03:04:05.000Z level=INFO msg="a message"`,
					func(s string) string { return s },
				},
				{
					"replace",

				// actually selected.
				r := resolveReplacement(m)
				keep[modkey(r)] = true
			}
		})

		if which == addBuildListZipSums {
			for _, m := range mg.BuildList() {
				r := resolveReplacement(m)
				if keepModSumsForZipSums {
					keep[modkey(r)] = true // we need the go version from the go.mod file to do anything useful with the zipfile
				}
				keep[r] = true

			if checksumOk("/go.mod") {
				gomod, err := modfetch.CachePath(ctx, mod, "mod")
				if err == nil {
					if info, err := os.Stat(gomod); err == nil && info.Mode().IsRegular() {
						m.GoMod = gomod
					}
				}
				if gomodsum, ok := modfetch.RecordedSum(modkey(mod)); ok {
					m.GoModSum = gomodsum
				}
			}
			if checksumOk("") {
				dir, err := modfetch.DownloadDir(ctx, mod)
				if err == nil {

        final String minKey = constraintAnnotation.minKey();
        if (StringUtil.isNotBlank(minKey)) {
            min = Integer.parseInt(fessConfig.get(minKey));
        }
        final String maxKey = constraintAnnotation.maxKey();
        if (StringUtil.isNotBlank(maxKey)) {
            max = Integer.parseInt(fessConfig.get(maxKey));
        }
        message = constraintAnnotation.message();

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface MapKey {
    String value();

  selfLink: selfLinkValue
  uid: uidValue
spec:
  limits:
  - default:
      defaultKey: "0"
    defaultRequest:
      defaultRequestKey: "0"
    max:
      maxKey: "0"
    maxLimitRequestRatio:
      maxLimitRequestRatioKey: "0"
    min:
      minKey: "0"

			expectedMetrics: expectedMetrics{1, 0},
		},
		{
			name:   "no-such-pod",
			podKey: podKey(testPodWithEphemeral),
		},
		{
			name: "pod-deleted",
			pods: func() []*v1.Pod {
				deleted := metav1.Now()
				pods := []*v1.Pod{testPodWithEphemeral.DeepCopy()}
				pods[0].DeletionTimestamp = &deleted
				return pods
			}(),
			podKey: podKey(testPodWithEphemeral),
		},
		{
			name:   "no-volumes",

				if c.Name == inject.ProxyContainerName {
					out.insertContainer(p.Namespace, deployment, p.Name, c.Name)
				}
			}
		}

		out.Labels[PodKey(p.Namespace, p.Name)] = p.Labels
		out.Annotations[PodKey(p.Namespace, p.Name)] = p.Annotations
		out.Pod[PodKey(p.Namespace, p.Name)] = &pods.Items[i]
	}

	return out, nil
}

// Resources defines a tree of cluster resource names.
type Resources struct {

			pods:          []*v1.Pod{testPodWithResource},
			templates:     nil,
			key:           podKey(testPodWithResource),
			expectedError: true,
		},
		{
			name:           "find-existing-claim-by-label",
			pods:           []*v1.Pod{testPodWithResource},
			key:            podKey(testPodWithResource),
			claims:         []*resourcev1alpha2.ResourceClaim{generatedTestClaim},

package gorm

import "time"

// Model a basic GoLang struct which includes the following fields: ID, CreatedAt, UpdatedAt, DeletedAt
// It may be embedded into your model or you may build your own model without it
//
//	type User struct {
//	  gorm.Model
//	}
type Model struct {
	ID        uint `gorm:"primarykey"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt DeletedAt `gorm:"index"`