001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: /**
019: * @author Evgueni V. Brevnov
020: * @version $Revision$
021: */package java.lang.reflect;
022:
023: import java.lang.reflect.Method;
024:
025: import org.apache.harmony.lang.C2;
026: import org.apache.harmony.lang.ProtectedMethod;
027: import org.apache.harmony.lang.ProtectedSuccessor;
028: import org.apache.harmony.test.TestResources;
029:
030: import junit.framework.TestCase;
031:
032: @SuppressWarnings(value={"all"})
033: public class MethodTestInvoke extends TestCase {
034:
035: static class MyException extends RuntimeException {
036: }
037:
038: public static void doFail() {
039: throw new MyException();
040: }
041:
042: /**
043: * Regression test for HARMONY-5179.
044: */
045: public void testLoaderAccess() throws Throwable {
046: ClassLoader l1 = TestResources.createLoader();
047: ClassLoader l2 = TestResources.createLoader();
048: Class c1 = l1
049: .loadClass("org.apache.harmony.lang.test.resource.DefaultMethodInvoker");
050: Class c2 = l2
051: .loadClass("org.apache.harmony.lang.test.resource.DefaultMethodInvoker");
052: Method m1 = c1.getMethod("run", new Class[] { Method.class,
053: Object.class, Object[].class });
054: Method m2 = c2.getMethod("dummy", new Class[] {});
055: try {
056: m1.setAccessible(true);
057: m1.invoke(null, new Object[] { m2, null, null });
058: fail("Access to package methods should be checked with runtime packages");
059: } catch (InvocationTargetException expected) {
060: Throwable cause = expected.getCause();
061: assertTrue("bad cause: " + cause,
062: cause instanceof IllegalAccessException);
063: }
064: }
065:
066: /**
067: * Tests that correct cause of reflection error is provided.
068: */
069: public void testInvocationTargetExceptionCause() throws Exception {
070: try {
071: this .getClass().getMethod("doFail").invoke(null);
072: } catch (InvocationTargetException e) {
073: Throwable cause = e.getCause();
074: assertTrue("Unexpected cause: " + cause,
075: cause instanceof MyException);
076: }
077: }
078:
079: int state = 0;
080:
081: public void test1() {
082: new Inner1().test1();
083: }
084:
085: public void test2() {
086: new Inner2().test2();
087: }
088:
089: public void test3() {
090: int status = 0;
091: try {
092: Method meth = C2.class.getMethod("publicMethod",
093: (Class[]) null);
094: Field statField = C2.class.getField("stat");
095: C2 clazz = new C2();
096: assertEquals(0, clazz.stat);
097: clazz.publicMethod();
098: assertEquals(10, clazz.stat);
099: meth.invoke(clazz, (Object[]) null);
100: status = ((Integer) statField.get(clazz)).intValue();
101: } catch (Exception e) {
102: fail(e.toString());
103: }
104: assertEquals(20, status);
105: }
106:
107: public void test4() {
108: new Inner3().test4();
109: }
110:
111: public void test5() {
112: new Inner4().test5();
113: }
114:
115: /* PRIVATE SECTION */
116:
117: private void privateMethod() {
118: state += 10;
119: }
120:
121: // helper class for test1
122: class Inner1 extends Object {
123:
124: void test1() {
125: try {
126: assertEquals(0, state);
127: privateMethod();
128: assertEquals(10, state);
129: Method method = MethodTestInvoke.class
130: .getDeclaredMethod("privateMethod",
131: (Class[]) null);
132: method.invoke(MethodTestInvoke.this , (Object[]) null);
133: assertEquals(20, state);
134: } catch (Exception e) {
135: fail(e.toString());
136: }
137: }
138: }
139:
140: // helper class for test 2
141: class Inner2 extends ProtectedMethod {
142:
143: public void test2() {
144: Inner2 this Instance = new Inner2();
145: ProtectedMethod super Instance = new ProtectedMethod();
146: Method m = null;
147: try {
148: assertEquals(0, status);
149: assertEquals(0, this Instance.status);
150: assertEquals(0, super Instance.status);
151: m = ProtectedMethod.class.getDeclaredMethod(
152: "protectedMethod", new Class[] {});
153: m.invoke(this Instance, (Object[]) null);
154: } catch (Exception e) {
155: fail(e.toString());
156: }
157: try {
158: assertEquals(0, status);
159: assertEquals(10, this Instance.status);
160: assertEquals(0, super Instance.status);
161: m.invoke(super Instance, (Object[]) null);
162: } catch (IllegalAccessException e) {
163: assertEquals(0, status);
164: assertEquals(10, this Instance.status);
165: assertEquals(0, super Instance.status);
166: return;
167: } catch (Exception e) {
168: }
169: fail("IllegalAccessException expected");
170: }
171: }
172:
173: // helper class for test4
174: class Inner3 {
175:
176: public void test4() {
177: try {
178: Method m = ProtectedMethod.class.getDeclaredMethod(
179: "protectedMethod", new Class[] {});
180: m.invoke(this , (Object[]) null);
181: } catch (IllegalArgumentException e) {
182: return;
183: } catch (Exception e) {
184: fail(e.toString());
185: }
186: fail("IllegalArgumentException expected");
187: }
188: }
189:
190: // helper class for test 5
191: class Inner4 extends ProtectedSuccessor {
192:
193: public void test5() {
194: Method m = null;
195: try {
196: assertEquals(0, status);
197: this .protectedMethod();
198: assertEquals(10, status);
199: m = ProtectedMethod.class.getDeclaredMethod(
200: "protectedMethod", new Class[] {});
201: m.invoke(this , (Object[]) null);
202: } catch (Exception e) {
203: fail(e.toString());
204: }
205: try {
206: assertEquals(20, status);
207: ProtectedSuccessor successor = new ProtectedSuccessor();
208: m = ProtectedSuccessor.class.getDeclaredMethod(
209: "privateMethod", new Class[] {});
210: m.invoke(successor, (Object[]) null);
211: } catch (IllegalAccessException e) {
212: } catch (Exception e) {
213: fail(e.toString());
214: }
215: try {
216: assertEquals(20, status);
217: m = ProtectedSuccessor.class.getDeclaredMethod(
218: "privateMethod", new Class[] {});
219: m.invoke(this , (Object[]) null);
220: } catch (IllegalAccessException e) {
221: } catch (Exception e) {
222: fail(e.toString());
223: }
224: assertEquals(20, status);
225: }
226: }
227: }
|