CollectSpliterators.flatMapToLong(
                    Arrays.spliterator(new Long[] {1L, 0L, 1L, 2L, 3L}),
                    (Long i) -> i == 0L ? null : LongStream.of(i).spliterator(),
                    Spliterator.SIZED | Spliterator.DISTINCT | Spliterator.NONNULL,
                    4))
        .expect(1L, 1L, 2L, 3L);
  }

  public void testFlatMapToDouble_nullStream() {
    SpliteratorTester.ofDouble(

    assertEquals(3L, countDownLatch.getCount());

    list.execute();

    // Verify that all of the runnables execute in a reasonable amount of time.
    assertTrue(countDownLatch.await(1L, SECONDS));
  }

  public void testExecute_idempotent() {
    AtomicInteger runCalled = new AtomicInteger();
    list.add(
        new Runnable() {
          @Override
          public void run() {

    Long.MAX_VALUE - (1L << 11) + 1,
    Long.MAX_VALUE - 2,
    Long.MAX_VALUE - 1,
    Long.MAX_VALUE,
    -16,
    -1L << 53,
    -(1L << 53) - 1,
    -(1L << 53) - 2,
    -(1L << 53) - 3,
    -(1L << 53) - 4,
    -1L << 54,
    -(1L << 54) - 1,
    -(1L << 54) - 2,
    -(1L << 54) - 3,
    -(1L << 54) - 4,
    Long.MIN_VALUE + 2,
    Long.MIN_VALUE + 1,

            } ?: return
          }
        } catch (thrown: Throwable) {
          // A task failed. Update execution state and re-throw the exception.
          withLock {
            afterRun(task, -1L, false)
          }
          if (thrown is InterruptedException) {
            Thread.currentThread().interrupt()
          } else {
            throw thrown
          }
        } finally {

    // Add boundary values manually to avoid over/under flow (this covers 2^N for 31 and 63).
    longValues.add(Integer.MAX_VALUE + 1L, Long.MAX_VALUE - 1L, Long.MAX_VALUE);

    // Now add values near 2^N for lots of values of N.
    for (int exponent : asList(32, 33, 39, 40, 41, 47, 48, 49, 55, 56, 57)) {
      long x = 1L << exponent;
      longValues.add(x, x + 1, x - 1);
    }

          invokeStartEvent = false
          eventListener.responseBodyStart(call)
        }

        if (read == -1L) {
          complete(null)
          return -1L
        }

        val newBytesReceived = bytesReceived + read
        if (contentLength != -1L && newBytesReceived > contentLength) {
          throw ProtocolException("expected $contentLength bytes but received $newBytesReceived")
        }

        searchRenderData.setCurrentStartRecordNumber(1L);
        assertEquals(1L, searchRenderData.getCurrentStartRecordNumber());

        searchRenderData.setCurrentStartRecordNumber(9999L);
        assertEquals(9999L, searchRenderData.getCurrentStartRecordNumber());

        // Test with negative value
        searchRenderData.setCurrentStartRecordNumber(-1L);
        assertEquals(-1L, searchRenderData.getCurrentStartRecordNumber());

        originalFessConfig = ComponentUtil.getFessConfig();

        // Set up test FessConfig
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override
            public String getCookieDefaultPath() {
                return "/test/path";
            }

            @Override
            public Integer getCookieDefaultExpireAsInteger() {

   * prefix, or when one array is a prefix of the other, treats the shorter array as the lesser. For
   * example, {@code [] < [1L] < [1L, 2L] < [2L] < [1L << 63]}.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(long[],

    //                                                                          Definition
    //                                                                          ==========
    private static final long serialVersionUID = 1L;

    // ===================================================================================
    //                                                                           Attribute