element.input = unescape(parts[i++])

        val base = if (i < parts.size) parts[i++] else null
        element.base =
          when {
            base == null || base.isEmpty() -> list[list.size - 1].base
            else -> unescape(base)
          }

        while (i < parts.size) {
          val piece = parts[i]
          if (piece.startsWith("#")) {
            i++
            continue

        assertNotNull(buffer2, "Second buffer should not be null");
        assertEquals(1024, buffer1.length, "Buffer should have expected size");
        assertEquals(1024, buffer2.length, "Buffer should have expected size");
        assertNotSame(buffer1, buffer2, "Different calls should return different buffers initially");
    }

    @Test

        lastWrite.setAccessible(true);
        lastWrite.setLong(resp, 1630000000000L);
        java.lang.reflect.Field size = SmbComQueryInformationResponse.class.getDeclaredField("fileSize");
        size.setAccessible(true);
        size.setInt(resp, 2048);

        assertEquals(0xABCD, resp.getAttributes());
        assertEquals(1630000001000L, resp.getCreateTime());

  int size;

  // use concrete classes to remove any possible polymorphic overhead?
  Object[] array;
  ArrayList<Object> arrayList;
  LinkedList<Object> linkedList;

  @BeforeExperiment
  void setUp() {
    array = new Object[size];
    arrayList = Lists.newArrayListWithCapacity(size);
    linkedList = new LinkedList<>();

    for (int i = 0; i < size; i++) {
      Object value = new Object();

    int len = string.length();
    int size = len * count;
    char[] array = new char[size];
    string.getChars(0, len, array, 0);
    int n;
    for (n = len; n < size - n; n <<= 1) {
      System.arraycopy(array, 0, array, n, n);
    }
    System.arraycopy(array, 0, array, n, size - n);
    return new String(array);
  }

    }

    /**
     * Gets the size of the original unencrypted message
     *
     * @return the original message size
     */
    public int getOriginalMessageSize() {
        return this.originalMessageSize;
    }

    /**
     * Sets the size of the original unencrypted message
     *
     * @param originalMessageSize
     *            the original message size to set
     */

        }

        @Test
        @DisplayName("Should align size to 8-byte boundary")
        void testSizeAlignment() {
            // Test various data lengths to ensure 8-byte alignment
            for (int i = 0; i < 16; i++) {
                request.setData(new byte[i], 0, i);
                int size = request.size();
                assertEquals(0, size % 8, "Size should be aligned to 8-byte boundary");

        return this;
    }

    /**
     * Gets the fragment size.
     *
     * @return the fragment size in characters
     */
    public int getFragmentSize() {
        return fragmentSize;
    }

    /**
     * Sets the fragment size with fluent interface.
     *
     * @param fragmentSize the fragment size in characters
     * @return this HighlightInfo instance for method chaining
     */

  @BeforeExperiment
  void setUp() {
    checkArgument(size > 0, "empty collection not supported");
    Set<Integer> set = new LinkedHashSet<>(size);

    Random random = new Random();
    while (set.size() < size) {
      set.add(random.nextInt());
    }
    List<Integer> list = new ArrayList<>(set);
    inputOrder.arrange(list);
    input = ImmutableList.copyOf(list);
  }

  @Benchmark
  int collections(int reps) {

            assertEquals(expectedSize, req.size());
        }

        @Test
        @DisplayName("Should align size to 8-byte boundary")
        void testSizeAlignment() {
            int size = request.size();
            assertEquals(0, size % 8, "Size should be aligned to 8-byte boundary");
        }

        @ParameterizedTest
        @DisplayName("Should calculate size for various lock counts")