assertEquals(-10L, mock.length());
        }
    }

    @ParameterizedTest(name = "getType returns {0}")
    @ValueSource(ints = { 0, 1, -5, Integer.MAX_VALUE })
    @DisplayName("Parameterized type values")
    void typeParameterized(int type) {
        FileEntry mock = mock(FileEntry.class);
        when(mock.getType()).thenReturn(type);
        assertEquals(type, mock.getType());
    }

    }

    private void ensureRoomFor(int numberToAdd) {
      int newCount = count + numberToAdd; // TODO(kevinb): check overflow now?
      if (newCount > array.length) {
        array = Arrays.copyOf(array, expandedCapacity(array.length, newCount));
      }
    }

    // Unfortunately this is pasted from ImmutableCollection.Builder.
    private static int expandedCapacity(int oldCapacity, int minCapacity) {
      if (minCapacity < 0) {

				PutByteBuffer(payload)
				if err != nil {
					r := RemoteErr(err.Error())
					return &r
				}
			}

			var inT chan Req
			if h.InCapacity > 0 {
				// Don't add extra buffering
				inT = make(chan Req)
				go func() {
					defer xioutil.SafeClose(inT)
					for {
						select {
						case <-ctx.Done():
							return
						case v, ok := <-in:
							if !ok {
								return

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

  Graph<Integer> undirectedGraph;

  ImmutableList<MutableNetwork<Integer, String>> networksToTest;
  Network<Integer, String> directedNetwork;
  Network<Integer, String> undirectedNetwork;

  @Before
  public void init() {
    MutableGraph<Integer> mutableDirectedGraph =
        GraphBuilder.directed().allowsSelfLoops(true).build();
    MutableGraph<Integer> mutableUndirectedGraph =

        // 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;

    public static final int SMB_DIRECT_RESPONSE_REQUESTED = 0x00000001;
    
    // Default RDMA settings
    public static final int DEFAULT_RDMA_READ_WRITE_SIZE = 1048576;  // 1MB
    public static final int DEFAULT_RECEIVE_CREDIT_MAX = 255;
    public static final int DEFAULT_SEND_CREDIT_TARGET = 32;
    public static final int DEFAULT_MAX_RECEIVE_SIZE = 8192;
    public static final int DEFAULT_MAX_FRAGMENTED_SIZE = 131072;    // 128KB

        int exitCode;
        try {
            SingletonLaContainerFactory.setConfigPath("app.xml");
            SingletonLaContainerFactory.setExternalContext(new GenericExternalContext());
            SingletonLaContainerFactory.setExternalContextComponentDefRegister(new GenericExternalContextComponentDefRegister());
            SingletonLaContainerFactory.init();

    private boolean loadBalance;
    private boolean enableBasic;
    private boolean insecureBasic;
    private String realm;

    @Override
    public void init(final FilterConfig filterConfig) throws ServletException {
        String name;
        int level;

        /* Set jcifs.smb1 properties we know we want; soTimeout and cachePolicy to 30min.
         */