doTestAllMatches(forPredicate(Predicates.equalTo('c')), "ccc");
    doTestAllMatches(CharMatcher.digit(), "0123456789\u0ED0\u1B59");
    doTestAllMatches(CharMatcher.javaDigit(), "0123456789");
    doTestAllMatches(CharMatcher.digit().and(CharMatcher.ascii()), "0123456789");
    doTestAllMatches(CharMatcher.singleWidth(), "\t0123ABCdef~\u00A0\u2111");
  }

	// Output:
	// -gopher!
	// "go-gopher!"
	// go-gopher
	// go-gopher!
}

func ExampleTrimLeft() {
	fmt.Print(string(bytes.TrimLeft([]byte("453gopher8257"), "0123456789")))
	// Output:
	// gopher8257
}

func ExampleTrimLeftFunc() {
	fmt.Println(string(bytes.TrimLeftFunc([]byte("go-gopher"), unicode.IsLetter)))

						int64(1e10 - blockSize),
						strings.Repeat("\x00", blockSize-100) + strings.Repeat("0123456789", 10),
						int64(1e10 - blockSize),
						strings.Repeat("\x00", blockSize-100) + strings.Repeat("0123456789", 10),
						int64(1e10 - blockSize),
						strings.Repeat("\x00", blockSize-100) + strings.Repeat("0123456789", 10),
						int64(1e10 - blockSize),

			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",

        // Test text that exceeds maximum length after encoding
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 500; i++) {
            sb.append("0123456789");
        }
        String longText = sb.toString();
        String id = SuggestUtil.createSuggestTextId(longText);
        assertNotNull(id);

        // Test write(byte[], int, int) method
        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);
        byte[] data = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        cos.write(data, 2, 3); // Write bytes at index 2, 3, 4
        assertTrue(cos.isInMemory());
        cos.close();
    }

    @Test

        CacheBuilder.newBuilder().concurrencyLevel(1).maximumSize(10).build(loader);
    CacheTesting.warmUp(cache, 0, 10);
    Set<Integer> keySet = cache.asMap().keySet();
    assertThat(keySet).containsExactly(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

    // re-order
    getAll(cache, asList(0, 1, 2));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(3, 4, 5, 6, 7, 8, 9, 0, 1, 2);

    // evict 3, 4, 5

		// if there is data following that NUL character.
		// This is reasonable as GNU long names are C-strings.
		file: "testdata/gnu-long-nul.tar",
		headers: []*Header{{
			Name:     "0123456789",
			Mode:     0644,
			Uid:      1000,
			Gid:      1000,
			ModTime:  time.Unix(1486082191, 0),
			Typeflag: '0',
			Uname:    "rawr",
			Gname:    "dsnet",
			Format:   FormatGNU,
		}},

// 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")
		}

	PSTW R24, $0, 45(R13)                   // 06000000930d002d
	PSTXSD V1, $1, 12345678(R2)             // 041000bcb822614e
	PSTXSSP V1, $1, 1234567890(R0)          // 04104996bc2002d2
	PSTXSSP V1, $1, 1234567890(R1)          // 04104996bc2102d2
	PSTXSSP V1, $0, 1234567890(R3)          // 04004996bc2302d2
	PSTXV VS6, $1, 1234567890(R5)           // 04104996d8c502d2
	PSTXVP VS2, $1, 12345678(R2)            // 041000bcf842614e