Error:    err,
						})
				} else {
					added.STSPolicies = append(added.STSPolicies, map[string][]string{u: strings.Split(pm.Policies, ",")})
				}
			}
		}
	}

	if apiVer == "v2" {
		iamr := madmin.ImportIAMResult{
			Skipped: skipped,
			Removed: removed,
			Added:   added,
			Failed:  failed,
		}

		b, err := json.Marshal(iamr)

      return this;
    }

    /** Adds a key-value mapping to the built multimap if it is not already present. */
    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(K key, V value) {
      super.put(key, value);
      return this;
    }

    /**
     * Adds an entry to the built multimap if it is not already present.
     *
     * @since 11.0

  <description>Flat directory structure case: module = ../child directory path + child directory path != child-artifact-id</description>

  <!-- 5 inherited urls with ../${project.artifactId} added to parent -->
  <url>http://www.apache.org/path/to/parent/../child-artifact-id/</url>
  <scm>
    <connection>scm:my-scm:http://domain.org/base/../child-artifact-id</connection>

  /**
   * Notifies the listener that a removal occurred at some point in the past.
   *
   * <p>This does not always signify that the key is now absent from the cache, as it may have
   * already been re-added.
   */
  // Technically should accept RemovalNotification<? extends K, ? extends V>, but because
  // RemovalNotification is guaranteed covariant, let's make users' lives simpler.

   * <p>The collections returned by {@link Multimap#keySet()}, {@link Multimap#keys()}, and {@link
   * Multimap#asMap()} will iterate through the keys in the order that they were first added to the
   * multimap, save that if all values associated with a key are removed and then the key is added
   * back into the multimap, that key will come last in the key iteration order.
   */
  public static MultimapBuilderWithKeys<@Nullable Object> linkedHashKeys() {

   * <p>The collections returned by {@link Multimap#keySet()}, {@link Multimap#keys()}, and {@link
   * Multimap#asMap()} will iterate through the keys in the order that they were first added to the
   * multimap, save that if all values associated with a key are removed and then the key is added
   * back into the multimap, that key will come last in the key iteration order.
   */
  public static MultimapBuilderWithKeys<@Nullable Object> linkedHashKeys() {

     * <i>Note:</i> This will not automagically make a mojo run when the plugin declaration is added to the POM. It
     * merely enables the user to omit the <code>&lt;phase&gt;</code> element from the surrounding
     * <code>&lt;execution&gt;</code> element.
     */
    private String phase;

    /** Specify the version when the Mojo was added to the API. Similar to Javadoc since. */
    private String since;

  }

  public void testExceptionThrown_whileClosingLastCloseable() throws IOException {
    Closer closer = new Closer(suppressor);

    IOException exception = new IOException();

    // c1 is added first, closed last
    TestCloseable c1 = closer.register(TestCloseable.throwsOnClose(exception));
    TestCloseable c2 = closer.register(TestCloseable.normal());

    try {
      closer.close();

        } else if (SMBSERVER_NAME.equals(this.calledName)) {
            NetbiosAddress[] addrs;

            try {
                addrs = tc.getNameServiceClient().getNodeStatus(this);
                if (this.getNameType() == 0x1D) {
                    for (final NetbiosAddress addr : addrs) {
                        if (addr.getNameType() == 0x20) {
                            return addr.getHostName();

     * system properties collected so far, along with other information. This method should return altered
     * (contributions applied) user properties, not only the "new" or "added" properties!
     *
     * @param protoSession The proto session, never {@code null}.
     * @return The user properties with contributions.
     */
    default Map<String, String> contribute(ProtoSession protoSession) {