}

	if name := DB.Dialector.Name(); name == "postgres" {
		stmt := gorm.Statement{DB: DB}
		stmt.Parse(&Blog{})
		stmt.Schema.LookUpField("ID").Unique = true
		stmt.Parse(&Tag{})
		stmt.Schema.LookUpField("ID").Unique = true
		// postgers only allow unique constraint matching given keys
	}

		t.Fatal("Unmarshal: ", err)
	} else if len(jk.Keys) != 2 {
		t.Fatalf("Expected 2 keys, got %d", len(jk.Keys))
	}

	keys := make([]crypto.PublicKey, len(jk.Keys))
	for ii, jks := range jk.Keys {
		var err error
		keys[ii], err = jks.DecodePublicKey()
		if err != nil {
			t.Fatalf("Failed to decode key %d: %v", ii, err)
		}
	}

	//nolint:gocritic
	if key0, ok := keys[0].(*ecdsa.PublicKey); !ok {

	tests := []struct {
		input          string
		keys           []string
		expectedFields map[string]struct{}
	}{
		// No keys present
		{
			input:          "",
			keys:           []string{"comment"},
			expectedFields: map[string]struct{}{},
		},
		// No keys requested for tokenizing
		{
			input:          `comment="Hi this is my comment ="`,
			keys:           []string{},
			expectedFields: map[string]struct{}{},

            Entry<K, V> entry = requireNonNull(entryArray[i]);
            K key = entry.getKey();
            V value = entry.getValue();
            checkEntryNotNull(key, value);
            keys[i] = key;
            values[i] = value;
            checkNoConflict(comparator.compare(prevKey, key) != 0, "key", prevEntry, entry);
            prevKey = key;
          }
        }
        return new ImmutableSortedMap<>(

      public Map<Object, Object> create(List<?> keys) {
        return ImmutableMap.copyOf(
            Lists.transform(keys, k -> Maps.immutableEntry(k, "dummy value")));
      }
    },
    BUILDER_PUT_ONE_BY_ONE {
      @Override
      public Map<Object, Object> create(List<?> keys) {
        ImmutableMap.Builder<Object, Object> builder = ImmutableMap.builder();
        for (Object k : keys) {
          builder.put(k, "dummy value");

		var key []byte
		key, buf, err = msgp.ReadMapKeyZC(buf)
		if err != nil {
			return keys, err
		}
		if len(key) == 0 {
			return keys, fmt.Errorf("xlMetaInlineData: key %d is length 0", i)
		}
		keys = append(keys, string(key))
		// Skip data...
		_, buf, err = msgp.ReadBytesZC(buf)
		if err != nil {
			return keys, err
		}
	}
	return keys, nil
}

		t.Fatal("failed to get the duplicxate item by key '99' after adding")
	}
	keys, items, err = batch.GetAll()
	if err != nil {
		t.Fatalf("unable to get the items from the batch; %v", err)
	}
	if len(items) != 1 {
		t.Fatalf("Expected length of the batch items to be 1 but got %v", len(items))
	}
	if len(keys) != 1 {
		t.Fatalf("Expected length of the batch keys to be 1 but got %v", len(items))
	}

    List<? extends Entry<?, ?>> entries = Lists.newArrayList(map.entrySet());
    List<Object> keys = Lists.newArrayList(map.keySet());
    List<Object> values = Lists.newArrayList(map.values());
    assertEquals(2 * entries.size(), alternatingKeysAndValues.length);
    assertEquals(2 * keys.size(), alternatingKeysAndValues.length);
    assertEquals(2 * values.size(), alternatingKeysAndValues.length);

     * cause {@link #build} to fail.
     *
     * @since 19.0
     */
    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(Entry<? extends K, ? extends V> entry) {
      super.put(entry);
      return this;
    }

    /**
     * Associates all of the given map's keys and values in the built bimap. Duplicate keys or

   *
   * @param keys the unique, non-null keys whose values should be loaded
   * @return a map from each key in {@code keys} to the value associated with that key; <b>may not
   *     contain null values</b>
   * @throws Exception if unable to load the result
   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is