SystemUtil.maskSensitiveValue(String.valueOf(e.getKey()), String.valueOf(e.getValue()))));
                System.getenv()
                        .entrySet()
                        .forEach(e -> logger.debug("Env: {}={}", e.getKey(), SystemUtil.maskSensitiveValue(e.getKey(), e.getValue())));
                logger.debug("Options: options={}", options);
            } catch (final Exception e) {

      ImmutableSetMultimap.Builder<String, String> builder = ImmutableSetMultimap.builder();
      for (Entry<String, String> entry : entries) {
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.build();
    }
  }

  @J2ktIncompatible
  @AndroidIncompatible // test-suite builders
  private static final class ImmutableSetMultimapCopyOfEntriesGenerator

                    Map<String, String> map = new LinkedHashMap<>();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return new StandardImplForwardingMap<>(map);
                  }
                })
            .named("ForwardingMap[LinkedHashMap] with standard implementations")

            }

            // Mock by index - getHeaderField(int)
            // Index 0 is status line, then headers in order
            int index = 1;
            for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
                when(conn.getHeaderField(index++)).thenReturn(entry.getValue().get(0));
            }
        }

        System.out.println("Active test descriptors:");
        for (Map.Entry<Object, TestDescriptorInternal> entry : activeDescriptorsById.entrySet()) {
            System.out.println("id= " + entry.getKey() + " -- " + entry.getValue().getDisplayName());
        }
        illegalArgumentException.printStackTrace();
    }

    public void reset() {
        this.activeDescriptorsById.clear();

    // TODO: can these be moved to MapInterfaceTest?
    for (Entry<K, V> entry : map.entrySet()) {
      assertThat(entry.toString()).isEqualTo(entry.getKey() + "=" + entry.getValue());
    }

    assertThat(map.toString()).isEqualTo("{" + JOINER.join(map.entrySet()) + "}");
    assertThat(map.entrySet().toString()).isEqualTo("[" + JOINER.join(map.entrySet()) + "]");

    public Builder<K, V> putAll(Multimap<? extends K, ? extends V> multimap) {
      for (Entry<? extends K, ? extends Collection<? extends V>> entry :
          multimap.asMap().entrySet()) {
        putAll(entry.getKey(), entry.getValue());
      }
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    Builder<K, V> combine(ImmutableMultimap.Builder<K, V> other) {
      super.combine(other);
      return this;

        return convertEmptyToNull(key);
    }

    public void setKey(String value) {
        registerModifiedProperty("key");
        this.key = value;
    }

    public String getValue() {
        checkSpecifiedProperty("value");
        return convertEmptyToNull(value);
    }

    public void setValue(String value) {
        registerModifiedProperty("value");
        this.value = value;

                continue;
            }
            if (excludeFields.contains(field)) {
                continue;
            }

            final Object value = entry.getValue();
            if (value instanceof Collection) {
                for (final Object item : (Collection<?>) value) {
                    html.append("<meta name=\"fess:")
                            .append(escapeHtml(field))

        for (final Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
            writer.accept("Thread: " + entry.getKey());
            final StackTraceElement[] trace = entry.getValue();
            for (final StackTraceElement element : trace) {
                writer.accept("\tat " + element);
            }
        }
    }