*            the value to add
     * @return a new array with the value appended
     */
    public static boolean[] add(final boolean[] array, final boolean value) {
        assertArgumentNotNull("array", array);
        final boolean[] newArray = (boolean[]) Array.newInstance(boolean.class, array.length + 1);
        System.arraycopy(array, 0, newArray, 0, array.length);
        newArray[array.length] = value;
        return newArray;
    }

        }
    }

    /**
     * Asserts that the argument is neither <code>null</code> nor an empty array.
     *
     * @param argName
     *            The name of the argument that must not be {@code null} or an empty array.
     * @param argValue
     *            The value of the argument.
     * @throws EmptyArgumentException
     *             If the argument is <code>null</code> or an empty array.

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

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.lang;

import static org.codelibs.core.collection.ArrayUtil.asArray;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.log;

import static org.codelibs.core.collection.ArrayUtil.asArray;
import static org.codelibs.core.collection.CollectionsUtil.newHashMap;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

        return getTraverser(url, null, rootDir);
    }

    /**
     * Returns an array of {@link Traverser} instances that handle collections of classes or resources based on the specified root package.
     *
     * @param rootPackage
     *            The root package.
     * @return An array of {@link Traverser} instances that handle collections of resources based on the specified root package.
     */

    // For datasets of many double values created from an array, we test many combinations of
    // finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();
      StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();
      accumulator.addAll(values.asArray());
      for (double value : values.asIterable()) {

        }

        private void evaluateArray(Object target) throws ModelInterpolationException {
            int len = Array.getLength(target);
            for (int i = 0; i < len; i++) {
                Object value = Array.get(target, i);
                if (value != null) {
                    if (String.class == value.getClass()) {

        return ((Map<?, ?>) value).isEmpty();
      } else if (value instanceof Optional) {
        return !((Optional) value).isPresent();
      } else if (value.getClass().isArray()) {
        return Array.getLength(value) == 0;
      }
      return false;
    }

    /**
     * Returns a string in the format specified by {@link MoreObjects#toStringHelper(Object)}.
     *

    // TODO(user): This is not the most efficient way to handle generic
    // arrays, but is there another way to extract the array class in a
    // non-hacky way (i.e. using String value class names- "[L...")?
    return Array.newInstance(componentType, 0).getClass();
  }

  /*
   * TODO(benyu): Once behavior is the same for all Java (and Android) versions we support, delete