type User struct {
		ID        int32 `gorm:"primaryKey"`
		Name      string
		CreatedBy *int32
		Creator   *User `gorm:"foreignKey:CreatedBy;references:ID"`
	}

	checkStructRelation(t, &User{}, Relation{
		Name: "Creator", Type: schema.BelongsTo, Schema: "User", FieldSchema: "User",
		References: []Reference{{"ID", "User", "CreatedBy", "User", "", false}},
	})
}

func TestBelongsToWithMixin(t *testing.T) {

	Birthday     sql.NullTime
	RegisteredAt mytime
	DeletedAt    *mytime
	Active       mybool
	Admin        *mybool
}

type BaseModel struct {
	ID        uint
	CreatedAt time.Time
	CreatedBy *int
	Created   *VersionUser `gorm:"foreignKey:CreatedBy"`
	UpdatedAt time.Time
	DeletedAt gorm.DeletedAt `gorm:"index"`
}

type VersionModel struct {
	BaseModel
	Version int
}

		{Name: "ID", DBName: "id", BindNames: []string{"VersionModel", "BaseModel", "ID"}, DataType: schema.Uint, PrimaryKey: true, Size: 64, HasDefaultValue: true, AutoIncrement: true},
		{Name: "CreatedBy", DBName: "created_by", BindNames: []string{"VersionModel", "BaseModel", "CreatedBy"}, DataType: schema.Uint, Size: 64},
		{Name: "Version", DBName: "version", BindNames: []string{"VersionModel", "Version"}, DataType: schema.Int, Size: 64},
	}

		if wildcard.MatchAsPatternPrefix(req.Prefix, keyName) {
			matches = append(matches, madmin.KMSKeyInfo{Name: keyName, CreatedAt: StubCreatedAt, CreatedBy: StubCreatedBy})
		}
	}

	return matches, "", nil
}

// CreateKey creates a new key with the given name.
func (s *StubKMS) CreateKey(_ context.Context, req *CreateKeyRequest) error {
	if s.containsKeyName(req.Name) {
		return ErrKeyExists
	}

	for i, v := range resp.Items {
		keyInfos[i].Name = v.Name
		keyInfos[i].CreatedAt = v.CreatedAt
		keyInfos[i].CreatedBy = v.CreatedBy.String()
	}
	return keyInfos, resp.ContinueAt, nil
}

func (c *kmsConn) CreateKey(ctx context.Context, req *CreateKeyRequest) error {
	if err := c.client.CreateKey(ctx, c.enclave, &kms.CreateKeyRequest{
		Name: req.Name,
	}); err != nil {

  "component": {
    "group": "${pom.groupId}",
    "module": "${pom.artifactId}",
    "version": "${pom.version}",
    "attributes": {
      "org.gradle.status": "${module.status}"
    }
  },
  "createdBy": {
    "maven": {
      "version": "${maven.version}",
      "buildId": "${maven.build.version}"
    }
  },
  "variants": [
    {
      "name": "${variant.jvmEnvironmentVariantName}ApiElements",

		}

		for i, want := range keys {
			if want.CreatedBy != kms.StubCreatedBy {
				t.Fatalf("want key created by %s, got %s", kms.StubCreatedBy, want.CreatedBy)
			}
			if want.CreatedAt != kms.StubCreatedAt {
				t.Fatalf("want key created at %s, got %s", kms.StubCreatedAt, want.CreatedAt)
			}
			if test.wantKeyNames[i] != want.Name {

}

// SetCreatedAt preserves the CreatedAt time for bucket across sites in site replication. It defaults to
// creation time of bucket on this cluster in all other cases.
func (b *BucketMetadata) SetCreatedAt(createdAt time.Time) {
	if b.Created.IsZero() {
		b.Created = UTCNow()
	}
	if !createdAt.IsZero() {
		b.Created = createdAt.UTC()
	}
}

        cursor
        node {
          number
          author {
            login
            avatarUrl
            url
          }
          createdAt
          comments(first: 50) {
            totalCount
            nodes {
              createdAt
              author {
                login
                avatarUrl
                url
              }
              isAnswer

		} else {
			AssertObjEqual(t, newPet, pet, "ID", "CreatedAt", "UpdatedAt", "DeletedAt", "UserID", "Name")
			AssertObjEqual(t, newPet, expect, "ID", "CreatedAt", "UpdatedAt", "DeletedAt", "UserID", "Name")
		}
	}

	AssertObjEqual(t, pet, expect, "ID", "CreatedAt", "UpdatedAt", "DeletedAt", "UserID", "Name")

	AssertObjEqual(t, pet.Toy, expect.Toy, "ID", "CreatedAt", "UpdatedAt", "DeletedAt", "Name", "OwnerID", "OwnerType")