}

  @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));

      builder.add(i);
    }
    for (int j = 0; j < 1000; j++) {
      builder.add(9);
    }
    ImmutableSortedSet<Integer> unused = builder.build();
    assertThat(compares[0]).isAtMost(10000);
    // hopefully something quadratic would have more digits
  }

For migrating from Apache Solr:

#### Document Export and Import

**Step 1: Export from Solr**

```bash
# Export Solr documents as JSON
curl "http://solr-server:8983/solr/collection1/select?q=*:*&rows=10000&wt=json" \
  -o solr-export.json
```

**Step 2: Transform to Fess Format**

Create a transformation script to map Solr fields to Fess fields:

```python
import json

# Load Solr export

        }

        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);
    }

        System.gc();
        long current = MemoryUtil.getUsedMemory();
        for (int i = 0; i < 10000; i++) {
            if (i % 1000 == 0) {
                logger.info("count:" + i + ", " + MemoryUtil.getMemoryUsageLog());
            }
            ResponseData responseData = new ResponseData();

            tc.getConfig().getRandom().nextBytes(ntlmClientChallenge);

            long ts = (System.currentTimeMillis() + SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601) * 10000;
            if (haveTimestamp) {
                ts = ((AvTimestamp) AvPairs.get(avPairs, AvPair.MsvAvTimestamp)).getTimestamp();
            }

	if r.ContentLength <= 0 {
		writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentLength), r.URL)
		return
	}

	// The max. XML contains 100000 object names (each at most 1024 bytes long) + XML overhead
	const maxBodySize = 2 * 100000 * 1024

	if r.ContentLength > maxBodySize {
		writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrEntityTooLarge), r.URL)
		return

  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{}