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) {

   * Integer.MAX_VALUE} elements, returns {@code Integer.MAX_VALUE}.
   */
  public int size() {
    return map.size();
  }

  /** Returns {@code true} if this map contains no key-value mappings. */
  public boolean isEmpty() {
    return map.isEmpty();
  }

  /**

        hoge.setA("A");
        hoge.setB(true);
        hoge.setC(3);
        final Map<String, Object> map = newHashMap();
        BeanUtil.copyBeanToMap(hoge, map);
        assertThat(map, is(notNullValue()));
        assertThat(map.get("a"), is((Object) "A"));
        assertThat(map.get("b"), is((Object) true));
        assertThat(map.get("c"), is((Object) 3));
    }

    /**
     * @throws Exception
     */

    public String getLogMessage() {
        return getSearchWord();
    }

    @Override
    public Map<String, Object> toSource() {
        final Map<String, Object> sourceMap = super.toSource();
        if (fields != null) {
            sourceMap.putAll(fields);
        }
        final Map<String, List<String>> searchFieldMap = searchFieldLogList.stream()

    assertEquals(map.size(), oldSize - 1);
    assertFalse(map.containsKey(key));
    assertEquals(subMap.size(), oldSize - 2);
  }

  public void testTailMapClearThrough() {
    SortedMap<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int oldSize = map.size();
    if (map.size() < 2 || !supportsClear) {
      return;
    }

    }

    @BeforeEach
    protected void initializeDictId() {
        final Map<String, Object> searchBody = new HashMap<>();
        final String response = checkMethodBase(searchBody).get("/api/admin/dict").asString();
        final List<Map<String, String>> dicts = JsonPath.from(response).getList("response.settings");

        for (Map<String, String> item : dicts) {
            assertTrue(item.containsKey("id"));

    map.put("bar", 2);
    map.put("quux", 3);

    map.remove("bar");
    assertThat(map.entrySet())
        .containsExactly(immutableEntry("foo", 1), immutableEntry("quux", 3))
        .inOrder();
  }

  public void testInsertionOrderAfterRemoveLast() {
    BiMap<String, Integer> map = HashBiMap.create();
    map.put("foo", 1);
    map.put("bar", 2);
    map.put("quux", 3);

    map.remove("quux");

		AMQP:          make(map[string]target.AMQPArgs),
		MQTT:          make(map[string]target.MQTTArgs),
		NATS:          make(map[string]target.NATSArgs),
		Redis:         make(map[string]target.RedisArgs),
		MySQL:         make(map[string]target.MySQLArgs),
		Kafka:         make(map[string]target.KafkaArgs),
		Webhook:       make(map[string]target.WebhookArgs),
		PostgreSQL:    make(map[string]target.PostgreSQLArgs),

	}
}

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 {

    assertThat(map.needsAllocArrays()).isTrue();
    assertThat(map.entries).isNull();
    assertThat(map.keys).isNull();
    assertThat(map.values).isNull();

    map.put(1, "1");
    assertThat(map.needsAllocArrays()).isFalse();
    assertThat(map.entries).hasLength(CompactHashing.DEFAULT_SIZE);
    assertThat(map.keys).hasLength(CompactHashing.DEFAULT_SIZE);
    assertThat(map.values).hasLength(CompactHashing.DEFAULT_SIZE);