getMockRequest().setLocale(Locale.JAPANESE);
        helpUrl = systemHelper.getHelpUrl("https://example.com/{lang}/{version}/test.html");
        // Check if Japanese is actually supported or just use the fallback
        assertTrue(helpUrl.contains("98.76"));

        getMockRequest().setLocale(Locale.ITALIAN);
        helpUrl = systemHelper.getHelpUrl("https://example.com/{lang}/{version}/test.html");

 *       the values corresponding to {@code key}
 * </ul>
 *
 * <p>The collections returned by the {@link #replaceValues replaceValues} and {@link #removeAll
 * removeAll} methods, which contain values that have just been removed from the multimap, are
 * naturally <i>not</i> views.
 *
 * <h3>Subinterfaces</h3>
 *
 * <p>Instead of using the {@code Multimap} interface directly, prefer the subinterfaces {@link

            out[i] = ch;
            i++;
            p++;
        }
        while (p < len && pathInfo.charAt(p) == '/') {
            p++;
        }
        if (p < len) { /* then there must be a share */
            out[i] = '/';
            i++;
            do { /* collect the share name */
                out[i++] = ch = pathInfo.charAt(p++);
            } while (p < len && ch != '/');
        }

            // Given
            byte[] buffer = new byte[60];
            int bufferIndex = 0;

            // Structure Size (2 bytes) - must be 60
            SMBUtil.writeInt2(60, buffer, bufferIndex);
            // Flags (2 bytes)
            SMBUtil.writeInt2(SMB2_CLOSE_FLAG_POSTQUERY_ATTIB, buffer, bufferIndex + 2);
            // Reserved (4 bytes)

// It is set per-"handler function registration" in the router to allow for
// behavior modification via flags.
//
// This middleware always calls `collectAPIStats` to collect API stats.
//
// The passed in handler function must be a method of `objectAPIHandlers` for
// the name displayed in logs and trace to be accurate. The name is extracted
// via reflection.
//
// When **no** flags are passed, the behavior is to trace both headers and body,

 *
 * <p><b>Warning: joiner instances are always immutable</b>; a configuration method such as {@code
 * useForNull} has no effect on the instance it is invoked on! You must store and use the new joiner
 * instance returned by the method. This makes joiners thread-safe, and safe to store as {@code
 * static final} constants.
 *
 * {@snippet :
 * // Bad! Do not do this!

  public void testLargeBloomFilterDoesntOverflow() {
    long numBits = Integer.MAX_VALUE;
    numBits++;

    LockFreeBitArray bitArray = new LockFreeBitArray(numBits);
    assertTrue(
        "BitArray.bitSize() must return a positive number, but was " + bitArray.bitSize(),
        bitArray.bitSize() > 0);

    // Ideally we would also test the bitSize() overflow of this BF, but it runs out of heap space

   * the end).
   *
   * @throws IllegalArgumentException if {@code n < 0}
   */
  public static BigInteger factorial(int n) {
    checkNonNegative("n", n);

    // If the factorial is small enough, just use LongMath to do it.
    if (n < LongMath.factorials.length) {
      return BigInteger.valueOf(LongMath.factorials[n]);
    }

    // Pre-allocate space for our list of intermediate BigIntegers.

            out[i] = ch;
            i++;
            p++;
        }
        while (p < len && pathInfo.charAt(p) == '/') {
            p++;
        }
        if (p < len) { /* then there must be a share */
            out[i] = '/';
            i++;
            do { /* collect the share name */
                out[i++] = ch = pathInfo.charAt(p++);
            } while (p < len && ch != '/');
        }

	l.lazyInit()
	return l.insertValue(k, v, expiresAt, &l.root)
}

// MoveToFront moves element e to the front of list l.
// If e is not an element of l, the list is not modified.
// The element must not be nil.
func (l *LruList[K, V]) MoveToFront(e *Entry[K, V]) {
	if e.list != l || l.root.next == e {
		return
	}
	// see comment in List.Remove about initialization of l
	l.move(e, &l.root)