// Verify
        assertEquals("1234567890", attributes.get("sub"));
        assertEquals("John Doe", attributes.get("name"));

        // Check groups array
        final String[] groups = DocumentUtil.getValue(attributes, "groups", String[].class);
        assertArrayEquals(new String[] { "group1", "group2" }, groups);

        OpenIdConnectCredential credential = new OpenIdConnectCredential(attributes);

            if (fieldConfigs.getConfig(e.getKey()).map(FieldConfigs.Config::isOverwrite).orElse(false)
                    && e.getValue() instanceof final Object[] values && values.length > 0) {
                newDataMap.put(e.getKey(), values[values.length - 1]);
            } else {
                newDataMap.put(e.getKey(), e.getValue());
            }
        }
        return newDataMap;
    }

  }

  private String expectedToString(Set<Entry<K, V>> entries) {
    Map<K, V> reference = new LinkedHashMap<>();
    for (Entry<K, V> entry : entries) {
      reference.put(entry.getKey(), entry.getValue());
    }
    return reference.toString();
  }

            return null;
        }
        String convertedUrl = url;
        for (final Map.Entry<String, String> entry : convertMap.entrySet()) {
            convertedUrl = convertedUrl.replaceAll(entry.getKey(), entry.getValue());
        }
        return convertedUrl;
    }

    /**
     * Adds a conversion rule.
     *
     * @param target The target string.
     * @param replacement The replacement string.
     */

                System.getProperties().entrySet().stream().forEach(e -> logger.debug("Property: {}={}", e.getKey(), e.getValue()));
                System.getenv().entrySet().forEach(e -> logger.debug("Env: {}={}", e.getKey(), e.getValue()));
                logger.debug("Option: {}", options);
            } catch (final Exception e) {
                // ignore
            }
        }

    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;

    for (RemovalNotification<String, String> notification : listener) {
      removalNotifications.put(notification.getKey(), notification.getValue());
      assertEquals(
          "Unexpected key/value pair passed to removalListener",
          notification.getKey(),
          notification.getValue());
    }

    // All of the seed values should have been visible, so we should have gotten removal
    // notifications for all of them.

    for (RemovalNotification<String, String> notification : listener) {
      removalNotifications.put(notification.getKey(), notification.getValue());
      assertEquals(
          "Unexpected key/value pair passed to removalListener",
          notification.getKey(),
          notification.getValue());
    }

    // All of the seed values should have been visible, so we should have gotten removal
    // notifications for all of them.

        for (Map.Entry<String, byte[]> entry : rawKeys.entrySet()) {
            Arrays.fill(entry.getValue(), (byte) 0);
        }
        rawKeys.clear();

        // Destroy all secret keys
        for (Map.Entry<String, SecretKey> entry : sessionKeys.entrySet()) {
            SecretKey key = entry.getValue();
            if (key instanceof Destroyable) {
                try {

                factory.setAttribute(entry.getKey(), entry.getValue());
            }

            for (final Map.Entry<String, String> entry : featureMap.entrySet()) {
                factory.setFeature(entry.getKey(), "true".equalsIgnoreCase(entry.getValue()));
            }

            factory.setCoalescing(coalescing);