public void setReplacement_Equal(String replacement) {
        setReplacement_Term(replacement, null);
    }

    public void setReplacement_Equal(String replacement, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setReplacement_Term(replacement, opLambda);
    }

    public void setReplacement_Term(String replacement) {
        setReplacement_Term(replacement, null);
    }

      if (matches(c)) {
        if (c == replacement && (i == len - 1 || !matches(sequence.charAt(i + 1)))) {
          // a no-op replacement
          i++;
        } else {
          StringBuilder builder = new StringBuilder(len).append(sequence, 0, i).append(replacement);
          return finishCollapseFrom(sequence, i + 1, len, replacement, builder, true);
        }
      }
    }

    public void setReplacement_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
        setReplacement_Terms("replacement", opLambda, null);
    }

    public void setReplacement_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsPathMappingCA> aggsLambda) {
        setReplacement_Terms("replacement", opLambda, aggsLambda);
    }

 * API</h2>
 *
 * <p>The successor to Guava's caching API is <a
 * href="https://github.com/ben-manes/caffeine/wiki">Caffeine</a>. Its API is designed to make it a
 * nearly drop-in replacement. It requires Java 8+, and is not available for Android or GWT/J2CL,
 * and may have <a href="https://github.com/ben-manes/caffeine/wiki/Guava">different (usually

 * API</h2>
 *
 * <p>The successor to Guava's caching API is <a
 * href="https://github.com/ben-manes/caffeine/wiki">Caffeine</a>. Its API is designed to make it a
 * nearly drop-in replacement. It requires Java 8+, and is not available for Android or GWT/J2CL,
 * and may have <a href="https://github.com/ben-manes/caffeine/wiki/Guava">different (usually

  }

  @Test
  fun fragmentPercentEncodedPartialCodePoint() {
    val url = parse("http://host/#%80")
    assertThat(url.toString()).isEqualTo("http://host/#%80")
    // Unicode replacement character.
    assertThat(url.fragment).isEqualTo("\ufffd")
    assertThat(url.encodedFragment).isEqualTo("%80")
  }

  @Test
  fun relativePath() {
    val base = parse("http://host/a/b/c")

	// Invalid runes, including negative ones, should be written as the
	// replacement character.
	for _, r := range []rune{-1, utf8.MaxRune + 1} {
		var buf strings.Builder
		w := NewWriter(&buf)
		w.WriteRune(r)
		w.Flush()
		if s := buf.String(); s != "\uFFFD" {
			t.Errorf("WriteRune(%d) wrote %q, not replacement character", r, s)
		}
	}
}

func TestReadStringAllocs(t *testing.T) {

		{"InvalidASCII", []byte("foo\xffbar")},
		{"InvalidNonASCII", []byte("日本語\xff日本語")},
	}
	replacement := []byte("\uFFFD")
	b.ResetTimer()
	for _, test := range tests {
		b.Run(test.name, func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				ToValidUTF8(test.input, replacement)
			}
		})
	}
}

func makeBenchInputHard() []byte {
	tokens := [...]string{

   * concurrently readable hash table. The map supports non-blocking reads and concurrent writes
   * across different segments.
   *
   * The page replacement algorithm's data structures are kept casually consistent with the map. The
   * ordering of writes to a segment is sequentially consistent. An update to the map and recording

   * concurrently readable hash table. The map supports non-blocking reads and concurrent writes
   * across different segments.
   *
   * The page replacement algorithm's data structures are kept casually consistent with the map. The
   * ordering of writes to a segment is sequentially consistent. An update to the map and recording