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: *
015: * See the License for the specific language governing permissions and
016: * limitations under the License.
017: */
018:
019: /**
020: * @author Anatoly F. Bondarenko
021: * @version $Revision: 1.4 $
022: */
023:
024: /**
025: * Created on 18.02.2005
026: */package org.apache.harmony.jpda.tests.jdwp.ReferenceType;
027:
028: import org.apache.harmony.jpda.tests.framework.jdwp.CommandPacket;
029: import org.apache.harmony.jpda.tests.framework.jdwp.JDWPCommands;
030: import org.apache.harmony.jpda.tests.framework.jdwp.ReplyPacket;
031: import org.apache.harmony.jpda.tests.jdwp.share.JDWPSyncTestCase;
032: import org.apache.harmony.jpda.tests.share.JPDADebuggeeSynchronizer;
033:
034: /**
035: * JDWP Unit test for ReferenceType.MethodsWithGeneric command.
036: */
037: public class MethodsWithGenericTest extends JDWPSyncTestCase {
038:
039: static final int testStatusPassed = 0;
040: static final int testStatusFailed = -1;
041: static final String this CommandName = "ReferenceType.MethodsWithGeneric command";
042: static final String debuggeeSignature = "Lorg/apache/harmony/jpda/tests/jdwp/ReferenceType/MethodsWithGenericDebuggee;";
043:
044: protected String getDebuggeeClassName() {
045: return "org.apache.harmony.jpda.tests.jdwp.ReferenceType.MethodsWithGenericDebuggee";
046: }
047:
048: /**
049: * This testcase exercises ReferenceType.ClassObject command.
050: * <BR>The test starts MethodsWithGenericDebuggee class, requests referenceTypeId
051: * for this class by VirtualMachine.ClassesBySignature command, then
052: * performs ReferenceType.MethodsWithGeneric command and checks that returned
053: * list of methods corresponds to expected list of methods with expected attributes.
054: */
055: public void testMethodsWithGeneric001() {
056: String this TestName = "testMethodsWithGeneric001";
057: logWriter.println("==> " + this TestName + " for "
058: + this CommandName + ": START...");
059: int testStatus = testStatusPassed;
060: String failMessage = "";
061: synchronizer
062: .receiveMessage(JPDADebuggeeSynchronizer.SGNL_READY);
063:
064: long refTypeID = getClassIDBySignature(debuggeeSignature);
065:
066: logWriter.println("=> Debuggee class = "
067: + getDebuggeeClassName());
068: logWriter.println("=> referenceTypeID for Debuggee class = "
069: + refTypeID);
070: logWriter.println("=> CHECK: send " + this CommandName
071: + " and check reply...");
072:
073: CommandPacket methodsWithGenericCommand = new CommandPacket(
074: JDWPCommands.ReferenceTypeCommandSet.CommandSetID,
075: JDWPCommands.ReferenceTypeCommandSet.MethodsWithGenericCommand);
076: methodsWithGenericCommand
077: .setNextValueAsReferenceTypeID(refTypeID);
078:
079: ReplyPacket methodsWithGenericReply = debuggeeWrapper.vmMirror
080: .performCommand(methodsWithGenericCommand);
081: methodsWithGenericCommand = null;
082: checkReplyPacket(methodsWithGenericReply, this CommandName);
083:
084: int returnedMethodsNumber = methodsWithGenericReply
085: .getNextValueAsInt();
086: logWriter.println("=> Returned methods number = "
087: + returnedMethodsNumber);
088:
089: String methodNames[] = { "staticTestMethod",
090: "objectTestMethod", "run", "main", "<init>" };
091:
092: String methodSignatures[] = { "(D)Z",
093: "(Ljava/util/Collection;)Ljava/lang/Object;", "()V",
094: "([Ljava/lang/String;)V", "()V" };
095:
096: String methodGenericSignatures[] = { "", "", "", "", "" };
097:
098: int methodModifiers[] = { 0x8, // ACC_STATIC flag
099: 0x0, 0x1, // ACC_PUBLIC flag
100: 0x9, // ACC_STATIC | ACC_PUBLIC flags
101: 0x1 // ACC_PUBLIC flag
102: };
103:
104: boolean methodFound[] = { false, false, false, false, false };
105: int expectedMetodsNumber = methodNames.length;
106: int methodSyntheticFlag = 0xf0000000;
107:
108: logWriter.println("=> CHECK for all expected methods...");
109: for (int i = 0; i < returnedMethodsNumber; i++) {
110: long returnedMethodID = methodsWithGenericReply
111: .getNextValueAsMethodID();
112: String returnedMethodName = methodsWithGenericReply
113: .getNextValueAsString();
114: String returnedMethodSignature = methodsWithGenericReply
115: .getNextValueAsString();
116: String returnedGenericSignature = methodsWithGenericReply
117: .getNextValueAsString();
118: int returnedMethodModifiers = methodsWithGenericReply
119: .getNextValueAsInt();
120: logWriter.println("\n=> Method ID = " + returnedMethodID);
121: logWriter.println("=> Method name = " + returnedMethodName);
122: logWriter.println("=> Method signature = \""
123: + returnedMethodSignature + "\"");
124: logWriter.println("=> Method generic signature = \""
125: + returnedGenericSignature + "\"");
126: logWriter.println("=> Method modifiers = 0x"
127: + Integer.toHexString(returnedMethodModifiers));
128: if ((returnedMethodModifiers & methodSyntheticFlag) == methodSyntheticFlag) {
129: continue; // do not check synthetic methods
130: }
131: int k = 0;
132: for (; k < expectedMetodsNumber; k++) {
133: if (!methodNames[k].equals(returnedMethodName)) {
134: continue;
135: }
136: if (methodFound[k]) {
137: logWriter
138: .println("\n## FAILURE: The method is found out repeatedly in the list");
139: logWriter.println("## Method name = "
140: + returnedMethodName);
141: testStatus = testStatusFailed;
142: failMessage = failMessage
143: + "The method is found repeatedly in the list: "
144: + returnedMethodName + ";\n";
145: break;
146: }
147: methodFound[k] = true;
148: if (!methodSignatures[k]
149: .equals(returnedMethodSignature)) {
150: logWriter
151: .println("\n## FAILURE: Unexpected method signature is returned:");
152: logWriter.println("## Method name = "
153: + returnedMethodName);
154: logWriter.println("## Expected signature = "
155: + methodSignatures[k]);
156: logWriter.println("## Returned signature = "
157: + returnedMethodSignature);
158: testStatus = testStatusFailed;
159: failMessage = failMessage
160: + "Unexpected method signature is returned:"
161: + ", Method = " + returnedMethodName
162: + ", Expected = " + methodSignatures[k]
163: + ", Returned = " + returnedMethodSignature
164: + ";\n";
165: }
166: if (!methodGenericSignatures[k]
167: .equals(returnedGenericSignature)) {
168: logWriter
169: .println("\n## FAILURE: Unexpected method generic signature is returned:");
170: logWriter.println("## Method name = "
171: + returnedMethodName);
172: logWriter
173: .println("## Expected generic signature = "
174: + methodGenericSignatures[k]);
175: logWriter
176: .println("## Returned generic signature = "
177: + returnedGenericSignature);
178: testStatus = testStatusFailed;
179: failMessage = failMessage
180: + "Unexpected method generic signature is returned:"
181: + ", Method = " + returnedMethodName
182: + ", Expected = "
183: + methodGenericSignatures[k]
184: + ", Returned = "
185: + returnedGenericSignature + ";\n";
186: }
187: if (methodModifiers[k] != returnedMethodModifiers) {
188: logWriter
189: .println("\n## FAILURE: Unexpected method modifiers are returned:");
190: logWriter.println("## Method name = "
191: + returnedMethodName);
192: logWriter.println("## Expected modifiers = 0x"
193: + Integer.toHexString(methodModifiers[k]));
194: logWriter
195: .println("## Returned modifiers = 0x"
196: + Integer
197: .toHexString(returnedMethodModifiers));
198: testStatus = testStatusFailed;
199: failMessage = failMessage
200: + "Unexpected method modifiers are returned:"
201: + ", Method name = "
202: + returnedMethodName
203: + ", Expected modifiers = 0x"
204: + Integer.toHexString(methodModifiers[k])
205: + ", Returned modifiers = 0x"
206: + Integer
207: .toHexString(returnedMethodModifiers)
208: + ";\n";
209: }
210: break;
211: }
212: if (k == expectedMetodsNumber) {
213: // returned method is not found out in the list of expected methos
214: logWriter
215: .println("\n## FAILURE: It is found out unexpected returned method:");
216: logWriter.println("## Method name = "
217: + returnedMethodName);
218: logWriter.println("## Method signature = "
219: + returnedMethodSignature);
220: logWriter.println("## Method generic signature = "
221: + returnedGenericSignature);
222: logWriter.println("## Method modifiers = 0x"
223: + Integer.toHexString(returnedMethodModifiers));
224: testStatus = testStatusFailed;
225: failMessage = failMessage
226: + "Unexpected method has been found: "
227: + ", name = " + returnedMethodName
228: + ", signature = " + returnedMethodSignature
229: + ", generic signature = "
230: + returnedGenericSignature + ", modifiers = 0x"
231: + Integer.toHexString(returnedMethodModifiers)
232: + ";\n";
233: }
234: }
235:
236: for (int k = 0; k < expectedMetodsNumber; k++) {
237: if (!methodFound[k]) {
238: logWriter
239: .println("\n## FAILURE: Expected method is NOT found out in the list of retuned methods:");
240: logWriter.println("## Method name = " + methodNames[k]);
241: testStatus = testStatusFailed;
242: failMessage = failMessage
243: + "Expected method is NOT found in the list of retuned methods: "
244: + " name = " + methodNames[k];
245: }
246: }
247:
248: if (testStatus == testStatusPassed) {
249: logWriter
250: .println("=> CHECK PASSED: All expected methods are found out and have expected attributes");
251: }
252:
253: assertAllDataRead(methodsWithGenericReply);
254:
255: synchronizer
256: .sendMessage(JPDADebuggeeSynchronizer.SGNL_CONTINUE);
257: logWriter.println("==> " + this TestName + " for "
258: + this CommandName + ": FINISH");
259:
260: if (testStatus == testStatusFailed) {
261: fail(failMessage);
262: }
263: }
264:
265: public static void main(String[] args) {
266: junit.textui.TestRunner.run(MethodsWithGenericTest.class);
267: }
268: }
|