}
		if field.UniqueIndex != uniqueIndex {
			t.Fatalf("%v: %q column %q uniqueIndex should be %v but got %v", utils.FileWithLineNum(), stmt.Schema, fieldName, uniqueIndex, field.UniqueIndex)
		}
	}

	type ( // not unique
		UniqueStruct1 struct {
			Name string `gorm:"size:10"`
		}

				)
			}
		}
	}
}

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)
	}
	constraints := user.ParseUniqueConstraints()

		FieldC string `gorm:"index:,unique"`     // uniqueIndex
		FieldD string `gorm:"uniqueIndex;index"` // uniqueIndex and index

		FieldE1 string `gorm:"uniqueIndex:uniq_field_e1_e2"` // mul uniqueIndex
		FieldE2 string `gorm:"uniqueIndex:uniq_field_e1_e2"`

		FieldF1 string `gorm:"uniqueIndex:uniq_field_f1_f2;index"` // mul uniqueIndex and index
		FieldF2 string `gorm:"uniqueIndex:uniq_field_f1_f2;"`

// ParseIndexes parse schema indexes
func (schema *Schema) ParseIndexes() map[string]Index {
	indexes := map[string]Index{}

	for _, field := range schema.Fields {
		if field.TagSettings["INDEX"] != "" || field.TagSettings["UNIQUEINDEX"] != "" {
			fieldIndexes, err := parseFieldIndexes(field)
			if err != nil {
				schema.err = err
				break
			}
			for _, index := range fieldIndexes {
				idx := indexes[index.Name]
				idx.Name = index.Name

 * limitations under the License.
 */

package com.google.common.collect;

import static com.google.common.base.Functions.toStringFunction;
import static com.google.common.collect.Maps.uniqueIndex;
import static java.util.Arrays.asList;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import com.google.caliper.api.Footprint;

    assertThrows(
        NullPointerException.class, () -> fluent(1, 2, 3).uniqueIndex(Functions.constant(null)));
  }

  public void testUniqueIndex_nullValue() {
    assertThrows(
        NullPointerException.class,
        () -> {
          ImmutableMap<Object, Integer> unused =
              fluent(1, null, 2)
                  .uniqueIndex(
                      new Function<Integer, Object>() {

	// In some db (e.g. MySQL), Unique and UniqueIndex are indistinguishable.
	// When a column has a (not Mul) UniqueIndex, Migrator always reports its gorm.ColumnType is Unique.
	// It causes field unnecessarily migration.
	// Therefore, we need to record the UniqueIndex on this column (exclude Mul UniqueIndex) for MigrateColumnUnique.
	UniqueIndex string
}

func (field *Field) BindName() string {

	tidbSkip(t, "not support the foreign key feature")

	type Profile struct {
		ID       uint
		Name     string
		MemberID uint
	}

	type Member struct {
		ID      uint
		Refer   uint `gorm:"uniqueIndex"`
		Name    string
		Profile Profile `gorm:"Constraint:OnUpdate:CASCADE,OnDelete:CASCADE;FOREIGNKEY:MemberID;References:Refer"`
	}

	DB.Migrator().DropTable(&Profile{}, &Member{})

			PkgPath: ownField.StructField.PkgPath,
			Type:    ownField.StructField.Type,
			Tag: removeSettingFromTag(appendSettingFromTag(ownField.StructField.Tag, "primaryKey"),
				"column", "autoincrement", "index", "unique", "uniqueindex"),
		})
	}

	for idx, relField := range refForeignFields {
		joinFieldName := cases.Title(language.Und, cases.NoLower).String(relation.FieldSchema.Name) + relField.Name

   * @since 14.0
   */
  @SuppressWarnings("nullness") // Unsafe, but we can't do much about it now.
  public final <K> ImmutableMap<K, @NonNull E> uniqueIndex(Function<? super E, K> keyFunction) {
    return Maps.uniqueIndex((Iterable<@NonNull E>) getDelegate(), keyFunction);
  }

  /**
   * Returns an array containing all of the elements from this fluent iterable in iteration order.
   *