apche org.common.lang.arrayutils类的ut测试

apche commons包是对jdk包的扩展，提供了功能更加强大的api，对程序的编写十分有用。今天对本包下的lang包下的ArrayUtils类进行了测试，总体印象是数组的基本操作：将数组转化成map型数组，往数组中添加元素，删除元素，复制元素，反转数组，求子数组，基本类型数组和对象型数组的转化，检索元素是否存在该数组，指定位置取数组中的值等，十分齐全。一下是具体的UT测试。
UT测试用到的JUint test 4.：

package commons.lang;

import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang.ArrayUtils;
import org.junit.Test;

/**
 * 
 * @Progect_name: ApacheCommonTest
 * @Class_description: 测试apache commons.lang包下的： ArrayUtils
 * @Author: LinYiSong
 * @Date: 2010-11-6~
 * @Vesion:
 */
public class ArrayUtilsTest {
	int[] data1={1,2,3};
	int[] data2={4,5,6};
	/**
	 * 比较数组是否相等
	 */
	@Test
	public void testIsEquals() {
		// 字符串数组
		String[] str = { "aa", "bbbccc" };
		String[] str1 = { "bbbccc", "aa" };
		String[] str2 = { "aa", "bbbccc" };
		assertThat(ArrayUtils.isEquals(str, str1), is(false));
		assertThat(ArrayUtils.isEquals(str, str2), is(true));
		// double 数组 考虑到精度
		double[] d1 = { 1.2, 12.3 };
		double[] d2 = { 1.20, 12.300 };
		assertThat(ArrayUtils.isEquals(d1, d2), is(true));
		//自定义对象 数组 自定义对象要提供equals和hashCode方法 
		User user1=new User(1,"12");
		User user2=new User(1,"12");
		assertThat(user1.equals(user2),is(true));
		User[] users1={user1,user2};
		User[] users2={user2,user1};
		assertThat(ArrayUtils.isEquals(users1, users2), is(true));
	}

