fun parseIanaCsvRow(s: String): SuiteId? {
  if (s.contains("Reserved") || s.contains("Unassigned")) return null
  val matcher = IANA_CSV_PATTERN.matchEntire(s) ?: return null
  val id = (matcher.groupValues[1] + matcher.groupValues[2]).decodeHex()
  return SuiteId(id, matcher.groupValues[3])
}

class IanaSuites(
  val name: String,
  val suites: List<SuiteId>,
) {
  fun fromJavaName(javaName: String): SuiteId {

                "color": "red",
                "value": 80
              }
            ]
          },
          "unit": "short"
        },
        "overrides": [
          {
            "matcher": {
              "id": "byName",
              "options": "Replication Errors"
            },
            "properties": [
              {
                "id": "color",
                "value": {

type DeploymentController struct {
	client         kube.Client
	clusterID      cluster.ID
	env            *model.Environment
	queue          controllers.Queue
	patcher        patcher
	gateways       kclient.Client[*gateway.Gateway]
	gatewayClasses kclient.Client[*gateway.GatewayClass]

	clients         map[schema.GroupVersionResource]getter
	injectConfig    func() inject.WebhookConfig

        Matcher matcher = UNIQUE_SNAPSHOT.matcher(moduleComponentIdentifier.getVersion());
        if (!matcher.matches()) {
            return null;
        }
        return new MavenUniqueSnapshotModuleSource(matcher.group(1));
    }

    private MavenMetadata parseMavenMetadata(ExternalResourceName metadataLocation) {

		case "SUCCESS":
		case "FAILURE":
			exp.failure = true
			if len(c) != 2 {
				return exp, fmt.Errorf("bad header line for FAILURE: %q", s.Text())
			}
			matcher, err := parseMatcher(c[1])
			if err != nil {
				return exp, err
			}
			exp.errorMatcher = matcher
		default:
			return exp, fmt.Errorf("bad header line: %q", s.Text())
		}
		return exp, nil
	}
	return exp, s.Err()
}

	expressionOptionalVars := cel.OptionalVariableDeclarations{HasParams: hasParam, HasAuthorizer: false, StrictCost: strictCost}
	failurePolicy := policy.Spec.FailurePolicy
	var matcher matchconditions.Matcher = nil
	matchConditions := policy.Spec.MatchConditions
	var compositionEnvTemplate *cel.CompositionEnv
	if strictCost {
		compositionEnvTemplate = compositionEnvTemplateWithStrictCost
	} else {

            return null;
        }
        StringBuilder builder = new StringBuilder();
        Matcher matcher = WORD_SEPARATOR.matcher(string);
        int pos = 0;
        boolean first = true;
        while (matcher.find()) {
            String chunk = string.subSequence(pos, matcher.start()).toString();
            pos = matcher.end();
            if (chunk.isEmpty()) {
                continue;
            }

			requestURI: "http://server/apis/foo.bar/v1/events?watch=true&sendInitialEvents=true",
			requestInfo: &apirequest.RequestInfo{
				Verb:     "watch",
				APIGroup: "foo.bar",
				Resource: "events",
			},
			counts: map[string]int64{
				"events.foo.bar": 799,
			},
			initialSeatsExpected: 8,
		},
		{
			name:       "request verb is create, no watches",

	m := &matcher.StringMatcher{}

	m.MatchPattern = &matcher.StringMatcher_Prefix{
		Prefix: spiffe.URIPrefix + push.Mesh.GetTrustDomain() + "/ns/" + proxy.Metadata.Namespace + "/sa/",
	}
	return cb.buildConnectOriginate(proxy, push, m)
}

func (cb *ClusterBuilder) buildConnectOriginate(proxy *model.Proxy, push *model.PushContext, uriSanMatchers ...*matcher.StringMatcher) *cluster.Cluster {

		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			var matcher matchconditions.Matcher
			if tc.matcher == nil {
				matcher = &fakeCELMatcher{matches: true}
			} else {
				matcher = tc.matcher
			}
			v := validator{
				failPolicy: tc.failPolicy,
				celMatcher: matcher,
				validationFilter: &fakeCelFilter{
					evaluations: tc.evaluations,