import java.io.File;
import java.io.FileNotFoundException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Arrays;
static final File COMPILER_OUTPUT_DIR = new File(COMPILER_OUTPUT_PATH);
static final String BASE_PATH = "org" + FS + "opendaylight" + FS + "yang" + FS + "gen" + FS + "v1";
- static final String NS_TEST = BASE_PATH + FS + "urn" + FS + "opendaylight" + FS + "test" + FS
- + "rev131008";
+ static final String NS_TEST = BASE_PATH + FS + "urn" + FS + "opendaylight" + FS + "test" + FS + "rev131008";
static final String NS_FOO = BASE_PATH + FS + "urn" + FS + "opendaylight" + FS + "foo" + FS + "rev131008";
static final String NS_BAR = BASE_PATH + FS + "urn" + FS + "opendaylight" + FS + "bar" + FS + "rev131008";
static final String NS_BAZ = BASE_PATH + FS + "urn" + FS + "opendaylight" + FS + "baz" + FS + "rev131008";
}
/**
- * Test if generated source implements interface.
+ * Asserts that class contains field with fiven name and type.
*
- * @param classToTest
+ * @param clazz
+ * class to test
+ * @param name
+ * field name
+ * @param type
+ * field type
+ * @return field with given name if present in class
+ */
+ static Field assertContainsField(Class<?> clazz, String name, Class<?> type) {
+ try {
+ Field f = clazz.getDeclaredField(name);
+ assertEquals(type, f.getType());
+ return f;
+ } catch (NoSuchFieldException e) {
+ throw new AssertionError("Field " + name + " does not exists in class " + clazz.getSimpleName());
+ }
+ }
+
+ /**
+ * Asserts that class contains field with given name and value. Method tries
+ * to create new instance of class and get value of field. If class
+ * constructor contains any arguments, class is instantiated with null
+ * values.
+ *
+ * @param clazz
+ * class to test
+ * @param name
+ * name of field
+ * @param returnType
+ * return type of field
+ * @param expectedValue
+ * expected value of field
+ * @param constructorArgs
+ * constructor arguments of class to test
+ */
+ static void assertContainsFieldWithValue(Class<?> clazz, String name, Class<?> returnType, Object expectedValue,
+ Class<?>... constructorArgs) {
+ Object[] initargs = null;
+ if (constructorArgs != null && constructorArgs.length > 0) {
+ initargs = new Object[constructorArgs.length];
+ for (int i = 0; i < constructorArgs.length; i++) {
+ initargs[i] = null;
+ }
+ }
+ assertContainsFieldWithValue(clazz, name, returnType, expectedValue, constructorArgs, initargs);
+ }
+
+ /**
+ * Asserts that class contains field with given name, return type and value.
+ *
+ * @param clazz
+ * class to test
+ * @param name
+ * name of field
+ * @param returnType
+ * return type of field
+ * @param expectedValue
+ * expected value of field
+ * @param constructorArgs
+ * array of constructor arguments classes
+ * @param initargs
+ * array of constructor values
+ */
+ static void assertContainsFieldWithValue(Class<?> clazz, String name, Class<?> returnType, Object expectedValue,
+ Class<?>[] constructorArgs, Object... initargs) {
+ Field f = assertContainsField(clazz, name, returnType);
+ try {
+ Constructor<?> c = clazz.getDeclaredConstructor(constructorArgs);
+ Object o = c.newInstance(initargs);
+ assertEquals(expectedValue, f.get(o));
+ } catch (Exception e) {
+ throw new AssertionError("Failed to perform " + name + " field test", e);
+ }
+ }
+
+ /**
+ * Asserts that class contains constructor with parameter types.
+ *
+ * @param clazz
+ * class to test
+ * @param args
+ * array of argument classes
+ */
+ static void assertContainsConstructor(Class<?> clazz, Class<?>... args) {
+ try {
+ clazz.getDeclaredConstructor(args);
+ } catch (NoSuchMethodException e) {
+ throw new AssertionError("Constructor with args " + Arrays.toString(args) + " does not exists in class "
+ + clazz.getSimpleName());
+ }
+ }
+
+ /**
+ * Asserts that class contains method with given name, return type and
+ * parameter types.
+ *
+ * @param clazz
+ * class to test
+ * @param returnType
+ * method return type
+ * @param name
+ * method name
+ * @param args
+ * array of parameter type classes
+ */
+ static void assertContainsMethod(Class<?> clazz, Class<?> returnType, String name, Class<?>... args) {
+ try {
+ Method m = clazz.getDeclaredMethod(name, args);
+ assertEquals(returnType, m.getReturnType());
+ } catch (NoSuchMethodException e) {
+ throw new AssertionError("Method " + name + " with args " + Arrays.toString(args)
+ + " does not exists in class " + clazz.getSimpleName());
+ }
+ }
+
+ /**
+ * Asserts that class contains method with given name and return type.
+ *
+ * @param clazz
+ * class to test
+ * @param returnTypeStr
+ * name of method return type
+ * @param name
+ * method name
+ * @param loader
+ * current class loader
+ */
+ static void assertContainsMethod(Class<?> clazz, String returnTypeStr, String name, ClassLoader loader) {
+ Class<?> returnType;
+ try {
+ returnType = Class.forName(returnTypeStr, true, loader);
+ Method method = clazz.getMethod(name);
+ assertEquals(returnType, method.getReturnType());
+ } catch (ClassNotFoundException e) {
+ throw new AssertionError("Return type of method '" + name + "' not found");
+ } catch (NoSuchMethodException e) {
+ throw new AssertionError("Method " + name + " does not exists in class " + clazz.getSimpleName());
+ }
+ }
+
+ /**
+ * Asserts that class containes hashCode, equals and toString methods.
+ *
+ * @param clazz
+ * class to test
+ */
+ static void assertContainsDefaultMethods(Class<?> clazz) {
+ assertContainsMethod(clazz, Integer.TYPE, "hashCode");
+ assertContainsMethod(clazz, Boolean.TYPE, "equals", Object.class);
+ assertContainsMethod(clazz, String.class, "toString");
+ }
+
+ /**
+ * Asserts that class contains 'public static
+ * java.util.List<com.google.common.collect.Range<java.lang.Integer>>
+ * getLength()' method.
+ *
+ * @param clazz
+ * class to test
+ */
+ static void assertContainsGetLength(Class<?> clazz) {
+ try {
+ Method m = clazz.getDeclaredMethod("getLength");
+ java.lang.reflect.Type returnType = m.getGenericReturnType();
+ assertTrue("Return type of getLength method must be ParameterizedType",
+ returnType instanceof ParameterizedType);
+ ParameterizedType listType = (ParameterizedType) returnType;
+ assertEquals("interface java.util.List", listType.getRawType().toString());
+
+ java.lang.reflect.Type[] args = listType.getActualTypeArguments();
+ assertEquals(1, args.length);
+ java.lang.reflect.Type range = args[0];
+ assertTrue(range instanceof ParameterizedType);
+ ParameterizedType pRange = (ParameterizedType) range;
+ assertEquals("class com.google.common.collect.Range", pRange.getRawType().toString());
+
+ args = pRange.getActualTypeArguments();
+ assertEquals(1, args.length);
+ java.lang.reflect.Type integer = args[0];
+ assertEquals("class java.lang.Integer", integer.toString());
+ } catch (NoSuchMethodException e) {
+ throw new AssertionError("Method getLength does not exists in class " + clazz.getSimpleName());
+ }
+ }
+
+ /**
+ * Asserts that class implements given interface.
+ *
+ * @param clazz
* source to test
- * @param ifcClass
- * expected interface type
+ * @param ifc
+ * expected interface
*/
- static void testImplementsIfc(Class<?> classToTest, Class<?> ifcClass) {
- Class<?>[] interfaces = classToTest.getInterfaces();
+ static void assertImplementsIfc(Class<?> clazz, Class<?> ifc) {
+ Class<?>[] interfaces = clazz.getInterfaces();
List<Class<?>> ifcsList = Arrays.asList(interfaces);
- if (!ifcsList.contains(ifcClass)) {
- throw new AssertionError(classToTest + " should implement " + ifcClass);
+ if (!ifcsList.contains(ifc)) {
+ throw new AssertionError(clazz + " should implement " + ifc);
}
}
* Test if interface generated from augment extends Augmentation interface
* with correct generic type.
*
- * @param classToTest
+ * @param clazz
* interface generated from augment
- * @param genericType
+ * @param genericTypeName
* fully qualified name of expected parameter type
*/
- static void testAugmentation(Class<?> classToTest, String genericType) {
- final String ifcToImplement = "interface org.opendaylight.yangtools.yang.binding.Augmentation";
- testImplementParameterizedIfc(classToTest, ifcToImplement, genericType);
+ static void testAugmentation(Class<?> clazz, String genericTypeName) {
+ final String ifcName = "interface org.opendaylight.yangtools.yang.binding.Augmentation";
+ assertImplementsParameterizedIfc(clazz, ifcName, genericTypeName);
}
- static void testImplementParameterizedIfc(Class<?> classToTest, String ifcToImplement, String genericType) {
- ParameterizedType augmentation = null;
- for (java.lang.reflect.Type ifc : classToTest.getGenericInterfaces()) {
+ /**
+ * Asserts that class implements interface with given name and generic type
+ * parameter.
+ *
+ * @param clazz
+ * class to test
+ * @param ifcName
+ * name of interface
+ * @param genericTypeName
+ * name of generic type
+ */
+ static void assertImplementsParameterizedIfc(Class<?> clazz, String ifcName, String genericTypeName) {
+ ParameterizedType ifcType = null;
+ for (java.lang.reflect.Type ifc : clazz.getGenericInterfaces()) {
if (ifc instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) ifc;
- if (ifcToImplement.equals(pt.getRawType().toString())) {
- augmentation = pt;
+ if (ifcName.equals(pt.getRawType().toString())) {
+ ifcType = pt;
}
}
}
- assertNotNull(augmentation);
+ assertNotNull(ifcType);
- java.lang.reflect.Type[] typeArguments = augmentation.getActualTypeArguments();
+ java.lang.reflect.Type[] typeArguments = ifcType.getActualTypeArguments();
assertEquals(1, typeArguments.length);
- assertEquals("interface " + genericType, typeArguments[0].toString());
+ assertEquals("interface " + genericTypeName, typeArguments[0].toString());
}
/**
assertTrue(compiled);
}
- static void testFilesCount(File dir, int count) {
+ /**
+ * Asserts that directory contains exactly given count of files.
+ *
+ * @param dir
+ * directory to test
+ * @param count
+ * expected count of files in directory
+ */
+ static void assertFilesCount(File dir, int count) {
File[] dirContent = dir.listFiles();
if (dirContent == null) {
throw new AssertionError("File " + dir + " doesn't exists or it's not a directory");
Code Review / yangtools.git / blobdiff