}

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

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

	}
}

type metricValue struct {
	Labels map[string]string
	Value  float64
}

// MetricValues - type to set metric values retrieved while loading metrics. A
// value of this type is passed to the `MetricsLoaderFn`.
type MetricValues struct {
	values      map[MetricName][]metricValue
	descriptors map[MetricName]MetricDescriptor
}

func newMetricValues(d map[MetricName]MetricDescriptor) MetricValues {

      Map<K, ? extends V> map, @ParametricNullness V defaultValue) {
    return new ForMapWithDefault<>(map, defaultValue);
  }

  private static final class FunctionForMapNoDefault<
          K extends @Nullable Object, V extends @Nullable Object>
      implements Function<K, V>, Serializable {
    final Map<K, V> map;

    FunctionForMapNoDefault(Map<K, V> map) {
      this.map = checkNotNull(map);
    }

    @Override

    private static final Logger logger = LogManager.getLogger(PasswordBasedExtractor.class);

    /** Map of regex patterns to passwords for static password configuration. */
    protected Map<Pattern, String> passwordMap = new HashMap<>();

    /** Cache for parsed password configurations from extraction parameters. */
    private final Map<String, List<Pair<Pattern, String>>> configPasswordMap = new ConcurrentHashMap<>();

    /**

  }

  @Test fun regularMappings() {
    assertThat("hello".map()).isEqualTo("hello")
    assertThat("hello-world".map()).isEqualTo("hello-world")
    assertThat("HELLO".map()).isEqualTo("hello")
    assertThat("Hello".map()).isEqualTo("hello")

    // These compound characters map their its components.
    assertThat("¼".map()).isEqualTo("1⁄4")
    assertThat("™".map()).isEqualTo("tm")
  }

        return "Role [name=" + name + "]";
    }

    public Map<String, String> getAttributes() {
        return attributes;
    }

    public void setAttributes(final Map<String, String> attributes) {
        this.attributes = attributes;
    }

    @Override
    public Map<String, Object> toSource() {
        final Map<String, Object> sourceMap = new HashMap<>();
        if (name != null) {

# 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

        }
    }

    @Override
    public boolean add(final Map<String, Object> e) {
        return parent.add(e);
    }

    @Override
    public void add(final int index, final Map<String, Object> element) {
        parent.add(index, element);
    }

    @Override
    public boolean addAll(final Collection<? extends Map<String, Object>> c) {
        return parent.addAll(c);
    }

    }

    @Test
    @DisplayName("Options map is not mutated by configuration (verify no writes)")
    void optionsMap_notMutated_verifyNoWrites() {
        // Arrange: create a regular map first, then spy on it
        Map<String, Object> originalMap = new HashMap<>();
        originalMap.put("refreshKrb5Config", "true");

        @SuppressWarnings("unchecked")
        Map<String, Object> spyOpts = spy(originalMap);

  }

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

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