def "does not schedule garbage collection check when GC strategy is unknown" () {
        when:
        new DefaultGarbageCollectionMonitor(GarbageCollectorMonitoringStrategy.UNKNOWN, scheduledExecutorService)

        then:
        0 * scheduledExecutorService.scheduleAtFixedRate(_, _, _, _)
    }

    def "heap stats defaults to empty given unknown garbage collector"() {
        given:

  protobuf::TextFormat::Parser parser;
  // Don't produce errors when attempting to parse text format as it would fail
  // when the input is actually a binary file.
  NoOpErrorCollector collector;
  parser.RecordErrorsTo(&collector);
  // Attempt to parse as text.
  absl::string_view text_proto_without_prefix = text_proto;
  if (!prefix_to_strip.empty()) {
    TF_RETURN_IF_ERROR(

            String publishedVariantName = outgoingConfigurationName + StringUtils.capitalize(subvariant.getName());
            visitVariant(collector, seen, subvariant, publishedVariantName);
        }
    }

    private void visitVariant(
        Consumer<UsageContext> collector,
        Set<String> seen,
        ConfigurationVariant subvariant,
        String name
    ) {

  selector:
    app: jaeger
---
apiVersion: v1
kind: Service
metadata:
  name: jaeger-collector
  namespace: istio-system
  labels:
    app: jaeger
spec:
  type: ClusterIP
  ports:
  - name: jaeger-collector-http
    port: 14268
    targetPort: 14268
    protocol: TCP
  - name: jaeger-collector-grpc
    port: 14250
    targetPort: 14250
    protocol: TCP
  - port: 9411

	ch <- volumeStatsInodesUsedDesc
	ch <- volumeStatsHealthAbnormalDesc
}

// CollectWithStability implements the metrics.StableCollector interface.
func (collector *volumeStatsCollector) CollectWithStability(ch chan<- metrics.Metric) {
	ctx := context.Background()
	podStats, err := collector.statsProvider.ListPodStats(ctx)
	if err != nil {
		return
	}
	addGauge := func(desc *metrics.Desc, pvcRef *stats.PVCReference, v float64, lv ...string) {

        Object value = it[key]
        toExclude(key, value)
    }

    private void collectOperands(Object value, List<String> collector) {
        if (value instanceof List) {
            value.each {
                collectOperands(it, collector)
            }
        } else {
            collector << toExclude(value)
        }
    }

    private String toExclude(String opType, Object value) {

        unit.addSource("action", src)
        ClassCollector collector = new ClassCollector(target: target)
        unit.setClassgenCallback(collector);
        unit.compile(Phases.CLASS_GENERATION);

        Object instance = JavaReflectionUtil.newInstance(collector.generated)
        instance.key = counter.getAndIncrement()
        ACTIONS[instance.key] = action
        return instance

    @Override
    public void collectArguments(JavaCompileSpec spec, ArgCollector collector) {
        for (String arg : generate(spec)) {
            collector.args(arg);
        }
    }

    public Iterable<String> generate(JavaCompileSpec spec) {

    private final Symlink symlink;
    private final FileMetadataAccessor metadata;
    private final StatStatistics.Collector statisticsCollector;

    public GenericFileSystem(
        FileModeMutator chmod,
        FileModeAccessor stat,
        Symlink symlink,
        FileMetadataAccessor metadata,
        StatStatistics.Collector statisticsCollector,
        TemporaryFileProvider temporaryFileProvider
    ) {

        ProblemCollector collector = ProblemCollectorFactory.newInstance(null);
        problems.forEach(p -> collector.add(
                Problem.Severity.valueOf(p.getSeverity().name()),
                p.getMessage(),
                p.getLineNumber(),
                p.getColumnNumber(),
                p.getException()));
        return collector.getProblems();
    }