}

    /**
     * Inner class for handling updates to the character mapping file.
     * This class manages the temporary file creation, writing operations,
     * and atomic updates to ensure data consistency during modifications.
     */
    protected class MappingUpdater implements Closeable {

        /** Flag indicating whether changes should be committed to the file. */

        return ByteOrder.nativeOrder().equals(ByteOrder.LITTLE_ENDIAN)
            ? UnsafeByteArray.UNSAFE_LITTLE_ENDIAN
            : UnsafeByteArray.UNSAFE_BIG_ENDIAN;
      }
    } catch (Throwable t) {
      // ensure we really catch *everything*
    }

    return JavaLittleEndianBytes.INSTANCE;
  }

  // Compare AbstractFuture.VarHandleAtomicHelperMaker.
  private enum VarHandleLittleEndianBytesMaker {
    INSTANCE {

CYGWIN* | MINGW*)
  [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")"
  native_path() { cygpath --path --windows "$1"; }
  ;;
esac

# set JAVACMD and JAVACCMD
set_java_home() {
  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
  if [ -n "${JAVA_HOME-}" ]; then
    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
      # IBM's JDK on AIX uses strange locations for the executables

            log.get().log(Level.SEVERE, "Exception while executing runnable " + task, e);
          } finally {
            task = null;
          }
        }
      } finally {
        // Ensure that if the thread was interrupted at all while processing the task queue, it
        // is returned to the delegate Executor interrupted so that it may handle the
        // interruption if it likes.

     */

    // First, ensure that our classloaders are initializing the correct helper versions:

    checkHelperVersion(getClass().getClassLoader(), "AtomicReferenceFieldUpdaterAtomicHelper");
    /*
     * Since we use AtomicReferenceFieldUpdaterAtomicHelper by default, we'll "obviously" use it
     * even when Unsafe isn't available. But it's nice to have a check here to make sure that

  public void runTest() throws Exception {
    /*
     * Note that we do not run this test under Android at the moment. For Android testing, see
     * AbstractFutureDefaultAtomicHelperTest.
     */

    // First, ensure that our classloaders are initializing the correct helper versions:

    if (isJava8()) {
      checkHelperVersion(getClass().getClassLoader(), "UnsafeAtomicHelper");
    } else {

        // Verify - invalid case format should return empty due to exception
        assertFalse(result.isPresent());
    }

    // Test multiple calls to ensure consistency
    public void test_findBusinessLocale_multipleCallsConsistency() {
        // Setup mock config
        FessConfig mockConfig = new FessConfig.SimpleImpl() {
            @Override

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Tester to ensure forwarding wrapper works by delegating calls to the corresponding method with
 * the same parameters forwarded and return value forwarded back or exception propagated as is.
 *
 * <p>For example:
 *
 * {@snippet :

      for (int insertion = 0; insertion < totalInsertions; insertion++) {
        RandomHasherAction.pickAtRandom(random).performAction(random, sinksAndControl);
      }
      // We need to ensure that at least 4 bytes have been put into the hasher or else
      // Hasher#hash will throw an ISE.
      int intToPut = random.nextInt();
      for (Hasher hasher : sinksAndControl) {
        hasher.putInt(intToPut);

    protected static final String JAVABIN = "javabin";

    /** Constant for Kryo serializer type. */
    protected static final String KRYO = "kryo";

    /** ThreadLocal container for Kryo instances to ensure thread safety. */
    protected final ThreadLocal<Kryo> kryoThreadLocal;

    /**
     * Constructs a new DataSerializer.
     * <p>
     * Initializes the ThreadLocal Kryo instances with appropriate configuration.