map.put("data1", 20);
        assertTrue(docBoostMatcher.match(map));

        map.put("data1", 5);
        assertFalse(docBoostMatcher.match(map));

        map.remove("data1");
        assertFalse(docBoostMatcher.match(map));

        map.put("data2", 5);
        assertFalse(docBoostMatcher.match(map));
    }

    public void test_string() {

  name: testing-service-01-test-02
  namespace: default
spec:
  gateways:
  - istio-system/testing-gateway-01-test-02
  hosts:
  - 'web.testing-02.com' # Expected: no validation error since this host match the wildcard
  http:
  - match:
    - uri:
        prefix: /
    route:
    - destination:
        host: ratings
---
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:

		return true
	}
	// match: (MOVBUreg x:(FEQS _ _))
	// result: x
	for {
		x := v_0
		if x.Op != OpRISCV64FEQS {
			break
		}
		v.copyOf(x)
		return true
	}
	// match: (MOVBUreg x:(FNES _ _))
	// result: x
	for {
		x := v_0
		if x.Op != OpRISCV64FNES {
			break
		}
		v.copyOf(x)
		return true
	}
	// match: (MOVBUreg x:(FLED _ _))
	// result: x

  namespace: default
spec:
  gateways:
    - istio-system/testing-gateway-2
  hosts:
    - testing-01.com # Expected: no validation error because the gateway ns prefix is a wildcard match
  http:
    - match:
        - uri:
            prefix: /
      route:
        - destination:
            host: ratings
---
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: testing-gateway-3

	if match == nil {
		return true
	}

	gatewayMatch := len(match.Gateways) == 0
	for _, gateway := range match.Gateways {
		gatewayMatch = gatewayMatch || gateways.Contains(gateway)
	}

	labelMatch := labels.Instance(match.SourceLabels).SubsetOf(proxyLabels)

	portMatch := match.Port == 0 || match.Port == uint32(port)

	nsMatch := match.SourceNamespace == "" || match.SourceNamespace == proxyNamespace

	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (AtomicLoad32 ptr mem)
	// result: (LoweredAtomicLoad32 [1] ptr mem)
	for {
		ptr := v_0
		mem := v_1
		v.reset(OpPPC64LoweredAtomicLoad32)
		v.AuxInt = int64ToAuxInt(1)
		v.AddArg2(ptr, mem)
		return true
	}
}
func rewriteValuePPC64_OpAtomicLoad64(v *Value) bool {
	v_1 := v.Args[1]
	v_0 := v.Args[0]
	// match: (AtomicLoad64 ptr mem)

							},
						},
					},
				},
			},
			want: false,
		},
		{
			name: "full match",
			args: args{
				vh: &route.VirtualHost{
					Name: "scooby",
				},
				cp: &model.EnvoyFilterConfigPatchWrapper{
					Match: &networking.EnvoyFilter_EnvoyConfigObjectMatch{
						ObjectTypes: &networking.EnvoyFilter_EnvoyConfigObjectMatch_RouteConfiguration{

	}{
		{
			name:           "Direct match",
			err:            &StatusError{ErrStatus: metav1.Status{Reason: metav1.StatusReasonUnauthorized}},
			expectedReason: metav1.StatusReasonUnauthorized,
		},
		{
			name:           "No match",
			err:            errors.New("some other error"),
			expectedReason: metav1.StatusReasonUnknown,
		},
		{
			name:           "Nested match",

    with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
        app = FastAPI()

        @app.post("/")
        async def root(f: bytes = File()):
            return f  # pragma: nocover


def test_incorrect_multipart_installed_multi_form(monkeypatch):
    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
    with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):

			})
			for _, match := range matches {
				if includeConfigType {
					name := fmt.Sprintf("listener/%s", l.Name)
					fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\n", name, strings.Join(addresses, ","), port, match.match, match.destination)
				} else {
					fmt.Fprintf(w, "%v\t%v\t%v\t%v\n", strings.Join(addresses, ","), port, match.match, match.destination)
				}
			}
		} else {