// Test valid character ranges
        String input = "Test" + String.valueOf((char) 0x0020) // space
                + String.valueOf((char) 0x0009) // tab
                + String.valueOf((char) 0x000A) // line feed
                + String.valueOf((char) 0x000D) // carriage return
                + String.valueOf((char) 0xD7FF) + String.valueOf((char) 0xE000) + String.valueOf((char) 0xFFFD);

     *
     * This method removes characters that are not allowed in XML documents
     * according to the XML 1.0 specification. Valid characters include:
     * - Tab (0x9)
     * - Line feed (0xA)
     * - Carriage return (0xD)
     * - Any character between 0x20 and 0xD7FF
     * - Any character between 0xE000 and 0xFFFD
     * - Any character between 0x10000 and 0x10FFFF
     *

   * Where there's a hierarchy in the types, list it via a parent
   * Highly specific magic matches get a high priority
   * General magic matches which could trigger a false-positive need
     a low one
   * The priority for containers normally need to be higher than for
     the things they contain, so they don't accidently get detected
     as what's in them
   * For logic too complex to be expressed in a magic match, do the best

      long seed = insertRandomly(elements, q);
      while (!q.isEmpty()) {
        elements.add(0, q.pollLast());
      }
      assertEqualsUsingSeed(seed, expected, elements);
    }
  }

  public void testCorrectOrdering_randomAccess() {
    long seed = new Random().nextLong();
    Random random = new Random(seed);
    PriorityQueue<Integer> control = new PriorityQueue<>();

     */
    public List<String> getWordList(final SearchRequestType searchRequestType, final String seed, final String[] tags, final String[] roles,
            final String[] fields, final String[] excludes) {
        final String baseSeed = seed != null ? seed : fessConfig.getSuggestPopularWordSeed();
        final String[] baseTags = tags != null ? tags : fessConfig.getSuggestPopularWordTagsAsArray();

    own the intellectual property, then you'll need to sign an [individual
    CLA][]. Please include your GitHub username.
  - If you work for a company that wants to allow you to contribute your work,
    then you'll need to sign a [corporate CLA][].

You generally only need to submit a CLA once, so if you've already submitted
one (even if it was for a different project), you probably don't need to do it
again.

OdHOim9+
-----END PRIVATE KEY-----
```

Recommendations
---------------

Typically servers need a held certificate plus a chain of intermediates. Servers only need the
private key for their own certificate. The chain served by a server doesn't need the root
certificate.

The trusted roots don't need to be the same for client and server when using client authentication.

# For most projects, this workflow file will not need changing; you simply need
# to commit it to your repository.
#
# You may wish to alter this file to override the set of languages analyzed,
# or to provide custom queries or build logic.
name: "CodeQL"

on:
  push:
    branches: [master]
  pull_request:
    # The branches below must be a subset of the branches above
    branches: [master]
  schedule:
    - cron: '0 11 * * 4'

jobs:

    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--
    Some tests need reflective access to the internals of these packages. It is only the
    tests themselves and not the code being tested that needs that access, though there's no
    obvious way to ensure that.

    We could consider arranging things so that only the tests we know need this would get
    the add-opens. Right now that doesn't seem worth the effort, though.

    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--
    Some tests need reflective access to the internals of these packages. It is only the
    tests themselves and not the code being tested that needs that access, though there's no
    obvious way to ensure that.

    We could consider arranging things so that only the tests we know need this would get
    the add-opens. Right now that doesn't seem worth the effort, though.