}},
			References: []Reference{{"ID", "User", "UserID", "UserSpeak", "", true}, {"Code", "Language", "LanguageCode", "UserSpeak", "", false}},
		},
		{
			Name: "Friends", Type: schema.Many2Many, Schema: "User", FieldSchema: "User",
			JoinTable: JoinTable{Name: "user_friends", Table: "user_friends", Fields: []schema.Field{
				{
					Name: "UserID", DBName: "user_id", BindNames: []string{"UserID"}, DataType: schema.Uint,

            }

            // Compute User IDs with Domain ID to get User SIDs
            // First extra is user if userId is empty
            if (!userId.isEmpty() && !userId.isBlank()) {
                this.userSid = new SID(domainId, userId);
            } else if (this.extraSids.length > 0) {
                this.userSid = this.extraSids[0];
            }

	}
}

func CheckUserUnscoped(t *testing.T, user User, expect User) {
	doCheckUser(t, user, expect, true)
}

func CheckUser(t *testing.T, user User, expect User) {
	doCheckUser(t, user, expect, false)
}

func doCheckUser(t *testing.T, user User, expect User, unscoped bool) {
	if user.ID != 0 {
		var newUser User
		if err := db(unscoped).Where("id = ?", user.ID).First(&newUser).Error; err != nil {

        assertEquals("Abc", StringUtil.capitalize("abc"));
        assertEquals("Abc", StringUtil.capitalize("Abc"));
        assertEquals("ABC", StringUtil.capitalize("ABC"));
        assertEquals("UserId", StringUtil.capitalize("userId"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testDecapitalize() throws Exception {
        assertEquals("abc", StringUtil.decapitalize("abc"));

    this.ok = ok;
    this.access_token = accessToken;
    this.scope = scope;
    this.user_id = userId;
    this.team_name = teamName;
    this.team_id = teamId;
  }

  @Override public String toString() {
    return String.format("(ok=%s, access_token=%s, scope=%s, user_id=%s, team_name=%s, team_id=%s)",
        ok, access_token, scope, user_id, team_name, team_id);
  }

		CheckUser(t, user, users2[idx])
	}
}

func TestJoinConds(t *testing.T) {
	user := *GetUser("joins-conds", Config{Account: true, Pets: 3})
	DB.Save(&user)

	var users1 []User
	DB.Joins("inner join pets on pets.user_id = users.id").Where("users.name = ?", user.Name).Find(&users1)
	if len(users1) != 3 {
		t.Errorf("should find two users using left join, but got %v", len(users1))
	}

	var users2 []User

	Friends   []*User    `gorm:"many2many:user_friends;"`
	Active    bool
}

type Account struct {
	gorm.Model
	UserID sql.NullInt64
	Number string
}

type Pet struct {
	gorm.Model
	UserID *uint
	Name   string
	Toy    Toy `gorm:"polymorphic:Owner;"`
}

type Toy struct {
	gorm.Model
	Name      string
	OwnerID   string
	OwnerType string
}

type Tools struct {

        String sessionId = MDC.get("sessionId");
        if (sessionId != null) {
            context.put("sessionId", sessionId);
        }
        String userId = MDC.get("userId");
        if (userId != null) {
            context.put("userId", userId);
        }
    }

    /**
     * Log an authentication event with optimized performance
     *
     * @param success whether authentication succeeded

		gorm.Model
		Name   string
		UserID uint
	}

	type User struct {
		gorm.Model
		Refer   string
		Profile Profile `gorm:"ForeignKey:UserID;References:Refer"`
	}

	checkStructRelation(t, &User{}, Relation{
		Name: "Profile", Type: schema.HasOne, Schema: "User", FieldSchema: "Profile",
		References: []Reference{{"Refer", "User", "UserID", "Profile", "", true}},
	})
}

     * Note: If the first two characters are uppercase, the string will not be decapitalized.
     * <p>
     * Usage example:
     * </p>
     *
     * <pre>
     * StringUtil.decapitalize("UserId")  = "userId"
     * StringUtil.decapitalize("ABC")     = "ABC"
     * </pre>
     *
     * @param name
     *            the string to decapitalize
     * @return the decapitalized string
     */