/*
* File：SimpleMock.java
* User：xiaocao000
* Date：2009-8-1
*/
package com.xiaocao000.lang;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* SimpleMock<br>
* SimpleMock 1. primitive array 2. inner class
* @author xiaocao000
* @version 1.0
*/
public class SimpleMock
{
private static final int UNKNOWN_TYPE = -1;
private static final int VOID = 0;
private static final int BYTE = 1;
private static final int SHORT = 2;
private static final int INT = 3;
private static final int LONG = 4;
private static final int FLOAT = 5;
private static final int DOUBLE = 6;
private static final int CHAR = 7;
private static final int BOOLEAN = 8;
private static final int STRING = 9;
private static final int DATE = 10;
private static final int CALENDAR = 11;
private static final int OBJECT = 99;
private static final int CLASS = 98;
private static Map<Class<?>, Integer> classMap = new HashMap<Class<?>, Integer>();
static
{
classMap.put(void.class, VOID);
classMap.put(byte.class, BYTE);
classMap.put(short.class, SHORT);
classMap.put(int.class, INT);
classMap.put(long.class, LONG);
classMap.put(float.class, FLOAT);
classMap.put(double.class, DOUBLE);
classMap.put(char.class, CHAR);
classMap.put(boolean.class, BOOLEAN);
classMap.put(Void.class, VOID);
classMap.put(Byte.class, BYTE);
classMap.put(Short.class, SHORT);
classMap.put(Integer.class, INT);
classMap.put(Long.class, LONG);
classMap.put(Float.class, FLOAT);
classMap.put(Double.class, DOUBLE);
classMap.put(Character.class, CHAR);
classMap.put(Boolean.class, BOOLEAN);
classMap.put(String.class, STRING);
classMap.put(Date.class, DATE);
classMap.put(Calendar.class, CALENDAR);
classMap.put(Object.class, OBJECT);
classMap.put(Class.class, CLASS);
}
private static Integer getJavaType(Class<?> clazz)
{
if (classMap.containsKey(clazz))
{
return classMap.get(clazz);
}
return UNKNOWN_TYPE;
}
private static <T> T getValue(Class<T> clazz)
{
Object value = null;
int javaType = getJavaType(clazz);
switch (javaType)
{
case BYTE:
{
value = SimpleRandom.getByte();
break;
}
case SHORT:
{
value = SimpleRandom.getShort();
break;
}
case INT:
{
value = SimpleRandom.getInt();
break;
}
case LONG:
{
value = SimpleRandom.getLong();
break;
}
case FLOAT:
{
value = SimpleRandom.getFloat();
break;
}
case DOUBLE:
{
value = SimpleRandom.getDouble();
break;
}
case CHAR:
{
value = SimpleRandom.getCharacter();
break;
}
case BOOLEAN:
{
value = SimpleRandom.getBoolean();
break;
}
case STRING:
{
value = SimpleRandom.getString();
break;
}
case DATE:
{
value = SimpleRandom.getDate();
break;
}
case CALENDAR:
{
value = SimpleRandom.getCalendar();
break;
}
case UNKNOWN_TYPE:
{
// TODO Inner Class
// if (clazz.getSimpleName().indexOf("$") != -1)
// {
// System.out.println("innerClass:" + clazz.getName());
// value = null;
// break;
// }
value = mockObject(clazz);
break;
}
case OBJECT:
case CLASS:
case VOID:
default:
{
value = null;
break;
}
}
return (T)value;
}
/**
* 模拟对象
* @param <T>
* @param clazz
* @return
*/
public static <T> T mockObject(Class<T> clazz)
{
if (classMap.containsKey(clazz))
{
return (T)getValue(clazz);
}
T obj = null;
try
{
obj = clazz.newInstance();
// Field[] fields = clazz.getDeclaredFields();
Field[] fields = ClassUtil.getAllField(clazz);
AccessibleObject.setAccessible(fields, true);
for (Field field : fields)
{
if (ObjectUtil.isIgnoreField(field))
{
continue;
}
field.set(obj, getValue(field.getType()));
}
}
catch (Exception e)
{
return null;
}
return obj;
}
/**
* 模拟对象数组
* @param <T>
* @param clazz
* @return
*/
public static <T> T[] mockObjectArray(Class<T> clazz, int length)
{
length = (length > 0) ? length : 0;
Object array = Array.newInstance(clazz, length);
for (int i = 0; i < length; i++)
{
Array.set(array, i, mockObject(clazz));
}
System.out.println(ObjectUtil.toString(array));
return (T[])array;
// T[] t = null;
// if (clazz.isPrimitive())
// {
// // TODO primitive array
// // Object array = new Integer[length];
// // System.out.println(clazz);
// // t = (T[])array;
// }
// else
// {
// t = (T[])Array.newInstance(clazz, length);
// }
//
// for (int i = 0; i < length; i++)
// {
// // t[i] = mockObject(clazz);
// Array.set(t, i, mockObject(clazz));
// }
// return t;
}
/**
* 模拟对象List
* @param <T> List元素类型
* @param valueType List元素Class类型
* @return 模拟对象List
*/
public static <T> List<T> mockObjectList(Class<T> valueType, int size)
{
int length = (size > 0) ? size : 0;
List<T> list = new ArrayList<T>(length);
for (int i = 0; i < length; i++)
{
list.add(mockObject(valueType));
}
return list;
}
/**
* 模拟对象Map
* @param <K> Key的类型
* @param <V> Value的类型
* @param keys Key值数组
* @param valueType value的Class Type
* @return 模拟对象Map
*/
public static <K,V> Map<K,V> mockObjectMap(K[] keys, Class<V> valueType)
{
int length = (keys == null) ? 0 : keys.length;
Map<K,V> map = new HashMap<K,V>(length);
for (int i = 0; i < length; i++)
{
map.put(keys[i], mockObject(valueType));
}
return map;
}
/**
* 模拟对象Map
* @param <K> Key的类型
* @param <V> Value的类型
* @param keyType Key的Class Type
* @param valueType value的Class Type
* @param size 要模拟的Map大小
* @return 模拟的对象Map
*/
public static <K,V> Map<K,V> mockObjectMap(Class<K> keyType, Class<V> valueType, int size)
{
int length = (size > 0) ? size : 0;
Map<K,V> map = new HashMap<K,V>(length);
for (int i = 0; i < length; i++)
{
map.put(mockObject(keyType), mockObject(valueType));
}
return map;
}
}
