response = spy(response);
        when(response.getHeaderStart()).thenReturn(0);

        // Due to bug in line 96, data must be written at bufferIndex=8
        // Write entries with proper nextEntryOffset chain starting at 8
        int currentOffset = 8;
        for (int i = 0; i < 3; i++) {
            // Set NextEntryOffset (104 bytes to next, 0 for last)
            SMBUtil.writeInt4(i < 2 ? 104 : 0, buffer, currentOffset);

     * This method traverses the parent hierarchy and includes profiles defined in parent POMs.
     * The returned list contains profiles from the current project and all of its ancestors in
     * the project inheritance chain.
     *
     * @return a non-null, possibly empty list of all profiles from this project and its parents
     * @see Profile
     * @see #getDeclaredProfiles()
     */
    @Nonnull

Corentin Godeau, Crefeda Rodrigues, Danny Burrow, dependabot[bot], Dimitris Vardoulakis, Dragan Mladjenovic, Elfie Guo, Emmanuel Ferdman, fiberflow, flyingcat, Gary Yi-Hung Chen, Georg Stefan Schmid, Gerwout Van Der Veen, Harsha H S, Harshit Monish, Hugo Mano, i.Pear, Ilia Sergachev, Jane Liu, Jaroslav Sevcik, Jc (Jonathan Chen), Jerry Ge, Jian Li, johndoknjas, Johnny, Jonathan Albrecht, Kaixi Hou, Kanvi Khanna, keerthanakadiri, Kevin Ji, Kiran Sai Ramineni, kwoncy2020, LakshmiKalaKadali, Lee, Jun...

   * part of the smeared hash of the key not covered by the hashtable mask, whereas the low bits are
   * the "next" pointer (pointing to the next entry in the bucket chain), which will always be less
   * than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb
   * </pre>
   *

        }

        // options: interpolate
        if (context.options != null) {
            context.options = context.options.interpolate(Interpolator.chain(
                    context.extraInterpolationSource()::get,
                    context.userProperties::get,
                    context.systemProperties::get));
        }

little of the right-hand bit to try the effect:  the next moment
she felt a violent blow underneath her chin:  it had struck her
foot!

  She was a good deal frightened by this very sudden change, but
she felt that there was no time to be lost, as she was shrinking
rapidly; so she set to work at once to eat some of the other bit.
Her chin was pressed so closely against her foot, that there was

  }

  /**
   * Returns a stream of this fluent iterable's contents (similar to calling {@link
   * Collection#stream} on a collection).
   *
   * <p><b>Note:</b> the earlier in the chain you can switch to {@code Stream} usage (ideally not
   * going through {@code FluentIterable} at all), the more performant and idiomatic your code will
   * be. This method is a transitional aid, to be used only when really necessary.

   *
   * <p>Invalid: - Collected: key/value was partially collected, but not yet cleaned up
   */
  interface InternalEntry<K, V, E extends InternalEntry<K, V, E>> {
    /** Gets the next entry in the chain. */
    E getNext();

    /** Gets the entry's hash. */
    int getHash();

    /** Gets the key for this entry. */
    K getKey();

    /** Gets the value for the entry. */
    V getValue();

	// prepare
	u := User{Name: "GenericsSetUpdate_Before", Age: 30}
	if err := gorm.G[User](DB).Create(ctx, &u); err != nil {
		t.Fatalf("prepare user failed: %v", err)
	}

	// update with Set after chain
	newName := "GenericsSetUpdate_After"
	newAge := uint(31)
	rows, err := gorm.G[User](DB).
		Where("id = ?", u.ID).
		Set(
			clause.Assignment{Column: clause.Column{Name: "name"}, Value: newName},

	Raw(sql string, values ...interface{}) ExecInterface[T]
	Exec(ctx context.Context, sql string, values ...interface{}) error
	CreateInterface[T]
}

type CreateInterface[T any] interface {
	ExecInterface[T]
	// chain methods available at start; Select/Omit keep CreateInterface to allow Create chaining
	Scopes(scopes ...func(db *Statement)) ChainInterface[T]
	Where(query interface{}, args ...interface{}) ChainInterface[T]