if !empty(c.GetFilterChainMatch()) {
			anySet = true
			break
		}
	}
	if !anySet {
		log.Debugf("%v: none set, skipping", desc)
		return chains
	}
	for i, c := range chains {
		if match(c.GetFilterChainMatch()) {
			log.Debugf("%v: matched chain %v/%v", desc, i, c.GetName())
			res = append(res, c)
		}
	}
	// Return all matching filter chains
	if len(res) > 0 {
		return res
	}

  }

 private:
  Option<bool> skip_raise_cpu_ops_{
      *this, "skip-raise-cpu-ops",
      llvm::cl::desc("Whether to cluster and raise CPU ops."),
      llvm::cl::init(false)};

  Option<bool> ignore_inference_type_{
      *this, "ignore-inference-type",
      llvm::cl::desc("Whether to ignore the inference type in clustering."),
      llvm::cl::init(false)};

  llvm::StringRef getArgument() const final {

    "tf-xla-input-types",
    llvm::cl::desc("XLA input argument types (kinds), separated by ','. "
                   "Supported types include ['parameter', 'resource']. If "
                   "empty, all arguments are assumed to be parameters."),
    llvm::cl::init(""));
// NOLINTNEXTLINE
llvm::cl::opt<bool> emit_use_tuple_arg(
    "tf-xla-emit-use-tuple-args",
    llvm::cl::desc(

func (p *parser) parseEvent(raw *rawEvent, ev *Event) error {
	desc := &EventDescriptions[raw.typ]
	if desc.Name == "" {
		return fmt.Errorf("missing description for event type %d", raw.typ)
	}
	narg := raw.argNum()
	if len(raw.args) != narg {
		return fmt.Errorf("%s has wrong number of arguments: want %d, got %d", desc.Name, narg, len(raw.args))
	}
	switch raw.typ {
	case EvBatch:

static llvm::cl::opt<bool> print_function_result_mapping(
    "print-function-result-mapping",
    llvm::cl::desc(
        "Print the mapping of function result to flatbuffer output buffer"),
    llvm::cl::init(false));

// NOLINTNEXTLINE
static llvm::cl::opt<std::string> weight_quantization(
    "weight_quantization",
    llvm::cl::desc("The type of the quantized weight buffer. Must be NONE, "
                   "INT8, FLOAT16."),

        0 * delegate._

        where:
        [maxRetries, exception, effectiveRetries] << retryCombinations()
    }

    @Unroll
    def "blocks repo immediately when receives #desc"() {
        access = createAccess(1)

        given:
        def artifact = Mock(ComponentArtifactMetadata)
        def artifactId = Mock(ComponentArtifactIdentifier)

        expectReindentedValidationMessage()
        // This is required for the daemon to clean up symlinks between builds
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
    }

    def "#desc can handle symlinks"() {
        def buildScript = file("build.gradle")
        def baseDir = file('build')
        baseDir.file('file').text = 'some contents'
        def symlinked = baseDir.file('symlinked')

  Option<std::string> force_data_format{
      *this, "force-data-format",
      llvm::cl::desc("Force data format for all layout sensitive ops")};
  Option<bool> skip_fold_transpose_in_ops{
      *this, "skip-fold-transpose-in-ops",
      llvm::cl::desc("Skip folding transpose operands in Ops which can support "
                     "different layouts.")};
};

      *this, "post-training-quantize", llvm::cl::init(false),
      llvm::cl::desc("Enable post training quantization. Only used in tests.")};

  // A local flag is needed for testing conditions in
  // prepare_quantize_ptq_per_channel.mlir.
  Option<bool> enable_per_channel_quantization_{
      *this, "enable-per-channel-quantization", llvm::cl::init(false),
      llvm::cl::desc("Whether enable per-channel quantized weights.")};
};

		}
		if err := store.Add(makeTestPod("bar", 5)); err != nil {
			t.Errorf("unexpected error: %v", err)
		}
	}()

	testCases := []struct {
		desc            string
		resourceVersion uint64
		want            string
	}{
		{
			desc:            "resourceVersion is non-zero",
			resourceVersion: 5,
			want: `