StackTraceElementTest.java revision 89c1feb0a69a7707b271086e749975b3f7acacf7 
1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package org.apache.harmony.luni.tests.java.lang;
18
19import dalvik.annotation.TestInfo;
20import dalvik.annotation.TestLevel;
21import dalvik.annotation.TestTarget;
22import dalvik.annotation.TestTargetClass;
23
24import junit.framework.TestCase;
25
26@TestTargetClass(StackTraceElement.class)
27public class StackTraceElementTest extends TestCase {
28    private StackTraceElementOriginal original;
29
30    @Override
31    protected void setUp() throws Exception {
32        original = new StackTraceElementOriginal();
33        super.setUp();
34    }
35
36    @Override
37    protected void tearDown() throws Exception {
38        super.tearDown();
39    }
40
41    /**
42     * @tests java.lang.StackTraceElement#StackTraceElement(java.lang.String,
43     *     java.lang.String, java.lang.String, int)
44     */
45    @TestInfo(
46      level = TestLevel.COMPLETE,
47      purpose = "",
48      targets = {
49        @TestTarget(
50          methodName = "StackTraceElement",
51          methodArgs = {java.lang.String.class, java.lang.String.class, java.lang.String.class, int.class}
52        )
53    })
54    public void
55    test_ConstructorLjava_lang_StringLjava_lang_StringLjava_lang_StringI() {
56        StackTraceElement ste2 = null;
57        try {
58            original.pureJavaMethod(new Object());
59        } catch (Exception e) {
60            StackTraceElement ste1 = e.getStackTrace()[0];
61            ste2 = new StackTraceElement(ste1.getClassName(),
62                    ste1.getMethodName(),
63                    ste1.getFileName(),
64                    ste1.getLineNumber());
65            assertEquals("Incorrect value of class name",
66                    ste1.getClassName(), ste2.getClassName());
67            assertEquals("Incorrect value of method name",
68                    ste1.getMethodName(), ste2.getMethodName());
69            assertEquals("Incorrect value of file name",
70                    ste1.getFileName(), ste2.getFileName());
71            assertEquals("Incorrect value of line number",
72                    ste1.getLineNumber(), ste2.getLineNumber());
73        }
74        assertNotNull("Incorrect stack trace object", ste2);
75        try {
76            new StackTraceElement(null,
77                    ste2.getMethodName(),
78                    ste2.getFileName(),
79                    ste2.getLineNumber());
80            fail("Expected NullPointerException was not thrown");
81        } catch (NullPointerException e) {
82            // expected
83        }
84        try {
85            new StackTraceElement(ste2.getClassName(),
86                    null,
87                    ste2.getFileName(),
88                    ste2.getLineNumber());
89            fail("Expected NullPointerException was not thrown");
90        } catch (NullPointerException e) {
91            // expected
92        }
93        try {
94            new StackTraceElement(ste2.getClassName(),
95                    ste2.getMethodName(),
96                    null,
97                    ste2.getLineNumber());
98        } catch (NullPointerException e) {
99            fail("Unexpected exception " + e.toString());
100        }
101    }
102
103    /**
104     * @tests java.lang.StackTraceElement#equals(java.lang.Object)
105     */
106    @TestInfo(
107      level = TestLevel.COMPLETE,
108      purpose = "",
109      targets = {
110        @TestTarget(
111          methodName = "equals",
112          methodArgs = {java.lang.Object.class}
113        )
114    })
115    public void test_equalsLjava_lang_Object() {
116        try {
117            original.pureJavaMethod(new Object());
118        } catch (Exception e) {
119            StackTraceElement ste1 = e.getStackTrace()[0];
120            StackTraceElement ste2 =
121                new StackTraceElement(ste1.getClassName(),
122                        ste1.getMethodName(),
123                        ste1.getFileName(),
124                        ste1.getLineNumber());
125            assertEquals("Objects are equaled", ste1, ste2);
126        }
127    }
128
129    /**
130     * @tests java.lang.StackTraceElement#getClassName()
131     */
132    @TestInfo(
133      level = TestLevel.COMPLETE,
134      purpose = "",
135      targets = {
136        @TestTarget(
137          methodName = "getClassName",
138          methodArgs = {}
139        )
140    })
141    public void test_getClassName() {
142        try {
143            original.pureJavaMethod(new Object());
144        } catch (Exception e) {
145            assertEquals("Incorrect class name",
146                    getClass().getPackage().getName() +
147                    ".StackTraceElementOriginal",
148                    e.getStackTrace()[0].getClassName());
149            assertEquals("Incorrect class name",
150                    getClass().getPackage().getName() +
151                    ".StackTraceElementTest",
152                    e.getStackTrace()[1].getClassName());
153        }
154    }
155
156    /**
157     * @tests java.lang.StackTraceElement#getFileName()
158     */
159    @TestInfo(
160      level = TestLevel.COMPLETE,
161      purpose = "",
162      targets = {
163        @TestTarget(
164          methodName = "getFileName",
165          methodArgs = {}
166        )
167    })
168    public void test_getFileName() {
169        try {
170            original.pureJavaMethod(new Object());
171        } catch (Exception e) {
172            assertEquals("Incorrect file name",
173                    "StackTraceElementOriginal.java",
174                    e.getStackTrace()[0].getFileName());
175            assertEquals("Incorrect file name",
176                    "StackTraceElementTest.java",
177                    e.getStackTrace()[1].getFileName());
178        }
179    }
180
181    /**
182     * @tests java.lang.StackTraceElement#getLineNumber()
183     */
184    @TestInfo(
185      level = TestLevel.COMPLETE,
186      purpose = "",
187      targets = {
188        @TestTarget(
189          methodName = "getLineNumber",
190          methodArgs = {}
191        )
192    })
193    public void _test_getLineNumber() {
194        try {
195            original.pureJavaMethod(new Object());
196        } catch (Exception e) {
197            assertEquals("Incorrect line number",
198                    24, e.getStackTrace()[0].getLineNumber());
199        }
200    }
201
202    /**
203     * @tests java.lang.StackTraceElement#getMethodName()
204     */
205    @TestInfo(
206      level = TestLevel.COMPLETE,
207      purpose = "",
208      targets = {
209        @TestTarget(
210          methodName = "getMethodName",
211          methodArgs = {}
212        )
213    })
214    public void test_getMethodName() {
215        try {
216            original.pureJavaMethod(new Object());
217        } catch (Exception e) {
218            assertEquals("Incorrect method name",
219                    "pureJavaMethod",
220                    e.getStackTrace()[0].getMethodName());
221            assertEquals("Incorrect method name",
222                    "test_getMethodName",
223                    e.getStackTrace()[1].getMethodName());
224        }
225    }
226
227    /**
228     * @tests java.lang.StackTraceElement#hashCode()
229     */
230    @TestInfo(
231      level = TestLevel.COMPLETE,
232      purpose = "",
233      targets = {
234        @TestTarget(
235          methodName = "hashCode",
236          methodArgs = {}
237        )
238    })
239    public void test_hashCode() {
240        try {
241            original.pureJavaMethod(new Object());
242        } catch (Exception e) {
243            StackTraceElement ste1 = e.getStackTrace()[0];
244            StackTraceElement ste2 =
245                new StackTraceElement(ste1.getClassName(),
246                        ste1.getMethodName(),
247                        ste1.getFileName(),
248                        ste1.getLineNumber());
249            assertEquals("Incorrect value of hash code",
250                    ste1.hashCode(), ste2.hashCode());
251            assertFalse("Incorrect value of hash code",
252                    ste1.hashCode() == e.getStackTrace()[1].hashCode());
253        }
254    }
255
256    /**
257     * @tests java.lang.StackTraceElement#isNativeMethod()
258     */
259    @TestInfo(
260      level = TestLevel.COMPLETE,
261      purpose = "",
262      targets = {
263        @TestTarget(
264          methodName = "isNativeMethod",
265          methodArgs = {}
266        )
267    })
268    public void test_isNativeMethod() {
269        try {
270            original.pureJavaMethod(new Object());
271        } catch (Exception e) {
272            assertFalse("Incorrect method type",
273                    e.getStackTrace()[0].isNativeMethod());
274        }
275        try {
276            original.pureNativeMethod(new Object());
277        } catch (Error e) {
278            assertTrue("Incorrect method type",
279                    e.getStackTrace()[0].isNativeMethod());
280        }
281    }
282
283    /**
284     * @tests java.lang.StackTraceElement#toString()
285     */
286    @TestInfo(
287      level = TestLevel.COMPLETE,
288      purpose = "",
289      targets = {
290        @TestTarget(
291          methodName = "toString",
292          methodArgs = {}
293        )
294    })
295    public void _test_toString() {
296        try {
297            original.pureJavaMethod(new Object());
298        } catch (Exception e) {
299            StackTraceElement ste = e.getStackTrace()[0];
300            assertTrue("String representation doesn't contain a package name",
301                    ste.toString().contains(getClass().getPackage().getName()));
302            assertTrue("String representation doesn't contain a class name",
303                    ste.toString().contains("StackTraceElementOriginal"));
304            assertTrue("String representation doesn't contain a file name",
305                    ste.toString().contains("StackTraceElementOriginal.java"));
306            assertTrue("String representation doesn't contain a line number",
307                    ste.toString().contains("24"));
308            assertTrue("String representation doesn't contain a method name",
309                    ste.toString().contains("pureJavaMethod"));
310        }
311    }
312}
313