assertEquals(engine2, retrievedByClass);

        // But original names should still work
        assertEquals(engine1, scriptEngineFactory.getScriptEngine("name1"));
        assertEquals(engine2, scriptEngineFactory.getScriptEngine("name2"));
    }

    // Test with engine that has very long class name
    public void test_add_longClassName() {

)

func NameIn1And2(d *gorm.DB) *gorm.DB {
	return d.Where("name in (?)", []string{"ScopeUser1", "ScopeUser2"})
}

func NameIn2And3(d *gorm.DB) *gorm.DB {
	return d.Where("name in (?)", []string{"ScopeUser2", "ScopeUser3"})
}

func NameIn(names []string) func(d *gorm.DB) *gorm.DB {
	return func(d *gorm.DB) *gorm.DB {
		return d.Where("name in (?)", names)
	}
}

func TestScopes(t *testing.T) {
	users := []*User{

        when(mockDeferredNdrBuffer.dec_ndr_long()).thenReturn(2); // _namess

        transNameArray.decode(mockNdrBuffer);

        assertEquals(2, transNameArray.count);
        assertNotNull(transNameArray.names);
        assertEquals(2, transNameArray.names.length);
        assertNotNull(transNameArray.names[0]);
        assertNotNull(transNameArray.names[1]);

	}

	DB.Create(&users)

	var names []string
	if err := DB.Model(User{}).Where("name like ?", "pluck-user%").Order("name").Pluck("name", &names).Error; err != nil {
		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)

        for (String name : expectedNames) {
            bb.put(name.getBytes(StandardCharsets.UTF_16LE));
            bb.putShort((short) 0);
        }

        referral.decode(testBuffer, 0, testBuffer.length);

        assertArrayEquals(expectedNames, referral.getExpandedNames());
    }

    given-names: Lukasz
  - family-names: Kudlur
    given-names: Manjunath
  - family-names: Levenberg
    given-names: Josh
  - family-names: Mané
    given-names: Dan
  - family-names: Schuster
    given-names: Mike
  - family-names: Monga
    given-names: Rajat
  - family-names: Moore
    given-names: Sherry
  - family-names: Murray
    given-names: Derek
  - family-names: Olah
    given-names: Chris

            names.names[0].sid_index = 0;
            // Second is a domain group
            names.names[1] = new lsarpc.LsarTranslatedName();
            names.names[1].sid_type = (short) jcifs.SID.SID_TYPE_DOM_GRP;
            names.names[1].name = new UnicodeString("Domain Users", false);
            names.names[1].sid_index = 0;
            rpc.names = names;
            return null;

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

        final Path confPath = getConfPath(names);
        if (Files.exists(confPath)) {
            return confPath;
        }
        return org.codelibs.core.io.ResourceUtil.getResourceAsFile(String.join("/", names)).toPath();
    }

    /**
     * Gets the path to compiled classes directory.
     *
     * @param names the path components to append to the classes directory

func TestMigrateConstraint(t *testing.T) {
	names := []string{"Account", "fk_users_account", "Pets", "fk_users_pets", "Company", "fk_users_company", "Team", "fk_users_team", "Languages", "fk_users_languages"}

	for _, name := range names {
		if !DB.Migrator().HasConstraint(&User{}, name) {
			DB.Migrator().CreateConstraint(&User{}, name)
		}

		if err := DB.Migrator().DropConstraint(&User{}, name); err != nil {