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