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.TestTargets;
20import dalvik.annotation.TestLevel;
21import dalvik.annotation.TestTargetNew;
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    @TestTargetNew(
46        level = TestLevel.COMPLETE,
47        notes = "",
48        method = "StackTraceElement",
49        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, int.class}
50    )
51    public void
52    test_ConstructorLjava_lang_StringLjava_lang_StringLjava_lang_StringI() {
53        StackTraceElement ste2 = null;
54        try {
55            original.pureJavaMethod(new Object());
56        } catch (Exception e) {
57            StackTraceElement ste1 = e.getStackTrace()[0];
58            ste2 = new StackTraceElement(ste1.getClassName(),
59                    ste1.getMethodName(),
60                    ste1.getFileName(),
61                    ste1.getLineNumber());
62            assertEquals("Incorrect value of class name",
63                    ste1.getClassName(), ste2.getClassName());
64            assertEquals("Incorrect value of method name",
65                    ste1.getMethodName(), ste2.getMethodName());
66            assertEquals("Incorrect value of file name",
67                    ste1.getFileName(), ste2.getFileName());
68            assertEquals("Incorrect value of line number",
69                    ste1.getLineNumber(), ste2.getLineNumber());
70        }
71        assertNotNull("Incorrect stack trace object", ste2);
72        try {
73            new StackTraceElement(null,
74                    ste2.getMethodName(),
75                    ste2.getFileName(),
76                    ste2.getLineNumber());
77            fail("Expected NullPointerException was not thrown");
78        } catch (NullPointerException e) {
79            // expected
80        }
81        try {
82            new StackTraceElement(ste2.getClassName(),
83                    null,
84                    ste2.getFileName(),
85                    ste2.getLineNumber());
86            fail("Expected NullPointerException was not thrown");
87        } catch (NullPointerException e) {
88            // expected
89        }
90        try {
91            new StackTraceElement(ste2.getClassName(),
92                    ste2.getMethodName(),
93                    null,
94                    ste2.getLineNumber());
95        } catch (NullPointerException e) {
96            fail("Unexpected exception " + e.toString());
97        }
98    }
99
100    /**
101     * @tests java.lang.StackTraceElement#equals(java.lang.Object)
102     */
103    @TestTargetNew(
104        level = TestLevel.COMPLETE,
105        notes = "",
106        method = "equals",
107        args = {java.lang.Object.class}
108    )
109    public void test_equalsLjava_lang_Object() {
110        try {
111            original.pureJavaMethod(new Object());
112        } catch (Exception e) {
113            StackTraceElement ste1 = e.getStackTrace()[0];
114            StackTraceElement ste2 =
115                new StackTraceElement(ste1.getClassName(),
116                        ste1.getMethodName(),
117                        ste1.getFileName(),
118                        ste1.getLineNumber());
119            assertEquals("Objects are equaled", ste1, ste2);
120        }
121    }
122
123    /**
124     * @tests java.lang.StackTraceElement#getClassName()
125     */
126    @TestTargetNew(
127        level = TestLevel.COMPLETE,
128        notes = "",
129        method = "getClassName",
130        args = {}
131    )
132    public void test_getClassName() {
133        try {
134            original.pureJavaMethod(new Object());
135        } catch (Exception e) {
136            assertEquals("Incorrect class name",
137                    getClass().getPackage().getName() +
138                    ".StackTraceElementOriginal",
139                    e.getStackTrace()[0].getClassName());
140            assertEquals("Incorrect class name",
141                    getClass().getPackage().getName() +
142                    ".StackTraceElementTest",
143                    e.getStackTrace()[1].getClassName());
144        }
145    }
146
147    /**
148     * @tests java.lang.StackTraceElement#getFileName()
149     */
150    @TestTargetNew(
151        level = TestLevel.COMPLETE,
152        notes = "",
153        method = "getFileName",
154        args = {}
155    )
156    public void test_getFileName() {
157        try {
158            original.pureJavaMethod(new Object());
159        } catch (Exception e) {
160            assertEquals("Incorrect file name",
161                    "StackTraceElementOriginal.java",
162                    e.getStackTrace()[0].getFileName());
163            assertEquals("Incorrect file name",
164                    "StackTraceElementTest.java",
165                    e.getStackTrace()[1].getFileName());
166        }
167    }
168
169    /**
170     * @tests java.lang.StackTraceElement#getLineNumber()
171     */
172    @TestTargetNew(
173        level = TestLevel.COMPLETE,
174        notes = "",
175        method = "getLineNumber",
176        args = {}
177    )
178    public void test_getLineNumber() {
179        try {
180            original.pureJavaMethod(new Object());
181        } catch (Exception e) {
182            assertEquals("Incorrect line number",
183                    26, e.getStackTrace()[0].getLineNumber());
184        }
185    }
186
187    /**
188     * @tests java.lang.StackTraceElement#getMethodName()
189     */
190    @TestTargetNew(
191        level = TestLevel.COMPLETE,
192        notes = "",
193        method = "getMethodName",
194        args = {}
195    )
196    public void test_getMethodName() {
197        try {
198            original.pureJavaMethod(new Object());
199        } catch (Exception e) {
200            assertEquals("Incorrect method name",
201                    "pureJavaMethod",
202                    e.getStackTrace()[0].getMethodName());
203            assertEquals("Incorrect method name",
204                    "test_getMethodName",
205                    e.getStackTrace()[1].getMethodName());
206        }
207    }
208
209    /**
210     * @tests java.lang.StackTraceElement#hashCode()
211     */
212    @TestTargetNew(
213        level = TestLevel.COMPLETE,
214        notes = "",
215        method = "hashCode",
216        args = {}
217    )
218    public void test_hashCode() {
219        try {
220            original.pureJavaMethod(new Object());
221        } catch (Exception e) {
222            StackTraceElement ste1 = e.getStackTrace()[0];
223            StackTraceElement ste2 =
224                new StackTraceElement(ste1.getClassName(),
225                        ste1.getMethodName(),
226                        ste1.getFileName(),
227                        ste1.getLineNumber());
228            assertEquals("Incorrect value of hash code",
229                    ste1.hashCode(), ste2.hashCode());
230            assertFalse("Incorrect value of hash code",
231                    ste1.hashCode() == e.getStackTrace()[1].hashCode());
232        }
233    }
234
235    /**
236     * @tests java.lang.StackTraceElement#isNativeMethod()
237     */
238    @TestTargetNew(
239        level = TestLevel.COMPLETE,
240        notes = "",
241        method = "isNativeMethod",
242        args = {}
243    )
244    public void test_isNativeMethod() {
245        try {
246            original.pureJavaMethod(new Object());
247        } catch (Exception e) {
248            assertFalse("Incorrect method type",
249                    e.getStackTrace()[0].isNativeMethod());
250        }
251        try {
252            original.pureNativeMethod(new Object());
253        } catch (Error e) {
254            assertTrue("Incorrect method type",
255                    e.getStackTrace()[0].isNativeMethod());
256        }
257    }
258
259    /**
260     * @tests java.lang.StackTraceElement#toString()
261     */
262    @TestTargetNew(
263        level = TestLevel.COMPLETE,
264        notes = "",
265        method = "toString",
266        args = {}
267    )
268    public void test_toString() {
269        try {
270            original.pureJavaMethod(new Object());
271        } catch (Exception e) {
272            StackTraceElement ste = e.getStackTrace()[0];
273            assertTrue("String representation doesn't contain a package name",
274                    ste.toString().contains(getClass().getPackage().getName()));
275            assertTrue("String representation doesn't contain a class name",
276                    ste.toString().contains("StackTraceElementOriginal"));
277            assertTrue("String representation doesn't contain a file name",
278                    ste.toString().contains("StackTraceElementOriginal.java"));
279            assertTrue("String representation doesn't contain a line number",
280                    ste.toString().contains("26"));
281            assertTrue("String representation doesn't contain a method name",
282                    ste.toString().contains("pureJavaMethod"));
283        }
284    }
285}
286