Configuration cfg = mock(Configuration.class);
        return new Smb2SessionSetupResponse(cfg);
    }

    /**
     * Build a minimal SMB2 header for a response at the given offset.
     * The header is prepared as a synchronous response with server-to-redirector flag.
     */
    private void buildHeader(byte[] buf, int start, int status, int command, long sessionId) {

          private final ByteArrayOutputStream out = new ByteArrayOutputStream();

          @Override
          public boolean processBytes(byte[] buffer, int offset, int length) throws IOException {
            if (length >= 0) {
              out.write(buffer, offset, length);
            }
            return true;
          }

          @Override
          public byte[] getResult() {

     */
    int read(byte[] b) throws SmbException;

    /**
     * Read into buffer from current position
     *
     * @param b
     *            buffer
     * @param off
     *            offset into buffer
     * @param len
     *            read up to <code>len</code> bytes
     * @return number of bytes read
     * @throws SmbException if an I/O error occurs during read
     */

            $boxElement.css("display", "none");
            listNum = 0;
          },

          resize: function() {
            $boxElement.css("top", $textArea.offset().top + $textArea.height() + 6);
            $boxElement.css("left", $textArea.offset().left);
            $boxElement.css("height", "auto");
            $boxElement.css("width", "auto");
            if ($boxElement.width() < $textArea.width() + settingAdjustWidthVal) {

        // Test with offset out of bounds
        PagingList<ProtwordsItem> list = protwordsFile.selectList(100, 10);
        assertEquals(0, list.size());
        assertTrue(list.isEmpty());
    }

    public void test_selectList_negativeOffset() {
        // Load data first
        protwordsFile.reload(null);

        // Test with negative offset

            }
        }
        return str;
    }

    int stringWireLength(final String str, final int offset) {
        int len = str.length() + 1;
        if (useUnicode) {
            len = str.length() * 2 + 2;
            len = offset % 2 != 0 ? len + 1 : len;
        }
        return len;
    }

    int readStringLength(final byte[] src, final int srcIndex, final int max) {

    }

    @Override
    public int encode(byte[] dst, int dstIndex) {
        int start = dstIndex;

        // Write context header
        SMBUtil.writeInt4(16, dst, dstIndex); // Next (offset to next context, 0 for last)
        dstIndex += 4;

        SMBUtil.writeInt2(4, dst, dstIndex); // NameOffset (from start of context)
        dstIndex += 2;

    assertThat(encoding.encode(decoded.getBytes(UTF_8))).isEqualTo(encoded);
  }

  private static void testEncodesWithOffset(
      BaseEncoding encoding, String decoded, int offset, int len, String encoded) {
    assertThat(encoding.encode(decoded.getBytes(UTF_8), offset, len)).isEqualTo(encoded);
  }

  private static void testDecodes(BaseEncoding encoding, String encoded, String decoded) {
    assertThat(encoding.canDecode(encoded)).isTrue();

     */
    @Override
    public void getUserSessionKey(final CIFSContext tc, final byte[] chlng, final byte[] dest, final int offset) throws SmbException {
        if (this.hashesExternal) {
            return;
        }
        super.getUserSessionKey(tc, chlng, dest, offset);
    }

			// Format the sparse map.
			formatSPD := func(sp sparseDatas, sa sparseArray) sparseDatas {
				for i := 0; len(sp) > 0 && i < sa.MaxEntries(); i++ {
					f.formatNumeric(sa.Entry(i).Offset(), sp[0].Offset)
					f.formatNumeric(sa.Entry(i).Length(), sp[0].Length)
					sp = sp[1:]
				}
				if len(sp) > 0 {
					sa.IsExtended()[0] = 1
				}
				return sp
			}