assertFalse(
        "Lists of different sizes should not be equal.",
        getList().equals(new ArrayList<E>(fewerElements)));
  }

  public void testEquals_longerList() {
    Collection<E> moreElements = getSampleElements(getNumElements() + 1);
    assertFalse(
        "Lists of different sizes should not be equal.",
        getList().equals(new ArrayList<E>(moreElements)));
  }

    assertFalse(
        "Sets of different sizes should not be equal.",
        getSet().equals(MinimalSet.from(fewerElements)));
  }

  public void testEquals_largerSet() {
    Collection<E> moreElements = getSampleElements(getNumElements() + 1);
    assertFalse(
        "Sets of different sizes should not be equal.",
        getSet().equals(MinimalSet.from(moreElements)));
  }

    }

    @Test
    @DisplayName("Test size method without input buffer")
    void testSizeWithoutInputBuffer() {
        request = new Smb2QueryInfoRequest(mockConfig);

        int size = request.size();

        // Expected size calculation: size8(SMB2_HEADER_LENGTH + 40)
        // size8 rounds up to nearest multiple of 8

        return super.chain(n);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + 24 + (this.token != null ? this.token.length : 0));
    }

    /**
     * {@inheritDoc}
     *

-h | display help dialog

## Benchmarks

Obligatory benchmarks performed on files with arrays of objects, where the decoded objects are to be extracted.

Two file sizes are used -- regular (1.6mb, 1000 objects) and large (128mb, 100000 objects)

input size | lib | MB/s | Allocated
--- | --- | --- | ---
regular | standard | 97 | 3.6MB
regular | jstream | 175 | 2.1MB
large | standard | 92 | 305MB
large | jstream | 404 | 69MB

	setIndexes  [][]uint64 // All the sets.
}

// Supported set sizes this is used to find the optimal
// single set size.
var setSizes = []uint64{2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}

// getDivisibleSize - returns a greatest common divisor of
// all the ellipses sizes.
func getDivisibleSize(totalSizes []uint64) (result uint64) {
	gcd := func(x, y uint64) uint64 {
		for y != 0 {

        return new Smb2ChangeNotifyResponse(tc.getConfig());
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + 32);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)

    TF_ShapeAndTypeList* input_shapes =
        TF_NewShapeAndTypeList(input_shapes_vec.size());
    for (size_t i = 0; i < input_shapes_vec.size(); ++i) {
      const auto& input_shape = input_shapes_vec[i];
      if (input_shape.has_value()) {
        TF_ShapeAndTypeListSetShape(input_shapes, i, input_shape->data(),
                                    input_shape->size());
      } else {
        TF_ShapeAndTypeListSetUnknownShape(input_shapes, i);

  private static final int BYTE_MAX_SIZE = 1 << Byte.SIZE; // 2^8 = 256
  private static final int BYTE_MASK = (1 << Byte.SIZE) - 1; // 2^8 - 1 = 255

  private static final int SHORT_MAX_SIZE = 1 << Short.SIZE; // 2^16 = 65_536
  private static final int SHORT_MASK = (1 << Short.SIZE) - 1; // 2^16 - 1 = 65_535

  /**
   * Returns the power of 2 hashtable size required to hold the expected number of items or the

  private CollectSpliterators() {}

  static <T extends @Nullable Object> Spliterator<T> indexed(
      int size, int extraCharacteristics, IntFunction<T> function) {
    return indexed(size, extraCharacteristics, function, null);
  }

  static <T extends @Nullable Object> Spliterator<T> indexed(
      int size,
      int extraCharacteristics,
      IntFunction<T> function,
      @Nullable Comparator<? super T> comparator) {