}},
			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,

        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"));

            }

            // 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];
            }

        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

		Joins("LEFT OUTER JOIN pets ON pets.user_id = users.id").Find(&results)

	if len(results) == 0 {
		t.Fatalf("no record find")
	} else if results[0].Pet.UserID == nil || *(results[0].Pet.UserID) != user.ID {
		t.Fatalf("wrong user id in pet")
	} else if results[0].Pet.Name != user.Pets[0].Name {
		t.Fatalf("wrong pet name")
	}
}

func TestJoinArgsWithDB(t *testing.T) {

	type Profile struct {
		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
     */

	Allergen         NullString
	Password         EncryptedData
	Bytes            []byte
	Num              Num
	Strings          StringsSlice
	Structs          StructsSlice
	Role             Role
	UserID           *sql.NullInt64
	User             User
	EmptyTime        EmptyTime
	ExampleStruct    ExampleStruct
	ExampleStructPtr *ExampleStruct
}

type EncryptedData []byte

}

func TestCreateWithNoGORMPrimaryKey(t *testing.T) {
	type JoinTable struct {
		UserID   uint
		FriendID uint
	}

	DB.Migrator().DropTable(&JoinTable{})
	if err := DB.AutoMigrate(&JoinTable{}); err != nil {
		t.Errorf("no error should happen when auto migrate, but got %v", err)
	}

	jt := JoinTable{UserID: 1, FriendID: 2}
	err := DB.Create(&jt).Error
	if err != nil {

/**
 * An immutable builder for {@link Multimap} instances, letting you independently select the desired
 * behaviors (for example, ordering) of the backing map and value-collections. Example:
 *
 * {@snippet :
 * ListMultimap<UserId, ErrorResponse> errorsByUser =
 *     MultimapBuilder.linkedHashKeys().arrayListValues().build();
 * SortedSetMultimap<String, Method> methodsForName =
 *     MultimapBuilder.treeKeys().treeSetValues(this::compareMethods).build();