def classNames = [ 'allowed.Class1', 'allowed.Class2' ]
        def disallowedClassNames = [ 'disallowed.Class1', 'disallowed.Class2' ]
        def packagePrefixes = [ 'allowed.pkgprefix1.', 'allowed.pkgprefix2' ]
        def disallowedPackagePrefixes = [ 'disallowed.pkgprefix1.', 'disallowed.pkgprefix2.' ]
        def packageNames = [ 'allowed.pkg1', 'allowed.pkg2' ]

			origins:        []string{"http://example.com", "example.com"},
			allowed:        true,
		},
		{
			name:           "allowed regexp is not a match",
			allowedOrigins: []string{"example.com"},
			origins:        []string{"http://not-allowed.com", "not-allowed.com"},
			allowed:        false,
		},
		{
			name:           "allowed list with multiple regex",
			allowedOrigins: []string{"not-matching.com", "example.com"},

    def filteringClassloaderSpec() {
        def classNames = [ 'allowed.Class1', 'allowed.Class2' ]
        def disallowedClassNames = [ 'disallowed.Class1', 'disallowed.Class2' ]
        def packagePrefixes = [ 'allowed.pkgprefix1.', 'allowed.pkgprefix2' ]
        def disallowedPackagePrefixes = [ 'disallowed.pkgprefix1.', 'disallowed.pkgprefix2.' ]
        def packageNames = [ 'allowed.pkg1', 'allowed.pkg2' ]

			},
			expectAllowed: true,
		},
		// Allowed mutating
		{
			name:     "v1beta1 allowed mutating",
			uid:      "123",
			mutating: true,
			review: &admissionv1beta1.AdmissionReview{
				Response: &admissionv1beta1.AdmissionResponse{Allowed: true},
			},
			expectAllowed: true,
		},
		{
			name:     "v1 allowed mutating",
			uid:      "123",

kind: VirtualService
metadata:
  name: route-via-egressgateway-2
  namespace: {{ .From.NamespaceName }}
spec:
  hosts:
    - "{{ .Allowed.ServiceName }}-{{ .Allowed.NamespaceName }}-only.com"
    - "jwt-only.com"
    - "jwt-and-{{ .Allowed.ServiceName }}-{{ .Allowed.NamespaceName }}-only.com"
  gateways:
    - test-egress
    - mesh
  http:
    - match:
        - gateways:
            - mesh

		printTests := func() {
			if code++; allowed(code) {
				p(b, "	if code == %v { break }\n", code)
			}
			if code++; allowed(code) {
				p(b, "	if code == %v { continue }\n", code)
			}
			if code++; allowed(code) {
				p(b, "	switch { case code == %v: continue }\n", code)
			}
			if code++; allowed(code) {
				p(b, "	if code == %v { return %[1]v }\n", code)
			}

			Response: &v1beta1.AdmissionResponse{
				Allowed: false,
				Result: &metav1.Status{
					Code: http.StatusForbidden,
				},
			},
		})
	case "/disallowReason":
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(&v1beta1.AdmissionReview{
			Response: &v1beta1.AdmissionResponse{
				Allowed: false,
				Result: &metav1.Status{
					Message: "you shall not pass",

				Object:    runtime.RawExtension{Raw: extraKeyConfig},
				Operation: kube.Create,
			},
			allowed: false,
		},
	}

	for i, c := range cases {
		t.Run(fmt.Sprintf("[%d] %s", i, c.name), func(t *testing.T) {
			got := wh.validate(c.in)
			if got.Allowed != c.allowed {
				t.Fatalf("got %v want %v", got.Allowed, c.allowed)
			}
		})
	}
}

				"m/a",
				"m/b",
				"m/c",
				"m/a"
			],
			"Pos": "",
			"Err": "import cycle not allowed"
		}
	]
}
{
	"ImportPath": "m/b",
	"DepsErrors": [
		{
			"ImportStack": [
				"m/a",
				"m/b",
				"m/c",
				"m/a"
			],
			"Pos": "",
			"Err": "import cycle not allowed"
		}
	]
}
{
	"ImportPath": "m/a",
	"Error": {
		"ImportStack": [
			"m/a",
			"m/b",

        'resolve()'                  | 'dependencyScope' | 'resolve()'                                                                                                                          || "Resolving dependency configuration 'custom' is not allowed as it is defined as 'canBeResolved=false'."