} else {
                final Object[] values = Arrays.copyOf(oldValues, oldValues.length + 1);
                values[values.length - 1] = value;
                dataMap.put(key, values);
            }
        }
    }

    default void putResultDataWithTemplate(final Map<String, Object> dataMap, final String key, final Object value, final String template,
            final String scriptType) {

    }

    public synchronized void putToInfoMap(final String key, final String value) {
        if (infoMap == null) {
            infoMap = Collections.synchronizedMap(new LinkedHashMap<>());
        }
        logger.debug("infoMap: {}={} => {}", key, value, infoMap);
        infoMap.put(key, value);
    }

    public void updateParams(final String sessionId, final String name, final int dayForCleanup) {

    }

    public void deleteElevateWord(final String word, final boolean apply) {
        suggester.indexer().deleteElevateWord(word, apply);
        refresh();
    }

    public void addElevateWord(final String word, final String reading, final String[] tags, final String[] permissions, final Float boost,
            final boolean apply) {
        final String[] readings;
        if (StringUtil.isBlank(reading)) {

        final DynamicProperties systemProperties = ComponentUtil.getSystemProperties();
        final FailureUrlCB cb = new FailureUrlCB();
        ComponentUtil.register(new FailureUrlBhv() {
            @Override
            public ListResultBean<FailureUrl> selectList(final CBCall<FailureUrlCB> cbLambda) {
                cbLambda.callback(cb);
                final ListResultBean<FailureUrl> list = new ListResultBean<>();

 *
 * @author Louis Wasserman
 */
public class DoubleMathRoundingBenchmark {
  private static final double[] doubleInIntRange = new double[ARRAY_SIZE];
  private static final double[] doubleInLongRange = new double[ARRAY_SIZE];
  private static final double[] positiveDoubles = new double[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

import jnr.unixsocket.UnixSocketAddress;
import jnr.unixsocket.UnixSocketChannel;

/** Impersonate TCP-style ServerSocketFactory over UNIX domain sockets. */
public final class UnixDomainServerSocketFactory extends ServerSocketFactory {
  private final File path;

  public UnixDomainServerSocketFactory(File path) {
    this.path = path;
  }

  @Override public ServerSocket createServerSocket() throws IOException {

import static org.junit.jupiter.api.Assertions.assertNotEquals;

/**
 */
abstract class AbstractVersionTest {

    protected static final int X_LT_Y = -1;

    protected static final int X_EQ_Y = 0;

    protected static final int X_GT_Y = 1;

    protected abstract Version newVersion(String version);

    protected void assertOrder(int expected, String version1, String version2) {

    public <T> StandardCrawlerContainer prototype(final String name, final Class<T> cls) {
        return prototype(name, cls, null);
    }

    public <T> StandardCrawlerContainer singleton(final String name, final Class<T> cls, final Consumer<T> initializer,
            final Consumer<T> destroyer) {
        final ComponentDef<T> componentDef = new ComponentDef<>(cls, initializer, this);
        final T instance = componentDef.get();

 */
public abstract class DisposableUtil {

    /** 登録済みの{@link Disposable} */
    protected static final Deque<Disposable> disposables = newLinkedList();

    /**
     * 破棄可能なリソースを登録します。
     *
     * @param disposable
     *            破棄可能なリソース。{@literal null}であってはいけません
     */
    public static synchronized void add(final Disposable disposable) {
        assertArgumentNotNull("disposable", disposable);

 * Maven core itself or a Maven core extension.
 *
 * @since 3.3.0
 */
public class CoreExtensionEntry {
    private final ClassRealm realm;

    private final Set<String> artifacts;

    private final Set<String> packages;

    private final String key;

    private final XmlNode configuration;

    public CoreExtensionEntry(
            ClassRealm realm,
            Collection<String> artifacts,