assertEquals("fine", tokens.get(7).getTerm());
    }

    @Test
    public void testAnalyzeWithNumbers() {
        // Test analyze with numbers
        String text = "123 456.789 0xFF 3.14159";
        String field = "content";
        String lang = "en";

        List<AnalyzeToken> tokens = analyzer.analyze(text, field, lang);

        assertNotNull(tokens);

}

func benchmarkCompareBytesBigUnaligned(b *testing.B, offset int) {
	b.StopTimer()
	b1 := make([]byte, 0, 1<<20)
	for len(b1) < 1<<20 {
		b1 = append(b1, "Hello Gophers!"...)
	}
	b2 := append([]byte("12345678")[:offset], b1...)
	b.StartTimer()
	for j := 0; j < b.N; j++ {
		if Compare(b1, b2[offset:]) != 0 {
			b.Fatal("b1 != b2")
		}
	}
	b.SetBytes(int64(len(b1)))
}

    assertInvalid("http://[::g]/", "Invalid URL host: \"[::g]\"")
  }

  @Test
  fun hostIpv6CanonicalForm() {
    assertThat(parse("http://[abcd:ef01:2345:6789:abcd:ef01:2345:6789]/").host)
      .isEqualTo("abcd:ef01:2345:6789:abcd:ef01:2345:6789")
    assertThat(parse("http://[a:0:0:0:b:0:0:0]/").host).isEqualTo("a::b:0:0:0")
    assertThat(parse("http://[a:b:0:0:c:0:0:0]/").host).isEqualTo("a:b:0:0:c::")

			ok:   true,
		},
		{
			name: "ExactNanos",
			in:   "1.123456789",
			want: time.Unix(1, 123456789),
			ok:   true,
		},
		{
			name: "WithNanoPadding",
			in:   "1.123",
			want: time.Unix(1, 123000000),
			ok:   true,
		},
		{
			name: "WithNanoTruncate",
			in:   "1.123456789123",
			want: time.Unix(1, 123456789),
			ok:   true,
		},
		{
			name: "TrailingError",

        // Maximum practical length (avoid OutOfMemoryError)
        StringBuilder maxName = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            maxName.append("0123456789");
        }
        testTransformer.setName(maxName.toString());
        assertEquals(10000, testTransformer.getName().length());
        assertEquals(maxName.toString(), testTransformer.getName());
    }

        assertEquals("00FF", Hexdump.toHexString(255L, 4));

        // Test larger values
        assertEquals("0000000012345678", Hexdump.toHexString(0x12345678L, 16));
        assertEquals("12345678", Hexdump.toHexString(0x12345678L, 8));
        assertEquals("5678", Hexdump.toHexString(0x12345678L, 4));

        // Test negative values (treated as unsigned)

		Parts:            nil,
		Erasure: ErasureInfo{
			Algorithm:    ReedSolomon.String(),
			DataBlocks:   4,
			ParityBlocks: 2,
			BlockSize:    10000,
			Index:        1,
			Distribution: []int{1, 2, 3, 4, 5, 6, 7, 8},
			Checksums: []ChecksumInfo{{
				PartNumber: 1,
				Algorithm:  HighwayHash256S,
				Hash:       nil,
			}},
		},
		MarkDeleted:      false,
		Data:             data,
		NumVersions:      1,

    assertPermutationsCount(5040, Collections2.permutations(newArrayList(1, 2, 3, 4, 5, 6, 7)));
    assertPermutationsCount(40320, Collections2.permutations(newArrayList(1, 2, 3, 4, 5, 6, 7, 8)));
  }

  public void testPermutationSetSizeOverflow() {
    // 13 elements overflow an int
    assertEquals(
        Integer.MAX_VALUE,

// interface{} that holds the actual data
func (d *Decoder) any() (any, ValueType, error) {
	c := d.cur()

	switch c {
	case '"':
		i, err := d.string()
		return i, String, err
	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
		i, err := d.number()
		return i, Number, err
	case '-':
		if c = d.next(); c < '0' || c > '9' {
			return nil, Unknown, d.mkError(ErrSyntax, "in negative numeric literal")
		}

			},
		},
		Erasure: ErasureInfo{
			Algorithm:    ReedSolomon.String(),
			DataBlocks:   4,
			ParityBlocks: 2,
			BlockSize:    10000,
			Index:        1,
			Distribution: []int{1, 2, 3, 4, 5, 6, 7, 8},
			Checksums: []ChecksumInfo{
				{
					PartNumber: 1,
					Algorithm:  HighwayHash256S,
					Hash:       nil,
				},
				{
					PartNumber: 2,
					Algorithm:  HighwayHash256S,