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.5 $
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.FieldsWithGeneric command.
036: */
037: public class FieldsWithGenericTest extends JDWPSyncTestCase {
038:
039: static final int testStatusPassed = 0;
040: static final int testStatusFailed = -1;
041: static final String this CommandName = "ReferenceType.FieldsWithGeneric command";
042: static final String debuggeeSignature = "Lorg/apache/harmony/jpda/tests/jdwp/ReferenceType/FieldsWithGenericDebuggee;";
043:
044: protected String getDebuggeeClassName() {
045: return "org.apache.harmony.jpda.tests.jdwp.ReferenceType.FieldsWithGenericDebuggee";
046: }
047:
048: /**
049: * This testcase exercises ReferenceType.FieldsWithGeneric command.
050: * <BR>The test starts FieldsWithGenericDebuggee class,
051: * requests referenceTypeId for this class by VirtualMachine.ClassesBySignature
052: * command, then performs ReferenceType.FieldsWithGeneric command
053: * and checks that returned list of fields corresponds to expected list
054: * with expected attributes.
055: */
056: public void testFieldsWithGeneric001() {
057: String this TestName = "testFieldsWithGeneric001";
058: logWriter.println("==> " + this TestName + " for "
059: + this CommandName + ": START...");
060: int testStatus = testStatusPassed;
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 fieldsWithGenericCommand = new CommandPacket(
074: JDWPCommands.ReferenceTypeCommandSet.CommandSetID,
075: JDWPCommands.ReferenceTypeCommandSet.FieldsWithGenericCommand);
076: fieldsWithGenericCommand
077: .setNextValueAsReferenceTypeID(refTypeID);
078:
079: ReplyPacket fieldsWithGenericReply = debuggeeWrapper.vmMirror
080: .performCommand(fieldsWithGenericCommand);
081: fieldsWithGenericCommand = null;
082: checkReplyPacket(fieldsWithGenericReply, this CommandName);
083:
084: int returnedFieldsNumber = fieldsWithGenericReply
085: .getNextValueAsInt();
086: logWriter.println("=> Returned fields number = "
087: + returnedFieldsNumber);
088:
089: String fieldNames[] = { "staticLongField", "stringArrayField",
090: "objectArrayField", "classObjectField" };
091:
092: String fieldSignatures[] = { "J", "[Ljava/lang/String;",
093: "[Ljava/lang/Object;", "Ljava/lang/Class;" };
094:
095: String fieldGenericSignatures[] = { "", "", "", "" };
096:
097: int fieldModifiers[] = { 0x8, // ACC_STATIC flag
098: 0x0, 0x0, 0x0 };
099:
100: boolean fieldFound[] = { false, false, false, false };
101: int expectedFieldsNumber = fieldNames.length;
102: int fieldSyntheticFlag = 0xf0000000;
103: String message = null;
104:
105: logWriter.println("=> CHECK for all expected fields...");
106: for (int i = 0; i < returnedFieldsNumber; i++) {
107: long returnedFieldID = fieldsWithGenericReply
108: .getNextValueAsFieldID();
109: String returnedFieldName = fieldsWithGenericReply
110: .getNextValueAsString();
111: String returnedFieldSignature = fieldsWithGenericReply
112: .getNextValueAsString();
113: String returnedGenericSignature = fieldsWithGenericReply
114: .getNextValueAsString();
115: int returnedFieldModifiers = fieldsWithGenericReply
116: .getNextValueAsInt();
117: logWriter.println("\n=> Field ID = " + returnedFieldID);
118: logWriter.println("=> Field name = " + returnedFieldName);
119: logWriter.println("=> Field signature = \""
120: + returnedFieldSignature + "\"");
121: logWriter.println("=> Field generic signature = \""
122: + returnedGenericSignature + "\"");
123: logWriter.println("=> Field modifiers = 0x"
124: + Integer.toHexString(returnedFieldModifiers));
125: if ((returnedFieldModifiers & fieldSyntheticFlag) == fieldSyntheticFlag) {
126: continue; // do not check synthetic fields
127: }
128: int k = 0;
129: for (; k < expectedFieldsNumber; k++) {
130: if (!fieldNames[k].equals(returnedFieldName)) {
131: continue;
132: }
133: if (fieldFound[k]) {
134: logWriter
135: .println("\n## FAILURE: The field is found out repeatedly in the list");
136: logWriter.println("## Field name = "
137: + returnedFieldName);
138: testStatus = testStatusFailed;
139: message = "The field is found repeatedly in the list: "
140: + returnedFieldName;
141: break;
142: }
143: fieldFound[k] = true;
144: if (!fieldSignatures[k].equals(returnedFieldSignature)) {
145: logWriter
146: .println("\n## FAILURE: Unexpected field signature is returned:");
147: logWriter.println("## Field name = "
148: + returnedFieldName);
149: logWriter.println("## Expected signature = "
150: + fieldSignatures[k]);
151: logWriter.println("## Returned signature = "
152: + returnedFieldSignature);
153: testStatus = testStatusFailed;
154: message = "Unexpected signature is returned for field: "
155: + returnedFieldName
156: + ", expected: "
157: + fieldSignatures[k]
158: + ", returned: "
159: + returnedFieldSignature;
160: }
161: if (!fieldGenericSignatures[k]
162: .equals(returnedGenericSignature)) {
163: logWriter
164: .println("\n## FAILURE: Unexpected field generic signature is returned:");
165: logWriter.println("## Field name = "
166: + returnedFieldName);
167: logWriter
168: .println("## Expected generic signature = \""
169: + fieldGenericSignatures[k] + "\"");
170: logWriter
171: .println("## Returned generic signature = \""
172: + returnedGenericSignature + "\"");
173: testStatus = testStatusFailed;
174: message = "Unexpected generic signature is returned for filed: "
175: + returnedFieldName
176: + ", expected: \""
177: + fieldGenericSignatures[k]
178: + "\""
179: + ", returned: \""
180: + returnedGenericSignature + "\"";
181: }
182: if (fieldModifiers[k] != returnedFieldModifiers) {
183: logWriter
184: .println("\n## FAILURE: Unexpected field modifiers are returned:");
185: logWriter.println("## Field name = "
186: + returnedFieldName);
187: logWriter.println("## Expected modifiers = 0x"
188: + Integer.toHexString(fieldModifiers[k]));
189: logWriter
190: .println("## Returned modifiers = 0x"
191: + Integer
192: .toHexString(returnedFieldModifiers));
193: testStatus = testStatusFailed;
194: message = "Unexpected modifiers are returned for field: "
195: + returnedFieldName
196: + ", expected: 0x"
197: + Integer.toHexString(fieldModifiers[k])
198: + ", returned: 0x"
199: + Integer
200: .toHexString(returnedFieldModifiers);
201: }
202: break;
203: }
204: if (k == expectedFieldsNumber) {
205: // returned field is not found out in the list of expected fields
206: logWriter
207: .println("\n## FAILURE: It is found out unexpected returned field:");
208: logWriter.println("## Field name = "
209: + returnedFieldName);
210: logWriter.println("## Field signature = "
211: + returnedFieldSignature);
212: logWriter.println("## Field generic signature = \""
213: + returnedGenericSignature + "\"");
214: logWriter.println("## Field modifiers = 0x"
215: + Integer.toHexString(returnedFieldModifiers));
216: testStatus = testStatusFailed;
217: message = "Unexpected returned field: "
218: + returnedFieldName + ", signature = "
219: + returnedFieldSignature
220: + ", generic signature = \""
221: + returnedGenericSignature + "\""
222: + ", modifiers = 0x"
223: + Integer.toHexString(returnedFieldModifiers);
224: }
225: }
226:
227: for (int k = 0; k < expectedFieldsNumber; k++) {
228: if (!fieldFound[k]) {
229: logWriter
230: .println("\n## FAILURE: Expected field is NOT found out in the list of retuned fields:");
231: logWriter.println("## Field name = " + fieldNames[k]);
232: testStatus = testStatusFailed;
233: message = "Expected field is NOT found in the list of retuned fields: "
234: + fieldNames[k];
235: }
236: }
237:
238: if (testStatus == testStatusPassed) {
239: logWriter
240: .println("=> CHECK PASSED: All expected fields are found out and have expected attributes");
241: }
242:
243: synchronizer
244: .sendMessage(JPDADebuggeeSynchronizer.SGNL_CONTINUE);
245: logWriter.println("==> " + this TestName + " for "
246: + this CommandName + ": FINISH");
247: if (testStatus == testStatusFailed) {
248: fail(message);
249: }
250:
251: assertAllDataRead(fieldsWithGenericReply);
252: }
253:
254: public static void main(String[] args) {
255: junit.textui.TestRunner.run(FieldsWithGenericTest.class);
256: }
257: }
|