// Path: src/main/java/com/cinchapi/common/base/Array.java
// public final class Array {
// 
//     /**
//      * Return an array containing all the {@code args}.
//      * <p>
//      * This method is just syntactic sugar for easily passing array objects to
//      * methods that don't take varargs.
//      * </p>
//      * 
//      * @param args the elements that should go in the array.
//      * @return args
//      */
//     @SafeVarargs
//     public static <T> T[] containing(T... args) {
//         return args;
//     }
// 
//     /**
//      * Return a new array that contains the items in the {@code args} array in
//      * reverse order.
//      * 
//      * @param args
//      * @return an array containing the {@code args} in reverse
//      */
//     @SafeVarargs
//     public static <T> T[] reverse(T... args) {
//         T[] copy = Arrays.copyOf(args, args.length);
//         reverseInPlace(copy);
//         return copy;
//     }
// 
//     /**
//      * Reverse the order of the items in the {@code args} array in-place (e.g.
//      * edit the input array).
//      * 
//      * @param args
//      */
//     @SafeVarargs
//     public static <T> void reverseInPlace(T... args) {
//         for (int i = 0; i < args.length / 2; ++i) {
//             T swap = args[i];
//             args[i] = args[args.length - i - 1];
//             args[args.length - i - 1] = swap;
//         }
//     }
// 
//     private Array() {}
// 
// }


import java.io.FileNotFoundException;
import java.io.Serializable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import com.cinchapi.common.base.Array;
import com.google.common.base.CaseFormat;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
        }
    }

    @Test
    public void testCallMethodWithVarArgs() {
        Reflection.call(new Foo(), "varArgs", "foo");
        Reflection.call(new Foo(), "varArgs2", "foo", "foo", "bar");
        Reflection.call(new Foo(), "varArgs");
        Reflection.call(new Foo(), "varArgs2", "foo");
        Assert.assertTrue(true); // lack of exception means we pass
    }

    @Test
    public void testIsCallableWithReproA() {
        Assert.assertFalse(
                Reflection.isCallableWith(
                        Reflection.getMethodUnboxed(Foo.class, "reproA",
                                char.class, CaseFormat[].class),
                        Predicates.alwaysTrue()));
    }

    @Test
    public void testCallOverloadedVarArgsReproA() {
        Reflection.call(new Foo(), "overloadVarArgs");
        Reflection.call(new Foo(), "overloadVarArgs", "a");
        Reflection.call(new Foo(), "overloadVarArgs", "a", "b");
    }

    @Test
    public void testIsCallableWithReproB() {
// Path: src/main/java/com/cinchapi/common/base/Array.java
// public final class Array {
// 
//     /**
//      * Return an array containing all the {@code args}.
//      * <p>
//      * This method is just syntactic sugar for easily passing array objects to
//      * methods that don't take varargs.
//      * </p>
//      * 
//      * @param args the elements that should go in the array.
//      * @return args
//      */
//     @SafeVarargs
//     public static <T> T[] containing(T... args) {
//         return args;
//     }
// 
//     /**
//      * Return a new array that contains the items in the {@code args} array in
//      * reverse order.
//      * 
//      * @param args
//      * @return an array containing the {@code args} in reverse
//      */
//     @SafeVarargs
//     public static <T> T[] reverse(T... args) {
//         T[] copy = Arrays.copyOf(args, args.length);
//         reverseInPlace(copy);
//         return copy;
//     }
// 
//     /**
//      * Reverse the order of the items in the {@code args} array in-place (e.g.
//      * edit the input array).
//      * 
//      * @param args
//      */
//     @SafeVarargs
//     public static <T> void reverseInPlace(T... args) {
//         for (int i = 0; i < args.length / 2; ++i) {
//             T swap = args[i];
//             args[i] = args[args.length - i - 1];
//             args[args.length - i - 1] = swap;
//         }
//     }
// 
//     private Array() {}
// 
// }


// Path: src/test/java/com/cinchapi/common/reflect/ReflectionTest.java
import java.io.FileNotFoundException;
import java.io.Serializable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import com.cinchapi.common.base.Array;
import com.google.common.base.CaseFormat;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;

        }
    }

    @Test
    public void testCallMethodWithVarArgs() {
        Reflection.call(new Foo(), "varArgs", "foo");
        Reflection.call(new Foo(), "varArgs2", "foo", "foo", "bar");
        Reflection.call(new Foo(), "varArgs");
        Reflection.call(new Foo(), "varArgs2", "foo");
        Assert.assertTrue(true); // lack of exception means we pass
    }

    @Test
    public void testIsCallableWithReproA() {
        Assert.assertFalse(
                Reflection.isCallableWith(
                        Reflection.getMethodUnboxed(Foo.class, "reproA",
                                char.class, CaseFormat[].class),
                        Predicates.alwaysTrue()));
    }

    @Test
    public void testCallOverloadedVarArgsReproA() {
        Reflection.call(new Foo(), "overloadVarArgs");
        Reflection.call(new Foo(), "overloadVarArgs", "a");
        Reflection.call(new Foo(), "overloadVarArgs", "a", "b");
    }

    @Test
    public void testIsCallableWithReproB() {
        Object[] params = (Object[]) java.lang.reflect.Array