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

	var names2 []string
	DB.Scopes(func(db *gorm.DB) *gorm.DB {
		return db.Table("users")
	}).Where("name like ?", "distinct%").Order("name").Pluck("name", &names2)
	AssertEqual(t, names2, []string{"distinct", "distinct", "distinct", "distinct-2", "distinct-3"})

	var results []User

        Name name2 = new Name(mockConfig, "TEST", 0x20, "scope");

        assertTrue(name1.equals(name2));
    }

    @Test
    void equals_withDifferentName_shouldReturnFalse() {
        Name name1 = new Name(mockConfig, "TEST1", 0x20, "scope");
        Name name2 = new Name(mockConfig, "TEST2", 0x20, "scope");

        assertFalse(name1.equals(name2));
    }

    @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();

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

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

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

        BsUser entity2 = new BsUser();
        entity2.setName("name2");

        Set<BsUser> entitySet = new HashSet<>();

		}
		// Symlink will not be added to entries.
		if err := os.Symlink(filepath.Join(dir, name1), filepath.Join(dir, name2)); err != nil {
			t.Fatalf("Unable to create a symlink, %s", err)
		}
		// Add to entries.
		entries = append(entries, name1)
		// Symlinks are preserved for regular files
		entries = append(entries, name2)
	}
	if err := os.MkdirAll(filepath.Join(dir, "mydir"), 0o777); err != nil {

        assertNull(param.getValues()[3]);
    }

    public void test_constructor_withSpecialCharacters() {
        // Test with special characters in name and values
        String name = "param-name_123!@#";
        String[] values = { "value with spaces", "value@special#chars", "日本語" };
        RequestParameter param = new RequestParameter(name, values);

        assertEquals(name, param.getName());

        TestScriptEngine engine1 = new TestScriptEngine("first");
        TestScriptEngine engine2 = new TestScriptEngine("second");

        scriptEngineFactory.add("name1", engine1);
        scriptEngineFactory.add("name2", engine2);

        // Both engines have same class name, so second should replace first for class name lookup
        ScriptEngine retrievedByClass = scriptEngineFactory.getScriptEngine("testscriptengine");

		t.Errorf("got error when pluck name: %v", err)
	}

	var names2 []string
	if err := DB.Model(User{}).Where("name like ?", "pluck-user%").Order("name desc").Pluck("name", &names2).Error; err != nil {
		t.Errorf("got error when pluck name: %v", err)
	}

	sort.Slice(names2, func(i, j int) bool { return names2[i] < names2[j] })
	AssertEqual(t, names, names2)

	var ids []int

        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 {

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

	if err := DB.Create(&data).Error; err != nil {