}

    @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) {

// the buffered reader to read from r.
// Calling Reset on the zero value of [Reader] initializes the internal buffer
// to the default size.
// Calling b.Reset(b) (that is, resetting a [Reader] to itself) does nothing.
func (b *Reader) Reset(r io.Reader) {
	// If a Reader r is passed to NewReader, NewReader will return r.
	// Different layers of code may do that, and then later pass r
	// to Reset. Avoid infinite recursion in that case.
	if b == r {

func (r *Record) Set(name string, value *sql.Value) (sql.Record, error) {
	r.columnNames = append(r.columnNames, name)
	r.csvRecord = append(r.csvRecord, value.CSVString())
	return r, nil
}

// Reset data in record.
func (r *Record) Reset() {
	if len(r.columnNames) > 0 {
		r.columnNames = r.columnNames[:0]
	}
	if len(r.csvRecord) > 0 {
		r.csvRecord = r.csvRecord[:0]
	}
	clear(r.nameIndexMap)
}

// Clone the record.

    }

    /**
     * Verifies reset() clears flags2 and updates resumeKey and filename used for parameters.
     */
    @Test
    void testResetUpdatesStateAndParameters() {
        // Given
        Trans2FindNext2 next = new Trans2FindNext2(0x0001, 0x0AAA0BBB, "old");
        next.flags2 = 0xFFFF; // simulate non-zero flags2

        // When
        next.reset(0x11121314, "last.dat");

        // Then

        }

        // Should have some state
        AuthenticationRateLimiter.RateLimiterStats stats = rateLimiter.getStats();
        assertTrue(stats.getActiveAccounts() > 0);

        // Reset
        rateLimiter.reset();

        // State should be cleared
        stats = rateLimiter.getStats();
        assertEquals(0, stats.getTotalBlocked());
        assertEquals(0, stats.getAccountsLocked());

        } catch (Exception e) {
            // It's ok if it fails, we just want to verify reset was called
        }

        // Request/response reset should happen on retry
        verify(req, atLeastOnce()).reset();
        verify(resp, atLeastOnce()).reset();
        // Verify disconnect was called on retry
        verify(c, atLeastOnce()).disconnect(eq(true));
    }

    @Test

        run: |
          set -eu
          git config --global user.email "******@****.***"
          git config --global user.name "GitHub Action"

          git reset origin/master --hard

          ./gradlew wrapper --gradle-version=nightly
          ./gradlew wrapper

          if ! git diff --quiet; then
            ./gradlew -v

    }

    /**
     * Resets the search criteria and displays all related query items.
     *
     * @param form the search form to reset
     * @return HTML response with the reset related query list
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse reset(final SearchForm form) {
        relatedQueryPager.clear();
        return asHtml(path_AdminRelatedquery_AdminRelatedqueryJsp).renderWith(data -> {

		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.

    }

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