KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > quilt > cl > TestTransformer


1 /* TestTransformer.java */
2 package org.quilt.cl;
3
4 import java.io.*;
5 import java.lang.Class JavaDoc;
6 import java.lang.reflect.*;
7 import java.net.*;
8 import junit.framework.*;
9
10 /**
11  * A somewhat prettified TestQuiltClassLoader with transforming
12  * enabled.
13  *
14  * XXX KNOWN PROBLEMS: NestedTryBlocks and SuperClass generate
15  * control flow graphs with serious errors.
16  *
17  * @author <a HREF="jddixon@users.sourceforge.net">Jim Dixon</a>
18  */
19 public class TestTransformer extends TestCase {
20
21     private URL [] cp = null;
22
23     private String JavaDoc[] delegating = {
24         // NOTHING beyond standard defaults
25 };
26     // we want everything to be instrumented
27 private String JavaDoc[] include = {
28         "test.data.",
29         "AnonymousClass", "AnonymousClass2Catches",
30         "BasicLoad",
31         "ExceptionLoad", "ExceptionThrow",
32         "InnerClass", "NestedTryBlocks",
33         "PrivateClass", "SuperClass",
34         "Wimple"
35     };
36     private String JavaDoc[] exclude = {
37         // NOTHING
38 };
39
40     private GraphXformer spy;
41     private GraphXformer talker;
42    
43     private QuiltClassLoader qLoader = null;
44
45     public TestTransformer (String JavaDoc name) {
46         super(name);
47     }
48
49
50     public void setUp () {
51         File sam1 = new File ("target/test-data-classes/");
52         String JavaDoc fullPath1 = sam1.getAbsolutePath() + "/";
53         File sam2 = new File ("target/classes");
54         String JavaDoc fullPath2 = sam2.getAbsolutePath() + "/";
55         File sam3 = new File ("target/test-classes");
56         String JavaDoc fullPath3 = sam3.getAbsolutePath() + "/";
57         try {
58             // Terminating slash is required. Relative paths don't
59 // work.
60 URL [] samples = {
61                 new URL ( "file://" + fullPath1),
62                 new URL ( "file://" + fullPath2),
63                 new URL ( "file://" + fullPath3)
64             };
65             cp = samples;
66         } catch (MalformedURLException e) {
67             e.printStackTrace();
68             fail ("problem creating class path");
69         }
70         qLoader = new QuiltClassLoader(
71                         cp,
72                         null, // parent
73 delegating, // delegated classes
74 include, // being instrumented
75 exclude); // do NOT instrument
76
77         // this is sufficient to force graph generation
78 spy = new GraphSpy();
79         qLoader.addGraphXformer(spy);
80         // this makes for a very verbose output
81 // talker = new GraphTalker();
82 // qLoader.addGraphXformer(talker);
83 }
84   public void testLoader() {
85       Class JavaDoc a1 = null;
86       try {
87           a1 = qLoader.loadClass("AnonymousClass");
88       } catch (ClassNotFoundException JavaDoc e) {
89           e.printStackTrace();
90           fail ("Error loading AnonymousClass using loadClass");
91       }
92       assertNotNull("qLoader returned null", a1);
93   }
94  
95     private RunTest loadAsRunTest (String JavaDoc name) {
96         Class JavaDoc clazz = null;
97         try {
98             clazz = qLoader.loadClass(name);
99         } catch (ClassNotFoundException JavaDoc e) {
100             e.printStackTrace();
101             fail ("exception loading " + name + " using loadClass");
102         }
103         RunTest rt = null;
104         try {
105             rt = (RunTest) clazz.newInstance();
106         } catch ( InstantiationException JavaDoc e ) {
107             fail ("InstantiationException instantiating loaded class " + name);
108         } catch ( IllegalAccessException JavaDoc e ) {
109             fail ("IllegalAccessException instantiating loaded class " + name);
110         } catch (ClassCastException JavaDoc e) {
111             fail ("ClassCastException instantiating loaded class " + name);
112         }
113         return rt;
114     }
115     public void testInvokeTestData() {
116         RunTest rt = loadAsRunTest("AnonymousClass");
117         // AnonymousClass.runTest(x) returns x
118 assertEquals ("AnonymousClass isn't working", 47, rt.runTest(47));
119
120         rt = loadAsRunTest("BasicLoad");
121         // BasicLoad.runTest(x) returns x*x
122 assertEquals ("BasicLoad isn't working", 49, rt.runTest(7));
123
124         // XXX causes ClassCastException when instantiating
125 rt = loadAsRunTest("ExceptionLoad");
126         // ExceptionLoad.runTest(x) also returns x*x
127 assertEquals ("ExceptionLoad isn't working", 121, rt.runTest(11));
128     }
129       public void testInvokeTestData2() {
130         RunTest
131             rt = loadAsRunTest("Finally");
132         // Finally.runTest(x) returns -1
133 assertEquals ("Finally isn't working", -1, rt.runTest(11));
134         assertEquals ("Finally isn't working", -1, rt.runTest(1));
135
136         rt = loadAsRunTest("Finally2Catches");
137         // what Finally.runTest(x) returns is a bit complicated ...
138 assertEquals ("Finally2Catches isn't working", 3600, rt.runTest(11));
139
140         rt = loadAsRunTest("InnerClass");
141         // InnerClass.runTest(x) also returns x*x
142 assertEquals ("InnerClass isn't working", 9, rt.runTest(3));
143
144         rt = loadAsRunTest("NestedTryBlocks");
145         assertEquals ("NestedTryBlocks isn't working", 22, rt.runTest(7));
146     }
147
148     public void testInvokeTestData3() {
149         RunTest
150         rt = loadAsRunTest("PrivateClass");
151         // returns 4
152 assertEquals ("PrivateClass isn't working", 4, rt.runTest(7));
153
154         rt = loadAsRunTest("SuperClass");
155         // returns 3*x
156 assertEquals ("SuperClass isn't working", 21, rt.runTest(7));
157         
158         rt = loadAsRunTest("Wimple");
159         // returns ??
160 assertEquals ("Wimple isn't working", 92, rt.runTest(7));
161     }
162
163     public void testInvokeTestData4 () {
164         RunTest
165         rt = loadAsRunTest("ComplicatedConstructor");
166         assertEquals("ComplicatedConstructor isn't working",
167                                                     61, rt.runTest(3));
168         rt = loadAsRunTest("Looper");
169         assertEquals("Looper isn't working", 127008000, rt.runTest(5));
170
171         rt = loadAsRunTest("StaticInit");
172         assertEquals("StaticInit isn't working", 10, rt.runTest(7));
173     }
174
175     // test all synthesized classes
176 public void testSynth () {
177         assertEquals ("synthesizing isn't disabled in loader",
178                 false, qLoader.getSynthEnabled() );
179         qLoader.setSynthEnabled(true);
180         assertEquals ("enabling synthesizing failed",
181                 true, qLoader.getSynthEnabled() );
182
183         RunTest rt = loadAsRunTest("test.data.TestDefault");
184         // testDefault.runTest(x) returns 2 whatever the input is
185 assertEquals ("testDefault isn't working", 2, rt.runTest(47));
186         assertEquals ("testDefault isn't working", 2, rt.runTest(-7));
187
188         rt = loadAsRunTest("test.data.TestIfThen");
189         // testIfThen.runTest(x) returns 3 if x > 0, 5 otherwise
190 assertEquals ("testIfThen isn't working", 3, rt.runTest(47));
191         assertEquals ("testIfThen isn't working", 5, rt.runTest(-7));
192
193         rt = loadAsRunTest("test.data.TestNPEWithCatch");
194         // testNPEWithCatch.runTest(x) always returns 3
195 assertEquals ("testNPEWithCatch isn't working", 3, rt.runTest(47));
196         assertEquals ("testNPEWithCatch isn't working", 3, rt.runTest(-7));
197
198         rt = loadAsRunTest("test.data.TestNPENoCatch");
199         // testNPENoCatch.runTest(x) always throws a NullPointerException
200 int x;
201         try {
202             x = rt.runTest(47);
203             fail ("testNPENoCatch didn't throw exception");
204         } catch (NullPointerException JavaDoc e) {
205             ; // ignore it
206 }
207         try {
208             x = rt.runTest(-7);
209             fail ("testNPENoCatch didn't throw exception");
210         } catch (NullPointerException JavaDoc e) {
211             ; // ignore it
212 }
213
214         rt = loadAsRunTest("test.data.TestSelect");
215         // testSelect.runTest(x) returns
216 // 1 if x == 1; 3 if x == 2; 5 if x == 3; 2 otherwise
217 assertEquals ("testSelect isn't working", 2, rt.runTest(47));
218         assertEquals ("testSelect isn't working", 2, rt.runTest(-7));
219         assertEquals ("testSelect isn't working", 1, rt.runTest(1));
220         assertEquals ("testSelect isn't working", 3, rt.runTest(2));
221         assertEquals ("testSelect isn't working", 5, rt.runTest(3));
222
223         rt = loadAsRunTest("test.data.TestWhile");
224         // testWhile.runTest(x) returns
225 // 0 if x >= 0, x otherwise
226 assertEquals ("testWhile isn't working", 0, rt.runTest(47));
227         assertEquals ("testWhile isn't working",-7, rt.runTest(-7));
228     }
229
230 }
231
Popular Tags