assertThat(ArrayUtil.addAll(emptyArray, array), is(sameInstance(array)));
        assertThat(ArrayUtil.addAll(array, emptyArray), is(sameInstance(array)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testAdd_int() throws Exception {
        final int[] array = new int[] { 1 };
        final int[] newArray = ArrayUtil.add(array, 2);
        assertThat(newArray.length, is(2));

            }
        }

        return di - start;
    }

    /**
     * Decodes a UTF-8 encoded string from a byte array.
     *
     * @param src the source byte array
     * @param si the starting index in the source array
     * @param slim the limit index in the source array
     * @return the decoded String
     * @throws IOException if a decoding error occurs
     */

        ctr1.array[0].remark = "Remark1";
        ctr1.array[1] = new srvsvc.ShareInfo1();
        ctr1.array[1].netname = "Share2";
        ctr1.array[1].type = 1;
        ctr1.array[1].remark = "Remark2";

        // Set up mocks
        mockDeferredBuffer.index = 0; // Set field directly
        mockDeferredBuffer.deferred = mockDeferredBuffer;

        ctr1.encode(mockNdrBuffer);

    int len = string.length();
    int size = len * count;
    char[] array = new char[size];
    string.getChars(0, len, array, 0);
    int n;
    for (n = len; n < size - n; n <<= 1) {
      System.arraycopy(array, 0, array, n, n);
    }
    System.arraycopy(array, 0, array, n, size - n);
    return new String(array);
  }

        }

        /**
         * The number of shares in the array.
         */
        /**
         * The number of shares in the array.
         */
        public int count;
        /**
         * Array of ShareInfo0 structures containing share information.
         */
        public ShareInfo0[] array;

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {

    T[] result = newArray(array, array.length + 1);
    result[0] = element;
    arraycopy(array, 0, result, 1, array.length);
    return result;
  }

  /**
   * Returns a new array that appends {@code element} to {@code array}.
   *
   * @param array the array of elements to prepend
   * @param element the element to append to the end

    T[] result = newArray(array, array.length + 1);
    result[0] = element;
    arraycopy(array, 0, result, 1, array.length);
    return result;
  }

  /**
   * Returns a new array that appends {@code element} to {@code array}.
   *
   * @param array the array of elements to prepend
   * @param element the element to append to the end

    Arrays.sort(array, fromIndex, toIndex);
    reverse(array, fromIndex, toIndex);
  }

  /**
   * Reverses the elements of {@code array}. This is equivalent to {@code
   * Collections.reverse(Floats.asList(array))}, but is likely to be more efficient.
   *
   * @since 23.1
   */
  public static void reverse(float[] array) {
    checkNotNull(array);
    reverse(array, 0, array.length);
  }

  /**

    if (toLessThanMid == midLessThanFrom) {
      // Either array[to] < array[mid] < array[from] or array[from] <= array[mid] <= array[to].
      swap(array, mid, from);
    } else if (toLessThanMid != toLessThanFrom) {
      // Either array[from] <= array[to] < array[mid] or array[mid] <= array[to] < array[from].
      swap(array, from, to);
    }

    Arrays.sort(array, fromIndex, toIndex);
    reverse(array, fromIndex, toIndex);
  }

  /**
   * Reverses the elements of {@code array}. This is equivalent to {@code
   * Collections.reverse(Doubles.asList(array))}, but is likely to be more efficient.
   *
   * @since 23.1
   */
  public static void reverse(double[] array) {
    checkNotNull(array);
    reverse(array, 0, array.length);
  }