public class StorageException extends FessSystemException {
    private static final long serialVersionUID = 1L;

    /**
     * Constructs a new storage exception with the specified detail message and cause.
     *
     * @param message The detail message.
     * @param cause   The cause of the exception.
     */
    public StorageException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**

import org.dbflute.utflute.core.PlainTestCase;

public class ResultDataTest extends PlainTestCase {

    public void test_setRawData() {
        // ## Arrange ##
        final ResultData resultData = new ResultData();
        final Object rawData = new Object();

        // ## Act ##
        resultData.setRawData(rawData);

        // ## Assert ##
        assertEquals(rawData, resultData.getRawData());

 * the order of magnitude of the generated values uniformly at random.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
final class MathBenchmarking {
  static final int ARRAY_SIZE = 0x10000;
  static final int ARRAY_MASK = 0x0ffff;
  static final Random RANDOM_SOURCE = new Random(314159265358979L);
  static final int MAX_EXPONENT = 100;

  /*
   * Duplicated from LongMath.
   * binomial(biggestBinomials[k], k) fits in a long, but not

        // NOP
    }

    /**
     * Registers this rule with the {@link RuleManager}.
     *
     * @param index the index at which the rule should be registered
     */
    public void register(final int index) {
        final RuleManager ruleManager = crawlerContainer.getComponent("ruleManager");
        ruleManager.addRule(index, this);
    }

    @Override
    public String getRuleId() {
        return ruleId;
    }

  Iterator<C> createColumnKeyIterator() {
    return new ColumnKeyIterator();
  }

  private final class ColumnKeyIterator extends AbstractIterator<C> {
    // Use the same map type to support TreeMaps with comparators that aren't
    // consistent with equals().
    final Map<C, V> seen = factory.get();
    final Iterator<Map<C, V>> mapIterator = backingMap.values().iterator();

    base: Statement,
    description: Description,
  ): Statement =
    object : Statement() {
      override fun evaluate() {
        beforeEach(null)
        try {
          base.evaluate()
        } finally {
          afterEach(null)
        }
      }
    }

  fun takeAll(): List<String> {
    val list = mutableListOf<String>()
    logs.drainTo(list)
    return list
  }

  fun take(): String =

/**
 * @author koichik
 *
 */
public class MethodDescTest {

    /**
     * @throws Exception
     */
    @Test
    public void testFoo() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final MethodDesc foo = beanDesc.getMethodDesc("foo");
        assertThat(foo, is(notNullValue()));
        assertThat(foo.getBeanDesc(), is(sameInstance(beanDesc)));

    public void functionScore(OperatorCall<SearchLogCQ> queryLambda, ScoreFunctionCall<ScoreFunctionCreator<SearchLogCQ>> functionsLambda,
            final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
        SearchLogCQ cq = new SearchLogCQ();
        queryLambda.callback(cq);
        final Collection<FilterFunctionBuilder> list = new ArrayList<>();
        if (functionsLambda != null) {

  static final long EXPONENT_MASK = 0x7ff0000000000000L;

  // The mask for the sign, according to the {@link
  // Double#doubleToRawLongBits(double)} spec.
  static final long SIGN_MASK = 0x8000000000000000L;

  static final int SIGNIFICAND_BITS = 52;

  static final int EXPONENT_BIAS = 1023;

  /** The implicit 1 bit that is omitted in significands of normal doubles. */

  }

  private final int[] factorials = new int[ARRAY_SIZE];
  private final int[][] binomials = new int[ARRAY_SIZE][2];
  private final int[][] nonnegInt = new int[ARRAY_SIZE][2];
  private final long[][] nonnegLong = new long[ARRAY_SIZE][2];
  private final int[][] intsToAdd = new int[ARRAY_SIZE][2];
  private final int[][] intsToMul = new int[ARRAY_SIZE][2];
  private final long[][] longsToAdd = new long[ARRAY_SIZE][2];