1   /*
2    $Id: DumpClass.java,v 1.22 2005/03/02 08:22:42 jstrachan Exp $
3   
4    Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
5   
6    Redistribution and use of this software and associated documentation
7    ("Software"), with or without modification, are permitted provided
8    that the following conditions are met:
9   
10   1. Redistributions of source code must retain copyright
11      statements and notices.  Redistributions must also contain a
12      copy of this document.
13  
14   2. Redistributions in binary form must reproduce the
15      above copyright notice, this list of conditions and the
16      following disclaimer in the documentation and/or other
17      materials provided with the distribution.
18  
19   3. The name "groovy" must not be used to endorse or promote
20      products derived from this Software without prior written
21      permission of The Codehaus.  For written permission,
22      please contact info@codehaus.org.
23  
24   4. Products derived from this Software may not be called "groovy"
25      nor may "groovy" appear in their names without prior written
26      permission of The Codehaus. "groovy" is a registered
27      trademark of The Codehaus.
28  
29   5. Due credit should be given to The Codehaus -
30      http://groovy.codehaus.org/
31  
32   THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
33   ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
34   NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
35   FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
36   THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
37   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
39   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
41   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
42   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
43   OF THE POSSIBILITY OF SUCH DAMAGE.
44  
45   */
46  
47  package org.codehaus.groovy.classgen;
48  
49  import groovy.lang.Closure;
50  import groovy.lang.MetaClass;
51  
52  import java.util.Iterator;
53  import java.util.List;
54  import java.util.Map;
55  
56  import org.codehaus.groovy.runtime.InvokerHelper;
57  
58  /***
59   * This is a scratch class used to experiment with ASM to see what kind of 
60   * stuff is output for normal Java code
61   * 
62   * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
63   * @version $Revision: 1.22 $
64   */
65  public class DumpClass {
66  
67      private String bar;
68      private String result;
69      private Object x;
70  
71      public String getResult() {
72          return result;
73      }
74  
75      public String getBar() {
76          return bar;
77      }
78  
79      public void setBar(String value) {
80          this.bar = value;
81      }
82  
83      public void iterateOverList() {
84          // equivalent of
85          //        for i in ["a", "b", "c"] {
86          //            System.out.println(i);
87          //        }
88          List list = InvokerHelper.createList(new Object[] { "a", "b", "c" });
89          for (Iterator iter = InvokerHelper.asIterator(list); iter.hasNext();) {
90              Object i = iter.next();
91              InvokerHelper.invokeMethod(System.out, "println", i);
92          }
93      }
94  
95      public void iterateOverMap() {
96          Map map = InvokerHelper.createMap(new Object[] { "a", "x", "b", "y", "c", "z" });
97          for (Iterator iter = InvokerHelper.asIterator(map); iter.hasNext();) {
98              Object i = iter.next();
99              InvokerHelper.invokeMethod(System.out, "println", i);
100         }
101     }
102 
103     public void printValues(Object collection) {
104         for (Iterator iter = InvokerHelper.asIterator(collection); iter.hasNext();) {
105             Object foo = iter.next();
106             InvokerHelper.invokeMethod(System.out, "println", foo);
107         }
108     }
109 
110     public Object emptyMethod() {
111         return null;
112     }
113 
114     public void emptyVoidMethod() {
115     }
116 
117     //    public void testAssertion() {
118     //        assert bar == null;
119     //        assert result == null : "message";
120     //    }
121 
122     public void testGroovyAssertion2() {
123         if (InvokerHelper.compareEqual(bar, "foo")) {
124         }
125         else {
126             InvokerHelper.assertFailed("expression", "message");
127         }
128 
129         bar = "abc";
130 
131         if (InvokerHelper.compareNotEqual(bar, "foo")) {
132         }
133         else {
134             InvokerHelper.assertFailed("expression", "not null");
135         }
136 
137         if (InvokerHelper.compareEqual(bar, "abc")) {
138         }
139         else {
140             InvokerHelper.assertFailed("expression", "not null");
141         }
142     }
143 
144     public void testFieldSet() {
145         if (InvokerHelper.compareNotEqual(x, "foo")) {
146         }
147         else {
148             InvokerHelper.assertFailed("expression", "message");
149         }
150 
151         x = "foo";
152 
153         if (InvokerHelper.compareEqual(x, "foo")) {
154         }
155         else {
156             InvokerHelper.assertFailed("expression", "message");
157         }
158         if (InvokerHelper.compareNotEqual(x, "foo")) {
159         }
160         else {
161             InvokerHelper.assertFailed("expression", "message");
162         }
163     }
164     public void assertFailed() {
165         StringBuffer buffer = new StringBuffer("Exception: ");
166         buffer.append("x = ");
167         buffer.append(x);
168         InvokerHelper.assertFailed(buffer, "message");
169     }
170 
171     public void setLocalVar() {
172         Object x = null;
173         Object i = null;
174         for (Iterator iter = InvokerHelper.asIterator(InvokerHelper.createRange(new Integer(0), new Integer(10), true));
175             iter.hasNext();
176             ) {
177             i = iter.next();
178             x = i;
179         }
180     }
181 
182     public void testGroovyAssertion() {
183         x = "abc";
184         if (InvokerHelper.compareEqual(x, "foo")) {
185         }
186         else {
187             InvokerHelper.assertFailed("expression", "message");
188         }
189     }
190 
191     public void doPlus() {
192         Object z = "abcd";
193         x = InvokerHelper.invokeMethod(z, "length", null);
194     }
195 
196     public void setBoolean() {
197         x = Boolean.TRUE;
198     }
199 
200     public void tryCatch() {
201         try {
202             InvokerHelper.invokeMethod(this, "testGroovyAssertion", null);
203         }
204         catch (AssertionError e) {
205             InvokerHelper.invokeMethod(this, "onException", e);
206         }
207         finally {
208             InvokerHelper.invokeMethod(this, "finallyBlock", null);
209         }
210         InvokerHelper.invokeMethod(this, "afterTryCatch", null);
211     }
212 
213     public void doPrintln() {
214         Object value = InvokerHelper.getProperty(System.class, "out");
215         InvokerHelper.invokeMethod(value, "println", "Hello");
216     }
217 
218     public void doClosure() {
219         x = new Closure(this) {
220             public Object call(Object arguments) {
221                 System.out.println();
222                 return null;
223             }
224 
225             public MetaClass getMetaClass() {
226                 return null;
227             }
228 
229             public void setMetaClass(MetaClass metaClass) {
230             }
231         };
232     }
233 
234     public Object ifDemo() {
235         if (InvokerHelper.compareEqual(bar, "abc")) {
236             return Boolean.TRUE;
237         }
238         else {
239             return Boolean.FALSE;
240         }
241     }
242 
243     public void testWhile() {
244         while (InvokerHelper.compareEqual(bar, "abc")) {
245             System.out.println("Hello");
246         }
247     }
248 
249     public void testDoWhile() {
250         do {
251             System.out.println("Hello");
252         }
253         while (InvokerHelper.compareEqual(bar, "abc"));
254     }
255 }