| `minio_node_scanner_bucket_scans_started`  | Total number of bucket scans started since server start.    |
| `minio_node_scanner_directories_scanned`   | Total number of directories scanned since server start.     |
| `minio_node_scanner_objects_scanned`       | Total number of unique objects scanned since server start.  |

        this.fileName = new String(nameBytes, StandardCharsets.UTF_16LE);
        return bufferIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        dst[dstIndex] = (byte) (this.replaceIfExists ? 1 : 0);
        dstIndex += 8; // 7 Reserved

     */
    @Test
    public void testPerformance() throws Exception {
        final int num = 100;
        long start = System.currentTimeMillis();
        for (int i = 0; i < num; i++) {
            System.out.println("test" + i);
        }
        final long sysout = System.currentTimeMillis() - start;
        start = System.currentTimeMillis();
        for (int i = 0; i < num; i++) {
            logger.fatal("test" + i);
        }

  static BigInteger listProduct(List<BigInteger> nums, int start, int end) {
    switch (end - start) {
      case 0:
        return BigInteger.ONE;
      case 1:
        return nums.get(start);
      case 2:
        return nums.get(start).multiply(nums.get(start + 1));
      case 3:
        return nums.get(start).multiply(nums.get(start + 1)).multiply(nums.get(start + 2));
      default:

        if (ownerUOffset > 0) {
            bufferIndex = start + ownerUOffset;
            this.ownerUserSid = new SID(buffer, bufferIndex);
            bufferIndex += 8 + 4 * this.ownerUserSid.sub_authority_count;
        }

        if (ownerGOffset > 0) {
            bufferIndex = start + ownerGOffset;
            this.ownerGroupSid = new SID(buffer, bufferIndex);

| `minio_scanner_bucket_scans_finished`      | Total number of bucket scans completed since server start. <br><br>Type: counter  | `server` |
| `minio_scanner_bucket_scans_started`       | Total number of bucket scans started since server start. <br><br>Type: counter    | `server` |
| `minio_scanner_directories_scanned`        | Total number of directories scanned since server start. <br><br>Type: counter     | `server` |

								Quorum:    &quorum,
							})
							if !ok || err != nil {
								t.Fatal("failed:", err, ok)
							}
						}
					}
					start := time.Now()
					l.expireOldLocks(time.Hour)
					t.Logf("Scan Took: %v. Left: %d/%d", time.Since(start).Round(time.Millisecond), len(l.lockUID), len(l.lockMap))
					if len(l.lockMap) != locks {
						t.Fatalf("objects deleted, want %d != got %d", locks, len(l.lockMap))

    }

    /**
     * Gets the response status code
     * @return the status
     */
    public final int getStatus() {
        return this.status;
    }

    /**
     * Sets the response status code
     * @param status
     *            the status to set
     */
    protected final void setStatus(final int status) {
        this.status = status;
    }

    /**

                if (pathOffset > 0) {
                    this.rpath = readString(buffer, start + pathOffset, len);
                }
                if (nodeOffset > 0) {
                    this.node = readString(buffer, start + nodeOffset, len);
                }
                if (altPathOffset > 0) {
                    this.altPath = readString(buffer, start + altPathOffset, len);
                }
            } else {

        } catch (SmbException e) {
            // Expected
        }

        stats = validator.getStats();
        assertTrue(stats.getTotalValidations() > 0);
        assertTrue(stats.getFailedValidations() > 0);
        assertTrue(stats.getFailureRate() > 0);
        assertTrue(stats.getFailureRate() <= 1.0);
    }

    @Test
    public void testBufferOverflowPrevention() throws Exception {