escapeByte(0x80 | (ch >> 6) & 0x3F, builder);
                    escapeByte(0x80 | ch & 0x3F, builder);
                }
            }
        }
        return builder.toString();
    }

    private static void escapeByte(int ch, StringBuilder builder) {
        builder.append('%');
        builder.append(Character.toUpperCase(Character.forDigit(ch >> 4 & 0xFF, 16)));

  TF_OpDefinitionBuilder* builder = TF_NewOpDefinitionBuilder("SomeOp");
  TF_OpDefinitionBuilderAddAttr(builder, "attr1: string");
  TF_OpDefinitionBuilderAddInput(builder, "input1: uint8");
  TF_OpDefinitionBuilderAddInput(builder, "input2: uint16");
  TF_OpDefinitionBuilderAddOutput(builder, "output1: uint32");
  TF_Status* status = TF_NewStatus();
  TF_RegisterOpDefinition(builder, status);

  auto attr = DenseElementsAttr::get(type, val);
  return builder->create<arith::ConstantOp>(location, type, attr);
}

Value CreatTfF32ConstOp(OpBuilder* builder, ArrayRef<int64_t> shape, float val,
                        mlir::Location location) {
  auto type = RankedTensorType::get(shape, builder->getF32Type());
  auto ele_type = RankedTensorType::get({1}, builder->getF32Type());

      )
    for (i in 0..599) {
      val builder = MockResponse.Builder().code(i)
      val expectedReason = reasons[i / 100]
      assertThat(builder.status).isEqualTo("HTTP/1.1 $i $expectedReason")
      assertThat(headersToList(builder)).containsExactly("Content-Length: 0")
    }
  }

  @Test
  fun setStatusControlsWholeStatusLine() {
    val builder = MockResponse.Builder().status("HTTP/1.1 202 That'll do pig")

                    }
                };

                // Clear the user's environment
                builder.environment("GRADLE_HOME", "");
                builder.environment("JAVA_HOME", "");
                builder.environment("GRADLE_OPTS", "");
                builder.environment("JAVA_OPTS", "");
                builder.environment(ArtifactCachesProvider.READONLY_CACHE_ENV_VAR, "");

    ImmutableMultiset.Builder<String> builder = ImmutableMultiset.builder();
    builder.addCopies("a", 2);
    builder.add("b");
    builder.add("c");
    builder.setCount("b", 0);
    ImmutableMultiset<String> multiset = builder.build();
    assertThat(multiset.elementSet()).containsExactly("a", "c").inOrder();
    builder.add("b");

        ${class.name}.Builder builder = ${class.name}.newBuilder(target);
        merge${class.name}(builder, target, source, sourceDominant, context);
        return builder.build();
    }

    protected void merge${class.name}(${class.name}.Builder builder, ${class.name} target, ${class.name} source, boolean sourceDominant, Map<Object, Object> context) {

        configureUserAgent(builder);
        configureCookieSpecRegistry(builder);
        configureRequestConfig(builder);
        configureSocketConfig(builder);
        configureRedirectStrategy(builder);
        builder.setDefaultCredentialsProvider(credentialsProvider);
        builder.setMaxConnTotal(httpSettings.getMaxConnTotal());

                          Value token) {
  builder.setInsertionPoint(send_to_host);
  token = CreateSendOp(builder, send_to_host.getLoc(), send_to_host.getInput(),
                       send_to_host.getKey(),
                       /*index=*/0, token,
                       xla::kXlaHostTransferTfRendezvousHandlerName,
                       /*manual_sharding=*/false);

      Comparator<String> comparator = createExplicitComparator(elements);
      ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator);
      builder.add(BEFORE_FIRST);
      builder.add(BEFORE_FIRST_2);
      builder.add(elements);
      builder.add(AFTER_LAST);
      builder.add(AFTER_LAST_2);
      return builder
          .build()
          .subSet(BEFORE_FIRST_2, AFTER_LAST_2)
          .asList()