1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *
15 *  See the License for the specific language governing permissions and
16 *  limitations under the License.
17 */
18
19/**
20 * @author Anton V. Karnachuk
21 */
22
23/**
24 * Created on 24.02.2005
25 */
26package org.apache.harmony.jpda.tests.jdwp.StackFrame;
27
28import org.apache.harmony.jpda.tests.framework.jdwp.CommandPacket;
29import org.apache.harmony.jpda.tests.framework.jdwp.JDWPCommands;
30import org.apache.harmony.jpda.tests.framework.jdwp.JDWPConstants;
31import org.apache.harmony.jpda.tests.framework.jdwp.ReplyPacket;
32import org.apache.harmony.jpda.tests.framework.jdwp.TaggedObject;
33import org.apache.harmony.jpda.tests.share.JPDADebuggeeSynchronizer;
34
35
36/**
37 * JDWP Unit test for StackFrame.ThisObject command.
38 */
39public class ThisObjectTest extends JDWPStackFrameTestCase {
40
41    public static String[] KNOWN_METHOD_NAMES = {
42        "nestledMethod1",
43        "nestledMethod2",
44        "nestledMethod3",
45    };
46
47    /**
48     * This testcase exercises StackFrame.ThisObject command.
49     * <BR>The test starts StackTraceDebuggee and
50     * checks if StackFrame.ThisObject command returns correct data for each stack frame
51     * of main thread in debuggee, taking into account calls to known methods.
52     */
53    public void testThisObjectTest001() {
54        logWriter.println("==> ThisObjectTestTest001 started");
55        //boolean success = true;
56
57        // select main thread
58        String mainThreadName = synchronizer.receiveMessage();
59        logWriter.println("==> Searching for main thread by name: " + mainThreadName);
60        long mainThread = debuggeeWrapper.vmMirror.getThreadID(mainThreadName);
61        logWriter.println("==> Found main thread: " + mainThread);
62
63        // release on run()
64        synchronizer.sendMessage(JPDADebuggeeSynchronizer.SGNL_CONTINUE);
65
66        // pass nestledMethod1()
67        synchronizer.receiveMessage(JPDADebuggeeSynchronizer.SGNL_READY);
68        synchronizer.sendMessage(JPDADebuggeeSynchronizer.SGNL_CONTINUE);
69
70        // pass nestledMethod2()
71        synchronizer.receiveMessage(JPDADebuggeeSynchronizer.SGNL_READY);
72        synchronizer.sendMessage(JPDADebuggeeSynchronizer.SGNL_CONTINUE);
73
74        // enter nestledMethod3()
75        synchronizer.receiveMessage(JPDADebuggeeSynchronizer.SGNL_READY);
76
77        if ( mainThread == -1 ) {
78            logWriter.println("## FAILURE: main thread is not found!");
79            //assert True(false);
80            fail("main thread is not found!");
81        }
82
83        // suspend thread
84        logWriter.println("==> Suspending main thread");
85        jdwpSuspendThread(mainThread);
86
87        logWriter.println("==> Getting frames count");
88        int frameCount = jdwpGetFrameCount(mainThread);
89        logWriter.println("==> frames count = " + frameCount);
90
91        logWriter.println("==> Getting frames");
92        FrameInfo[] frameIDs = jdwpGetFrames(mainThread, 0, frameCount);
93        logWriter.println("==> frames count = " + frameIDs.length);
94        assertEquals("Invalid number of frames,", frameCount, frameIDs.length);
95        //assertTrue(frameIDs.length == frameCount);
96
97        for (int i = 0; i < frameCount; i++) {
98            logWriter.println("\n==> frame #" + i);
99
100            long frameID = frameIDs[i].frameID;
101            logWriter.println("==> frameID=" + frameID);
102            if (frameID == 0) {
103                logWriter.println("## FAILURE: ThreadReference.Frames returned NULL FrameID for frame #" + i);
104                //success = false;
105                fail("ThreadReference.Frames returned NULL FrameID for frame #" + i);
106                continue;
107            }
108
109            // logWriter.println("  location=" + frameIDs[i].location);
110
111            String methodName = debuggeeWrapper.vmMirror.getMethodName(frameIDs[i].location.classID, frameIDs[i].location.methodID);
112            logWriter.println("==> method name=" + methodName);
113
114            String methodSig = debuggeeWrapper.vmMirror.getMethodSignature(frameIDs[i].location.classID, frameIDs[i].location.methodID);
115            logWriter.println("==> method signature=" + methodSig);
116
117            String classSig = debuggeeWrapper.vmMirror.getClassSignature(frameIDs[i].location.classID);
118            logWriter.println("==> class signature=" + classSig);
119
120            // get ThisObject
121            logWriter.println("==> Send StackFrame::ThisObject command...");
122            CommandPacket packet = new CommandPacket(
123                    JDWPCommands.StackFrameCommandSet.CommandSetID,
124                    JDWPCommands.StackFrameCommandSet.ThisObjectCommand);
125            packet.setNextValueAsThreadID(mainThread);
126            packet.setNextValueAsLong(frameIDs[i].getFrameID());
127
128            ReplyPacket reply = debuggeeWrapper.vmMirror.performCommand(packet);
129            long knownMethodsThisObject = 0;
130            if (reply.getErrorCode() == JDWPConstants.Error.NONE) {
131                TaggedObject thisObject = reply.getNextValueAsTaggedObject();
132                logWriter.println("==> thisObject:");
133                logWriter.println("==> tag=" + thisObject.tag + "("
134                        + JDWPConstants.Tag.getName(thisObject.tag) + ")");
135                logWriter.println("==> id=" + thisObject.objectID);
136                if (thisObject.objectID != 0) {
137                    long classID = getObjectReferenceType(thisObject.objectID);
138                    logWriter.println("==> class=" + debuggeeWrapper.vmMirror.getClassSignature(classID));
139                }
140
141                for (int j = 0; j < KNOWN_METHOD_NAMES.length; j++) {
142                    if (KNOWN_METHOD_NAMES[j].equals(methodName)) {
143                        logWriter.println("==> frame for known method: " + KNOWN_METHOD_NAMES[j]);
144                        if (thisObject.objectID == 0) {
145                            logWriter.println
146                            ("## FAILURE: StackFrame.ThisObject returned NULL ObjectID for known method: " + methodName);
147                            //success = false;
148                            fail("StackFrame.ThisObject returned NULL ObjectID for known method: " + methodName);
149                        } else {
150                            if ( knownMethodsThisObject != 0 ) {
151                                if ( knownMethodsThisObject != thisObject.objectID ) {
152                                    logWriter.println
153                                    ("## FAILURE: Returned unexpected ObjectID for known method: " + methodName);
154                                    logWriter.println
155                                    ("## Expected ObjectID: " + knownMethodsThisObject);
156                                    //success = false;
157                                    fail("Returned unexpected ObjectID for known method: " + methodName);
158                                }
159                            } else {
160                                knownMethodsThisObject = thisObject.objectID;
161                            }
162                        }
163                        if (thisObject.tag != JDWPConstants.Tag.OBJECT_TAG) {
164                            logWriter.println
165                            ("## FAILURE: StackFrame.ThisObject returned not OBJECT_TAG for known method: " + methodName);
166                            //success = false;
167                            fail("StackFrame.ThisObject returned not OBJECT_TAG for known method: " + methodName);
168                        }
169                    }
170                }
171
172                String mainMethod = "main";
173                if (mainMethod.equals(methodName)) {
174                    logWriter.println("==> frame for method: " + mainMethod);
175                    if (thisObject.objectID != 0) {
176                        logWriter.println
177                        ("## FAILURE: Returned unexpected ObjectID for method: " + mainMethod);
178                        logWriter.println
179                        ("## Expected ObjectID: " + 0);
180                        //success = false;
181                        fail("Returned unexpected ObjectID for method: " + mainMethod);
182                    }
183                    if (thisObject.tag != JDWPConstants.Tag.OBJECT_TAG) {
184                        logWriter.println
185                        ("## FAILURE: StackFrame.ThisObject returned not OBJECT_TAG for method: " + mainMethod);
186                        //success = false;
187                        fail("StackFrame.ThisObject returned not OBJECT_TAG for method: " + mainMethod);
188                    }
189                }
190
191                assertAllDataRead(reply);
192
193            } else {
194                logWriter.println
195                ("## FAILURE: StackFrame::ThisObject command returns unexpected ERROR = "
196                        + reply.getErrorCode()
197                        + "(" + JDWPConstants.Error.getName(reply.getErrorCode()) + ")");
198                logWriter.println("## Expected ERROR = " + JDWPConstants.Error.NONE
199                        + "(" + JDWPConstants.Error.getName(JDWPConstants.Error.NONE) + ")");
200                //success = false;
201                fail("StackFrame::ThisObject command returns unexpected ERROR = " + reply.getErrorCode()
202                        + "(" + JDWPConstants.Error.getName(reply.getErrorCode()) + ")"
203                        + ", Expected ERROR = " + JDWPConstants.Error.NONE
204                        + "(" + JDWPConstants.Error.getName(JDWPConstants.Error.NONE) + ")");
205            }
206        }
207
208        // resume thread
209        logWriter.println("==> Resuming main thread");
210        jdwpResumeThread(mainThread);
211
212        // release nestledMethod3()
213        synchronizer.sendMessage(JPDADebuggeeSynchronizer.SGNL_CONTINUE);
214
215        //assertTrue(success);
216        logWriter.println("==> ThisObjectTestTest001 finished");
217    }
218}
219