var langs3 []Language
	if err := DB.Find(&langs3, "code LIKE ?", "upsert-slice%").Error; err != nil {
		t.Errorf("no error should happen when find languages with code, but got %v", err)
	} else if len(langs3) != 3 {
		t.Errorf("should only find only 3 languages, but got %+v", langs3)
	}

	for idx, lang := range langs {
		lang.Name = lang.Name + "_new"
		langs[idx] = lang
	}

	if err := DB.Clauses(clause.OnConflict{

            "analyzer": "russian_analyzer"
          }
        }
      },
      {
        "lang_si": {
          "match": "*_si",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_sq": {
          "match": "*_sq",
          "mapping": {
            "type": "text",

            "analyzer": "russian_analyzer"
          }
        }
      },
      {
        "lang_si": {
          "match": "*_si",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_sq": {
          "match": "*_sq",
          "mapping": {
            "type": "text",

            "analyzer": "russian_analyzer"
          }
        }
      },
      {
        "lang_si": {
          "match": "*_si",
          "mapping": {
            "type": "text",
            "analyzer": "empty_analyzer"
          }
        }
      },
      {
        "lang_sq": {
          "match": "*_sq",
          "mapping": {
            "type": "text",

	}).Create(ctx, &lang3); err != nil {
		t.Fatalf("failed to upsert, got %v", err)
	}

	if langs, err := gorm.G[Language](DB).Where("code = ?", lang.Code).Find(ctx); err != nil {
		t.Errorf("no error should happen when find languages with code, but got %v", err)
	} else if len(langs) != 1 {
		t.Errorf("should only find only 1 languages, but got %+v", langs)
	} else if langs[0].Name != "upsert-new" {

 * href="https://github.com/google/guava/wiki/PrimitivesExplained">primitive utilities</a>.
 *
 * @author Kevin Bourrillion
 * @since 1.0
 */
@GwtCompatible
public final class Longs {
  private Longs() {}

  /**
   * The number of bytes required to represent a primitive {@code long} value.
   *
   * <p>Prefer {@link Long#BYTES} instead.
   */
  public static final int BYTES = Long.BYTES;

  /**

                    if (japaneseMode && "ja".equals(lang)) {
                        // Simulate Japanese conversion
                        if ("東京".equals(text)) {
                            readings.add("トウキョウ");
                        } else {
                            readings.add(text.toUpperCase() + "_" + lang);
                        }
                    } else if (langs.length > 1) {

Ferner sagt die Spezifikation, dass der Client ein weiteres Formularfeld "`scope`" („Geltungsbereich“) senden kann.

Der Name des Formularfelds lautet `scope` (im Singular), tatsächlich handelt es sich jedoch um einen langen String mit durch Leerzeichen getrennten „Scopes“.

Jeder „Scope“ ist nur ein String (ohne Leerzeichen).

Diese werden normalerweise verwendet, um bestimmte Sicherheitsberechtigungen zu deklarieren, zum Beispiel:

     * @param searchWord Search word
     * @param field Field
     * @param langs Languages
     * @param analyzer Analyzer
     * @return True if the search word is excluded
     */
    protected boolean isExcludeSearchword(final String searchWord, final String field, final String[] langs,
            final SuggestAnalyzer analyzer) {
        if (langs == null || langs.length == 0) {

	}
	AssertAssociationCount(t, user, "Languages", 1, "after replace with 1 map")

	var langs []Language
	if err := DB.Model(&user).Association("Languages").Find(&langs); err != nil {
		t.Fatalf("find languages after replace: %v", err)
	}
	if len(langs) != 1 || langs[0].Code != "rm2m_map_1" {
		t.Fatalf("expected only rm2m_map_1 after replace, got %+v", langs)
	}