}

func (join Join) Build(builder Builder) {
	if join.Expression != nil {
		join.Expression.Build(builder)
	} else {
		if join.Type != "" {
			builder.WriteString(string(join.Type))
			builder.WriteByte(' ')
		}

		builder.WriteString("JOIN ")
		builder.WriteQuoted(join.Table)

		if len(join.ON.Exprs) > 0 {
			builder.WriteString(" ON ")
			join.ON.Build(builder)
		} else if len(join.Using) > 0 {

fun Request.Builder.commonDelete(body: RequestBody?): Request.Builder = method("DELETE", body)

fun Request.Builder.commonPut(body: RequestBody): Request.Builder = method("PUT", body)

fun Request.Builder.commonPatch(body: RequestBody): Request.Builder = method("PATCH", body)

fun Request.Builder.commonMethod(
  method: String,
  body: RequestBody?,
): Request.Builder =
  apply {

	public final fun rsa2048 ()Lokhttp3/tls/HeldCertificate$Builder;
	public final fun serialNumber (J)Lokhttp3/tls/HeldCertificate$Builder;
	public final fun serialNumber (Ljava/math/BigInteger;)Lokhttp3/tls/HeldCertificate$Builder;
	public final fun signedBy (Lokhttp3/tls/HeldCertificate;)Lokhttp3/tls/HeldCertificate$Builder;
	public final fun validityInterval (JJ)Lokhttp3/tls/HeldCertificate$Builder;
}

    @Override
    protected Map<String, String> create(Entry<String, String>[] entries) {
      ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
      for (Entry<String, String> entry : entries) {
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.buildOrThrow();
    }
  }

  public static class ImmutableMapCopyOfGenerator extends TestStringMapGenerator {
    @Override

        // Look for a build scoped builder
        ToolingModelBuilderLookup.Builder builder = buildScopeLookup.maybeLocateForBuildScope(modelName, param, buildState);
        if (builder != null) {
            return new BuildToolingScope(builder);
        }

        // Force configuration of the build and locate builder for default project

        expect:
        loadBuildEnvironment { builder -> builder.addJvmArguments() }
    }

    def "Adding null JVM argument throws NPE"() {
        when:
        loadBuildEnvironment { builder -> builder.addJvmArguments(null as String) }

        then:
        thrown(NullPointerException)

        when:
        loadBuildEnvironment { builder -> builder.addJvmArguments(null as List) }

        then:

#include "tensorflow/core/lib/core/errors.h"

namespace tensorflow {

using mlir::Builder;
using mlir::ShapedType;
using mlir::Type;

Status ConvertDataType(DataType dtype, Builder builder, Type* type) {
  switch (dtype) {
    case DT_HALF:
      *type = builder.getF16Type();
      return absl::OkStatus();
    case DT_FLOAT:
      *type = builder.getF32Type();
      return absl::OkStatus();
    case DT_DOUBLE:

        worker?.stop()
    }

    def "propagates failure to start worker process"() {
        when:
        def builder = workerFactory.multiRequestWorker(StatefulTestWorker.class)
        builder.baseName = 'broken worker'
        builder.javaCommand.jvmArgs("-broken")
        def worker = builder.build()
        worker.start()

        then:
        def e = thrown(WorkerProcessException)

    val root =
      HeldCertificate.Builder()
        .serialNumber(1L)
        .certificateAuthority(1)
        .build()
    val certA =
      HeldCertificate.Builder()
        .serialNumber(2L)
        .certificateAuthority(0)
        .signedBy(root)
        .build()
    val certB =
      HeldCertificate.Builder()
        .serialNumber(3L)
        .signedBy(certA)

        return () -> {
            TreeFormatter builder = new TreeFormatter();
            builder.node(String.format("Could not find any version that matches %s.", selector));
            addLocations(builder, locations);
            return builder.toString();
        };
    }

    private static void appendSizeLimited(TreeFormatter builder, Collection<?> values) {
        builder.startChildren();