m.ptype = 0;
        m.flags = 0x05;
        m.call_id = 0x123;

        NdrBuffer buf = new NdrBuffer(new byte[1024], 0);
        m.encode(buf);

        // Reset to read what was written
        buf.setIndex(0);

        // Verify header was written correctly
        assertEquals(5, buf.dec_ndr_small()); // RPC version
        assertEquals(0, buf.dec_ndr_small()); // minor version

        assertEquals("http://example.com/test", transformer.getLastResponseData().getUrl());

        // Reset and verify
        transformer.reset();
        assertEquals(0, transformer.getTransformCallCount());
        assertNull(transformer.getLastResponseData());

        // Name should persist after reset
        assertEquals("workflowTransformer", transformer.getName());
    }

     * the interrupting thread doesn't interrupt the _next_ thing to run on this thread.
     *
     * Note: We don't reset the interrupted bit, just wait for it to be set. If this is a thread
     * pool thread, the thread pool will reset it for us. Otherwise, the interrupted bit may have
     * been intended for something else, so don't clear it.
     */
    boolean restoreInterruptedBit = false;

        });
    }

    /**
     * Reset the search criteria and pager to default state.
     * Clears all filters and returns to the initial page view.
     *
     * @param form The search form to reset
     * @return HTML response showing the reset stemmer override list
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse reset(final SearchForm form) {

	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeDailyAllTierStats Msgsize() is inaccurate")
	}

	vn := DailyAllTierStats{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeDailyAllTierStats(b *testing.B) {
	v := DailyAllTierStats{}
	var buf bytes.Buffer

		t.Log("WARNING: TestEncodeDecodeBucketBandwidthReport Msgsize() is inaccurate")
	}

	vn := BucketBandwidthReport{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeBucketBandwidthReport(b *testing.B) {
	v := BucketBandwidthReport{}

	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 i := 0; i < b.N; i++ {
		buf.Reset()
		for i := 0; i < n; i++ {
			buf.WriteRune(r)
		}
	}
}

func (db *PreparedStmtDB) Close() {
	db.Mux.Lock()
	defer db.Mux.Unlock()

	for _, key := range db.Stmts.Keys() {
		db.Stmts.Delete(key)
	}
}

// Reset Deprecated use Close instead
func (db *PreparedStmtDB) Reset() {
	db.Close()
}

func (db *PreparedStmtDB) prepare(ctx context.Context, conn ConnPool, isTransaction bool, query string) (_ *stmt_store.Stmt, err error) {
	db.Mux.RLock()

    @Mock
    private CommonServerMessageBlockRequest splitRequest;

    @Mock
    private CommonServerMessageBlockRequest cancelRequest;

    @BeforeEach
    void setUp() {
        // Reset mocks before each test
        reset(request, nextRequest, splitRequest, cancelRequest);
    }

    @Test
    @DisplayName("Test isResponseAsync returns true when response is async")
    void testIsResponseAsyncTrue() {
        // Given

        return state.get();
    }

    /**
     * Reset the circuit breaker
     */
    public void reset() {
        state.set(State.CLOSED);
        consecutiveFailures.set(0);
        halfOpenSuccesses.set(0);
        lastFailureTime.set(0);
        stateChangeTime.set(System.currentTimeMillis());
        log.info("Circuit breaker {} reset", name);
    }

    /**
     * Force the circuit to open