}
	if got := TranslateCORSPolicy(node, corsPolicy); !reflect.DeepEqual(got, expectedCorsPolicy) {
		t.Errorf("TranslateCORSPolicy() = \n%v, want \n%v", got, expectedCorsPolicy)
	}
}

func TestTranslateCORSPolicy(t *testing.T) {
	node := &model.Proxy{
		IstioVersion: &model.IstioVersion{
			Major: 1,
			Minor: 21,
			Patch: 0,
		},
	}
	corsPolicy := &networking.CorsPolicy{
		AllowOrigins: []*networking.StringMatch{

kind: VirtualService
metadata:
  name: cors
  namespace: testns
spec:
  hosts:
    - cors.test.istio.io
  http:
    - route:
      - destination:
          host: cors.test.istio.io
      corsPolicy:
        allowOrigins:
          - exact: http://foo.example
        allowMethods:
          - POST
          - GET
          - OPTIONS
        allowHeaders:
          - content-type
        exposeHeaders:

"ingress"
"outgress"
"outboundTrafficPolicy"
"captureMode"
"defaultEndpoint"
"gateways"
"delegate"
"redirect"
"rewrite"
"timeout"
"retries"
"fault"
"mirror"
"mirrorPercentage"
"corsPolicy"
"headers"
"mirrorPercent"
"namespace"
"request"
"response"
"route"
"uri"
"method"
"authority"
"sourceLabels"
"queryParams"
"ignoreUriCase"
"withoutHeaders"

	"{.spec.gateways[0]}":                                           1,
	"{.spec.http[0].match[0].test.regex}":                           1,
	"{.spec.http[0].match[0].test.test.regex}":                      1,
	"{.spec.http[0].corsPolicy.allowOrigins[0].regex}":              1,
	"{.spec.workloadSelector.labels.test}":                          1,
	"{.spec.ports[0].port}":                                         1,

	HeaderAndQueryParamsRegexMatch = "{.spec.http[%d].match[%d].%s.%s.regex}"

	// Path for regex match of allowOrigins.
	// Required parameters: http index, allowOrigins index.
	AllowOriginsRegexMatch = "{.spec.http[%d].corsPolicy.allowOrigins[%d].regex}"

	// Path for workload selector.
	// Required parameters: selector label.
	WorkloadSelector = "{.spec.workloadSelector.labels.%s}"

	// Path for port from ports collections.

	}
	if in.Fault != nil || in.CorsPolicy != nil {
		out.TypedPerFilterConfig = make(map[string]*any.Any)
	}
	if in.Fault != nil {
		out.TypedPerFilterConfig[wellknown.Fault] = protoconv.MessageToAny(istio_route.TranslateFault(in.Fault))
	}
	if in.CorsPolicy != nil {
		out.TypedPerFilterConfig[wellknown.CORS] = protoconv.MessageToAny(istio_route.TranslateCORSPolicy(lb.node, in.CorsPolicy))
	}

	return out
}

		delegate.MirrorPercent = root.MirrorPercent
	}
	if delegate.MirrorPercentage == nil {
		delegate.MirrorPercentage = root.MirrorPercentage
	}
	if delegate.CorsPolicy == nil {
		delegate.CorsPolicy = root.CorsPolicy
	}
	if delegate.Mirrors == nil {
		delegate.Mirrors = root.Mirrors
	}
	if delegate.Headers == nil {
		delegate.Headers = root.Headers
	}
	return delegate
}

	}
	if in.Fault != nil || in.CorsPolicy != nil {
		out.TypedPerFilterConfig = make(map[string]*anypb.Any)
	}
	if in.Fault != nil {
		out.TypedPerFilterConfig[wellknown.Fault] = protoconv.MessageToAny(TranslateFault(in.Fault))
	}
	if in.CorsPolicy != nil {
		out.TypedPerFilterConfig[wellknown.CORS] = protoconv.MessageToAny(TranslateCORSPolicy(node, in.CorsPolicy))
	}

	}
	for _, name := range http.Headers.GetResponse().GetRemove() {
		errs = AppendValidation(errs, ValidateHTTPHeaderOperationName(name))
	}

	errs = AppendValidation(errs, validateCORSPolicy(http.CorsPolicy))
	errs = AppendValidation(errs, validateHTTPFaultInjection(http.Fault))

	// nolint: staticcheck
	if http.MirrorPercent != nil {
		if value := http.MirrorPercent.GetValue(); value > 100 {

			*r = wrapperspb.UInt32Value{}
		},
		func(r *networking.Percent, c fuzz.Continue) {
			*r = networking.Percent{}
		},
		func(r *networking.CorsPolicy, c fuzz.Continue) {
			*r = networking.CorsPolicy{}
		},
		func(r *networking.Headers, c fuzz.Continue) {
			*r = networking.Headers{}
		},
		func(r *networking.HTTPMirrorPolicy, c fuzz.Continue) {