@BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      positive[i] = randomPositiveBigInteger(Long.SIZE - 2).longValue();
      nonzero[i] = randomNonZeroBigInteger(Long.SIZE - 2).longValue();
      longs[i] = RANDOM_SOURCE.nextLong();
    }
  }

  @Benchmark
  int log2(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {

        if (maxContentLength != null && responseData.getContentLength() > maxContentLength.longValue()) {
            throw new MaxLengthExceededException("The content length (" + responseData.getContentLength() + " byte) is over "
                    + maxContentLength.longValue() + " byte. The url is " + responseData.getUrl());
        }
    }

    protected ResponseData doGet(final String url) {

        if (!arList.isEmpty()) {
            final long commitMarginTime = fessConfig.getIndexerWebfsCommitMarginTimeAsInteger().longValue();
            for (final AccessResult<?> ar : arList.toArray(new AccessResult[arList.size()])) {
                if (ar.getCreateTime().longValue() > execTime - commitMarginTime) {
                    arList.remove(ar);
                }
            }
        }

        def ops = buildOperationRunner.log.all(ExecuteDomainObjectCollectionCallbackBuildOperationType)
        ops.size() == 2
        ids.size() == 2
        ops[0].details.applicationId == id1.longValue()
        ops[1].details.applicationId == id2.longValue()
    }

    def "can configure task based on its provider"() {
        given:
        setupContainerDefaults()
        def p = container.register("r1")

    BigInteger absX = x.abs();
    int exponent = absX.bitLength() - 1;
    // exponent == floor(log2(abs(x)))
    if (exponent < Long.SIZE - 1) {
      return x.longValue();
    } else if (exponent > MAX_EXPONENT) {
      return x.signum() * POSITIVE_INFINITY;
    }

    /*
     * We need the top SIGNIFICAND_BITS + 1 bits, including the "implicit" one bit. To make rounding

        return new DefaultExternalResourceMetaData(
            uri,
            storageObject.getUpdated().getValue(),
            storageObject.getSize().longValue(),
            storageObject.getContentType(),
            storageObject.getEtag(),
            null // we cannot use md5 instead of sha1 here because cache will get corrupted due to its expectation of sha1 hashes
        );

      at.set(x);
      assertEquals((int) x, at.intValue());
    }
  }

  /** longValue returns current value. */
  public void testLongValue() {
    AtomicDouble at = new AtomicDouble();
    assertEquals(0L, at.longValue());
    for (double x : VALUES) {
      at.set(x);
      assertEquals((long) x, at.longValue());
    }
  }

  /** floatValue returns current value. */
  public void testFloatValue() {

        assertEquals(Integer.parseInt(expected), DocumentUtil.getValue(doc, "key1", Integer.class).intValue());
        assertEquals(Long.parseLong(expected), DocumentUtil.getValue(doc, "key1", Long.class).longValue());
        assertEquals(Float.parseFloat(expected), DocumentUtil.getValue(doc, "key1", Float.class).floatValue());
        assertEquals(Double.parseDouble(expected), DocumentUtil.getValue(doc, "key1", Double.class).doubleValue());

// The WriteOnce's Set method must be called with the lock held.
func NewCountingWriteOnce(activeCounter counter.GoRoutineCounter, lock sync.Locker, initial interface{}, doneCh <-chan struct{}, doneVal interface{}) promiseifc.WriteOnce {
	p := &countingPromise{
		lock:          lock,
		cond:          *sync.NewCond(lock),
		activeCounter: activeCounter,
		isSet:         initial != nil,
		value:         initial,
	}

        then:
        metaData != null
        metaData.location == uri
        metaData.lastModified == new Date(lastModified.value)
        metaData.contentLength == BigInteger.TEN.longValue()
        metaData.contentType == contentType
        metaData.etag == Integer.toString(16)
        metaData.sha1 == null
    }