	@Test
	public void testToMap(){
		/** 二维数组，[1][2] **/
		/**正常情况**/
//		String[][] strs={{"1","2"},{"3","4"},{"4","3"}};
//		Map map=ArrayUtils.toMap(strs);
//		Set keys=map.keySet();
//		Iterator i=keys.iterator();
//		while(i.hasNext()){
//			Object key=i.next();
//			System.out.println(key+":"+map.get(key));
//		}
//		/**
//		  	3:4
//			1:2
//			4:3
//		 * 
//		 */
		/**[2]中少1**/
//		String[][] strs={{"1"},{"3","4"},{"4","3"}};
//		Map map=ArrayUtils.toMap(strs);
//		Set keys=map.keySet();
//		Iterator i=keys.iterator();
//		while(i.hasNext()){
//			Object key=i.next();
//			System.out.println(key+":"+map.get(key));
//		}
		/**
		 *结果报错 
		 */
		/**[2]中多1个**/
//		String[][] strs={{"1","2"},{"3","4"},{"4","3","5"}};
//		Map map=ArrayUtils.toMap(strs);
//		Set keys=map.keySet();
//		Iterator i=keys.iterator();
//		while(i.hasNext()){
//			Object key=i.next();
//			System.out.println(key+":"+map.get(key));
//		}
//		/**
//		 * 结果：
//			3:4
//			1:2
//			4:3
//			舍弃第二个后多余的
//		 */
		/**[2]中发生冲突**/
		String[][] strs={{"1","2"},{"3","4"},{"3","5","5"}};
		Map map=ArrayUtils.toMap(strs);
		Set keys=map.keySet();
		Iterator i=keys.iterator();
		while(i.hasNext()){
			Object key=i.next();
			System.out.println(key+":"+map.get(key));
		}
//		/**结果：
//			3:5
//		    1:2
//		     会覆盖相同key的值
//		 */
	}
	/**
	 * 测试add方法，以添加boolean型数据为例
boolean[] add(boolean[] array, boolean element) 
        Copies the given array and adds the given element at the end of the new array. 
static boolean[] add(boolean[] array, int index, boolean element) 
        Inserts the specified element at the specified position in the array. 
	 */
	@Test
	public void testAdd(){
		boolean[] bools={true,false,true};
		bools=ArrayUtils.add(bools, true);
		boolean[] result1={true,false,true,true};
		assertThat(bools,is(result1));

		bools=ArrayUtils.add(bools,0,false);
		boolean[] result2={false,true,false,true,true};
		assertThat(bools,is(result2));
		//越界出错
//		bools=ArrayUtils.add(bools,-1,false);
//		bools=ArrayUtils.add(bools,6,false);

	}
	/**
	 * 测试addAll类以int类型为例
 static int[] addAll(int[] array1, int[] array2) 
          Adds all the elements of the given arrays into a new array. 
	 */
	@Test
	public void testAddAll(){

		int[] data3={1,2,3,4,5,6};
		assertThat(ArrayUtils.addAll(data1, data2),is(data3));	
	}
	/**
	 * 测试clone方法，以int为例
	 */
	@Test
	public void testClone(){
		int[] data2={1,2,3};
		assertThat(ArrayUtils.clone(data1),is(data2));
	}
	/**
	 * 测试contains，以double为例
	 */
	@Test
	public void testContains(){
		double[] array={1.2,1,3,1.4};
		assertThat(ArrayUtils.contains(array, 1.4),is(true));
	}
	/**
	 * 测试getLength，以int的型数组为例
 If the input array is null, 0 is returned.

 ArrayUtils.getLength(null)            = 0
 ArrayUtils.getLength([])              = 0
 ArrayUtils.getLength([null])          = 1
 ArrayUtils.getLength([true, false])   = 2
 ArrayUtils.getLength([1, 2, 3])       = 3
 ArrayUtils.getLength(["a", "b", "c"]) = 3
	 */
	@Test
	public void testGetLength(){
		//与array.length相同
		assertThat(ArrayUtils.getLength(data1),is(3));
		//特殊情况
		assertThat(ArrayUtils.getLength(null),is(0));
	}
	/**
	 * hashCode,为数组算出hashcode
	 */
	@Test
	public void testHashCode(){
		assertThat(ArrayUtils.hashCode(data1),is(862547));
	}
	/**
	 * indexof:存在数组中则返回在数组中第一次出现的位置，不在则返回-1
	 */
	@Test
	public void testIndexOf(){
		int[] data2={1,1,1};
		assertThat(ArrayUtils.indexOf(data1, 1),is(0));
		/**不在数组中**/
		assertThat(ArrayUtils.indexOf(data1, 4),is(-1));
		assertThat(ArrayUtils.indexOf(data2, 1),is(0));
	}
	/**
	 * 测试IsEmpty,数组为null或没有数据时被认定为空
	 */
	@Test
	public void testIsEmpty(){
		int[] data2=null;
		int[] data3={};
		assertThat(ArrayUtils.isEmpty(data1),is(false));
		assertThat(ArrayUtils.isEmpty(data2),is(true));
		assertThat(ArrayUtils.isEmpty(data3),is(true));
	}
	/**
	 * isSameLength:调用getLength后比较两数组的大小
	 */
	@Test
	public void testIsSameLength(){
		int[] data3={};
		int[] data4=null;
		assertThat(ArrayUtils.isSameLength(data1,data2),is(true));
		assertThat(ArrayUtils.isSameLength(data1,data3),is(false));
		assertThat(ArrayUtils.isSameLength(data4,data3),is(true));
	}
	/**
	 * 从数组后开始找数组中是否存在，给定的数
	 */
	@Test
	public void testLastIndexOf(){
		int[] data2={1,1,1};
		assertThat(ArrayUtils.lastIndexOf(data1,3),is(2));
		assertThat(ArrayUtils.lastIndexOf(data1,4),is(-1));
		assertThat(ArrayUtils.lastIndexOf(data2,1),is(2));

	 }
	/**
	 *测试remove指定数组的位置移除数据,如果下标越界会抛出异常
	 * remove(char[] array, int index) 
          Removes the element at the specified position from the specified array.
	 */
	@Test
	public void testRemove(){
		int[] temp={1,2};
		assertThat(ArrayUtils.remove(data1, 2),is(temp));
//		assertThat(ArrayUtils.remove(data1, 4),is(temp));
//		assertThat(ArrayUtils.remove(data1,-1),is(temp));
	}
	/**
	 * removeElement,根据指定的元素移除数组中的数，
	 * 如果数组中不存在则数组保持不变
	 */
	@Test
	public void testRemoveElement(){
		int[] temp={1,2};
		assertThat(ArrayUtils.removeElement(data1, 3),is(temp));
		assertThat(ArrayUtils.removeElement(data1, 4),is(data1));

	}
	/**
	 *reverse,将原数组反转，原数组发生改变，所以返回值为void
	 */
	@Test
	public void testReverse(){
		int[] temp={3,2,1};
		ArrayUtils.reverse(data1);
		assertThat(data1,is(temp));
	}
	/**
	 * subarray,截取子数组
	 * public static int[] subarray(int[] array,
                             int startIndexInclusive,
                             int endIndexExclusive)
          startIndexInclusive,从该位置开始截数组，包含此位置
          endIndexExclusive,到该位置停止截取数组，是在该位置前，不截取此位置
          startIndexInclusive,和    endIndexExclusive可以超过原数组的边界，
                    如果超过会选取与原队列相交的部分，截取不到是返回长度为0的数组              
	 */
	@Test
	public void testSubarray(){
		int[] temp={1,2};
		int[] temp1={1};
		int[] temp2={3};
		int[] temp3={};
		assertThat(ArrayUtils.subarray(data1,0,2),is(temp));
		assertThat(ArrayUtils.subarray(data1,0,1),is(temp1));
		assertThat(ArrayUtils.subarray(data1,-1,1),is(temp1));

		assertThat(ArrayUtils.subarray(data1,2,3),is(temp2));
		assertThat(ArrayUtils.subarray(data1,2,5),is(temp2));
		assertThat(ArrayUtils.subarray(data1,5,5),is(temp3));
	}
	/**
	 *toObject 将基本类型的数组转化成对象型的数组
	 */
	@Test
	public void testToObject(){
		Integer[] temp={1,2,3};
		assertThat(ArrayUtils.toObject(data1),is(temp));
	}

	/**
	 * toPrimitive,将对象型数组转化成基本类型数组
	 */
	@Test
	public void testToPrimitive(){
		Integer[] temp={1,2,3};
		assertThat(ArrayUtils.toPrimitive(temp),is(data1));
	}
	/**
	 * 将数组转化成String,将数组转化成java源代码的形式
	 * The format is that of Java source code, for example {a,b}.
	 */
	@Test
	public void testToString1(){
		String str="{1,2,3}";
		int[] temp=null;
		assertThat(ArrayUtils.toString(data1),is(str));
		assertThat(ArrayUtils.toString(temp),is("{}"));

	}
	/**
	 * 将数组转化成String,将数组转化成java源代码的形式，可以添加当数组为空时的返回值
	 * public static String toString(Object array,
                              String stringIfNull)
	 */
	@Test
	public void testToString2(){
		String str="{1,2,3}";
		int[] temp=null;
		assertThat(ArrayUtils.toString(data1),is(str));
		assertThat(ArrayUtils.toString(temp,"数组为空"),is("数组为空"));
	}
}