* @param ctype
     *            The array of character types. Must not be {@literal null} or empty.
     */
    public Tokenizer(final String str, final byte[] ctype) {
        assertArgumentNotNull("str", str);
        assertArgumentNotEmpty("ctype", ctype);

        this.str = str;
        this.ctype = ctype;
    }

    /**
     * Sets up the character type array.
     *
     * @param ctype2

            rpcUuid.node = new byte[6]; // Empty node array

            // Act
            UUID uuid = new UUID(rpcUuid);

            // Assert
            assertNotNull(uuid.node);
            assertEquals(6, uuid.node.length);
            assertArrayEquals(new byte[6], uuid.node, "Empty node array should be copied");
        }
    }

    @Nested

  @SuppressWarnings("DoNotCall")
  public void testRemove() {
    String[] array = {"a", "b", "c"};

    Iterator<String> iterator =
        new UnmodifiableIterator<String>() {
          int i;

          @Override
          public boolean hasNext() {
            return i < array.length;
          }

          @Override
          public String next() {
            if (!hasNext()) {

  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testCreateWithDuplicates() {
    E[] array = createSamplesArray();
    array[1] = e0();
    collection = getSubjectGenerator().create(array);

    expectContents(array);
  }

        // Test with null values array
        String name = "paramName";
        RequestParameter param = new RequestParameter(name, null);

        assertEquals(name, param.getName());
        assertNull(param.getValues());
    }

    public void test_constructor_withEmptyValues() {
        // Test with empty values array
        String name = "paramName";
        String[] values = {};

    /**
     * Returns an array of {@link MethodDesc}.
     *
     * @param methodName
     *            The method name. Must not be {@literal null} or empty string
     * @return An array of {@link MethodDesc}
     */
    MethodDesc[] getMethodDescs(String methodName);

    /**
     * Returns an array of method names.
     *
     * @return An array of method names
     */

    }

    /**
     * Encodes a string into bytes using the specified encoding.
     *
     * @param str the string to encode
     * @param encoding the character encoding to use
     * @return encoded byte array, or empty array if str is null
     */
    public static byte[] getBytes(final String str, final Charset encoding) {
        if (str == null) {
            return new byte[0];
        }
        return str.getBytes(encoding);

    /// Squash bytes down to ints.
    /**
     * Converts bytes to integers for internal DES processing
     * @param inBytes the input byte array
     * @param inOff the offset into the input array
     * @param outInts the output integer array
     * @param outOff the offset into the output array
     * @param intLen the number of integers to convert
     */

    return new Strings();
  }

  @Override
  public Queue<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Queue<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {

  public void testCreateWithNull_supported() {
    E[] array = createArrayWithNullElement();
    collection = getSubjectGenerator().create(array);
    expectContents(array);
  }

  @CollectionFeature.Require(absent = ALLOWS_NULL_VALUES)
  @CollectionSize.Require(absent = ZERO)
  public void testCreateWithNull_unsupported() {
    E[] array = createArrayWithNullElement();

    assertThrows(