"table1.name_23":     {"table1", "name_23"},
		"`table_1`.`name23`": {"table_1", "name23"},
		"'table23'.'name_1'": {"table23", "name_1"},
		"'table23'.name1":    {"table23", "name1"},
		"'name1'":            {"", "name1"},
		"`name_1`":           {"", "name_1"},
		"`Name_1`":           {"", "Name_1"},
		"`Table`.`nAme`":     {"Table", "nAme"},
		"my_table.*":         {"my_table", "*"},
		"`my_table`.*":       {"my_table", "*"},

	AssertEqual(t, false, DB.Migrator().HasIndex(&UniqueTest{}, "name"))
	AssertEqual(t, false, DB.Migrator().HasIndex(&UniqueTest{}, "name_1"))
	AssertEqual(t, false, DB.Migrator().HasIndex(&UniqueTest{}, "name_2"))

	ct, err = findColumnType(&UniqueTest{}, "name")
	if err != nil {
		t.Fatalf("findColumnType err:%v", err)
	}

	value, ok = ct.DefaultValue()

	AssertEqual(t, names, []string{"distinct", "distinct", "distinct", "distinct-2", "distinct-3"})

	var names1 []string
	DB.Model(&User{}).Where("name like ?", "distinct%").Distinct().Order("name").Pluck("Name", &names1)

	AssertEqual(t, names1, []string{"distinct", "distinct-2", "distinct-3"})

	var names2 []string
	DB.Scopes(func(db *gorm.DB) *gorm.DB {
		return db.Table("users")

	}, {
		SQL:          "name1 = @name1 AND name2 = @name2 AND name3 = @name1",
		Vars:         []interface{}{sql.Named("name1", "jinzhu"), sql.Named("name2", "jinzhu2")},
		Result:       "name1 = ? AND name2 = ? AND name3 = ?",
		ExpectedVars: []interface{}{"jinzhu", "jinzhu2", "jinzhu"},
	}, {
		SQL:          "name1 = @name1 AND name2 = @name2 AND name3 = @name1",
		Vars:         []interface{}{map[string]interface{}{"name1": "jinzhu", "name2": "jinzhu2"}},

func TestNamedArg(t *testing.T) {
	type NamedUser struct {
		gorm.Model
		Name1 string
		Name2 string
		Name3 string
	}

	DB.Migrator().DropTable(&NamedUser{})
	DB.AutoMigrate(&NamedUser{})

	namedUser := NamedUser{Name1: "jinzhu1", Name2: "jinzhu2", Name3: "jinzhu3"}
	DB.Create(&namedUser)

	var result NamedUser
	DB.First(&result, "name1 = @name OR name2 = @name OR name3 = @name", sql.Named("name", "jinzhu2"))

        assertFalse(name1.equals(name2));
    }

    @Test
    void equals_withDifferentHexCode_shouldReturnFalse() {
        Name name1 = new Name(mockConfig, "TEST", 0x20, "scope");
        Name name2 = new Name(mockConfig, "TEST", 0x1C, "scope");

        assertFalse(name1.equals(name2));
    }

    @Test
    void equals_withDifferentScope_shouldReturnFalse() {

    @Test
    public void test_methodConsistency() {
        // Test assistClientInvokeNames consistency
        String[] names1 = invokerAssistant.assistClientInvokeNames();
        String[] names2 = invokerAssistant.assistClientInvokeNames();
        assertSame(names1, names2);

        // Test assistByPassInvokeNames consistency
        String[] bypass1 = invokerAssistant.assistByPassInvokeNames();

        assertEquals("name1", map1.get("name"));

        Map<String, Object> map2 = resultList.get(1);
        assertEquals("name2", map2.get("name"));
    }

    @Test
    public void test_register_entitySet() {
        RenderData data = new RenderData();

        BsUser entity1 = new BsUser();
        entity1.setName("name1");

        BsUser entity2 = new BsUser();

    }

    auto s = TF_NewStatus();
    auto func = TF_GraphToFunction(graph_.get(), name_.data(), 0, -1, nullptr,
                                   inputs_.size(), inputs_.data(),
                                   graph_outputs.size(), graph_outputs.data(),
                                   nullptr, nullptr, name_.data(), s);
    *f = new GraphFunction(std::move(func->record->fdef()));
    TF_DeleteFunction(func);

				)
			}
		}
	}
}

func TestParseUniqueConstraints(t *testing.T) {
	type UserUnique struct {
		Name1 string `gorm:"unique"`
		Name2 string `gorm:"uniqueIndex"`
	}

	user, err := schema.Parse(&UserUnique{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {
		t.Fatalf("failed to parse user unique, got error %v", err)