if (initialBytes == null) {
        return checkNotNull(bytes);
      } else {
        byte[] result = new byte[initialBytes.length + bytes.length];
        System.arraycopy(initialBytes, 0, result, 0, initialBytes.length);
        System.arraycopy(bytes, 0, result, initialBytes.length, bytes.length);
        return result;
      }
    }

    @Override
    public byte[] getSinkContents() throws IOException {

    return CompactHashSet.create();
  }

  /**
   * Returns a new array of the given length with the same type as a reference array.
   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  /*
   * The new array contains nulls, even if the old array did not. If we wanted to be accurate, we

     * @param offset
     *            The starting offset at which the SMB header begins.
     * @param length
     *            The length of the SMB data starting at offset.
     * @param request
     *            request message
     * @param response
     *            response message
     */
    void sign(byte[] data, int offset, int length, CommonServerMessageBlock request, CommonServerMessageBlock response);

    /**

     * @param address remote memory address (offset)
     * @param length length of the memory region
     */
    public RdmaChannelInfo(int remoteKey, long address, int length) {
        // Create SMB2_RDMA_TRANSFORM structure
        this.transform = new Smb2RdmaTransform(address, remoteKey, length);
    }

    /**
     * Create from SMB2 RDMA Transform
     *

    Entry<K, V>[] entries = createArray(elements.length);
    arraycopy(elements, 0, entries, 0, elements.length);
    return createFromEntries(entries);
  }

  public abstract Set<Entry<K, V>> createFromEntries(Entry<K, V>[] entries);

  @Override
  @SuppressWarnings("unchecked") // generic arrays make typesafety sad
  public Entry<K, V>[] createArray(int length) {
    return (Entry<K, V>[]) new Entry<?, ?>[length];
  }

        // Prepare test data with zeros
        byte[] buffer = new byte[22];

        // All zeros
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = 0;
        }

        // Decode
        smbInfoAllocation.decode(buffer, 0, buffer.length);

        // Verify - all zeros should result in 0 capacity and free
        assertEquals(0L, smbInfoAllocation.getCapacity());

        assertThat(args.length, is(1));
        assertThat(args[0].getRawClass(), is(sameClass(Integer.class)));

        desc = ParameterizedClassDescFactory.createParameterizedClassDesc(method, 1, map);
        assertThat(desc.getRawClass(), is(sameClass(Map.class)));
        args = desc.getArguments();
        assertThat(args.length, is(2));

  }

  private final class SubList extends ImmutableList<E> {
    final transient int offset;
    final transient int length;

    SubList(int offset, int length) {
      this.offset = offset;
      this.length = length;
    }

    @Override
    public int size() {
      return length;
    }

    @Override
    @Nullable Object @Nullable [] internalArray() {

        final byte[] xmlBytes = xml.getBytes();
        final byte[] dataWithBOM = new byte[bom.length + xmlBytes.length];
        System.arraycopy(bom, 0, dataWithBOM, 0, bom.length);
        System.arraycopy(xmlBytes, 0, dataWithBOM, bom.length, xmlBytes.length);

        final InputStream in = new ByteArrayInputStream(dataWithBOM);
        final SitemapSet sitemapSet = sitemapsHelper.parse(in);

            byte[] actualPathBytes = new byte[expectedPathBytes.length];
            System.arraycopy(dst, 2, actualPathBytes, 0, expectedPathBytes.length);
            assertArrayEquals(expectedPathBytes, actualPathBytes);

            // Check null terminator at the end
            int nullTerminatorIndex = 2 + expectedPathBytes.length;
            assertEquals(0, dst[nullTerminatorIndex]);