path:   kmsKeyCreatePath,
			query:  map[string]string{"key-id": "new-test-key"},
			asRoot: false,

			wantStatusCode: http.StatusForbidden,
			wantResp:       []string{"AccessDenied"},
		},
		{
			name:   "create key as user with no resources specified want success",
			method: http.MethodPost,
			path:   kmsKeyCreatePath,
			query:  map[string]string{"key-id": "new-test-key"},
			asRoot: false,

			policy: `{"Effect": "Allow",

    //                                                                              ======
    @Override
    public Map<String, Object> toSource() {
        Map<String, Object> sourceMap = new HashMap<>();
        if (createdBy != null) {
            addFieldToSource(sourceMap, "createdBy", createdBy);
        }
        if (createdTime != null) {
            addFieldToSource(sourceMap, "createdTime", createdTime);

        updateProjectSourceRoot();
    }

    private void updateProjectSourceRoot() {
        // Convert the LinkedHashSet to a List to maintain order
        List<SourceRoot> sourcesList = new ArrayList<>(project.sources);

        // Find the index of the original SourceRoot
        int index = -1;
        for (int i = 0; i < sourcesList.size(); i++) {
            SourceRoot source = sourcesList.get(i);

  @LazyInit private transient @Nullable NavigableSet<E> elementSet;

  @Override
  public NavigableSet<E> elementSet() {
    NavigableSet<E> result = elementSet;
    if (result == null) {
      return elementSet = new SortedMultisets.NavigableElementSet<>(this);
    }
    return result;
  }

  @Override
  public @Nullable Entry<E> pollFirstEntry() {
    return forwardMultiset().pollLastEntry();
  }

  @Override

@GwtIncompatible
final class RegularImmutableSortedMultiset<E> extends ImmutableSortedMultiset<E> {
  private static final long[] zeroCumulativeCounts = {0};

  static final ImmutableSortedMultiset<?> NATURAL_EMPTY_MULTISET =
      new RegularImmutableSortedMultiset<>(Ordering.natural());

  @VisibleForTesting final transient RegularImmutableSortedSet<E> elementSet;
  private final transient long[] cumulativeCounts;
  private final transient int offset;

                                : null)
                .build();
    }

    @Nonnull
    static ToolchainsBuilderRequestBuilder builder() {
        return new ToolchainsBuilderRequestBuilder();
    }

    @NotThreadSafe
    class ToolchainsBuilderRequestBuilder {
        ProtoSession session;
        RequestTrace trace;
        Source installationToolchainsSource;

     * @throws XmlReaderException if an error occurs during the parsing
     * @see #toXmlString(Object)
     */
    @Nonnull
    default T fromXmlString(@Nonnull String xml) throws XmlReaderException {
        return read(new StringReader(xml));
    }

    /**
     * Converts the given content to an XML string.
     *
     * @param content the object to convert
     * @return the xml string representation

  private final List<Member> ignoredMembers = new ArrayList<>();

  private ExceptionTypePolicy policy = ExceptionTypePolicy.NPE_OR_UOE;

  /*
   * Requiring desugaring for guava-*testlib* is likely safe, at least for the reflection-based
   * NullPointerTester. But if you are a user who is reading this because this change caused you
   * trouble, please let us know: https://github.com/google/guava/issues/new
   */
  @IgnoreJRERequirement

                        .build(searchRequestType)
                        .stream()
                        .filter(StringUtil::isNotBlank)
                        .toArray(n -> new String[n]);
        final String[] baseFields = fields != null ? fields : fessConfig.getSuggestPopularWordFieldsAsArray();

            for (final Map.Entry<String, String> entry : paramEnvMap.entrySet()) {
                value = value.replace("${" + entry.getKey() + "}", entry.getValue());
            }
            return new Pair<>(key, value);
        }).collect(Collectors.toMap(Pair<String, String>::getFirst, Pair<String, String>::getSecond));
        final Map<String, String> configScriptMap = config.getHandlerScriptMap();