/** Default current page number for pagination */
    public static final int DEFAULT_CURRENT_PAGE_NUMBER = 1;

    /** Total number of records across all pages */
    private int allRecordCount;

    /** Total number of pages */
    private int allPageCount;

    /** Flag indicating if a previous page exists */
    private boolean existPrePage;

    /** Flag indicating if a next page exists */

        prepareSecurityDescriptorBufferWithDACL(testBuffer, 0, 3);

        securityDescriptor.decode(testBuffer, 0, testBuffer.length);

        ACE[] aces = securityDescriptor.getAces();
        assertNotNull(aces);
        assertEquals(3, aces.length);
        for (ACE ace : aces) {
            assertNotNull(ace);
        }
    }

    @Test
    @DisplayName("Test getOwnerUserSid returns correct SID")

	}
}

func TestGenericsSubQuery(t *testing.T) {
	ctx := context.Background()
	users := []User{
		{Name: "GenericsSubquery_1", Age: 10},
		{Name: "GenericsSubquery_2", Age: 20},
		{Name: "GenericsSubquery_3", Age: 30},
		{Name: "GenericsSubquery_4", Age: 40},
	}

	if err := gorm.G[User](DB).CreateInBatches(ctx, &users, len(users)); err != nil {
		t.Fatalf("CreateInBatches failed: %v", err)
	}

			Comment: "hello , world",
			Where:   "age > 10",
			Fields:  []schema.IndexOption{{Field: &schema.Field{Name: "Name5"}}},
		},
		{
			Name:    "profile",
			Comment: "hello , world",
			Where:   "age > 10",
			Option:  "WITH PARSER parser_name",
			Fields: []schema.IndexOption{{Field: &schema.Field{Name: "Name6"}}, {
				Field:      &schema.Field{Name: "Age"},
				Expression: "ABS(age)",
			}},
		},
		{

    /** Default current page number (first page). */
    public static final int DEFAULT_CURRENT_PAGE_NUMBER = 1;

    /** Total number of records across all pages. */
    private int allRecordCount;

    /** Total number of pages. */
    private int allPageCount;

    /** Flag indicating if there is a previous page. */
    private boolean existPrePage;

    /** Flag indicating if there is a next page. */

 * the access mask of the ACE, the access check is successful. Otherwise,
 * more ACEs are evaluated until all desired access bits (combined)
 * are "allowed". If all of the desired access bits are not "allowed"
 * the then same process is repeated for inherited ACEs.
 * <p>
 * For example, if user <code>WNET\alice</code> tries to open a file

        this.allRecordCount = allRecordCount;
    }

    /**
     * Gets the total number of pages.
     * @return The total number of pages.
     */
    public int getAllPageCount() {
        return allPageCount;
    }

    /**
     * Sets the total number of pages.
     * @param allPageCount The total number of pages.
     */
    public void setAllPageCount(final int allPageCount) {

	}

	DB.Where(&User{Name: "find or init"}).Assign("age", 44).FirstOrInit(&user4)
	if user4.Name != "find or init" || user4.ID != 0 || user4.Age != 44 {
		t.Errorf("user should be initialized with search value and assign attrs")
	}

	DB.Save(&User{Name: "find or init", Age: 33})
	DB.Where(&User{Name: "find or init"}).Attrs("age", 44).FirstOrInit(&user5)

                return "AES";
            }

            @Override
            public String getAppCipherKey() {
                return "1234567890123456"; // 16 bytes for AES
            }
        });

        // Create test cipher - use proper constructor with simple implementation
        InvertibleCryptographer cookieCipher = new InvertibleCryptographer("AES", "1234567890123456", null) {
            @Override

// Select accepts both string arguments and arrays.
//
//	// Select name and age of user using multiple arguments
//	db.Select("name", "age").Find(&users)
//	// Select name and age of user using an array
//	db.Select([]string{"name", "age"}).Find(&users)
func (db *DB) Select(query interface{}, args ...interface{}) (tx *DB) {
	tx = db.getInstance()

	switch v := query.(type) {