}
    };
  }

  private static <T> ImmutableMultiset<T> multiset(T value, int count) {
    return multiset(ImmutableMap.of(value, count));
  }

  private static <T> ImmutableMultiset<T> multiset(T value1, int count1, T value2, int count2) {
    return multiset(ImmutableMap.of(value1, count1, value2, count2));
  }

  private static <T> ImmutableMultiset<T> multiset(Map<T, Integer> counts) {

      }
    };
  }

  private static <T> ImmutableMultiset<T> multiset(T value, int count) {
    return multiset(ImmutableMap.of(value, count));
  }

  private static <T> ImmutableMultiset<T> multiset(T value1, int count1, T value2, int count2) {
    return multiset(ImmutableMap.of(value1, count1, value2, count2));
  }

  private static <T> ImmutableMultiset<T> multiset(Map<T, Integer> counts) {

        // Create test data
        DataConfig config = new DataConfig();
        config.setName("test-config");

        DataStoreParams params = new DataStoreParams();
        params.put("key1", "value1");
        params.put("key2", "value2");

        IndexUpdateCallback callback = new TestIndexUpdateCallback();

        // Execute store method
        dataStore.store(config, callback, params);

        // Verify store was called

    builder.put("key", "value");
    assertThat(builder.build().entries()).containsExactly(Maps.immutableEntry("key", "value"));
  }

  public void testBuilderWithExpectedKeysPositive() {
    ImmutableSetMultimap.Builder<String, String> builder =
        ImmutableSetMultimap.builderWithExpectedKeys(1);
    builder.put("key", "value");

// Sets `value` to the binary-serialized TensorShapeProto of the value of
// `attr_name` attribute of `oper`.
TF_CAPI_EXPORT extern void TF_OperationGetAttrTensorShapeProto(
    TF_Operation* oper, const char* attr_name, TF_Buffer* value,
    TF_Status* status);

// Fills in `values` with binary-serialized TensorShapeProto values of the

        // Test adding conditions
        generator = new TestThumbnailGenerator();

        // Test adding single condition
        generator.addCondition("field1", "value1");

        // Test adding multiple conditions for same field
        generator.addCondition("field1", "value2");

        // Test adding conditions for different fields
        generator.addCondition("field2", "pattern.*");

    // any values in that range. To see why, consider the case where:
    // safeMin <= {hi,lo} <= safeMax
    // where {hi,lo} are characters forming a surrogate pair such that:
    // codePointOf(hi, lo) > safeMax
    // which would result in the surrogate pair being (wrongly) considered safe.
    // If we clip the safe range used during the per-character tests so it is

				Values:  [][]interface{}{{"my name"}},
			},
		},
		{
			name: "Test convert int value",
			input: map[string]interface{}{
				"age": 18,
			},
			expect: clause.Values{
				Columns: []clause.Column{{Name: "age"}},
				Values:  [][]interface{}{{18}},
			},
		},
		{
			name: "Test convert float value",
			input: map[string]interface{}{
				"score": 99.5,
			},
			expect: clause.Values{

	assignments := make([]Assignment, len(values))
	for idx, value := range values {
		assignments[idx] = Assignment{Column: Column{Name: value}, Value: Column{Table: "excluded", Name: value}}
	}
	return assignments

import java.util.Map;
import org.jspecify.annotations.Nullable;

/**
 * A {@link CharEscaper} that uses an array to quickly look up replacement characters for a given
 * {@code char} value. An additional safe range is provided that determines whether {@code char}
 * values without specific replacements are to be considered safe and left unescaped or should be
 * escaped in a general way.
 *