* stores information-per-URL will need to either canonicalize manually, or suffer unnecessary
 * redundancy for such URLs.
 *
 * Because they don't attempt canonical form, these classes are surprisingly difficult to use
 * securely. Suppose you're building a webservice that checks that incoming paths are prefixed

            System.arraycopy(Type2Message.NTLMSSP_SIGNATURE, 0, invalidType, 0, Type2Message.NTLMSSP_SIGNATURE.length);
            // Set message type to something other than NTLMSSP_TYPE2
            Type2Message.writeULong(invalidType, 8, Type2Message.NTLMSSP_TYPE1);

            // When & Then
            IOException thrown = assertThrows(IOException.class, () -> new Type2Message(invalidType));

      this.expectedValuesPerKey = max(expectedValuesPerKey, 1);

      return this;
    }

    /**
     * By default, if we are handed a value collection bigger than expectedValuesPerKey, presize to
     * accept that many elements.
     *
     * <p>This gets overridden in ImmutableSetMultimap.Builder to only trust the size of {@code
     * values} if it is a Set and therefore probably already deduplicated.

labels.logout=Logout
# ... approximately 1,056 more entries
```

**`fess_message_[locale].properties`** contains system messages such as:
```properties
errors.required={0} is required.
errors.minlength={0} cannot be less than {1}.
success.login=Logged in successfully.
# ... approximately 200 more entries
```

### 3. Update Configuration File

Edit `src/main/resources/fess_config.properties`:

    return new TreeBasedTable<>(Ordering.natural(), Ordering.natural());
  }

  /**
   * Creates an empty {@code TreeBasedTable} that is ordered by the specified comparators.
   *
   * @param rowComparator the comparator that orders the row keys
   * @param columnComparator the comparator that orders the column keys
   */
  public static <R, C, V> TreeBasedTable<R, C, V> create(

        .supportsTlsExtensions(true)
        .build()

    /**
     * A backwards-compatible fallback configuration that works on obsolete client platforms and can
     * connect to obsolete servers. When possible, prefer to upgrade your client platform or server
     * rather than using this configuration.
     */
    @JvmField
    val COMPATIBLE_TLS =
      Builder(true)

    }

    /**
     * Configures this {@code Builder} to order entries by value according to the specified
     * comparator.
     *
     * <p>The sort order is stable, that is, if two entries have values that compare as equivalent,
     * the entry that was inserted first will be first in the built map's iteration order.
     *
     * @throws IllegalStateException if this method was already called
     * @since 19.0
     */

      auto& indices = iter->second;
      if (std::find(indices.begin(), indices.end(), idx) != indices.end()) {
        return InvalidArgument("TF_Output ", node->name(), ":", idx,
                               " appears more than once in the input list");
      }
      indices.push_back(idx);
    }
  }
  return absl::OkStatus();
}

// Converts `noutputs` and `outputs` into `outputs_tensors` and does various
// checks while doing so.

            // Mock parent close() to do nothing - explicitly mock the super.close() behavior
            // The close method calls super.close(), then handle.close(), then pipe.close()
            lenient().doNothing().when((DcerpcHandle) handle).close();

            // Setup close to call real method which will then call our mocked components
            doCallRealMethod().when(handle).close();

            handle.close();

        ComparableVersion seven = new ComparableVersion("7");
        ComparableVersion capitalJ = new ComparableVersion("J");
        ComparableVersion lowerCaseC = new ComparableVersion("c");
        // Digits are greater than letters
        assertTrue(seven.compareTo(capitalJ) > 0, "expected 7 > J");
        assertTrue(capitalJ.compareTo(seven) < 0, "expected J < 1");
        assertTrue(seven.compareTo(lowerCaseC) > 0, "expected 7 > c");