"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()

	}, {
		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"}},

        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() {

				)
			}
		}
	}
}

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)

	if err != nil {
		t.Fatal(err)
	}
	name1 := f.Name()
	defer os.Remove(name1)
	f.WriteString("aaaaaaaaaa")
	f.Close()

	f, err = os.CreateTemp(t.TempDir(), "")
	if err != nil {
		t.Fatal(err)
	}
	name2 := f.Name()
	defer os.Remove(name2)
	f.WriteString("bbbbbbbbbb")
	f.Close()

	if err = AppendFile(name1, name2, false); err != nil {
		t.Error(err)
	}

		t.Skip("symlinks not available on windows")
		return nil
	}
	dir := t.TempDir()
	entries := []string{}
	for i := range 10 {
		name1 := fmt.Sprintf("file-%d", i)
		name2 := fmt.Sprintf("file-%d", i+10)
		if err := os.WriteFile(filepath.Join(dir, name1), []byte{}, os.ModePerm); err != nil {
			// For cleanup, its required to add these entries into test results.
			testResults = append(testResults, result{dir, entries})

        tracker.setName("name1");
        tracker.transform(responseData);

        tracker.setName("name2");
        tracker.transform(responseData);

        tracker.setName("name3");
        tracker.transform(responseData);

        List<String> history = tracker.getNameHistory();
        assertEquals(3, history.size());
        assertEquals("name1", history.get(0));

		Password: EncryptedData("pass1"),
		Bytes:    []byte("byte"),
		Num:      18,
		Strings:  StringsSlice{"a", "b", "c"},
		Structs: StructsSlice{
			{"name1", "value1"},
			{"name2", "value2"},
		},
		Role:             Role{Name: "admin"},
		ExampleStruct:    ExampleStruct{"name", "value1"},
		ExampleStructPtr: &ExampleStruct{"name", "value2"},
	}

        tableField.setAccessible(true);
        Map<Name, NbtAddress> table = (Map<Name, NbtAddress>) tableField.get(lmhosts);

        Name name1 = new Name(mockConfig, "HOST1", 0x20, null);
        Name name2 = new Name(mockConfig, "HOST2", 0x20, null);

        assertNotNull(table.get(name1));
        assertNotNull(table.get(name2));
    }

    @Test
    void testPopulateWithIncludeDirective() throws Exception {