auto predicate = [](const Graph& graph) {
    const std::string kStatefulPartitionedCallOp = "StatefulPartitionedCall";
    for (const Node* node : graph.nodes()) {
      auto node_op = node->type_string();
      if (node_op == kStatefulPartitionedCallOp) {
        // Functions called by StatefulfulPartitionedCall ops with
        // _XlaMustCompile=true are compiled by XLA.

                - key: payload
                - key: aud
                value:
                  orMatch:
                    valueMatchers:
                    - listMatch:
                        oneOf:
                          orMatch:
                            valueMatchers:
                            - stringMatch:
                                exact: audiences
                            - stringMatch:

		allErrs = append(allErrs, validateNestedValueValidationCompleteness(&v.AnyOf[i], s, sPath, vPath.Child("anyOf").Index(i), opts)...)
	}
	for i := range v.OneOf {
		allErrs = append(allErrs, validateNestedValueValidationCompleteness(&v.OneOf[i], s, sPath, vPath.Child("oneOf").Index(i), opts)...)
	}

	return allErrs
}

    assertEquals(0, ms.count(Color.BLUE));
    assertEquals(1, ms.count(Color.YELLOW));
    assertEquals(2, ms.count(Color.RED));
  }

  public void testIllegalCreate() {
    Collection<Color> empty = EnumSet.noneOf(Color.class);
    try {
      EnumMultiset.create(empty);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCreateEmptyWithClass() {

    private boolean useNativeIntegrations;
    private File userHomeDir;
    private File nativeBaseDir;
    private final EnumSet<NativeFeatures> initializedFeatures = EnumSet.noneOf(NativeFeatures.class);
    private final EnumSet<NativeFeatures> enabledFeatures = EnumSet.noneOf(NativeFeatures.class);

    public enum NativeFeatures {
        FILE_SYSTEM_WATCHING {
            @Override

  message AffineParams {
    float scale = 1;
    int32 zero_point = 2;
  }

  // Params to quantize the axis. Only one of the field can be used.
  message PerAxisParams {
    oneof params_oneof {
      // min/max of the ranges.
      MinMax min_max = 1;

      // affine parameters to quantize the per axis value.
      AffineParams affine_params = 2;
    }
  }

		},
		{
			name: "oneOf",
			in: &apiextensions.JSONSchemaProps{
				OneOf: []apiextensions.JSONSchemaProps{
					{Type: "boolean"},
					{Type: "string"},
				},
			},
			expected: new(spec.Schema),
			// not supported by openapi v2
			// expected: &spec.Schema{
			// 	SchemaProps: spec.SchemaProps{
			// 		OneOf: []spec.Schema{
			// 			*spec.BooleanProperty(),

    private List<ModelProblem> problems;

    private String source;

    private Model sourceModel;

    private Model rootModel;

    private Set<ModelProblem.Severity> severities = EnumSet.noneOf(ModelProblem.Severity.class);

    DefaultModelProblemCollector(ModelBuildingResult result) {
        this.result = result;
        this.problems = result.getProblems();

	if in.AllOf != nil {
		in, out := &in.AllOf, &out.AllOf
		*out = make([]JSONSchemaProps, len(*in))
		for i := range *in {
			(*in)[i].DeepCopyInto(&(*out)[i])
		}
	}

	if in.OneOf != nil {
		in, out := &in.OneOf, &out.OneOf
		*out = make([]JSONSchemaProps, len(*in))
		for i := range *in {
			(*in)[i].DeepCopyInto(&(*out)[i])
		}
	}
	if in.AnyOf != nil {
		in, out := &in.AnyOf, &out.AnyOf

*/

// Sent from CNI to ztunnel
message WorkloadRequest {
  oneof payload {
    AddWorkload add = 1;
    KeepWorkload keep = 5;
    DelWorkload del = 2;
    SnapshotSent snapshot_sent = 3;
  }
}

// Sent from ztunnel to CNI
message WorkloadResponse {
  oneof payload {
    Ack ack = 1;
  }