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 21.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.JDWPConstants;
031: import org.apache.harmony.jpda.tests.framework.jdwp.ReplyPacket;
032: import org.apache.harmony.jpda.tests.jdwp.share.JDWPSyncTestCase;
033: import org.apache.harmony.jpda.tests.share.JPDADebuggeeSynchronizer;
034:
035: /**
036: * JDWP Unit test for ReferenceType.NestedTypes command.
037: */
038: public class NestedTypesTest extends JDWPSyncTestCase {
039:
040: static final int testStatusPassed = 0;
041: static final int testStatusFailed = -1;
042: static final String this CommandName = "ReferenceType.NestedTypes command";
043: static final String debuggeeSignature = "Lorg/apache/harmony/jpda/tests/jdwp/ReferenceType/NestedTypesDebuggee;";
044:
045: protected String getDebuggeeClassName() {
046: return "org.apache.harmony.jpda.tests.jdwp.ReferenceType.NestedTypesDebuggee";
047: }
048:
049: /**
050: * This testcase exercises ReferenceType.NestedTypes command.
051: * The test starts NestedTypesDebuggee class, requests referenceTypeId
052: * for this class by VirtualMachine.ClassesBySignature command, then
053: * performs ReferenceType.NestedTypes command and checks that returned
054: * list of nested classes corresponds to expected list.
055: */
056: public void testNestedTypes001() {
057: String this TestName = "testNestedTypes001";
058: logWriter.println("==> " + this TestName + " for "
059: + this CommandName + ": START...");
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 checkedCommand = new CommandPacket(
074: JDWPCommands.ReferenceTypeCommandSet.CommandSetID,
075: JDWPCommands.ReferenceTypeCommandSet.NestedTypesCommand);
076: checkedCommand.setNextValueAsReferenceTypeID(refTypeID);
077: ReplyPacket checkedReply = debuggeeWrapper.vmMirror
078: .performCommand(checkedCommand);
079: checkedCommand = null;
080: checkReplyPacket(checkedReply, this CommandName);
081:
082: int returnedNestedTypesNumber = checkedReply
083: .getNextValueAsInt();
084: logWriter.println("=> Returned nested types number = "
085: + returnedNestedTypesNumber);
086:
087: String nestedTypeSignatures[] = {
088: "Lorg/apache/harmony/jpda/tests/jdwp/ReferenceType/NestedTypesDebuggee$StatInterf_1;",
089: "Lorg/apache/harmony/jpda/tests/jdwp/ReferenceType/NestedTypesDebuggee$StatClass_1;",
090: "Lorg/apache/harmony/jpda/tests/jdwp/ReferenceType/NestedTypesDebuggee$NonStatClass_1;", };
091:
092: byte nestedTypeTags[] = { JDWPConstants.TypeTag.INTERFACE,
093: JDWPConstants.TypeTag.CLASS,
094: JDWPConstants.TypeTag.CLASS, };
095:
096: boolean nestedTypeFound[] = { false, false, false, };
097:
098: int expectedNestedTypesNumber = nestedTypeSignatures.length;
099:
100: logWriter.println("=> CHECK for all returned NestedTypes...");
101: for (int i = 0; i < returnedNestedTypesNumber; i++) {
102: logWriter.println("\n=> Check for returned nested type["
103: + i + "] ...");
104: byte returnedRefTypeTag = checkedReply.getNextValueAsByte();
105: logWriter.println("=> RefTypeTag of nested type = "
106: + returnedRefTypeTag + "("
107: + JDWPConstants.TypeTag.getName(returnedRefTypeTag)
108: + ")");
109: long returnedRefTypeID = checkedReply
110: .getNextValueAsReferenceTypeID();
111: logWriter.println("=> RefTypeID of nested type = "
112: + returnedRefTypeID);
113: logWriter.println("=> Get signature for nested type...");
114: CommandPacket signatureCommand = new CommandPacket(
115: JDWPCommands.ReferenceTypeCommandSet.CommandSetID,
116: JDWPCommands.ReferenceTypeCommandSet.SignatureCommand);
117: signatureCommand
118: .setNextValueAsReferenceTypeID(returnedRefTypeID);
119: ReplyPacket signatureReply = debuggeeWrapper.vmMirror
120: .performCommand(signatureCommand);
121: signatureCommand = null;
122: checkReplyPacket(signatureReply,
123: "ReferenceType::Signature command");
124:
125: String returnedSignature = signatureReply
126: .getNextValueAsString();
127: signatureReply = null;
128: logWriter.println("=> Signature of nested type = "
129: + returnedSignature);
130:
131: int k = 0;
132: for (; k < expectedNestedTypesNumber; k++) {
133: if (!nestedTypeSignatures[k].equals(returnedSignature)) {
134: continue;
135: }
136: if (nestedTypeFound[k]) {
137: logWriter
138: .println("\n## FAILURE: This nested type is found out repeatedly in the list");
139: failMessage = failMessage
140: + "This nested type is found repeatedly in the list;\n";
141: break;
142: }
143: nestedTypeFound[k] = true;
144: if (nestedTypeTags[k] != returnedRefTypeTag) {
145: logWriter
146: .println("\n## FAILURE: Unexpected RefTypeTag is returned:");
147: logWriter.println("## Expected RefTypeTag = "
148: + nestedTypeTags[k]
149: + "("
150: + JDWPConstants.TypeTag
151: .getName(nestedTypeTags[k]) + ")");
152: failMessage = failMessage
153: + "Unexpected RefTypeTag is returned:"
154: + returnedRefTypeTag
155: + "("
156: + JDWPConstants.TypeTag
157: .getName(returnedRefTypeTag)
158: + ")"
159: + ", Expected: "
160: + nestedTypeTags[k]
161: + "("
162: + JDWPConstants.TypeTag
163: .getName(nestedTypeTags[k])
164: + ");\n";
165: }
166: break;
167: }
168: if (k == expectedNestedTypesNumber) {
169: // returned nested type is not found out in the list of expected nested types
170: logWriter
171: .println("\n## FAILURE: It is unexpected nested type");
172: failMessage = failMessage
173: + "It is unexpected nested type;\n";
174: }
175: }
176:
177: for (int k = 0; k < expectedNestedTypesNumber; k++) {
178: if (!nestedTypeFound[k]) {
179: logWriter
180: .println("\n## FAILURE: Expected nested type is NOT found out in the returned list:");
181: logWriter.println("=> Signature of nested type = "
182: + nestedTypeSignatures[k]);
183: failMessage = failMessage
184: + "Expected nested type is NOT found in the returned list: "
185: + nestedTypeSignatures[k];
186: }
187: }
188:
189: finalSyncMessage = JPDADebuggeeSynchronizer.SGNL_CONTINUE;
190: if (failMessage.length() > 0) {
191: fail(failMessage);
192: }
193: assertAllDataRead(checkedReply);
194: finalSyncMessage = null;
195:
196: logWriter
197: .println("\n=> CHECK PASSED: All expected nested types are found out and have expected attributes");
198:
199: synchronizer
200: .sendMessage(JPDADebuggeeSynchronizer.SGNL_CONTINUE);
201: logWriter.println("\n==> " + this TestName + " for "
202: + this CommandName + ": OK.");
203: }
204:
205: public static void main(String[] args) {
206: junit.textui.TestRunner.run(NestedTypesTest.class);
207: }
208: }
|