verify(mockResponse, times(1)).setExpiration(expiration);
    }

    @Test
    void testReset() {
        // Call the method
        mockResponse.reset();

        // Verify that the method was called
        verify(mockResponse, times(1)).reset();
    }

    @Test
    void testGetException() {
        Exception testException = new RuntimeException("Test Exception");

		panic("bytes.Reader.WriteTo: invalid Write count")
	}
	r.i += int64(m)
	n = int64(m)
	if m != len(b) && err == nil {
		err = io.ErrShortWrite
	}
	return
}

// Reset resets the [Reader] to be reading from b.
func (r *Reader) Reset(b []byte) { *r = Reader{b, 0, -1} }

// NewReader returns a new [Reader] reading from b.

    }

    @Override
    public void reset() {
        super.reset();
        this.isPrimary = this.hasMore = true;
    }

    /**
     * Resets the transaction state with key and last name
     * @param key
     *            the key to use for reset
     * @param lastName
     *            the last name for the transaction
     */
    protected void reset(final int key, final String lastName) {

                }

                doReceiveFragment(frag, isDirect);
                fbuf.reset();
                fbuf.setIndex(8);
                fbuf.setLength(fbuf.dec_ndr_short());

                if (securityProvider != null) {
                    securityProvider.unwrap(fbuf);
                }

                fbuf.reset();
                msg.decode_header(fbuf);
                stub_frag_len = msg.length - 24;

                            : Math.min(MAX_RETRY_DELAY, retryDelayMs * multiplier);
                    Thread.sleep(delay);
                }

                // Attempt to reset the connection
                connection.reset();

                // Verify connection is working
                if (connection.getState() == RdmaConnection.RdmaConnectionState.ESTABLISHED) {

      <syntax>settings.offline</syntax>
      <configuration>
        <![CDATA[
    <offline>true</offline>
    ]]></configuration>
      <description>
        <![CDATA[
      Flags the system as offline, to prevent accessing the network to resolve artifacts or execute plugins.

      NOTE: It's also possible to switch to offline mode on a per-build basis, using the '-o' command-line option.
    ]]></description>
    </expression>

    }

    /**
     * Resets the search criteria and displays all search log entries.
     *
     * @param form the search form to reset
     * @return HTML response with the reset search log list
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse reset(final SearchForm form) {
        saveToken();
        searchLogPager.clear();

        assertTrue(response.hasMoreElements());
    }

    @Test
    @DisplayName("Test reset method")
    void testReset() {
        // Set some values
        response.setDataCount(50);

        // Call reset
        response.reset();

        // After reset, hasMore should be true
        assertTrue(response.hasMoreElements());
    }

    @Test

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

	vn := BatchJobPrefix{}
	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 BenchmarkEncodeBatchJobPrefix(b *testing.B) {
	v := BatchJobPrefix{}
	var buf bytes.Buffer

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

	vn := localLockMap{}
	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 BenchmarkEncodelocalLockMap(b *testing.B) {
	v := localLockMap{}
	var buf bytes.Buffer