response = new Smb2NegotiateResponse(mockConfig);
    }

    /**
     * Test that malformed structure size is properly rejected.
     */
    @Test
    public void testMalformedStructureSize() {
        byte[] malformedBuffer = createBasicNegotiateResponseBuffer();
        // Set incorrect structure size (should be 65)
        SMBUtil.writeInt2(64, malformedBuffer, 0);

        context.setMaxCacheAge(45000L);
        context.setNotificationEnabled(true);
        context.setNotificationFilter(0x1F);

        byte[] buffer = new byte[context.size()];
        int bytesWritten = context.encode(buffer, 0);

        assertEquals(context.size(), bytesWritten);

        // Verify context header
        assertEquals(0, SMBUtil.readInt4(buffer, 0)); // Next

/**
 * Test iteration speed at various size for {@link Set} instances.
 *
 * @author Christopher Swenson
 */
@NullUnmarked
public class SetIterationBenchmark {
  @Param({
    "3", "6", "11", "23", "45", "91", "181", "362", "724", "1448", "2896", "5793", "11585", "23170",
    "46341", "92682", "185364", "370728", "741455", "1482910", "2965821", "5931642"
  })
  private int size;

  // "" means no fixed seed
  @Param("1234")

          if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

          Headers responseHeaders = response.headers();
          for (int i = 0, size = responseHeaders.size(); i < size; i++) {
            System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
          }

          System.out.println(responseBody.string());
        }
      }
    });
  }

    }

    /**
     * Validate file size from server
     *
     * @param size file size
     * @throws SmbException if size is invalid
     */
    public void validateFileSize(long size) throws SmbException {
        totalValidations.incrementAndGet();

        if (size < 0) {
            failedValidations.incrementAndGet();
            log.warn("Negative file size: {}", size);

     * @param size the number of hex digits to write (will be left-padded with zeros)
     */
    public static void toHexChars(long val, final char dst[], final int dstIndex, int size) {
        while (size > 0) {
            dst[dstIndex + size - 1] = HEX_DIGITS[(int) (val & 0x000FL)];
            if (val != 0) {
                val >>>= 4;
            }
            size--;
        }
    }

        br.addElement(" in " + getClass().getSimpleName() + ".");
        br.addItem("Content Type");
        br.addElement(contentType);
        br.addItem("Boundary Size");
        br.addElement(boundarySize);
        br.addItem("Limit Size");
        br.addElement(limitSize);
        final String msg = br.buildExceptionMessage();

        assertEquals(1, result.get(ConfigName.CONFIG).size());
        assertEquals(1, result.get(ConfigName.CLIENT).size());
        assertEquals(1, result.get(ConfigName.XPATH).size());
        assertEquals(1, result.get(ConfigName.META).size());
        assertEquals(1, result.get(ConfigName.VALUE).size());
        assertEquals(1, result.get(ConfigName.SCRIPT).size());
        assertEquals(1, result.get(ConfigName.FIELD).size());

   *     size}
   * @throws IllegalArgumentException if {@code size} is negative
   */
  protected AbstractIndexedListIterator(int size, int position) {
    checkPositionIndex(position, size);
    this.size = size;
    this.position = position;
  }

  @Override
  public final boolean hasNext() {
    return position < size;
  }

  @Override
  @ParametricNullness

    }
  }

  enum Topology {
    BALANCED {
      @Override
      Optional<BinaryNode> createTree(int size, Random rng) {
        if (size == 0) {
          return Optional.absent();
        } else {
          int leftChildSize = (size - 1) / 2;
          int rightChildSize = size - 1 - leftChildSize;
          return Optional.of(
              new BinaryNode(