--- /dev/null
+/*\r
+\r
+ Derby - Class org.apache.derby.impl.drda.TestProto\r
+\r
+ Licensed to the Apache Software Foundation (ASF) under one or more\r
+ contributor license agreements. See the NOTICE file distributed with\r
+ this work for additional information regarding copyright ownership.\r
+ The ASF licenses this file to You under the Apache License, Version 2.0\r
+ (the "License"); you may not use this file except in compliance with\r
+ the License. You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+\r
+ */\r
+\r
+package org.apache.derby.impl.drda;\r
+\r
+import java.io.BufferedReader;\r
+import java.io.FileInputStream;\r
+import java.io.FileNotFoundException;\r
+import java.io.IOException;\r
+import java.io.InputStream;\r
+import java.io.InputStreamReader;\r
+import java.io.OutputStream;\r
+import java.io.StreamTokenizer;\r
+import java.io.UnsupportedEncodingException;\r
+import java.net.Socket;\r
+import java.net.UnknownHostException;\r
+import java.util.Enumeration;\r
+import java.util.Hashtable;\r
+import java.util.Locale;\r
+import java.util.Vector;\r
+\r
+/**\r
+ This class is used to test error conditions in the protocol.\r
+ The protocol to send to the Net server is contained in a file encoded\r
+ as calls to routines in ddmreader and ddmwriter.\r
+ Additional commands have been added for testing purposes.\r
+ To add tests, modify the file protocol.tests.\r
+ Tests can also be done as separate files and given as an argument to\r
+ this class.\r
+*/\r
+\r
+public class TestProto {\r
+\r
+ private static final CodePointNameTable codePointNameTable = new CodePointNameTable();\r
+ private static final Hashtable codePointValueTable = new Hashtable();\r
+ private static final Hashtable commandTable = new Hashtable();\r
+ private static final CcsidManager ccsidManager = new EbcdicCcsidManager();\r
+ //commands\r
+ private static final int CREATE_DSS_REQUEST = 1;\r
+ private static final int CREATE_DSS_OBJECT = 2;\r
+ private static final int END_DSS = 3;\r
+ private static final int END_DDM_AND_DSS = 4;\r
+ private static final int START_DDM = 5;\r
+ private static final int END_DDM = 6;\r
+ private static final int WRITE_BYTE = 7;\r
+ private static final int WRITE_NETWORK_SHORT = 8;\r
+ private static final int WRITE_NETWORK_INT = 9;\r
+ private static final int WRITE_BYTES = 10;\r
+ private static final int WRITE_CODEPOINT_4BYTES = 11;\r
+ private static final int WRITE_SCALAR_1BYTE = 12;\r
+ private static final int WRITE_SCALAR_2BYTES = 13;\r
+ private static final int WRITE_SCALAR_BYTES = 14;\r
+ private static final int WRITE_SCALAR_HEADER = 15;\r
+ private static final int WRITE_SCALAR_STRING = 16;\r
+ private static final int WRITE_SCALAR_PADDED_STRING = 17;\r
+ private static final int WRITE_SCALAR_PADDED_BYTES = 18;\r
+ private static final int WRITE_SHORT = 19;\r
+ private static final int WRITE_INT = 20;\r
+ private static final int WRITE_LONG = 21;\r
+ private static final int WRITE_FLOAT = 22;\r
+ private static final int WRITE_DOUBLE = 23;\r
+ private static final int READ_REPLY_DSS = 24;\r
+ private static final int READ_LENGTH_AND_CODEPOINT = 25;\r
+ private static final int READ_CODEPOINT = 26;\r
+ private static final int MARK_COLLECTION = 27;\r
+ private static final int GET_CODEPOINT = 28;\r
+ private static final int READ_BYTE = 29;\r
+ private static final int READ_NETWORK_SHORT = 30;\r
+ private static final int READ_SHORT = 31;\r
+ private static final int READ_NETWORK_INT = 32;\r
+ private static final int READ_INT = 33;\r
+ private static final int READ_LONG = 34;\r
+ private static final int READ_BOOLEAN = 35;\r
+ private static final int READ_STRING = 36;\r
+ private static final int READ_BYTES = 37;\r
+ private static final int FLUSH = 38;\r
+ private static final int DISPLAY = 39;\r
+ private static final int CHECKERROR = 40;\r
+ private static final int RESET = 41;\r
+ private static final int CREATE_DSS_REPLY = 42;\r
+ private static final int SKIP_DSS = 43;\r
+ private static final int READ_SCALAR_2BYTES = 44;\r
+ private static final int READ_SCALAR_1BYTE = 45;\r
+ private static final int END_TEST = 46;\r
+ private static final int SKIP_DDM = 47;\r
+ private static final int INCLUDE = 48;\r
+ private static final int SKIP_BYTES = 49;\r
+ private static final int WRITE_PADDED_STRING = 50;\r
+ private static final int WRITE_STRING = 51;\r
+ private static final int WRITE_ENCODED_STRING = 52;\r
+ private static final int WRITE_ENCODED_LDSTRING = 53;\r
+ private static final int CHECK_SQLCARD = 54;\r
+ private static final int MORE_DATA = 55;\r
+ private static final int COMPLETE_TEST = 56;\r
+ private static final int READ_SECMEC_SECCHKCD = 57;\r
+\r
+ private static final String MULTIVAL_START = "MULTIVALSTART";\r
+ private static final String MULTIVAL_SEP = "SEP";\r
+ private static final String MULTIVAL_END = "MULTIVALEND";\r
+ // initialize hash tables\r
+ static {\r
+ init();\r
+ }\r
+\r
+\r
+ private Socket monitorSocket = null;\r
+ private InputStream monitorIs = null;\r
+ private OutputStream monitorOs = null;\r
+ private DDMWriter writer = new DDMWriter(ccsidManager, null, null);\r
+ private DDMReader reader;\r
+ private boolean failed = false;\r
+ private StreamTokenizer tkn;\r
+ private String current_filename;\r
+ private int port;\r
+\r
+ // constructors\r
+ public TestProto(String filename, int port) \r
+ {\r
+ current_filename = filename;\r
+ this.port = port;\r
+ getConnection();\r
+\r
+ try \r
+ {\r
+ reader = new DDMReader(ccsidManager, monitorIs);\r
+ processFile(filename);\r
+ }\r
+ catch (Exception e)\r
+ {\r
+ int line = 0;\r
+ if (tkn != null)\r
+ line = tkn.lineno();\r
+ System.err.println("Unexpected exception in line " + line + " file: " + current_filename);\r
+ e.printStackTrace();\r
+ }\r
+ finally\r
+ {\r
+ closeConnection();\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Process include file\r
+ *\r
+ * @exception IOException, DRDAProtocolException error reading file or protocol\r
+ */\r
+ private void processIncludeFile()\r
+ throws IOException, DRDAProtocolException\r
+ {\r
+ String fileName = getString();\r
+ StreamTokenizer saveTkn = tkn;\r
+ processFile(fileName);\r
+ tkn = saveTkn;\r
+ }\r
+ /**\r
+ * Process a command file\r
+ *\r
+ * @param filename\r
+ * @exception IOException, DRDAProtocolException error reading file or protocol\r
+ */\r
+ private void processFile(String filename)\r
+ throws IOException, DRDAProtocolException\r
+ {\r
+ String prev_filename = current_filename;\r
+ current_filename = filename;\r
+ String hostName=getHostName();\r
+ BufferedReader fr;\r
+ try {\r
+ fr = new BufferedReader(new InputStreamReader(new FileInputStream(filename),"UTF-8"));\r
+ } catch (FileNotFoundException fnfe) {\r
+ // if useprocess=false & we're running in a suite, \r
+ // the location is different, try it\r
+ String userdir = System.getProperty("user.dir");\r
+ String sep = System.getProperty("file.separator");\r
+ fr = new BufferedReader (new InputStreamReader(new FileInputStream(userdir + sep + filename),"UTF-8"));\r
+ }\r
+ tkn = new StreamTokenizer(fr);\r
+ int val;\r
+ while ( (val = tkn.nextToken()) != StreamTokenizer.TT_EOF)\r
+ {\r
+ switch(val)\r
+ {\r
+ case StreamTokenizer.TT_NUMBER:\r
+ break;\r
+ case StreamTokenizer.TT_WORD:\r
+ processCommand();\r
+ break;\r
+ case StreamTokenizer.TT_EOL:\r
+ break;\r
+ }\r
+ }\r
+ current_filename = prev_filename;\r
+ }\r
+ /**\r
+ * Set up a connection to the Network server\r
+ */\r
+ private void getConnection() \r
+ {\r
+ String hostName=getHostName();\r
+ try {\r
+ monitorSocket = new Socket(hostName, port);\r
+ } catch (UnknownHostException e) {\r
+ System.err.println("Don't know about host: " + hostName);\r
+ System.exit(1);\r
+ } catch (IOException e) {\r
+ System.err.println("Couldn't get I/O for the connection to: " + hostName);\r
+ System.exit(1);\r
+ }\r
+ try\r
+ {\r
+ monitorIs = monitorSocket.getInputStream();\r
+ monitorOs = monitorSocket.getOutputStream();\r
+ }\r
+ catch (IOException e)\r
+ {\r
+ System.err.println("Couldn't get I/O for the connection to: " + hostName);\r
+ System.exit(1);\r
+ }\r
+ }\r
+ /**\r
+ * Close connection to the network server\r
+ */\r
+ private void closeConnection()\r
+ {\r
+ try {\r
+ monitorIs.close();\r
+ monitorOs.close();\r
+ monitorSocket.close();\r
+ }\r
+ catch (Exception e) {} //Ignore exceptions when closing the connection\r
+ }\r
+ /**\r
+ * Reset connection for another test\r
+ */\r
+ private void reset()\r
+ {\r
+ closeConnection();\r
+ getConnection();\r
+ reader.initialize(monitorIs);\r
+ writer.reset(null);\r
+ }\r
+ /**\r
+ * finish by cleaning up the last connection\r
+ */\r
+ private void completeTest()\r
+ {\r
+ closeConnection();\r
+ }\r
+ /**\r
+ * Initialize hashtable for commands and set up a table to translate from\r
+ * the codepoint name to the codepoint value\r
+ */\r
+ private static void init()\r
+ {\r
+ commandTable.put("createdssrequest", new Integer(CREATE_DSS_REQUEST));\r
+ commandTable.put("createdssobject", new Integer(CREATE_DSS_OBJECT));\r
+ commandTable.put("createdssreply", new Integer(CREATE_DSS_REPLY));\r
+ commandTable.put("enddss", new Integer(END_DSS));\r
+ commandTable.put("enddss", new Integer(END_DSS));\r
+ commandTable.put("endddmanddss", new Integer(END_DDM_AND_DSS));\r
+ commandTable.put("startddm", new Integer(START_DDM));\r
+ commandTable.put("endddm", new Integer(END_DDM));\r
+ commandTable.put("writebyte", new Integer(WRITE_BYTE));\r
+ commandTable.put("writenetworkshort", new Integer(WRITE_NETWORK_SHORT));\r
+ commandTable.put("writenetworkint", new Integer(WRITE_NETWORK_INT));\r
+ commandTable.put("writebytes", new Integer(WRITE_BYTES));\r
+ commandTable.put("writecodepoint4bytes", new Integer(WRITE_CODEPOINT_4BYTES));\r
+ commandTable.put("writescalar1byte", new Integer(WRITE_SCALAR_1BYTE));\r
+ commandTable.put("writescalar2bytes", new Integer(WRITE_SCALAR_2BYTES));\r
+ commandTable.put("writescalarbytes", new Integer(WRITE_SCALAR_BYTES));\r
+ commandTable.put("writescalarheader", new Integer(WRITE_SCALAR_HEADER));\r
+ commandTable.put("writescalarstring", new Integer(WRITE_SCALAR_STRING));\r
+ commandTable.put("writescalarpaddedstring", new Integer(WRITE_SCALAR_PADDED_STRING));\r
+ commandTable.put("writescalarpaddedbytes", new Integer(WRITE_SCALAR_PADDED_BYTES));\r
+ commandTable.put("writeshort", new Integer(WRITE_SHORT));\r
+ commandTable.put("writeint", new Integer(WRITE_INT));\r
+ commandTable.put("writelong", new Integer(WRITE_LONG));\r
+ commandTable.put("writefloat", new Integer(WRITE_FLOAT));\r
+ commandTable.put("writedouble", new Integer(WRITE_DOUBLE));\r
+ commandTable.put("readreplydss", new Integer(READ_REPLY_DSS));\r
+ commandTable.put("readlengthandcodepoint", new Integer(READ_LENGTH_AND_CODEPOINT));\r
+ commandTable.put("readcodepoint", new Integer(READ_CODEPOINT));\r
+ commandTable.put("markcollection", new Integer(MARK_COLLECTION));\r
+ commandTable.put("getcodepoint", new Integer(GET_CODEPOINT));\r
+ commandTable.put("readbyte", new Integer(READ_BYTE));\r
+ commandTable.put("readnetworkshort", new Integer(READ_NETWORK_SHORT));\r
+ commandTable.put("readshort", new Integer(READ_SHORT));\r
+ commandTable.put("readint", new Integer(READ_INT));\r
+ commandTable.put("readlong", new Integer(READ_LONG));\r
+ commandTable.put("readboolean", new Integer(READ_BOOLEAN));\r
+ commandTable.put("readstring", new Integer(READ_STRING));\r
+ commandTable.put("readbytes", new Integer(READ_BYTES));\r
+ commandTable.put("flush", new Integer(FLUSH));\r
+ commandTable.put("display", new Integer(DISPLAY));\r
+ commandTable.put("checkerror", new Integer(CHECKERROR));\r
+ commandTable.put("reset", new Integer(RESET));\r
+ commandTable.put("skipdss", new Integer(SKIP_DSS));\r
+ commandTable.put("skipddm", new Integer(SKIP_DDM));\r
+ commandTable.put("readscalar2bytes", new Integer(READ_SCALAR_2BYTES));\r
+ commandTable.put("readscalar1byte", new Integer(READ_SCALAR_1BYTE));\r
+ commandTable.put("endtest", new Integer(END_TEST));\r
+ commandTable.put("include", new Integer(INCLUDE));\r
+ commandTable.put("skipbytes", new Integer(SKIP_BYTES));\r
+ commandTable.put("writepaddedstring", new Integer(WRITE_PADDED_STRING));\r
+ commandTable.put("writestring", new Integer(WRITE_STRING));\r
+ commandTable.put("writeencodedstring", new Integer(WRITE_ENCODED_STRING));\r
+ commandTable.put("writeencodedldstring", new Integer(WRITE_ENCODED_LDSTRING));\r
+ commandTable.put("checksqlcard", new Integer(CHECK_SQLCARD));\r
+ commandTable.put("moredata", new Integer(MORE_DATA));\r
+ commandTable.put("completetest", new Integer(COMPLETE_TEST));\r
+ commandTable.put("readsecmecandsecchkcd", new Integer(READ_SECMEC_SECCHKCD));\r
+ \r
+ Integer key;\r
+ for (Enumeration e = codePointNameTable.keys(); e.hasMoreElements(); )\r
+ {\r
+ key = (Integer)e.nextElement();\r
+ codePointValueTable.put(codePointNameTable.get(key), key);\r
+ }\r
+ \r
+ }\r
+ /**\r
+ * Process a command\r
+ */\r
+ private void processCommand()\r
+ throws IOException, DRDAProtocolException\r
+ {\r
+ Integer icmd = (Integer)commandTable.get(tkn.sval.toLowerCase(Locale.ENGLISH));\r
+ if (icmd == null)\r
+ {\r
+ System.err.println("Unknown command, " + tkn.sval + " in line " +\r
+ tkn.lineno());\r
+ System.exit(1);\r
+ }\r
+ int cmd = icmd.intValue();\r
+ int codepoint;\r
+ int val;\r
+ int reqVal;\r
+ String str;\r
+\r
+ switch (cmd)\r
+ {\r
+ case INCLUDE:\r
+ processIncludeFile();\r
+ break;\r
+ case CREATE_DSS_REQUEST:\r
+ writer.createDssRequest();\r
+ break;\r
+ case CREATE_DSS_OBJECT:\r
+ writer.createDssObject();\r
+ break;\r
+ case CREATE_DSS_REPLY:\r
+ writer.createDssReply();\r
+ break;\r
+ case END_DSS:\r
+ tkn.nextToken();\r
+ tkn.pushBack();\r
+ if ((tkn.sval != null) && tkn.sval.startsWith("0x"))\r
+ // use specified chaining.\r
+ writer.endDss((getBytes())[0]);\r
+ else\r
+ // use default chaining\r
+ writer.endDss();\r
+ break;\r
+ case END_DDM:\r
+ writer.endDdm();\r
+ break;\r
+ case END_DDM_AND_DSS:\r
+ writer.endDdmAndDss();\r
+ break;\r
+ case START_DDM:\r
+ writer.startDdm(getCP());\r
+ break;\r
+ case WRITE_SCALAR_STRING:\r
+ writer.writeScalarString(getCP(), getString());\r
+ break;\r
+ case WRITE_SCALAR_2BYTES:\r
+ writer.writeScalar2Bytes(getCP(),getIntOrCP());\r
+ break;\r
+ case WRITE_SCALAR_1BYTE:\r
+ writer.writeScalar1Byte(getCP(),getInt());\r
+ break;\r
+ case WRITE_SCALAR_BYTES:\r
+ writer.writeScalarBytes(getCP(),getBytes());\r
+ break;\r
+ case WRITE_SCALAR_PADDED_BYTES:\r
+ writer.writeScalarPaddedBytes(getCP(), getBytes(), getInt(),\r
+ ccsidManager.space);\r
+ break;\r
+ case WRITE_BYTE:\r
+ writer.writeByte(getInt());\r
+ break;\r
+ case WRITE_BYTES:\r
+ writer.writeBytes(getBytes());\r
+ break;\r
+ case WRITE_SHORT:\r
+ writer.writeShort(getInt());\r
+ break;\r
+ case WRITE_INT:\r
+ writer.writeInt(getInt());\r
+ break;\r
+ case WRITE_CODEPOINT_4BYTES:\r
+ writer.writeCodePoint4Bytes(getCP(), getInt());\r
+ break;\r
+ case WRITE_STRING:\r
+ str = getString();\r
+ writer.writeBytes(getEBCDIC(str));\r
+ break;\r
+ case WRITE_ENCODED_STRING:\r
+ writeEncodedString(getString(), getString());\r
+ break;\r
+ case WRITE_ENCODED_LDSTRING:\r
+ writeEncodedLDString(getString(), getString(), getInt());\r
+ break;\r
+ case WRITE_PADDED_STRING:\r
+ str = getString();\r
+ writer.writeBytes(getEBCDIC(str));\r
+ int reqLen = getInt();\r
+ int strLen = str.length();\r
+ if (strLen < reqLen)\r
+ writer.padBytes(ccsidManager.space, reqLen-strLen);\r
+ break;\r
+ case READ_REPLY_DSS:\r
+ reader.readReplyDss();\r
+ break;\r
+ case SKIP_DSS:\r
+ skipDss();\r
+ break;\r
+ case SKIP_DDM:\r
+ skipDdm();\r
+ break;\r
+ case MORE_DATA:\r
+ boolean expbool;\r
+ str = getString();\r
+ if (str.equalsIgnoreCase("true"))\r
+ expbool = true;\r
+ else\r
+ expbool = false;\r
+ if (reader.moreData() && expbool == false )\r
+ fail("Failed - more data left");\r
+ if (!reader.moreData() && expbool == true )\r
+ fail("Failed - no data left");\r
+ break;\r
+ case READ_LENGTH_AND_CODEPOINT:\r
+ readLengthAndCodePoint();\r
+ break;\r
+ case READ_SCALAR_2BYTES:\r
+ readLengthAndCodePoint();\r
+ val = reader.readNetworkShort();\r
+ checkIntOrCP(val);\r
+ break;\r
+ case READ_SCALAR_1BYTE:\r
+ readLengthAndCodePoint();\r
+ val = reader.readByte();\r
+ checkIntOrCP(val);\r
+ break;\r
+ case READ_SECMEC_SECCHKCD:\r
+ readSecMecAndSECCHKCD();\r
+ break;\r
+ case READ_BYTES:\r
+ byte[] byteArray = reader.readBytes();\r
+ byte[] reqArray = getBytes();\r
+ if (byteArray.length != reqArray.length)\r
+ fail("Failed - byte array didn't match");\r
+ for (int i = 0; i < byteArray.length; i++)\r
+ if (byteArray[i] != reqArray[i])\r
+ fail("Failed - byte array didn't match");\r
+ break;\r
+ case READ_NETWORK_SHORT:\r
+ val = reader.readNetworkShort();\r
+ checkIntOrCP(val);\r
+ break;\r
+ case FLUSH:\r
+ writer.finalizeChain(reader.getCurrChainState(), monitorOs);\r
+ writer.reset(null);\r
+ break;\r
+ case DISPLAY:\r
+ System.out.println(getString());\r
+ break;\r
+ case CHECKERROR:\r
+ checkError();\r
+ break;\r
+ case CHECK_SQLCARD:\r
+ checkSQLCARD(getInt(), getString());\r
+ break;\r
+ case COMPLETE_TEST:\r
+ completeTest();\r
+ break;\r
+ case END_TEST:\r
+ // print that we passed the test if we haven't failed\r
+ if (failed == false)\r
+ System.out.println("PASSED");\r
+ failed = false;\r
+ reset();\r
+ break;\r
+ case RESET:\r
+ reset();\r
+ break;\r
+ case SKIP_BYTES:\r
+ reader.skipBytes();\r
+ break;\r
+ default:\r
+ System.out.println("unknown command in line " + tkn.lineno());\r
+ // skip remainder of line\r
+ while (tkn.nextToken() != StreamTokenizer.TT_EOL)\r
+ ;\r
+ \r
+ }\r
+ }\r
+ /**\r
+ * Skip a DSS communication \r
+ */\r
+ private void skipDss() throws DRDAProtocolException\r
+ {\r
+ reader.readReplyDss();\r
+ reader.skipDss();\r
+ }\r
+ /**\r
+ * Skip the a Ddm communication\r
+ */\r
+ private void skipDdm() throws DRDAProtocolException\r
+ {\r
+ reader.readLengthAndCodePoint( false );\r
+ reader.skipBytes();\r
+ }\r
+ /**\r
+ * Read an int from the command file\r
+ * Negative numbers are preceded by "-"\r
+ */\r
+ private int getInt() throws IOException\r
+ {\r
+ int mult = 1;\r
+ int val = tkn.nextToken();\r
+ if (tkn.sval != null && tkn.sval.equals("-"))\r
+ {\r
+ mult = -1;\r
+ val = tkn.nextToken();\r
+ }\r
+\r
+ if (val != StreamTokenizer.TT_NUMBER)\r
+ {\r
+ if (tkn.sval == null)\r
+ {\r
+ System.err.println("Invalid string on line " + tkn.lineno());\r
+ System.exit(1);\r
+ }\r
+ String str = tkn.sval.toLowerCase(Locale.ENGLISH);\r
+ if (!str.startsWith("0x"))\r
+ {\r
+ System.err.println("Expecting number, got " + tkn.sval + " on line " + tkn.lineno());\r
+ System.exit(1);\r
+ }\r
+ else\r
+ return convertHex(str);\r
+ }\r
+ return (new Double(tkn.nval).intValue() * mult);\r
+ }\r
+ /**\r
+ * Convert a token in hex format to int from the command file\r
+ */\r
+ private int convertHex(String str) throws IOException\r
+ {\r
+ int retval = 0;\r
+ int len = str.length(); \r
+ if ((len % 2) == 1 || len > 10)\r
+ {\r
+ System.err.println("Invalid length for byte string, " + len + \r
+ " on line " + tkn.lineno());\r
+ System.exit(1);\r
+ }\r
+ for (int i = 2; i < len; i++)\r
+ {\r
+ retval = retval << 4;\r
+ retval += Byte.valueOf(str.substring(i, i+1), 16).byteValue();\r
+ }\r
+ return retval;\r
+ }\r
+\r
+ /**\r
+ * checks if value matches next int or cp. \r
+ * Handles multiple legal values in protocol test file\r
+ * FORMAT for Multiple Values \r
+ * MULTIVALSTART 10 SEP 32 SEP 40 MULTIVALEND\r
+ **/\r
+ private boolean checkIntOrCP(int val) throws IOException\r
+ {\r
+ boolean rval = false;\r
+ int tknType = tkn.nextToken();\r
+ String reqVal = " ";\r
+\r
+ \r
+ if (tknType == StreamTokenizer.TT_WORD && tkn.sval.trim().equals(MULTIVAL_START))\r
+ {\r
+ do {\r
+ int nextVal = getIntOrCP();\r
+ reqVal = reqVal + nextVal + " ";\r
+ // System.out.println("Checking MULTIVAL (" + val + "==" + nextVal + ")");\r
+ rval = rval || (val == nextVal);\r
+ tkn.nextToken();\r
+ }\r
+ while(tkn.sval.trim().equals(MULTIVAL_SEP));\r
+ \r
+ if (! (tkn.sval.trim().equals(MULTIVAL_END)))\r
+ fail("Invalid test file format requires " + MULTIVAL_END + \r
+ " got: " + tkn.sval);\r
+ \r
+ }\r
+ else\r
+ {\r
+ tkn.pushBack();\r
+ int nextVal = getIntOrCP();\r
+ reqVal = " " + nextVal;\r
+ // System.out.println("Checking Single Value (" + val + "==" + nextVal + ")");\r
+ rval = (val == nextVal);\r
+ }\r
+ if (rval == false)\r
+ fail("Failed - wrong val = " + val + " Required Value: " + reqVal);\r
+\r
+ return rval;\r
+ }\r
+\r
+\r
+ /**\r
+ * Read an int or codepoint - codepoint is given as a string\r
+ */\r
+ private int getIntOrCP() throws IOException\r
+ {\r
+ int val = tkn.nextToken();\r
+ if (val == StreamTokenizer.TT_NUMBER)\r
+ {\r
+ return new Double(tkn.nval).intValue();\r
+ }\r
+ else if (val == StreamTokenizer.TT_WORD)\r
+ {\r
+ return decodeCP(tkn.sval);\r
+ }\r
+ else\r
+ {\r
+ fail("Expecting number, got " + tkn.sval + " on line "\r
+ + tkn.lineno());\r
+ System.exit(1);\r
+ }\r
+ return 0;\r
+ }\r
+ /**\r
+ * Read an array of bytes from the command file\r
+ * A byte string can start with 0x in which case the bytes are interpreted\r
+ * in hex format or it can just be a string, in which case each char is\r
+ * interpreted as 2 byte UNICODE\r
+ *\r
+ * @return byte array\r
+ */\r
+ private byte [] getBytes() throws IOException\r
+ {\r
+ byte[] retval = null;\r
+ int val = tkn.nextToken();\r
+ if (tkn.sval == null)\r
+ {\r
+ System.err.println("Invalid string on line " + tkn.lineno());\r
+ System.exit(1);\r
+ }\r
+ String str = tkn.sval.toLowerCase(Locale.ENGLISH);\r
+ if (!str.startsWith("0x"))\r
+ {\r
+ //just convert the string to ebcdic byte array\r
+ return ccsidManager.convertFromUCS2(str);\r
+ }\r
+ else\r
+ {\r
+ int len = str.length(); \r
+ if ((len % 2) == 1)\r
+ {\r
+ System.err.println("Invalid length for byte string, " + len + \r
+ " on line " + tkn.lineno());\r
+ System.exit(1);\r
+ }\r
+ retval = new byte[(len-2)/2]; \r
+ int j = 0;\r
+ for (int i = 2; i < len; i+=2, j++)\r
+ {\r
+ retval[j] = (byte)(Byte.valueOf(str.substring(i, i+1), 16).byteValue() << 4);\r
+ retval[j] += Byte.valueOf(str.substring(i+1, i+2), 16).byteValue();\r
+ }\r
+ }\r
+ return retval;\r
+ }\r
+ /**\r
+ * Read a string from the command file\r
+ *\r
+ * @return string found in file\r
+ * @exception IOException error reading file\r
+ */\r
+ private String getString() throws IOException\r
+ {\r
+ int val = tkn.nextToken();\r
+ if (val == StreamTokenizer.TT_NUMBER)\r
+ {\r
+ System.err.println("Expecting word, got " + tkn.nval + " on line " + tkn.lineno());\r
+ System.exit(1);\r
+ }\r
+ return tkn.sval;\r
+ }\r
+ /**\r
+ * Read the string version of a CodePoint\r
+ *\r
+ * @exception IOException error reading file\r
+ */\r
+ private int getCP() throws IOException\r
+ {\r
+ String strval = getString();\r
+ return decodeCP(strval);\r
+ }\r
+ /**\r
+ * Translate a string codepoint such as ACCSEC to the equivalent int value\r
+ *\r
+ * @param strval string codepoint\r
+ * @return integer value of codepoint\r
+ */\r
+ private int decodeCP(String strval) \r
+ {\r
+ Integer cp = (Integer)codePointValueTable.get(strval);\r
+ if (cp == null)\r
+ {\r
+ System.err.println("Unknown codepoint, "+ strval + " in line " \r
+ + tkn.lineno());\r
+ Exception e = new Exception();\r
+ e.printStackTrace();\r
+ System.exit(1);\r
+ }\r
+ return cp.intValue();\r
+ }\r
+ /**\r
+ * Print failure message and skip to the next test\r
+ *\r
+ * @exception IOException error reading file\r
+ */\r
+ private void fail(String msg) throws IOException\r
+ {\r
+ System.out.println("FAILED - " + msg + " in line " + tkn.lineno());\r
+ // skip remainder of the test look for endtest or end of file\r
+ int val = tkn.nextToken();\r
+ while (val != StreamTokenizer.TT_EOF)\r
+ {\r
+ if (val == StreamTokenizer.TT_WORD && tkn.sval.toLowerCase(Locale.ENGLISH).equals("endtest"))\r
+ break;\r
+\r
+ val = tkn.nextToken();\r
+ }\r
+ failed = true;\r
+ // get ready for next test\r
+ reset();\r
+ // print out stack trace so we know where the failure occurred\r
+ Exception e = new Exception();\r
+ e.printStackTrace();\r
+ }\r
+ /**\r
+ * Check error sent back to application requester\r
+ *\r
+ * @exception IOException, DRDAProtocolException error reading file or protocol\r
+ */\r
+ private void checkError() throws IOException, DRDAProtocolException\r
+ {\r
+ int svrcod = 0;\r
+ int invalidCodePoint = 0;\r
+ int prccnvcd = 0;\r
+ int synerrcd = 0;\r
+ int codepoint;\r
+ int reqVal;\r
+ Vector manager = new Vector(), managerLevel = new Vector() ;\r
+ reader.readReplyDss();\r
+ int error = reader.readLengthAndCodePoint( false );\r
+ int reqCP = getCP();\r
+ if (error != reqCP)\r
+ {\r
+ cpError(error, reqCP);\r
+ return;\r
+ }\r
+ while (reader.moreDssData())\r
+ {\r
+ codepoint = reader.readLengthAndCodePoint( false );\r
+ switch (codepoint)\r
+ {\r
+ case CodePoint.SVRCOD:\r
+ svrcod = reader.readNetworkShort();\r
+ break;\r
+ case CodePoint.CODPNT:\r
+ invalidCodePoint = reader.readNetworkShort();\r
+ break;\r
+ case CodePoint.PRCCNVCD:\r
+ prccnvcd = reader.readByte();\r
+ break;\r
+ case CodePoint.SYNERRCD:\r
+ synerrcd = reader.readByte();\r
+ break;\r
+ case CodePoint.MGRLVLLS:\r
+ while (reader.moreDdmData())\r
+ {\r
+ manager.addElement(new Integer(reader.readNetworkShort()));\r
+ managerLevel.addElement(new Integer(reader.readNetworkShort()));\r
+ }\r
+ break;\r
+ default:\r
+ //ignore codepoints we don't understand\r
+ reader.skipBytes();\r
+ \r
+ }\r
+ }\r
+ reqVal = getInt();\r
+ if (svrcod != reqVal)\r
+ {\r
+ fail("wrong svrcod val = " + Integer.toHexString(svrcod)\r
+ + ", required val = " + Integer.toHexString(reqVal));\r
+ return;\r
+ }\r
+ if (error == CodePoint.PRCCNVRM)\r
+ {\r
+ reqVal = getInt();\r
+ if (prccnvcd != reqVal)\r
+ {\r
+ fail("wrong prccnvd, val = " + Integer.toHexString(prccnvcd)\r
+ + ", required val = " + Integer.toHexString(reqVal));\r
+ return;\r
+ }\r
+ }\r
+ if (error == CodePoint.SYNTAXRM)\r
+ {\r
+ reqVal = getInt();\r
+ if (synerrcd != reqVal)\r
+ {\r
+ fail("wrong synerrcd, val = " + Integer.toHexString(synerrcd)\r
+ + ", required val = " + Integer.toHexString(reqVal));\r
+ return;\r
+ }\r
+ reqVal = getIntOrCP();\r
+ if (invalidCodePoint != reqVal)\r
+ {\r
+ cpError(invalidCodePoint, reqVal);\r
+ return;\r
+ }\r
+ }\r
+ if (error == CodePoint.MGRLVLRM)\r
+ {\r
+ int mgr, mgrLevel;\r
+ for (int i = 0; i < manager.size(); i++)\r
+ {\r
+ reqVal = getCP();\r
+ mgr = ((Integer)(manager.elementAt(i))).intValue();\r
+ if (mgr != reqVal)\r
+ {\r
+ cpError(mgr, reqVal);\r
+ return;\r
+ }\r
+ mgrLevel = ((Integer)(managerLevel.elementAt(i))).intValue();\r
+ reqVal = getInt();\r
+ if (mgrLevel != reqVal)\r
+ {\r
+ fail("wrong manager level, level = " + Integer.toHexString(mgrLevel)\r
+ + ", required val = " + Integer.toHexString(reqVal));\r
+ return;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ /**\r
+ * Read length and codepoint and check against required values\r
+ *\r
+ * @exception IOException, DRDAProtocolException error reading file or protocol\r
+ */\r
+ private void readLengthAndCodePoint() throws IOException, DRDAProtocolException\r
+ {\r
+ int codepoint = reader.readLengthAndCodePoint( false );\r
+ int reqCP = getCP();\r
+ if (codepoint != reqCP)\r
+ cpError(codepoint, reqCP);\r
+ }\r
+ \r
+ /**\r
+ * Handle the case of testing the reading of SECMEC and SECCHKCD, \r
+ * where on an invalid SECMEC value for ACCSEC, the server can send \r
+ * valid supported SECMEC values. One of the valid supported value can be \r
+ * EUSRIDPWD (secmec value of 9) depending on if the server JVM \r
+ * can actually support it or not.\r
+ * @exception IOException, DRDAProtocolException error reading file or protocol\r
+ */\r
+ private void readSecMecAndSECCHKCD() throws IOException, DRDAProtocolException\r
+ {\r
+ int codepoint;\r
+ boolean notDone = true;\r
+ int val = -1;\r
+ do\r
+ {\r
+ codepoint = reader.readLengthAndCodePoint( false );\r
+ switch(codepoint)\r
+ {\r
+ case CodePoint.SECMEC:\r
+ {\r
+ System.out.print("SECMEC=");\r
+ val = reader.readNetworkShort();\r
+ System.out.print(val+" ");\r
+ }\r
+ break;\r
+ case CodePoint.SECCHKCD:\r
+ {\r
+ System.out.print("SECCHKCD=");\r
+ val = reader.readByte();\r
+ System.out.println(val);\r
+ notDone = false;\r
+ }\r
+ break;\r
+ default:\r
+ notDone=false;\r
+ }\r
+ }while(notDone);\r
+ }\r
+\r
+ \r
+ /**\r
+ * Codepoint error\r
+ *\r
+ * @exception IOException error reading command file\r
+ */\r
+ private void cpError(int cp, int reqCP) throws IOException\r
+ {\r
+ String cpName = codePointNameTable.lookup(cp);\r
+ String reqCPName = codePointNameTable.lookup(reqCP);\r
+ fail("wrong codepoint val = " + Integer.toHexString(cp) + \r
+ "("+cpName+")" +\r
+ ", required codepoint = " + Integer.toHexString(reqCP) +\r
+ "("+reqCPName+")");\r
+ }\r
+ /**\r
+ * Translate a string to EBCDIC for use in the protocol\r
+ *\r
+ * @param str string to transform\r
+ * @return EBCDIC string\r
+ */\r
+ private byte[] getEBCDIC(String str)\r
+ {\r
+ byte [] buf = new byte[str.length()];\r
+ ccsidManager.convertFromUCS2(str, buf, 0);\r
+ return buf;\r
+ }\r
+ /**\r
+ * Write an encoded string\r
+ *\r
+ * @param str string to write\r
+ * @param encoding Java encoding to use\r
+ * @exception IOException\r
+ */\r
+ private void writeEncodedString(String str, String encoding)\r
+ throws IOException\r
+ {\r
+ try {\r
+ byte [] buf = str.getBytes(encoding);\r
+ writer.writeBytes(buf);\r
+ } catch (UnsupportedEncodingException e) {\r
+ fail("Unsupported encoding " + encoding); \r
+ }\r
+ }\r
+ /**\r
+ * Write length and encoded string\r
+ *\r
+ * @param str string to write\r
+ * @param encoding Java encoding to use\r
+ * @param len Size of length value (2 or 4 bytes)\r
+ * @exception IOException\r
+ */\r
+ private void writeEncodedLDString(String str, String encoding, int len)\r
+ throws IOException\r
+ {\r
+ try {\r
+ byte [] buf = str.getBytes(encoding);\r
+ if (len == 2)\r
+ writer.writeShort(buf.length);\r
+ else\r
+ writer.writeInt(buf.length);\r
+ writer.writeBytes(buf);\r
+ } catch (UnsupportedEncodingException e) {\r
+ fail("Unsupported encoding " + encoding); \r
+ }\r
+ }\r
+ /**\r
+ * Check the value of SQLCARD\r
+ *\r
+ * @param sqlCode SQLCODE value\r
+ * @param sqlState SQLSTATE value\r
+ * @exception IOException, DRDAProtocolException\r
+ */\r
+ private void checkSQLCARD(int sqlCode, String sqlState)\r
+ throws IOException, DRDAProtocolException\r
+ {\r
+ reader.readReplyDss();\r
+ int codepoint = reader.readLengthAndCodePoint( false );\r
+ if (codepoint != CodePoint.SQLCARD)\r
+ {\r
+ fail("Expecting SQLCARD got "+ Integer.toHexString(codepoint));\r
+ return;\r
+ }\r
+ int nullind = reader.readByte();\r
+ //cheating here and using readNetworkInt since the byteorder is the same\r
+ int code = reader.readNetworkInt();\r
+ if (code != sqlCode)\r
+ {\r
+ fail("Expecting sqlCode " + sqlCode + " got "+ Integer.toHexString(code));\r
+ return;\r
+ }\r
+ String state = reader.readString(5, "UTF-8");\r
+ if (!state.equals(sqlState))\r
+ {\r
+ fail("Expecting sqlState " + sqlState + " got "+ state);\r
+ return;\r
+ }\r
+ // skip the rest of the SQLCARD\r
+ reader.skipBytes();\r
+ }\r
+\r
+ private static String getHostName()\r
+ {\r
+ String hostName = (System.getProperty("hostName"));\r
+ if (hostName == null)\r
+ hostName="localhost";\r
+ return hostName;\r
+ }\r
+}\r
projects / Benchmarks_CSolver.git / blobdiff