generators.each { generator ->
                    generator.update(buffer, 0, len)
                }
            }
        }
        def signed = new File(toSign.parentFile, "${toSign.name}.asc")
        signed.newOutputStream().withCloseable { stream ->
            new ArmoredOutputStream(stream).withCloseable { out ->
                generators.each {
                    it.generate().encode(out)

	generators[v3.AddressType] = workloadGen
	generators[v3.WorkloadType] = workloadGen
	generators[v3.WorkloadAuthorizationType] = &xds.WorkloadRBACGenerator{Server: s}

	generators["grpc"] = &grpcgen.GrpcConfigGenerator{}
	generators["grpc/"+v3.EndpointType] = edsGen
	generators["grpc/"+v3.ListenerType] = generators["grpc"]
	generators["grpc/"+v3.RouteType] = generators["grpc"]
	generators["grpc/"+v3.ClusterType] = generators["grpc"]

	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.

        List<BuildGenerator> generators = getGenerators();
        List<BuildGenerator> result = new ArrayList<>(generators.size());
        for (BuildGenerator generator : generators) {
            if (generator.getComponentType().equals(componentType)) {
                result.add(generator);
            }
        }
        return result;
    }

          OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>> mapGenerator) {
    TestContainerGenerator<Map<K, V>, Entry<K, V>> generator = mapGenerator.getInnerGenerator();
    if (generator instanceof TestSortedMapGenerator
        && ((TestSortedMapGenerator<K, V>) generator).create().keySet() instanceof SortedSet) {
      return new MapSortedKeySetGenerator<>(mapGenerator);
    } else {

    // Remaining arguments (i.e. the positional args) are the requested Op names
    op_names_.assign((*argv) + 1, (*argv) + (*argc));
  }

  generator::cpp::CppConfig CppConfig() {
    return generator::cpp::CppConfig(category_);
  }

  generator::PathConfig PathConfig() {
    return generator::PathConfig(output_dir_, source_dir_, api_dirs_,
                                 op_names_);
  }

 private:

        when:
        def id = generator.generateId()
        def id2 = other.generateId()

        then:
        id != id2

        and:
        2 * target.generateId() >> 12
    }

    def compositeIdsAreEqualWhenOriginalIdsAreEqual() {
        when:
        def id = generator.generateId()
        def id2 = generator.generateId()

        then:
        id == id2

        and:

        }

        when:
        generator.generate()

        then:
        1 * generator.xmlWriter.write(fooTest, _)
        1 * generator.xmlWriter.write(barTest, _)
        0 * generator.xmlWriter._

        where:
        numThreads << [1, 4]
    }

    def "adds context information to the failure if something goes wrong"() {
        generator = generatorWithMaxThreads(1)

        def generator = new ClientBuildEventGenerator(consumer, subscriptions, [mapper1, mapper2], fallback)

        when:
        generator.started(operation, startEvent)

        then:
        0 * _

        when:
        generator.progress(operationId, progressEvent)

        then:
        0 * _

        when:
        generator.finished(operation, finishEvent)

        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()