return false, nil
}

func (ctx *context) runGenerators() error {
	generators, err := filepath.Glob("./generators/*.go")
	if err != nil {
		return fmt.Errorf("reading generators: %v", err)
	}
	genroot := "./tests"

	if err := os.MkdirAll(genroot, 0777); err != nil {
		return fmt.Errorf("creating generated root: %v", err)
	}
	for _, path := range generators {
		name := filepath.Base(path)

	Env *model.Environment

	// Generators allow customizing the generated config, based on the client metadata.
	// Key is the generator type - will match the Generator metadata to set the per-connection
	// default generator, or the combination of Generator metadata and TypeUrl to select a
	// different generator for a type.
	// Normal istio clients use the default generator - will not be impacted by this.

	"internal/trace"
	"internal/trace/traceviewer"
	"strings"
)

// generator is an interface for generating a JSON trace for the trace viewer
// from a trace. Each method in this interface is a handler for a kind of event
// that is interesting to render in the UI via the JSON trace.
type generator interface {
	// Global parts.
	Sync() // Notifies the generator of an EventSync event.
	StackSample(ctx *traceContext, ev *trace.Event)

            .ask();
        List<BuildGenerator> generators = projectLayoutRegistry.getGeneratorsFor(componentType);
        if (generators.size() == 1) {
            return generators.get(0);
        }

        Map<Language, BuildGenerator> generatorsByLanguage = new LinkedHashMap<>();
        for (Language language : Language.values()) {
            for (BuildGenerator generator : generators) {

}

// OpenAPISchemaType is used by the kube-openapi generator when constructing
// the OpenAPI spec of this type.
//
// See: https://github.com/kubernetes/kube-openapi/tree/master/pkg/generators
func (_ MicroTime) OpenAPISchemaType() []string { return []string{"string"} }

// OpenAPISchemaFormat is used by the kube-openapi generator when constructing
// the OpenAPI spec of this type.

	if g, f := s.Generators[con.proxy.Metadata.Generator+"/"+typeURL]; f {
		return g
	}
	if g, f := s.Generators[string(con.proxy.Type)+"/"+typeURL]; f {
		return g
	}

	if g, f := s.Generators[typeURL]; f {
		return g
	}

	// XdsResourceGenerator is the default generator for this connection. We want to allow
	// some types to use custom generators - for example EDS.

        def generator = new ProblematicClassGenerator(className, sourceSet)
        generator.addError()
        generator.addError()
        return generator.save()
    }

    TestFile writeJavaCausingTwoCompilationWarnings(String className) {
        def generator = new ProblematicClassGenerator(className)
        generator.addWarning()
        generator.addWarning()
        return generator.save()

/generators/sir-tests-generator/ "Kotlin Native"
/generators/protobuf/ "Kotlin Build Infrastructure"
# UNKNOWN: /generators/protobufCompare/
/generators/test-generator/ "Kotlin Compiler Core" "Kotlin JVM" "Kotlin Native" "Kotlin Wasm" "Kotlin Common Backend"
/generators/tests/ "Kotlin Compiler Core" "Kotlin JVM" "Kotlin Native" "Kotlin Wasm" "Kotlin Common Backend"

 */

import gradlebuild.performance.generator.tasks.BuildBuilderGenerator
import gradlebuild.performance.generator.tasks.CppMultiProjectGeneratorTask
import gradlebuild.performance.generator.tasks.JavaExecProjectGeneratorTask
import gradlebuild.performance.generator.tasks.JvmProjectGeneratorTask
import gradlebuild.performance.generator.tasks.KtsProjectGeneratorTask
import gradlebuild.performance.generator.tasks.MonolithicNativeProjectGeneratorTask

#include "tensorflow/c/experimental/ops/gen/model/arg_type.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {
namespace cpp {

ArgTypeView::ArgTypeView(ArgType arg_type) : arg_type_(arg_type) {}

string ArgTypeView::TypeName() const {
  if (arg_type_.is_read_only()) {
    if (arg_type_.is_list()) {