final DocumentBuilder builder = factory.newDocumentBuilder();

            final Document doc = builder.parse(is);

            final StringBuilder buf = new StringBuilder(1000);
            buf.append(getResultDataHeader());
            for (final Map.Entry<String, String> entry : fieldRuleMap.entrySet()) {
                final List<String> nodeStrList = new ArrayList<>();
                try {

     * The maximum amount of time after the client calls [close] to wait for a graceful shutdown. If
     * the server doesn't respond the web socket will be canceled.
     */
    const val CANCEL_AFTER_CLOSE_MILLIS = 60L * 1000

    /**
     * The smallest message that will be compressed. We use 1024 because smaller messages already
     * fit comfortably within a single ethernet packet (1500 bytes) even with framing overhead.
     *

    assertEquals(I18N, Files.toString(temp, UTF_16LE));
  }

  public void testWriteBytes() throws IOException {
    File temp = createTempFile();
    byte[] data = newPreFilledByteArray(2000);
    Files.write(data, temp);
    assertThat(Files.toByteArray(temp)).isEqualTo(data);

    assertThrows(NullPointerException.class, () -> Files.write(null, temp));
  }

            } else {
                LogStream.setLevel(0);
            }
        }

        LogStream.setInstance(new PrintStream(new OutputStream() {
            private static final int MAX_LEN = 1000;

            private final ByteArrayOutputStream buf = new ByteArrayOutputStream(MAX_LEN);

            @Override
            public void write(final int b) throws IOException {

    ImmutableSortedSet.Builder<Integer> builder =
        new ImmutableSortedSet.Builder<Integer>(countingComparator, 10);
    for (int i = 0; i < 9; i++) {
      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
  }

        int bufferIndex = 100;

        // Set structure size to 9
        SMBUtil.writeInt2(9, buffer, bufferIndex);
        // Set large buffer offset
        SMBUtil.writeInt2(1000, buffer, bufferIndex + 2);
        // Set buffer length
        SMBUtil.writeInt4(0, buffer, bufferIndex + 4);

        response = spy(response);
        when(response.getHeaderStart()).thenReturn(0);

/* jcifs smb client library in Java
 * Copyright (C) 2000  "Michael B. Allen" <jcifs at samba dot org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,

  -H "Content-Type: application/json" \
  -u admin:admin \
  -d '{
    "name": "Example Site",
    "urls": "http://example.com/",
    "depth": 3,
    "maxAccessCount": 1000,
    "userAgent": "Fess Crawler"
  }'
```

### 3. Command-Line Import

**Using curl with bulk files**:

```bash
# Import GSA configuration

        void testSizeWithSingleChunk() {
            // Given
            byte[] sourceKey = new byte[SOURCE_KEY_SIZE];
            SrvCopychunk chunk = new SrvCopychunk(0, 0, 0);
            SrvCopychunkCopy copy = new SrvCopychunkCopy(sourceKey, chunk);

            // When
            int size = copy.size();

            // Then

    /**
     * Test create and destroy with large number of objects
     */
    public void test_largeNumberOfObjects() throws Exception {
        TestComponent.resetCounter();

        final int objectCount = 1000;
        final List<PooledObject<TestComponent>> pooledObjects = new ArrayList<>();

        // Create many objects
        for (int i = 0; i < objectCount; i++) {
            TestComponent component = factory.create();