for _, a := range c.analyzers {
		for _, inputKind := range a.Metadata().Inputs {
			if kinds.Contains(inputKind) {
				selected = append(selected, a)
				break
			}
		}
	}
	return Combine("subset", selected...)
}

// Metadata implements Analyzer
func (c *InternalCombinedAnalyzer) Metadata() Metadata {
	return Metadata{
		Name:   c.name,
		Inputs: combineInputs(c.analyzers),
	}
}

// Analyze implements Analyzer

  std::vector<tensorflow::Tensor> inputs;

  // Adds inputs to the TF operation.
  for (const ElementsAttr& operand : operands) {
    tensorflow::Tensor tensor;
    RETURN_FAILURE_IF_ERROR(tensorflow::ConvertToTensor(operand, &tensor));
    inputs.push_back(std::move(tensor));
  }

  std::vector<tensorflow::TensorValue> input_values;
  for (tensorflow::Tensor& tensor : inputs) {
    input_values.emplace_back();

    }

    def "accepts no vcs commit ids"() {
        expect:
        new TestPageGenerator().createGitHubLinks(inputs).isEmpty()

        where:
        inputs << [[], null]
    }

      }))
    return failure();

  SmallVector<ElementsAttr, 4> inputs;
  inputs.reserve(operands.size());
  for (auto input : operands) {
    inputs.push_back(mlir::cast<ElementsAttr>(input));
  }

  SmallVector<Attribute> constants;
  LogicalResult status = EvaluateOperation(inst, inputs, constants);
  results.assign(constants.begin(), constants.end());
  return status;
}

# RUN: tf_tfl_translate -tf-input-arrays=input0,input1 \
# RUN:                  -tf-input-shapes=4:4 \
# RUN:                  -tf-input-data-types=DT_FLOAT,DT_FLOAT \
# RUN:                  -tf-output-arrays=Add \
# RUN:                  -tf-inference-type=DT_QUINT8 \
# RUN:                  -tf-input-min-values='-2,-3' \
# RUN:                  -tf-input-max-values='2,3' \
# RUN:                  --quant-stats=%s.stats \

// CHECK-NEXT:         quantization: {
// CHECK-EMPTY:
// CHECK-NEXT:         },
// CHECK-NEXT:         has_rank: true
// CHECK-NEXT:       } ],
// CHECK-NEXT:       inputs: [ 0 ],
// CHECK-NEXT:       outputs: [ 1 ],
// CHECK-NEXT:       operators: [ {
// CHECK-NEXT:         inputs: [ 0 ],
// CHECK-NEXT:         outputs: [ 1 ],
// CHECK-NEXT:         builtin_options_type: FakeQuantOptions,
// CHECK-NEXT:         builtin_options: {

	"istio.io/istio/pkg/config/schema/collections"
	"istio.io/istio/pkg/config/schema/resource"
)

func ConvertInputsToSchemas(inputs []config.GroupVersionKind) collection.Schemas {
	resultBuilder := collection.NewSchemasBuilder()
	for _, gv := range inputs {
		s, f := collections.All.FindByGroupVersionKind(gv)
		if !f {
			continue
		}
		_ = resultBuilder.Add(s)
	}

	return resultBuilder.Build()
}

            gradle.buildFinished { }
            classes {
                inputs.property('p', project)
                doLast { t -> t.project }
            }
        """
        buildFile << """
            tasks.register("broken") {
                gradle.addListener(new BuildAdapter())
                inputs.property('p', project).optional(true)
                doLast { }
            }

// information to the abstract model and/or elevating k8s
// representation to first-class type to avoid extra conversions.

func parseInputsImpl(inputs string, withValidate bool) ([]config.Config, []IstioKind, error) {
	var varr []config.Config
	var others []IstioKind
	reader := bytes.NewReader([]byte(inputs))
	empty := IstioKind{}

	// We store configs as a YaML stream; there may be more than one decoder.

    def "fails build when packing archive fails"() {
        when:
        file("input.txt") << "data"

        // Just a way to induce a packing error, i.e. corrupt/partial archive
        buildFile << """
            apply plugin: "base"
            task customTask {
                inputs.file "input.txt"
                outputs.file "build/output" withPropertyName "output"
                outputs.cacheIf { true }