}
}

func BenchmarkWriteByte(b *testing.B) {
	const n = 4 << 10
	b.SetBytes(n)
	buf := NewBuffer(make([]byte, n))
	for i := 0; i < b.N; i++ {
		buf.Reset()
		for i := 0; i < n; i++ {
			buf.WriteByte('x')
		}
	}
}

func BenchmarkWriteRune(b *testing.B) {
	const n = 4 << 10
	const r = '☺'
	b.SetBytes(int64(n * utf8.RuneLen(r)))
	buf := NewBuffer(make([]byte, n*utf8.UTFMax))

	for _, n := range sizes {
		if isRaceBuilder && n > 4<<10 {
			continue
		}
		b.Run(valName(n), func(b *testing.B) {
			if len(bmbuf) < n {
				bmbuf = make([]byte, n)
			}
			b.SetBytes(int64(n))
			f(b, n)
		})
	}
}

var indexSizes = []int{10, 32, 4 << 10, 4 << 20, 64 << 20}

var isRaceBuilder = strings.HasSuffix(testenv.Builder(), "-race")

a, m = m, a } if bytes.Compare(b, m) > 0 { b, m = m, b } M, err := NewModulus(m) if err != nil { t.Fatal(err) } A, err := NewNat().SetBytes(a, M) if err != nil { t.Fatal(err) } B, err := NewNat().SetBytes(b, M) if err != nil { t.Fatal(err) } A.Mul(B, M) ABytes := A.Bytes(M) mBig := new(big.Int).SetBytes(m) aBig := new(big.Int).SetBytes(a) bBig := new(big.Int).SetBytes(b) nBig := new(big.Int).Mul(aBig, bBig) nBig.Mod(nBig, mBig) nBigBytes := make([]byte, len(ABytes)) nBig.FillBytes(nBigBytes) if !bytes.Equal(ABytes,...

        final byte[] data1 = "abc".getBytes();
        assertEquals("YWJj", Base64Util.encode(data1));

        // Test case 2: Single padding
        final byte[] data2 = "abcd".getBytes();
        assertEquals("YWJjZA==", Base64Util.encode(data2));

        // Test case 3: Double padding
        final byte[] data3 = "abcde".getBytes();
        assertEquals("YWJjZGU=", Base64Util.encode(data3));

     */
    public void test_getText_withDefaultEncoding() {
        final String testContent = "Test content テスト 日本語";
        final InputStream in = new ByteArrayInputStream(testContent.getBytes());

        final ExtractData result = textExtractor.getText(in, null);

        assertNotNull(result);
        assertNotNull(result.getContent());
        assertTrue(result.getContent().contains("Test content"));

        final byte[] bytes = "".getBytes();
        final InputStream in = new ByteArrayInputStream(bytes);

        try {
            sitemapsHelper.parse(in);
            fail();
        } catch (final CrawlingAccessException e) {
            // NOP
        }
    }

    public void test_parseXmlSitemaps_invalid2() {
        final byte[] bytes = "test".getBytes();

     */
    public void test_validateInputStream_consistentAcrossMultipleCalls() {
        final InputStream in1 = new ByteArrayInputStream("data1".getBytes());
        final InputStream in2 = new ByteArrayInputStream("data2".getBytes());

        // First call
        extractor.testValidateInputStream(in1);

        // Second call with different stream
        extractor.testValidateInputStream(in2);

    }

    @Test
    public void testContentCache() {
        CurlResponse response = new CurlResponse();
        byte[] data = "test content".getBytes();
        ContentCache cache = new ContentCache(data);

        response.setContentCache(cache);

        // ContentCache is not directly accessible, but we can test through content methods

 */
public class IgnoreCloseInputStreamTest extends PlainTestCase {

    public void test_close_isIgnored() throws IOException {
        // Test that close() is ignored
        byte[] data = "Test data".getBytes();
        ByteArrayInputStream underlyingStream = new ByteArrayInputStream(data);
        IgnoreCloseInputStream stream = new IgnoreCloseInputStream(underlyingStream);

        // Read some data

                .stream(new ByteArrayInputStream("file1".getBytes()), 5, -1)
                .contentType("application/octet-stream")
                .build());
        minioClient.putObject(PutObjectArgs.builder()
                .bucket(bucketName)
                .object("dir1/file2.txt")
                .stream(new ByteArrayInputStream("file2".getBytes()), 5, -1)
                .contentType("application/octet-stream")