mmHeap.add(2);
    mmHeap.add(3);
    assertEquals(4, (int) mmHeap.pollLast());
    assertEquals(3, (int) mmHeap.peekLast());
    assertEquals(3, (int) mmHeap.pollLast());
    assertEquals(1, (int) mmHeap.peek());
    assertEquals(2, (int) mmHeap.peekLast());
    assertEquals(2, (int) mmHeap.pollLast());
    assertEquals(1, (int) mmHeap.peek());
    assertEquals(1, (int) mmHeap.peekLast());
    assertEquals(1, (int) mmHeap.pollLast());

        return SCOPE_OFFSET + writeScopeWireFormat(dst, dstIndex + SCOPE_OFFSET);
    }

    int readWireFormat(final byte[] src, final int srcIndex) {

        final byte tmp[] = new byte[SCOPE_OFFSET];
        int length = 15;
        for (int i = 0; i < 15; i++) {
            tmp[i] = (byte) ((src[srcIndex + 2 * i + 1] & 0xFF) - 0x41 << 4);

	tests := []struct {
		name     string
		input    []int
		trimLen  int
		expected []int
	}{
		{
			name:     "Trim two elements from end",
			input:    []int{1, 2, 3, 4, 5},
			trimLen:  2,
			expected: []int{1, 2, 3},
		},
		{
			name:     "Trim entire slice",
			input:    []int{1, 2, 3},
			trimLen:  3,
			expected: []int{},
		},
		{

    /**
     * Number of shards for the queue index.
     */
    protected int queueShards = Runtime.getRuntime().availableProcessors() * 2;

    /**
     * Number of shards for the data index.
     */
    protected int dataShards = Runtime.getRuntime().availableProcessors() * 2;

    /**
     * Number of shards for the filter index.
     */
    protected int filterShards = Runtime.getRuntime().availableProcessors() * 2;

    /**

/**
 * Unit tests for DirectoryLeaseContext
 */
public class DirectoryLeaseContextTest {

    @Test
    public void testConstructor() {
        Smb2LeaseKey key = new Smb2LeaseKey();
        int leaseState = DirectoryLeaseState.DIRECTORY_READ_HANDLE;
        DirectoryCacheScope scope = DirectoryCacheScope.IMMEDIATE_CHILDREN;

        DirectoryLeaseContext context = new DirectoryLeaseContext(key, leaseState, scope);

    // see https://msdn.microsoft.com/en-us/library/dd414577.aspx

    private int namedPipeState;
    private int readDataAvailable;
    private int numberOfMessages;
    private int messageLength;
    private byte[] data;

    /**
     * Gets the current state of the named pipe
     * @return the namedPipeState
     */
    public int getNamedPipeState() {
        return this.namedPipeState;
    }

    /**

    /**
     * SMB 3.0 persistent handle - survives server reboot
     */
    PERSISTENT(3);

    private final int value;

    HandleType(int value) {
        this.value = value;
    }

    /**
     * Get the numeric value of this handle type
     * @return the numeric value
     */
    public int getValue() {
        return value;
    }

    /**
     * Get HandleType from numeric value

  val alpnProtocols: List<String>,
  val ellipticCurves: List<Int>,
  val handshakeFormat: String,
  val hexHandshakeBytes: String,
  val highestProtocol: Int,
  val id: Int,
  val isGrade0: Boolean,
  val lowestProtocol: Int,
  val maxDhBits: Int,
  val maxRsaBits: Int,
  val minDhBits: Int,
  val minEcdsaBits: Int,
  val minRsaBits: Int,
  val name: String,
  val npnProtocols: List<String>,

    }
  }

  @Benchmark
  long divide(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += UnsignedLongs.divide(longs[j], divisors[j]);
    }
    return tmp;
  }

  @Benchmark
  long remainder(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;

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

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