tests/regression/resolving/TestController.java

   1 import java.util.Vector;
   2 import java.lang.reflect.Method;
   3 import java.lang.reflect.InvocationTargetException;
   4
   5 public class TestController {
   6
   7     boolean report_class_ids_ = false;
   8     Vector expectations_ = new Vector();
   9     boolean failed_ = false;
  10
  11     class Expectation {
  12         String tag_;
  13         String loader1_;
  14         String loader2_;
  15         String class_;
  16
  17         public Expectation(String tag, String ld1, String ld2, String cls) {
  18             tag_ = tag;
  19             loader1_ = ld1;
  20             loader2_ = ld2;
  21             class_ = cls;
  22         }
  23
  24         public Expectation(String tag, String ld1, String cls) {
  25             this(tag, ld1, null, cls);
  26         }
  27
  28         public boolean matches(String tag, String ld1, String ld2, String cls) {
  29             return tag_.equals(tag)
  30                 && loader1_.equals(ld1)
  31                 && ((loader2_ == ld2) || ((loader2_ != null) && (ld2 != null) && loader2_.equals(ld2)))
  32                 && class_.equals(cls);
  33         }
  34     }
  35
  36     public void setReportClassIDs(boolean rep) {
  37         report_class_ids_ = rep;
  38     }
  39
  40     void expect(Expectation exp) {
  41         expectations_.add(exp);
  42     }
  43
  44     void expect(String tag, String loader, String classname) {
  45         expect(new Expectation(tag, loader, classname));
  46     }
  47
  48     void expect(String tag, String loader1, String loader2, String classname) {
  49         expect(new Expectation(tag, loader1, loader2, classname));
  50     }
  51
  52     public void expect(String tag, ClassLoader loader, String classname) {
  53         expect(tag, loaderName(loader), classname);
  54     }
  55
  56     public void expect(String tag, ClassLoader loader1, ClassLoader loader2, String classname) {
  57         expect(tag, loaderName(loader1), loaderName(loader2), classname);
  58     }
  59
  60     public void expectLoadFromSystem(ClassLoader loader, String classname) {
  61         expect("requested", loader, classname);
  62         expect("delegated", loader, ClassLoader.getSystemClassLoader(), classname);
  63         expect("loaded", loader, "<" + classname + ">");
  64     }
  65
  66     public void expectDelegationAndDefinition(ClassLoader loader1, ClassLoader loader2, String classname) {
  67         expect("requested", loader1, classname);
  68         expect("delegated", loader1, loader2, classname);
  69         expect("requested", loader2, classname);
  70         expect("defined", loader2, "<" + classname + ">");
  71         expect("loaded", loader1, "<" + classname + ">");
  72     }
  73
  74     public void expectDelegationAndFound(ClassLoader loader1, ClassLoader loader2, String classname) {
  75         expect("requested", loader1, classname);
  76         expect("delegated", loader1, loader2, classname);
  77         expect("requested", loader2, classname);
  78         expect("found", loader2, "<" + classname + ">");
  79         expect("loaded", loader1, "<" + classname + ">");
  80     }
  81
  82     void fail(String message) {
  83         log("FAIL: " + message);
  84         failed_ = true;
  85     }
  86
  87     void ok(String message) {
  88         log("ok: " + message);
  89     }
  90
  91     void fail(String message, String tag, String ld1, String ld2, String cls) {
  92         fail(message + ": " + tag + " " + ld1 + " " + ld2 + " class=" + cls);
  93     }
  94
  95     void ok(String tag, String ld1, String ld2, String cls) {
  96         ok(tag + " " + ld1 + " " + ld2 + " class=" + cls);
  97     }
  98
  99     public void expectEnd() {
 100         if (expectations_.size() != 0)
 101             fail("missing reports");
 102         else
 103             ok("got all expected reports");
 104     }
 105
 106     public void checkStringGetter(Class cls, String methodname, String expected) {
 107         String id = invokeStringGetter(cls, methodname);
 108         if (id == null)
 109             fail("could not get return value of " + methodname + "()");
 110         else if (id.equals(expected))
 111             ok("returned string matches: " + id);
 112         else
 113             fail("wrong string returned: " + id + ", expected: " + expected);
 114     }
 115
 116     public void checkStringGetterMustFail(Class cls, String methodname) {
 117         String id = invokeStringGetter(cls, methodname);
 118         if (id == null)
 119             ok("method invocation failed as expected: " + methodname + "()");
 120         else
 121             fail("method invocation did not fail as expected: " + methodname + "()");
 122     }
 123
 124     public void checkClassId(Class cls, String expected) {
 125         String id = getClassId(cls);
 126         if (id == null)
 127             fail("could not get class id");
 128         else if (id.equals(expected))
 129             ok("class id matches: " + id);
 130         else
 131             fail("wrong class id: " + id + ", expected: " + expected);
 132     }
 133
 134     public synchronized void match(String tag, String ld1, String ld2, String cls) {
 135         if (expectations_.size() == 0) {
 136             fail("unexpected", tag, ld1, ld2, cls);
 137         }
 138         else {
 139             Expectation exp = (Expectation) expectations_.firstElement();
 140
 141             if (exp.matches(tag, ld1, ld2, cls)) {
 142                 expectations_.remove(0);
 143                 ok(tag, ld1, ld2, cls);
 144             }
 145             else {
 146                 fail("unexpected", tag, ld1, ld2, cls);
 147             }
 148         }
 149     }
 150
 151     void report(String tag, String loader, String classname) {
 152         match(tag, loader, null, classname);
 153     }
 154
 155     void report(String tag, String loader1, String loader2, String classname) {
 156         match(tag, loader1, loader2, classname);
 157     }
 158
 159     void report(String tag, ClassLoader loader, String classname) {
 160         report(tag, loaderName(loader), classname);
 161     }
 162
 163     void report(String tag, ClassLoader loader, Class cls) {
 164         report(tag, loaderName(loader), className(cls));
 165     }
 166
 167     void report(String tag, ClassLoader loader1, ClassLoader loader2, String classname) {
 168         report(tag, loaderName(loader1), loaderName(loader2), classname);
 169     }
 170
 171     public void reportRequest(ClassLoader loader, String classname) {
 172         report("requested", loader, classname);
 173     }
 174
 175     public void reportUnexpectedClassRequested(ClassLoader loader, String classname) {
 176         report("unexpected class requested", loader, classname);
 177     }
 178
 179     public void reportDelegation(ClassLoader loader, ClassLoader delegate, String classname) {
 180         report("delegated", loaderName(loader), loaderName(delegate), classname);
 181     }
 182
 183     public void reportDefinition(ClassLoader loader, Class cls) {
 184         report("defined", loaderName(loader), className(cls));
 185     }
 186
 187     public void reportFoundLoaded(ClassLoader loader, Class cls) {
 188         report("found", loaderName(loader), className(cls));
 189     }
 190
 191     public void reportLoaded(ClassLoader loader, Class cls) {
 192         report("loaded", loaderName(loader), className(cls));
 193     }
 194
 195     public void reportClassNotFound(ClassLoader loader, String classname, ClassNotFoundException e) {
 196         report("class not found", loaderName(loader), classname);
 197     }
 198
 199     public void reportException(Class cls, Throwable ex) {
 200         report("exception", ex.getClass().getName(), className(cls));
 201         log("exception was: " + ex);
 202         // ex.printStackTrace(System.out);
 203     }
 204
 205     public Class loadClass(ClassLoader loader, String classname) {
 206         try {
 207             Class cls = loader.loadClass(classname);
 208
 209             reportLoaded(loader, cls);
 210
 211             return cls;
 212         }
 213         catch (ClassNotFoundException e) {
 214             reportClassNotFound(loader, classname, e);
 215         }
 216
 217         return null;
 218     }
 219
 220     public void log(String str) {
 221         System.out.println(str);
 222     }
 223
 224     public String loaderName(ClassLoader loader) {
 225         if (loader == ClassLoader.getSystemClassLoader())
 226             return "<SystemClassLoader>";
 227
 228         return (loader == null) ? "<null>" : loader.toString();
 229     }
 230
 231     public String invokeStringGetter(Class cls, String methodname) {
 232         try {
 233             Method mid = cls.getMethod(methodname, null);
 234
 235             String id = (String) mid.invoke(null, null);
 236
 237             return id;
 238         }
 239         catch (NoSuchMethodException e) {
 240             return null;
 241         }
 242         catch (InvocationTargetException e) {
 243             reportException(cls, e.getCause());
 244             return null;
 245         }
 246         catch (Exception e) {
 247             reportException(cls, e);
 248             return null;
 249         }
 250     }
 251
 252     public String getClassId(Class cls) {
 253         return invokeStringGetter(cls, "id");
 254     }
 255
 256     public String className(Class cls) {
 257         if (report_class_ids_) {
 258             String id = getClassId(cls);
 259             if (id != null)
 260                 return "<" + cls.getName() + ":" + id + ">";
 261         }
 262
 263         return "<" + cls.getName() + ">";
 264     }
 265
 266     public void exit() {
 267         expectEnd();
 268         System.exit(failed_ ? 1 : 0);
 269     }
 270
 271 }
 272
 273 // vim: et sw=4