and DoesNotExist.
                          type: string
                        values:
                          description: values is an array of string values. If the
                            operator is In or NotIn, the values array must be non-empty.
                            If the operator is Exists or DoesNotExist, the values

        fileWithDollars << "Some Text"
        FileCollection files = project.getLayout().files(dirAndFile)

        when:
        ant.property(name: "my.property", value: "doesNotExist")
        ant.delete {
            files.addToAntBuilder(delegate, null, antType)
        }

        then:
        !fileWithDollars.exists()

        where:

        [filename, antType] << [[

		webhookRetryBackoff  *wait.Backoff
		expectErr            bool
		expectErrorSubString string
	}{
		{
			name:                 "Unknown modes should return errors",
			modes:                []string{"DoesNotExist"},
			expectErr:            true,
			expectErrorSubString: "is not a valid mode",
		},
		{
			name:                 "At least one authorizationMode is necessary",
			modes:                []string{},

        // root build does not inject any plugins to second
        vcsMapping('org.test:second', second)
        // first build injects a plugin in second
        nestedVcsMapping(first, 'org.test:second', second, ['com.example.DoesNotExist'])

        dependency(first, "org.test:second")
        shouldResolve(first, second)

        when:
        succeeds("resolve")

        then:

		{"----", "dir/obj", BucketNameInvalid{Bucket: "----"}},
		{"bucket", "", ObjectNameInvalid{Bucket: "bucket", Object: ""}},
		{"bucket", "doesnotexist", ObjectNotFound{Bucket: "bucket", Object: "doesnotexist"}},
		{"bucket", "dir/doesnotexist", ObjectNotFound{Bucket: "bucket", Object: "dir/doesnotexist"}},
		{"bucket", "dir", ObjectNotFound{Bucket: "bucket", Object: "dir"}},
		{"bucket", "dir/", ObjectNotFound{Bucket: "bucket", Object: "dir/"}},

}

func TestRegisterIfSum(t *testing.T) {
	mt := monitortest.New(t)

	testDisabledSum.With(name.Value("foo"), kind.Value("bar")).Increment()
	mt.Assert(testDisabledSum.Name(), nil, monitortest.DoesNotExist)

	testConditionalSum.With(name.Value("foo"), kind.Value("bar")).Increment()
	mt.Assert(testConditionalSum.Name(), map[string]string{"name": "foo", "kind": "bar"}, monitortest.Exactly(1))
}

			op = selection.In
		case metav1.LabelSelectorOpNotIn:
			op = selection.NotIn
		case metav1.LabelSelectorOpExists:
			op = selection.Exists
		case metav1.LabelSelectorOpDoesNotExist:
			op = selection.DoesNotExist
		default:
			return nil, fmt.Errorf("%q is not a valid label selector operator", expr.Operator)
		}
		r, err := labels.NewRequirement(expr.Key, op, append([]string(nil), expr.Values...))
		if err != nil {

		op = selection.In
	case v1.ScopeSelectorOpNotIn:
		op = selection.NotIn
	case v1.ScopeSelectorOpExists:
		op = selection.Exists
	case v1.ScopeSelectorOpDoesNotExist:
		op = selection.DoesNotExist
	default:
		return nil, fmt.Errorf("%q is not a valid scope selector operator", ssr.Operator)
	}
	r, err := labels.NewRequirement(string(ssr.ScopeName), op, ssr.Values)
	if err != nil {
		return nil, err
	}

    matchExpressions:
    - key: istio-injection
      operator: DoesNotExist
    - key: istio.io/rev
      operator: DoesNotExist
  objectSelector:
    matchExpressions:
    - key: sidecar.istio.io/inject
      operator: In
      values:
      - "true"
    - key: istio.io/rev
      operator: DoesNotExist
  reinvocationPolicy: Never
  rules:
  - apiGroups:
    - ""

			},
		},
	}
	cronjobSpecWithTZinSchedule = batch.CronJobSpec{
		Schedule:          "CRON_TZ=UTC 5 5 * * ?",
		ConcurrencyPolicy: batch.AllowConcurrent,
		TimeZone:          ptr.To("Asia/DoesNotExist"),
		JobTemplate: batch.JobTemplateSpec{
			Spec: batch.JobSpec{
				Template: validPodTemplateSpec,
			},
		},
	}
)

func completionModePtr(m batch.CompletionMode) *batch.CompletionMode {
	return &m