}

  @Test fun multipleSettingsFramesAreMerged() {
    // Write the mocking script.
    val settings1 = Settings()
    settings1[Settings.HEADER_TABLE_SIZE] = 10000
    settings1[Settings.INITIAL_WINDOW_SIZE] = 20000
    settings1[Settings.MAX_FRAME_SIZE] = 30000
    peer.sendFrame().settings(settings1)
    peer.acceptFrame() // ACK SETTINGS
    val settings2 = Settings()

    assertThat(Doubles.ensureCapacity(ARRAY1, 0, 1)).isSameInstanceAs(ARRAY1);
    assertThat(Doubles.ensureCapacity(ARRAY1, 1, 1)).isSameInstanceAs(ARRAY1);
    assertThat(Arrays.equals(new double[] {1.0, 0.0, 0.0}, Doubles.ensureCapacity(ARRAY1, 2, 1)))
        .isTrue();
  }

  public void testEnsureCapacity_fail() {
    assertThrows(IllegalArgumentException.class, () -> Doubles.ensureCapacity(ARRAY1, -1, 1));

	logger.FatalIf(gm.RegisterStreamingHandler(grid.HandlerTrace, grid.StreamHandler{
		Handle:      server.TraceHandler,
		Subroute:    "",
		OutCapacity: 100000,
		InCapacity:  0,
	}), "unable to register handler")

        }

        CacheEntry<DfsReferralDataInternal> refs = this.referrals;
        synchronized (this.referralsLock) {
            if (refs == null || System.currentTimeMillis() + 10000 > refs.expiration) {
                refs = new CacheEntry<>(tc.getConfig().getDfsTtl());
            }
            this.referrals = refs;
        }
        refs.map.put(key, dri);
    }

            return value.longValue();
        }
        value = getAsInteger("elasticsearch.heartbeat_interval");
        if (value != null) {
            return value.longValue();
        }
        return 10000L;
    }

  public void testByteArrayRoundTrips() {
    Random r = new Random(5);
    byte[] b = new byte[Shorts.BYTES];

    // total overkill, but, it takes 0.1 sec so why not...
    for (int i = 0; i < 10000; i++) {
      short num = (short) r.nextInt();
      assertThat(Shorts.fromByteArray(Shorts.toByteArray(num))).isEqualTo(num);

      r.nextBytes(b);

// license that can be found in the LICENSE file.

package bytes_test

import (
	. "bytes"
	"fmt"
	"internal/testenv"
	"io"
	"math/rand"
	"strconv"
	"testing"
	"unicode/utf8"
)

const N = 10000       // make this bigger for a larger (and slower) test
var testString string // test data for write tests
var testBytes []byte  // test data; same as testString but as a slice.

type negativeReader struct{}

    public void test_getTika_zip_bom() {
        final InputStream in = ResourceUtil.getResourceAsStream("extractor/zip/test_size.zip");
        tikaExtractor.maxCompressionRatio = 1;
        tikaExtractor.maxUncompressionSize = 10000;
        try {
            tikaExtractor.getText(in, null);
            fail();
        } catch (final ExtractException e) {
            logger.info(e.getMessage());
        }
    }

    val elapsedMillis = TimeUnit.NANOSECONDS.toMillis(elapsedNanos)

    // If we're working correctly, this should be greater than 100ms, but less than double that.
    // Previously we had a bug where we would download the entire response body as long as no
    // individual read took longer than 100ms.
    assertThat(elapsedMillis).isLessThan(500L)

    // Do another request to confirm that the discarded connection was not pooled.

    public static final int DEFAULT_INTERVAL_TIME_FOR_FS = 1000;

    /** Default interval time in milliseconds for web crawling. */
    public static final int DEFAULT_INTERVAL_TIME_FOR_WEB = 10000;

    /** Default number of threads for file system crawling. */
    public static final int DEFAULT_NUM_OF_THREAD_FOR_FS = 5;

    /** Default number of threads for web crawling. */