},
                        "type": "object",
                        "required": ["subname"],
                        "title": "SubItem",
                    },
                    "SubItem-Output": {
                        "properties": {
                            "subname": {"type": "string", "title": "Subname"},
                            "sub_description": {

				name = tag[0:idx]
				if name == "" {
					subName := field.Name
					const key = "COMPOSITE"
					if composite, found := settings[key]; found {
						if len(composite) == 0 || composite == key {
							err = fmt.Errorf(
								"the composite tag of %s.%s cannot be empty",
								field.Schema.Name,
								field.Name)
							return
						}
						subName = composite
					}

		}
	}

	for _, field := range schema.Fields {
		if field.DBName == "" && field.DataType != "" {
			field.DBName = namer.ColumnName(schema.Table, field.Name)
		}

		bindName := field.BindName()
		if field.DBName != "" {
			// nonexistence or shortest path or first appear prioritized if has permission

	"errors"
	"fmt"
	"math"
	"path/filepath"
	"runtime"
	"strings"
	"testing"
	"time"
)

func TestIsInvalidDBNameChar(t *testing.T) {
	for _, db := range []string{"db", "dbName", "db_name", "db1", "1dbname", "db$name"} {
		if fields := strings.FieldsFunc(db, IsInvalidDBNameChar); len(fields) != 1 {
			t.Fatalf("failed to parse db name %v", db)
		}
	}
}

func TestCheckTruth(t *testing.T) {

		{Name: "DeletedAt", DBName: "deleted_at", BindNames: []string{"Model", "DeletedAt"}, Tag: `gorm:"index"`, DataType: schema.Time},
		{Name: "Name", DBName: "name", BindNames: []string{"Name"}, DataType: schema.String},
		{Name: "Age", DBName: "age", BindNames: []string{"Age"}, DataType: schema.Uint, Size: 64},
		{Name: "Birthday", DBName: "birthday", BindNames: []string{"Birthday"}, DataType: schema.Time},

    return DBUser(name="John", surname="Doe", password_hash="secret")


@app.get("/response_model_list_of_model-no_annotation", response_model=list[User])
def response_model_list_of_model_no_annotation():
    return [
        DBUser(name="John", surname="Doe", password_hash="secret"),
        DBUser(name="Jane", surname="Does", password_hash="secret2"),
    ]

        return this;
    }

    public void setJobName_Equal(String jobName) {
        setJobName_Term(jobName, null);
    }

    public void setJobName_Equal(String jobName, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setJobName_Term(jobName, opLambda);
    }

    public void setJobName_Term(String jobName) {
        setJobName_Term(jobName, null);
    }

			}
		}

		if !stmt.SkipHooks && stmt.Schema != nil {
			for _, dbName := range stmt.Schema.DBNames {
				field := stmt.Schema.LookUpField(dbName)
				if field.AutoUpdateTime > 0 && value[field.Name] == nil && value[field.DBName] == nil {
					if v, ok := selectColumns[field.DBName]; (ok && v) || !ok {
						now := stmt.DB.NowFunc()
						assignValue(field, now)

        this.endTime = value;
    }

    public String getJobName() {
        checkSpecifiedProperty("jobName");
        return convertEmptyToNull(jobName);
    }

    public void setJobName(String value) {
        registerModifiedProperty("jobName");
        this.jobName = value;
    }

    public String getJobStatus() {
        checkSpecifiedProperty("jobStatus");

          value "MATRIX_${param[0].toUpperCase()}", param[1]
        }
      } else {
        tag jobName
        value 'Job Name', jobName
      }

      tag 'CI'
      link 'CI Build', buildUrl
      link 'GCP Upload', "https://console.cloud.google.com/storage/browser/_details/elasticsearch-ci-artifacts/jobs/${URLEncoder.encode(jobName, "UTF-8")}/build/${buildNumber}.tar.bz2"
      value 'Job Number', buildNumber
      if (jobBranch) {