*/
@Deprecated(since = "4.0.0")
class DefaultProblem implements Problem {

    private final String source;

    private final int lineNumber;

    private final int columnNumber;

    private final String message;

    private final Exception exception;

    private final Severity severity;

    /**

  }

  @Benchmark
  double percentile90(int reps) {
    double dummy = 0.0;
    for (int i = 0; i < reps; i++) {
      dummy += algorithm.singleQuantile(90, 100, dataset(i));
    }
    return dummy;
  }

  @Benchmark
  double percentile99(int reps) {
    double dummy = 0.0;
    for (int i = 0; i < reps; i++) {
      dummy += algorithm.singleQuantile(99, 100, dataset(i));
    }
    return dummy;
  }

     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int nciphers = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        this.ciphers = new int[nciphers];
        for (int i = 0; i < nciphers; i++) {

    for (int i = 1; i < 900; i += 2) {
      if (!falsePositives.contains(i)) {
        assertFalse("BF should not contain " + i, bf.mightContain(Integer.toString(i)));
      }
    }

    // Check that there are exactly 29824 false positives for this BF.
    int knownNumberOfFalsePositives = 29824;
    int numFpp = 0;
    for (int i = 1; i < numInsertions * 2; i += 2) {

        final int boundarySize = boundary.length;
        final int limitSize = getBoundaryLimitSize();
        if (boundarySize > getBoundaryLimitSize()) {
            throwTooLongBoundarySizeException(contentType, boundarySize, limitSize);
        }
    }

    protected int getBoundaryLimitSize() {

        // Calculate buffer size
        int serverNameSize = 16; // Fixed field size
        int versionSize = 2;
        int typeSize = 4;
        int offsetSize = 4;
        int commentSize = comment.length() + 1;
        int totalSize = serverNameSize + versionSize + typeSize + offsetSize + commentSize;

        byte[] buffer = new byte[totalSize + 100];
        int bufferIndex = 0;
        int start = 0;

     *            extra padding to include in signature
     * @param msg
     *            The message to verify
     * @return whether verification was unsuccessful
     */
    boolean verify(byte[] data, int offset, int length, int extraPad, CommonServerMessageBlock msg);

     */
    public UnicodeString(final String str, final boolean zterm) {
        this.zterm = zterm;

        final int len = str.length();
        final int zt = zterm ? 1 : 0;

        this.length = this.maximum_length = (short) ((len + zt) * 2);
        this.buffer = new short[len + zt];

        int i;
        for (i = 0; i < len; i++) {
            this.buffer[i] = (short) str.charAt(i);
        }
        if (zterm) {

   *     such index exists.
   */
  public static int indexOf(char[] array, char target) {
    return indexOf(array, target, 0, array.length);
  }

  // TODO(kevinb): consider making this public
  private static int indexOf(char[] array, char target, int start, int end) {
    for (int i = start; i < end; i++) {
      if (array[i] == target) {
        return i;
      }
    }

    /** Permission to write extended attributes */
    public static final int FILE_WRITE_EA = 0x00000010; // 5
    /** Permission to execute a file or traverse a directory */
    public static final int FILE_EXECUTE = 0x00000020; // 6
    /** Permission to delete a file or directory */
    public static final int FILE_DELETE = 0x00000040; // 7
    /** Permission to read file attributes */