# o isCheckDbCommentDiff: (NotRequired - Default false)
# o isCheckProcedureDiff: (NotRequired - Default false)
# o loadDataReverseMap: (NotRequired - Default map:{})
# o schemaSyncCheckMap: (NotRequired - Default map:{})
# o propertiesHtmlMap: (NotRequired - Default map:{})
#
# Example:
# map:{
#     ; documentOutputDirectory = ./output/doc
#     ; aliasDelimiterInDbComment = :
#     ; isDbCommentOnAliasBasis = true

        assertFalse(fieldConfigs.getConfig("foo").map(FieldConfigs.Config::isOverwrite).orElse(false));
    }

    @Test
    public void test_cache() {
        final Map<String, String> params = Maps.of("foo", "cache");
        FieldConfigs fieldConfigs = new FieldConfigs(params);
        assertTrue(fieldConfigs.getConfig("test").isEmpty());

    /**
     * Get the environment map.
     * @return The environment map.
     */
    protected Map<String, String> getEnvMap() {
        if (envMap != null) {
            return envMap;
        }
        return System.getenv();
    }

    /**
     * Set the environment map.
     * @param envMap The environment map.
     */
    public void setEnvMap(final Map<String, String> envMap) {

  }

  public void testKeySet() {
    Map<String, Integer> map = create();
    Set<String> keySet = map.keySet();
    assertTrue(keySet instanceof SynchronizedSet);
    assertThat(((SynchronizedSet<?>) keySet).mutex).isSameInstanceAs(mutex);
  }

  public void testValues() {
    Map<String, Integer> map = create();
    Collection<Integer> values = map.values();

      }
    }
  }

  /**
   * Returns an immutable map containing the same entries as {@code map}. If {@code map} somehow
   * contains entries with duplicate keys (for example, if it is a {@code SortedMap} whose
   * comparator is not <i>consistent with equals</i>), the results of this method are undefined.
   *
   * <p><b>Note:</b> Despite what the method name suggests, if {@code map} is an {@code

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

    private static final long serialVersionUID = 1L;

    /**
     * The internal LRU hash map used to store elements.
     */
    private final LruHashMap<E, Object> map;

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

    /**
     * Creates a new {@link LruHashSet} with the specified limit size.
     *

        // don't merge
    }

    @Override
    protected void mergeModel_Profiles(
            Model.Builder builder, Model target, Model source, boolean sourceDominant, Map<Object, Object> context) {
        Iterator<Profile> sourceIterator = source.getProfiles().iterator();
        builder.profiles(target.getProfiles().stream()

    // Hack around K not being a subtype of Comparable.
    // Unsafe, see ImmutableSortedSetFauxverideShim.
    @SuppressWarnings("unchecked")
    Ordering<K> naturalOrder = (Ordering<K>) NATURAL_ORDER;
    return copyOfInternal(map, naturalOrder);
  }

  /**
   * Returns an immutable map containing the same entries as {@code map}, with keys sorted by the

   * {@code EnumHashBiMap} or an {@link EnumBiMap}, the new bimap has the same key type as the input
   * bimap. Otherwise, the specified map must contain at least one mapping, in order to determine
   * the key type.
   *
   * @param map the map whose mappings are to be placed in this map