from fastapi.exceptions import FastAPIDeprecationWarning
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, ConfigDict


def create_app():
    app = FastAPI()

    class Item(BaseModel):
        data: str

        model_config = ConfigDict(
            json_schema_extra={"example": {"data": "Data in schema_extra"}}
        )

func TestPostgresReturningIDWhichHasStringType(t *testing.T) {
	if DB.Dialector.Name() != "postgres" {
		t.Skip()
	}

	type Yasuo struct {
		ID        string `gorm:"default:gen_random_uuid()"`
		Name      string
		CreatedAt time.Time `gorm:"type:TIMESTAMP WITHOUT TIME ZONE"`
		UpdatedAt time.Time `gorm:"type:TIMESTAMP WITHOUT TIME ZONE;default:current_timestamp"`
	}

	if err := DB.Exec("CREATE EXTENSION IF NOT EXISTS pgcrypto;").Error; err != nil {

        val classGraph = JarAnalyzer("", keepClasses, keepClasses, setOf()).analyze(artifact, classesDir, manifestFile, buildReceiptFile)

        createJar(classGraph, classesDir, manifestFile, jarFile)

        return jarFile
    }

    private
    fun createJar(classGraph: ClassGraph, classesDir: File, manifestFile: File, jarFile: File) {
        try {

	Name         *sql.NullString
	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
}

	if DB.Dialector.Name() != "gaussdb" {
		t.Skip()
	}

	type Yasuo struct {
		// TODO: function gen_random_uuid() does not exist
		ID        string `gorm:"default:gen_random_uuid()"`
		Name      string
		CreatedAt time.Time `gorm:"type:TIMESTAMP WITHOUT TIME ZONE"`
		UpdatedAt time.Time `gorm:"type:TIMESTAMP WITHOUT TIME ZONE;default:current_timestamp"`
	}

	if err := DB.Exec("CREATE EXTENSION IF NOT EXISTS pgcrypto;").Error; err != nil {

{
  "fess_log.favorite_log" : {
    "aliases" : { },
    "mappings" : {
      "favorite_log" : {
        "properties" : {
          "createdAt" : {
            "type" : "date",
            "format" : "date_optional_time"
          },
          "docId" : {
            "type" : "keyword"
          },
          "queryId" : {
            "type" : "keyword"
          },
          "url" : {
            "type" : "keyword"
          },

	user := User{Name: "CreateUserExistingTimestamp"}
	curTime := now.MustParse("2016-01-01")
	user.CreatedAt = curTime
	user.UpdatedAt = curTime
	DB.Save(&user)

	AssertEqual(t, user.CreatedAt, curTime)
	AssertEqual(t, user.UpdatedAt, curTime)

	var newUser User
	DB.First(&newUser, user.ID)

	AssertEqual(t, newUser.CreatedAt, curTime)
	AssertEqual(t, newUser.UpdatedAt, curTime)
}

		if err != nil {
			log.Fatal(err)
		}
		if strings.HasSuffix(path, ".zip") {
			log.Fatalf("unexpected file during walk: %s", path)
		}
		name := filepath.ToSlash(path)
		w, err := zw.CreateRaw(&zip.FileHeader{
			Name:               name,
			Method:             zip.Store,
			CompressedSize64:   uint64(len(data)),
			UncompressedSize64: uint64(len(data)),
			CRC32:              crc32.ChecksumIEEE(data),
		})

            nodes {
              name
            }
          }
          author {
            login
            avatarUrl
            url
          }
          title
          createdAt
          lastEditedAt
          updatedAt
          state
          reviews(first:100) {
            nodes {
              author {
                login
                avatarUrl
                url

	if opts.VersioningEnabled {
		optsMap["versioningEnabled"] = "true"
	}
	if opts.ForceCreate {
		optsMap["forceCreate"] = "true"
	}
	createdAt, _ := globalBucketMetadataSys.CreatedAt(bucket)
	optsMap["createdAt"] = createdAt.UTC().Format(time.RFC3339Nano)
	opts.CreatedAt = createdAt

	// Create bucket and enable versioning on all peers.
	makeBucketConcErr := c.concDo(
		func() error {