Help need regarding Java Reflection

Question

I need help in programming the following:
I have to generate a test Harness for OOP.This program that automatically tests
classes by instantiating them, selecting methods of these instantiated objects randomly or
using some criteria, invoking them, and using the returned values as input parameters to
invoke other methods. I have to use Java Reflection for this and methods must be of generic type!
For this
I have to generate a tree of functions(say 2 or 3).The functions could be say:int f(int){} and int g(int){}. or Int f(String), String g(float),Float h(int)..I have to create a tree of these function set and traverse them in BFS or DFS and generate combinations of these functions keeping some upper bound for the number of functions genrated(10) and size of combinations of functions(say 5).The output of one function should be the input to other function(so recursive).If any combination failed,then record(or throw exception).This all should be done using java reflection.The input can be provided though annotations or input file.This file can result in recording even the output for each function. I have tried using Junit for testing methods.My code with is following:I have two classes ClassUnderTestTests(which tests the methods of ClassUnderTest) and ClassUnderTest shown below
//Test Harness class
public class ClassUnderTestTests {
     Field[] fields;
     Method[] methods;
     Method minVal;
     Method maxVal;
     Method setVal1;
     Method setVal2;
     Method getVal1;
     Method getVal2;
     Class<?> cut;
     ClassUnderTest<Integer> obj1;
     ClassUnderTest<String> obj2;
     @Before public void setUp(){
          try {
               cut = Class.forName("com.the.ClassUnderTest");
          fields=cut.getDeclaredFields();
          methods=cut.getDeclaredMethods();
          print("Name of the CUT class >>"+ cut.getName());
          print("List of fields >>"+ getFieldNames(fields));
          print("List of Methods >>"+ getMethodNames(methods));
          //creating method objects for the methods declared in the class
          minVal=cut.getDeclaredMethod("minValue");
          minVal.setAccessible(true);
          maxVal=cut.getDeclaredMethod("maxValue");
          maxVal.setAccessible(true);
          setVal1=cut.getDeclaredMethod("setVal1", Comparable.class);
          setVal1.setAccessible(true);
          setVal2 = cut.getDeclaredMethod("setVal2", Comparable.class);
          setVal2.setAccessible(true);
          getVal1=cut.getDeclaredMethod("getVal1");
          getVal1.setAccessible(true);
          getVal2 = cut.getDeclaredMethod("getVal2");
          getVal2.setAccessible(true);
          } catch (ClassNotFoundException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
          } catch (Exception e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
     @Test public void cutIntegertest(){
          //instantiating the class using the argument constructor for Object 1
          Constructor<?> constr1;
          assertNotNull(cut);
          try {
               constr1 = cut.getDeclaredConstructor(Comparable.class,Comparable.class);
               obj1=(ClassUnderTest<Integer>)constr1.newInstance(Integer.valueOf(102),Integer.valueOf(20));
               assertNotNull(obj1);
               print("The object of CUT class instantiated with Integer Type");
               // invoking methods on Object1
          assertEquals(minVal.invoke(obj1),20);
          //Object x = minVal.invoke(obj1);
          print("tested successfully the min of two integers passed");
          assertEquals(maxVal.invoke(obj1),102);
          // maxVal.invoke(obj2);
          //print();
          print("tested successfully the max of two integer values" );
          } catch (Exception e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
@Test public void cutStringTest(){
     assertNotNull(cut);
     Constructor<?> constr2;
          try {
               constr2 = cut.getDeclaredConstructor(Comparable.class,Comparable.class);
               obj2=(ClassUnderTest<String>)constr2.newInstance(String.valueOf(obj1.maxValue().toString()),obj2.minValue().toString());
               //obj2=(ClassUnderTest<String>) cut.newInstance();
               assertNotNull(obj2);
               //assertNotNull("obj1 is not null",obj1);
               //print(obj1.maxValue().toString());
               print("Object 2 instantiated as String type ");
               print("setting values on object2 of type string from values of obj1 of type Integer by using toSting()");
               setVal1.invoke(obj2, obj1.maxValue().toString());
               setVal2.invoke(obj2, obj1.minValue().toString());//obj2.setVal2(obj1.minValue()
               assertEquals(getVal1.invoke(obj2),maxVal.invoke(obj1).toString());
               assertEquals(getVal2.invoke(obj2),minVal.invoke(obj1).toString());
               print("validating the Assert Equals set from object 1 after conversion to String");
               print("MinValue for Object2 when Integer treated as String>>> "+minVal.invoke(obj2));
               print("MaxValue for Object2 when Integer treated as String>>> "+maxVal.invoke(obj2));
          } catch (Exception e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
          //obj2.setVal1(obj1.maxValue()
     private static void print(String str){
          System.out.println(str);
     private String getMethodNames(Method[] methods) {
          StringBuffer sb= new StringBuffer();
          for(Method method: methods){
               sb.append(method.getName()+ " ");
          return sb.toString();
     private String getFieldNames(Field[] fields) {
          StringBuffer sb= new StringBuffer();
          for(Field field: fields){
               sb.append(field.getName()+ " ");
          return sb.toString();
//ClassUnderTest
public class ClassUnderTest <T extends Comparable<T>>{
     //Fields
     private T val1;
     private T val2;
     ClassUnderTest(){}
     public ClassUnderTest(T val1, T val2){
          this.val1=val1;
          this.val2=val2;
     * @return the val1
     public T getVal1() {
          return val1;
     * @param val1 the val1 to set
     public void setVal1(T val1) {
          this.val1 = val1;
     * @return the val2
     public T getVal2() {
          return val2;
     * @param val2 the val2 to set
     public void setVal2(T val2) {
          this.val2 = val2;
     public T maxValue(){
          T max=null;
          if(val1.compareTo(val2) >= 0){
               max= val1;
          }else {
               max= val2;
          return max;
     public T minValue(){
          T min=null;
          if(val1.compareTo(val2) < 0){
               min= val1;
          }else {
               min= val2;
          return min;
This code throws Null Pointer Exception if CutStringtest function(I think on calling obj1 in tht function) Please suggest!

Answer 1

Well, I can't help you specifically since I'm not into reflection too much, but here are some ideas:
* Either learn how to set breakpoints and single step through your code, or pepper your code with a lot more meaningful System.out.println() statements.
* Come up with simple test cases, pass them first, then progressively more complex test cases, until you test all possible situations. Try to get each test case to test only a single concept and not multiple concepts at the same time. If your code is broken on more than one concept, you will not be able to isolate each concept by itself to fix it without separating it.
* Consider refactoring your code so each sub-module accomplishes one task in isolation and verify that module can handle each possible situation that its asked to perform.
* The exception usually tells you what line in your code threw the exception. Look for a line in the exception printout that has the name of your package or class in it.