b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgBucketBandwidthReport(b *testing.B) {
	v := BucketBandwidthReport{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bts, _ = v.MarshalMsg(bts[0:0])
	}
}

        assertNull(BigDecimalConversionUtil.toBigDecimal(null));
        assertSame(ZERO, BigDecimalConversionUtil.toBigDecimal(ZERO));
        assertEquals(new BigDecimal("1"), BigDecimalConversionUtil.toBigDecimal(Byte.valueOf((byte) 1)));
        assertEquals(new BigDecimal("10"), BigDecimalConversionUtil.toBigDecimal(Short.valueOf((short) 10)));
        assertEquals(new BigDecimal("100"), BigDecimalConversionUtil.toBigDecimal(Integer.valueOf(100)));

                    for (int i = 0; i < operationsPerThread; i++) {
                        // Test allocation performance
                        long allocStart = System.nanoTime();
                        byte[] buffer = BufferCache.getBuffer();
                        long allocEnd = System.nanoTime();
                        totalAllocTime.addAndGet(allocEnd - allocStart);
                        allocations.incrementAndGet();

        byte[] data = response.getOutputBuffer();
        int offset = 0;
        
        while (offset < data.length) {
            int nextEntryOffset = readInt4(data, offset);
            int action = readInt4(data, offset + 4);
            int fileNameLength = readInt4(data, offset + 8);
            
            // Extract filename
            byte[] fileNameBytes = new byte[fileNameLength];

	v := BatchJobExpire{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgBatchJobExpire(b *testing.B) {
	v := BatchJobExpire{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bts, _ = v.MarshalMsg(bts[0:0])
	}
}

	v := AccElem{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgAccElem(b *testing.B) {
	v := AccElem{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bts, _ = v.MarshalMsg(bts[0:0])
	}
}

var IsSpace = isSpace

const DefaultBufSize = defaultBufSize

func (s *Scanner) MaxTokenSize(n int) {
	if n < utf8.UTFMax || n > 1e9 {
		panic("bad max token size")
	}
	if n < len(s.buf) {
		s.buf = make([]byte, n)
	}
	s.maxTokenSize = n
}

// ErrOrEOF is like Err, but returns EOF. Used to test a corner case.
func (s *Scanner) ErrOrEOF() error {
	return s.err

            response.setReturnCode(message.getReturnCode());

            if (message.isSuccess()) {
                // Generate registration ID from context handle
                byte[] contextHandle = message.getContextHandle();
                String registrationId = generateRegistrationId(contextHandle, request.getShareName());
                response.setRegistrationId(registrationId);

     * @throws CIFSException
     */
    @Test
    void testService_NtlmAuth_Success() throws Exception {
        ntlmServlet.init(servletConfig);
        setupMocksForAuth();

        byte[] challenge = new byte[8];
        NtlmPasswordAuthentication ntlmAuth = new NtlmPasswordAuthentication(cifsContext, "TEST_DOMAIN", "user", "password");

        try (MockedStatic<NtlmSsp> ntlmSspMock = Mockito.mockStatic(NtlmSsp.class)) {

// this in other places.
func encodeResponseList(response any) []byte {
	var buf bytes.Buffer
	buf.WriteString(xxml.Header)
	if err := xxml.NewEncoder(&buf).Encode(response); err != nil {
		bugLogIf(GlobalContext, err)
		return nil
	}
	return buf.Bytes()
}

// Encodes the response headers into JSON format.
func encodeResponseJSON(response any) []byte {
	var bytesBuffer bytes.Buffer
	e := json.NewEncoder(&bytesBuffer)