package clause

						Idx:      idx,
						Header:   b,
						Metadata: buf.Bytes(),
					}
					type erasureInfo struct {
						V2Obj *struct {
							EcDist   []int
							EcIndex  int
							EcM      int
							EcN      int
							DDir     []byte
							PartNums []int
							MetaSys  struct {
								Inline []byte `json:"x-minio-internal-inline-data"`
							}
						}
					}
					var ei erasureInfo

						if reflect.Indirect(rv).Kind() != reflect.Struct {
							break
						}

						if _, isZero := pkField.ValueOf(db.Statement.Context, rv); isZero {
							db.AddError(pkField.Set(db.Statement.Context, rv, insertID))
							insertID += pkField.AutoIncrementIncrement
						}
					}
				}
			case reflect.Struct:
				_, isZero := pkField.ValueOf(db.Statement.Context, db.Statement.ReflectValue)

}

// Unit test for DeleteObject in general.
func testDeleteObject(obj ObjectLayer, instanceType string, t TestErrHandler) {
	type objectUpload struct {
		name    string
		content string
	}

	testCases := []struct {
		bucketName         string
		objectToUploads    []objectUpload
		pathToDelete       string
		objectsAfterDelete []string
	}{

 */

LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	if !ok {
		return madmin.BgHealState{}, false
	}

	status := madmin.BgHealState{
		ScannedItemsCount: bgSeq.getScannedItemsCount(),
	}

	healDisksMap := map[string]struct{}{}
	for _, ep := range getLocalDisksToHeal() {
		healDisksMap[ep.String()] = struct{}{}
	}

	if o == nil {
		healing := globalBackgroundHealState.getLocalHealingDisks()
		for _, disk := range healing {

	user.UpdatedAt = time.Time{}
	if err := DB.Where(&user).First(&User{}).Error; err != nil {
		t.Errorf("search with struct with association should returns no error, but got %v", err)
	}

	if err := DB.Where(user).First(&User{}).Error; err != nil {
		t.Errorf("search with struct with association should returns no error, but got %v", err)
	}
}

func TestFindInBatches(t *testing.T) {
	users := []User{

import "gorm.io/gorm/utils"

type JoinType string

const (
	CrossJoin JoinType = "CROSS"
	InnerJoin JoinType = "INNER"
	LeftJoin  JoinType = "LEFT"
	RightJoin JoinType = "RIGHT"
)

type JoinTarget struct {
	Type        JoinType
	Association string
	Subquery    Expression
	Table       string
}

func Has(name string) JoinTarget {
	return JoinTarget{Type: InnerJoin, Association: name}
}

	AssertAssociationCount(t, users[1], "Company", 1, "After other user Delete")
}

func TestBelongsToDefaultValue(t *testing.T) {
	type Org struct {
		ID string
	}
	type BelongsToUser struct {
		OrgID string
		Org   Org `gorm:"default:NULL"`
	}

	tx := DB.Session(&gorm.Session{})
	tx.Config.DisableForeignKeyConstraintWhenMigrating = true