/*

   Derby - Class org.apache.derbyTesting.functionTests.tests.derbynet.ProtocolTest

   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

 */
package org.apache.derbyTesting.functionTests.tests.derbynet;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.net.URL;
import java.net.UnknownHostException;
import java.nio.charset.Charset;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Locale;
import junit.framework.Test;
import org.apache.derby.impl.drda.ProtocolTestAdapter;
import org.apache.derbyTesting.functionTests.util.PrivilegedFileOpsForTests;
import org.apache.derbyTesting.functionTests.util.ProtocolTestGrammar;
import org.apache.derbyTesting.junit.BaseJDBCTestCase;
import org.apache.derbyTesting.junit.BaseTestCase;
import org.apache.derbyTesting.junit.BaseTestSuite;
import org.apache.derbyTesting.junit.SecurityManagerSetup;
import org.apache.derbyTesting.junit.SupportFilesSetup;
import org.apache.derbyTesting.junit.TestConfiguration;

/**
 * This class is used to test error conditions in the protocol.
 * <p>
 * The protocol to send to the Net server is contained in a file encoded
 * as calls to routines in {@code DDMReader} and {@code DDMWriter}.
 * Additional commands have been added for testing purposes.
 * To add tests, modify the file protocol.tests.
 * Tests can also be done as separate files and given as an argument to
 * this class.
 * <p>
 * This test was copied / converted from testProto.
 */
public class ProtocolTest
    extends BaseTestCase {

    private static final String PREFIX =
        "org/apache/derbyTesting/functionTests/tests/derbynet/";
    /** Newline character(s). */
    private static final String NL =
            BaseTestCase.getSystemProperty("line.separator");

    // Constants used to encode / represent multiple values for a command.
    private static final String MULTIVAL_START = "MULTIVALSTART";
    private static final String MULTIVAL_SEP = "SEP";
    private static final String MULTIVAL_END = "MULTIVALEND";

    // Replaces %UTF8TestString% in protocol.tests
    private static final String UTF8_TEST_MATCH = "%UTF8TestString%";
    private static final String UTF8_TEST_STRING =
            "\u4f60\u597d\u4e16\u754cABCDEFGHIJKLMNOPQ";


    /** Name of the file from which the test is obtained. */
    private final String filename;
    /** The start line of the test from the input file. */
    private final int startLine;
    /** Number of lines this test is composed of. */
    private final int lineCount;
    /**
     * The sequence of commands this test is composed of.
     * <p>
     * The sequence is expected to be line oriented, that is a one command and
     * optionally its arguments per line. The lines must be separated by a
     * newline token.
     */
    private String commandSequence;
    /**
     * The adapter that lives on the DRDA package, allowing us to call the
     * otherwise unavailable methods we need to call in package private
     * classes.
     */
    private ProtocolTestAdapter adapter;

    /**
     * Creates a new test case.
     *
     * @param file name of file containing the protocol tests (for verbosity)
     * @param cmds the sequence of commands (see {@link #commandSequence})
     * @param startLine starting line in the source file
     * @param lines number of lines from the source file
     */
    private ProtocolTest(String file, String cmds, int startLine, int lines) {
        super("testProtocolSequence");
        this.filename = file;
        this.commandSequence = cmds;
        this.startLine = startLine;
        this.lineCount = lines;
    }

    /**
     * Executes the test sequence.
     *
     * @throws IOException if accessing a file or the socket fails, or if
     *      Derby detects an unexpected protocol error
     * @throws UnknownHostException if the server host cannot be resolved
     */
    public void testProtocolSequence()
            throws IOException, UnknownHostException {
        // Update the name of the test.
        super.setName(
                filename + "_" + startLine + "_" + (startLine + lineCount));
        println(getName() + " :: STARTED");
        // Validate the line count. Expects a newline also at end of last line.
        assertEquals("Actual line count does not match the specified count",
                this.lineCount, this.commandSequence.length() -
                this.commandSequence.replaceAll("\n", "").length() -1);

        adapter = new ProtocolTestAdapter(createSocket());
        Reader cmdStream = new StringReader(this.commandSequence);
        try {
            processCommands(cmdStream);
        } finally {
            try {
                adapter.close();
            } catch (IOException ioe) {
                // Don't act on the exception, but print its message.
                alarm("adapter.close() failed: " + ioe.getMessage());
            }
        }
    }

    /** Cleans up test resources. */
    public void tearDown()
            throws Exception {
        commandSequence = null;
        adapter.close();
        adapter = null;
        super.tearDown();
    }

    /**
     * Initializes a socket to the server.
     *
     * @return A socket connected to the server.
     * @throws IOException if reading/writing to the socket fails
     * @throws UnknownHostException if the server host cannot be resolved
     */
    private static Socket createSocket()
            throws IOException, UnknownHostException {
        Socket socket = null;
        final TestConfiguration cfg = TestConfiguration.getCurrent();
        try {
            socket = AccessController.doPrivileged (
                new java.security.PrivilegedExceptionAction<Socket>() {
                    public Socket run()
                            throws IOException, UnknownHostException {
                        return new Socket(cfg.getHostName(), cfg.getPort());
                    }
                }
            );
        } catch (PrivilegedActionException pae) {
            if (pae.getCause() instanceof IOException) {
                throw (IOException)pae.getCause();
            } else if (pae.getCause() instanceof UnknownHostException) {
                throw (UnknownHostException)pae.getCause();
            }
            fail("Unhandled exception", pae);
        }
        return socket;
    }

    /**
     * Executes the test commands in the specified file.
     *
     * @param fileName file containing the test
     * @throws IOException if accessing a file or the socket fails, or if
     *      Derby detects an unexpected protocol error
     */
    private void processFile(String fileName)
            throws IOException {
        File incFile = SupportFilesSetup.getReadOnly(fileName);
        assertTrue("Missing file: " + fileName,
               PrivilegedFileOpsForTests.exists(incFile));
        BufferedReader bIn = new BufferedReader(
               PrivilegedFileOpsForTests.getFileReader(incFile));
        try {
            processCommands(bIn);
        } finally {
            bIn.close();
        }
    }

    /**
     * Processes the test commands in the stream.
     *
     * @param cmdStream command stream (see {@link #commandSequence})
     * @throws IOException if accessing a file or the socket fails, or if
     *      Derby detects an unexpected protocol error
     */
    private void processCommands(Reader cmdStream)
            throws  IOException {
        StreamTokenizer tkn = new StreamTokenizer(cmdStream);
        boolean endSignalled = false;
        int val;
        while ( (val = tkn.nextToken()) != StreamTokenizer.TT_EOF) {
            assertFalse("End signalled, data to process left: " + tkn.sval,
                    endSignalled);
            switch(val) {
                case StreamTokenizer.TT_NUMBER:
                    break;
                case StreamTokenizer.TT_WORD:
                    endSignalled = processCommand(tkn);
                    break;
                case StreamTokenizer.TT_EOL:
                    break;
            }
        }
    }

    /**
     * Process a command.
     */
    private boolean processCommand(StreamTokenizer tkn)
        throws IOException
    {
        ProtocolTestGrammar cmd = ProtocolTestGrammar.cmdFromString(
                                        tkn.sval.toLowerCase(Locale.ENGLISH));
        if (cmd == null) { // To avoid generating string for each command.
            fail("Unknown command '" + tkn.sval + "' in line " + ln(tkn));
        }
        int val;
        String str;

        switch (cmd)
        {
            case INCLUDE:
                processFile(getString(tkn));
                break;
            case CREATE_DSS_REQUEST:
                adapter.wCreateDssRequest();
                break;
            case CREATE_DSS_OBJECT:
                adapter.wCreateDssObject();
                break;
            case CREATE_DSS_REPLY:
                adapter.wCreateDssReply();
                break;
            case END_DSS:
                tkn.nextToken();
                tkn.pushBack();
                if ((tkn.sval != null) && tkn.sval.startsWith("0x"))
                // use specified chaining.
                    adapter.wEndDss((getBytes(tkn))[0]);
                else
                // use default chaining
                    adapter.wEndDss();
                break;
            case END_DDM:
                adapter.wEndDdm();
                break;
            case END_DDM_AND_DSS:
                adapter.wEndDdmAndDss();
                break;
            case START_DDM:
                adapter.wStartDdm(getCP(tkn));
                break;
            case WRITE_SCALAR_STRING:
                adapter.wWriteScalarString(getCP(tkn), getString(tkn));
                break;
            case WRITE_SCALAR_2BYTES:
                adapter.wWriteScalar2Bytes(getCP(tkn),getIntOrCP(tkn));
                break;
            case WRITE_SCALAR_1BYTE:
                adapter.wWriteScalar1Byte(getCP(tkn),getInt(tkn));
                break;
            case WRITE_SCALAR_BYTES:
                adapter.wWriteScalarBytes(getCP(tkn),getBytes(tkn));
                break;
            case WRITE_SCALAR_PADDED_BYTES:
                adapter.wWriteScalarPaddedBytes(getCP(tkn), getBytes(tkn),
                        getInt(tkn), ProtocolTestAdapter.SPACE);
                break;
            case WRITE_BYTE:
                adapter.wWriteByte(getInt(tkn));
                break;
            case WRITE_BYTES:
                adapter.wWriteBytes(getBytes(tkn));
                break;
            case WRITE_SHORT:
                adapter.wWriteShort(getInt(tkn));
                break;
            case WRITE_INT:
                adapter.wWriteInt(getInt(tkn));
                break;
            case WRITE_CODEPOINT_4BYTES:
                adapter.wWriteCodePoint4Bytes(getCP(tkn), getInt(tkn));
                break;
            case WRITE_STRING:
                str = getString(tkn);
                adapter.wWriteBytes(getEBCDIC(str));
                break;
            case WRITE_ENCODED_STRING:
                writeEncodedString(getString(tkn), getString(tkn));
                break;
            case WRITE_ENCODED_LDSTRING:
                writeEncodedLDString(getString(tkn), getString(tkn), getInt(tkn));
                break;
            case WRITE_PADDED_STRING:
                str = getString(tkn);
                adapter.wWriteBytes(getEBCDIC(str));
                int reqLen = getInt(tkn);
                int strLen = str.length();
                if (strLen < reqLen)
                    adapter.wPadBytes(ProtocolTestAdapter.SPACE, reqLen-strLen);
                break;
            case READ_REPLY_DSS:
                adapter.rReadReplyDss();
                break;
            case SKIP_DSS:
                adapter.rSkipDss();
                break;
            case SKIP_DDM:
                adapter.rSkipDdm();
                break;
            case MORE_DATA:
                str = getString(tkn);
                boolean expbool = Boolean.parseBoolean(str);
                assertEquals("Too much/little data",
                        expbool, adapter.rMoreData());
                break;
            case READ_LENGTH_AND_CODEPOINT:
                readLengthAndCodePoint(tkn);
                break;
            case READ_SCALAR_2BYTES:
                readLengthAndCodePoint(tkn);
                val = adapter.rReadNetworkShort();
                checkIntOrCP(tkn, val);
                break;
            case READ_SCALAR_1BYTE:
                readLengthAndCodePoint(tkn);
                val = adapter.rReadByte();
                checkIntOrCP(tkn, val);
                break;
            case READ_SECMEC_AND_SECCHKCD:
                readSecMecAndSECCHKCD();
                break;
            case READ_BYTES:
                assertTrue("Mismatch between the byte arrays",
                        Arrays.equals(getBytes(tkn), adapter.rReadBytes()));
                break;
            case READ_NETWORK_SHORT:
                val = adapter.rReadNetworkShort();
                checkIntOrCP(tkn, val);
                break;
            case FLUSH:
                adapter.wFlush();
                break;
            case DISPLAY:
                println(getString(tkn));
                break;
            case CHECKERROR:
                checkError(tkn);
                break;
            case CHECK_SQLCARD:
                checkSQLCARD(getInt(tkn), getString(tkn));
                break;
            case END_TEST:
                // Nothing to do for ending the test, as resources are closed
                // elsewhere. Note that each test case will get it's own
                //  connection and set of resources.
                println(getName() + " :: FINISHED");
                return true;
            case SKIP_BYTES:
                adapter.rSkipBytes();
                break;
            case SWITCH_TO_UTF8_CCSID_MANAGER:
                adapter.setUtf8Ccsid();
                break;
            case DELETE_DATABASE:
                deleteDatabase(getString(tkn));
                break;
            default:
                fail("Command in line " + ln(tkn) + " not implemented: " +
                        cmd.toString());
        }
        return false;
    }

    /**
     * Read an int from the command file
     * Negative numbers are preceded by "-"
     */
    private int getInt(StreamTokenizer tkn) throws IOException
    {
        int mult = 1;
        int val = tkn.nextToken();
        if (tkn.sval != null && tkn.sval.equals("-"))
        {
            mult = -1;
            val = tkn.nextToken();
        }

        if (val != StreamTokenizer.TT_NUMBER)
        {
            assertNotNull("Invalid string on line " + ln(tkn), tkn.sval);
            String str = tkn.sval.toLowerCase(Locale.ENGLISH);
            if (!str.startsWith("0x")) {
                fail("Expecting number, got " + tkn.sval + " on line " +
                        ln(tkn));
            } else {
                return convertHex(str, ln(tkn));
            }
        }
        return Double.valueOf(tkn.nval).intValue() * mult;
    }

    /**
     * Convert a token in hex format to int from the command file
     */
    private int convertHex(String str, int lineNumber) throws IOException
    {
        int retval = 0;
        int len = str.length();
        if ((len % 2) == 1 || len > 10)
        {
            fail("Invalid length for byte string, " + len +
                    " on line " + lineNumber);
        }
        for (int i = 2; i < len; i++)
        {
            retval = retval << 4;
            retval += Byte.valueOf(str.substring(i, i+1), 16).byteValue();
        }
        return retval;
    }

    /**
     * checks if value matches next int or cp.
     * Handles multiple legal values in protocol test file
     * FORMAT for Multiple Values
     * MULTIVALSTART 10 SEP 32 SEP 40 MULTIVALEND
     **/
    private boolean checkIntOrCP(StreamTokenizer tkn, int val)
            throws IOException {
        boolean rval = false;
        int tknType = tkn.nextToken();
        String reqVal = " ";

        if (tknType == StreamTokenizer.TT_WORD &&
                tkn.sval.trim().equals(MULTIVAL_START)) {
            do {
                int nextVal = getIntOrCP(tkn);
                reqVal = reqVal + nextVal + " ";
                rval = rval || (val == nextVal);
                tkn.nextToken();
            }
            while(tkn.sval.trim().equals(MULTIVAL_SEP));

            if (! (tkn.sval.trim().equals(MULTIVAL_END)))
                fail("Invalid test file format, requires " + MULTIVAL_END +
                     ", got: " + tkn.sval);
        }
        else
        {
            tkn.pushBack();
            int nextVal = getIntOrCP(tkn);
            reqVal = " " + nextVal;
            rval = (val == nextVal);
        }
        assertTrue("Expected '" + reqVal + "', got '" + val + "'", rval);

        return rval;
    }


    /**
     * Read an int or codepoint - codepoint is given as a string
     */
    private int getIntOrCP(StreamTokenizer tkn) throws IOException
    {
        int val = tkn.nextToken();
        if (val == StreamTokenizer.TT_NUMBER) {
            return Double.valueOf(tkn.nval).intValue();
        } else if (val == StreamTokenizer.TT_WORD) {
            return decodeCP(tkn.sval, ln(tkn));
        } else {
            fail("Expecting number, got '" + tkn.sval + "' on line " + ln(tkn));
        }
        return 0;
    }

    /**
     * Read an array of bytes from the command file
     * A byte string can start with 0x in which case the bytes are interpreted
     * in hex format or it can just be a string, in which case each char is
     * interpreted as  2 byte UNICODE
     *
     * @return byte array
     */
    private byte []  getBytes(StreamTokenizer tkn) throws IOException
    {
        byte[] retval;
        tkn.nextToken();
        assertNotNull("Missing input on line " + ln(tkn), tkn.sval);
        String str = tkn.sval.toLowerCase(Locale.ENGLISH);
        if (!str.startsWith("0x"))
        {
            //just convert the string to ebcdic byte array
            return getEBCDIC(str);
        }
        else
        {
            int len = str.length();
            if ((len % 2) == 1) {
                fail("Invalid length for byte string, " + len +
                        " on line " + ln(tkn));
            }
            retval = new byte[(len-2)/2];
            int j = 0;
            for (int i = 2; i < len; i+=2, j++)
            {
                retval[j] = (byte)(Byte.valueOf(str.substring(i, i+1), 16).byteValue() << 4);
                retval[j] += Byte.valueOf(str.substring(i+1, i+2), 16).byteValue();
            }
        }
        return retval;
    }

    /**
     * Read a string from the command file
     *
     * @return string found in file
     * @exception     IOException     error reading file
     */
    private String getString(StreamTokenizer tkn) throws IOException
    {
        int val = tkn.nextToken();
        assertTrue("Expected string, got number '" + tkn.nval + "' on line " +
                ln(tkn), val != StreamTokenizer.TT_NUMBER);

        /* Check whether '%UTF8TestString%' is in the string and replace
         * it with Chinese characters for the UTF8 protocol tests */
        if (tkn.sval.contains(UTF8_TEST_MATCH))
            return tkn.sval.replace(UTF8_TEST_MATCH, UTF8_TEST_STRING);

        return tkn.sval;
    }

    /**
     * Read the string version of a CodePoint
     *
     * @exception     IOException     error reading file
     */
    private int getCP(StreamTokenizer tkn)
            throws IOException {
        String strval = getString(tkn);
        return decodeCP(strval, ln(tkn));
    }

    /**
     * Translate a string codepoint such as ACCSEC to the equivalent int value
     *
     * @param strval    string codepoint
     * @return         integer value of codepoint
     */
    private int decodeCP(String strval, int lineNumber) {
        Integer cp = adapter.decodeCodePoint(strval);
        assertNotNull("Unknown codepoint '" + strval + "' in line " +
                lineNumber, cp);
        return cp.intValue();
    }

    /**
     * Check error sent back to application requester
      *
     * @exception     IOException error reading file or protocol
     */
    private void checkError(StreamTokenizer tkn)
            throws IOException {
        int svrcod = 0;
        int invalidCodePoint = 0;
        int prccnvcd = 0;
        int synerrcd = 0;
        int codepoint;
        int reqVal;
        ArrayList<Integer> manager = new ArrayList<Integer>();
        ArrayList<Integer> managerLevel = new ArrayList<Integer>() ;
        adapter.rReadReplyDss();
        int error = adapter.rReadLengthAndCodePoint( false );
        int reqCP = getCP(tkn);
        assertCP(reqCP, error);
        while (adapter.rMoreDssData())
        {
            codepoint = adapter.rReadLengthAndCodePoint( false );
            switch (codepoint)
            {
                case ProtocolTestAdapter.CP_SVRCOD:
                    svrcod = adapter.rReadNetworkShort();
                    break;
                case ProtocolTestAdapter.CP_CODPNT:
                    invalidCodePoint = adapter.rReadNetworkShort();
                    break;
                case ProtocolTestAdapter.CP_PRCCNVCD:
                    prccnvcd = adapter.rReadByte();
                    break;
                case ProtocolTestAdapter.CP_SYNERRCD:
                    synerrcd = adapter.rReadByte();
                    break;
                case ProtocolTestAdapter.CP_MGRLVLLS:
                    while (adapter.rMoreDdmData())
                    {
                        manager.add(Integer.valueOf(adapter.rReadNetworkShort()));
                        managerLevel.add(Integer.valueOf(adapter.rReadNetworkShort()));
                    }
                    break;
                default:
                    //ignore codepoints we don't understand
                    adapter.rSkipBytes();
                    println("Skipped bytes for codepoint " + codepoint + " (" +
                            adapter.lookupCodePoint(codepoint) + ")");
            }
        }
        reqVal = getInt(tkn);
        assertEquals("Wrong svrcod (0x" + Integer.toHexString(reqVal) +
                " != 0x" + Integer.toHexString(svrcod) + ")", reqVal, svrcod);
        if (error == ProtocolTestAdapter.CP_PRCCNVRM) {
            reqVal = getInt(tkn);
            assertEquals("Wrong prccnvcd (0x" + Integer.toHexString(reqVal) +
                " != 0x" + Integer.toHexString(prccnvcd) + ")",
                reqVal, prccnvcd);
        }
        if (error == ProtocolTestAdapter.CP_SYNTAXRM) {
            reqVal = getInt(tkn);
            assertEquals("Wrong synerrcd (0x" + Integer.toHexString(reqVal) +
                " != 0x" + Integer.toHexString(synerrcd) + ")",
                reqVal, synerrcd);
            reqVal = getIntOrCP(tkn);
            assertCP(reqVal, invalidCodePoint);
        }
        if (error == ProtocolTestAdapter.CP_MGRLVLRM)
        {
            int mgr, mgrLevel;
            for (int i = 0; i < manager.size(); i++)
            {
                reqVal = getCP(tkn);
                mgr = manager.get(i);
                assertCP(reqVal, mgr);
                mgrLevel = managerLevel.get(i);
                reqVal = getInt(tkn);
                assertEquals("Wrong manager level (0x" +
                        Integer.toHexString(reqVal) + " != 0x" +
                        Integer.toHexString(mgrLevel) + ")", reqVal, mgrLevel);
            }
        }
    }

    /**
     * Read length and codepoint and check against required values
      *
     * @exception     IOException error reading file or protocol
     */
    private void readLengthAndCodePoint(StreamTokenizer tkn)
            throws IOException {
        int codepoint = adapter.rReadLengthAndCodePoint( false );
        int reqCP = getCP(tkn);
        assertCP(reqCP, codepoint);
    }

    /**
     * Handle the case of testing the reading of SECMEC and SECCHKCD,
     * where on an invalid SECMEC value for ACCSEC, the server can send
     * valid supported SECMEC values. One of the valid supported value can be
     * EUSRIDPWD (secmec value of 9) depending on if the server JVM
     * can actually support it or not.
     * @exception   IOException error reading file or protocol
     */
    private void readSecMecAndSECCHKCD() throws IOException
    {
        int codepoint;
        boolean notDone = true;
        int val;
        do
        {
            codepoint = adapter.rReadLengthAndCodePoint( false );
            switch(codepoint)
            {
              case ProtocolTestAdapter.CP_SECMEC:
              {
                  val = adapter.rReadNetworkShort();
                  println("SECMEC=" + val);
              }
              break;
              case ProtocolTestAdapter.CP_SECCHKCD:
              {
                  val = adapter.rReadByte();
                  println("SECCHKCD=" + val);
                  notDone = false;
              }
              break;
              default:
                  notDone=false;
            }
        }while(notDone);
    }

    /**
     * Codepoint error
      *
     * @exception IOException error reading command file
     */
    private void assertCP(int reqCP, int cp) {
        String cpName = adapter.lookupCodePoint(cp);
        String reqCPName = adapter.lookupCodePoint(reqCP);
        assertEquals("Wrong codepoint (0x" + Integer.toHexString(reqCP) +
             "/" + reqCPName + " != 0x" + Integer.toHexString(cp) +
             "/" + cpName + ")", reqCP, cp);
    }

    /**
     * Translate a string to EBCDIC for use in the protocol
     *
     * @param str    string to transform
     * @return EBCDIC string
     */
    private byte[] getEBCDIC(String str)
    {
        return adapter.convertFromJavaString(str);
    }

    /**
     * Write an encoded string
     *
     * @param str    string to write
     * @param encoding    Java encoding to use
     * @exception IOException
     */
    private void writeEncodedString(String str, String encoding) {
        try {
            byte [] buf = str.getBytes(encoding);
            adapter.wWriteBytes(buf);
        } catch (UnsupportedEncodingException e) {
            fail("Unsupported encoding " + encoding, e);
        }
    }

    /**
     * Write length and encoded string
     *
     * @param str string to write
     * @param encoding    Java encoding to use
     * @param len            Size of length value (2 or 4 bytes)
     * @exception IOException
     */
    private void writeEncodedLDString(String str, String encoding, int len) {
        try {
            byte [] buf = str.getBytes(encoding);
            if (len == 2)
                adapter.wWriteShort(buf.length);
            else
                adapter.wWriteInt(buf.length);
            adapter.wWriteBytes(buf);
        } catch (UnsupportedEncodingException e) {
            fail("Unsupported encoding " + encoding, e);
        }
    }

    /**
     * Check the value of SQLCARD
     *
     * @param sqlCode    SQLCODE value
     * @param sqlState    SQLSTATE value
     * @exception IOException, DRDAProtocolException
     */
    private void checkSQLCARD(int sqlCode, String sqlState)
            throws IOException {
        adapter.rReadReplyDss();
        int codepoint = adapter.rReadLengthAndCodePoint( false );
        assertEquals("Expected SQLCARD (0x2408), got " +
                Integer.toHexString(codepoint), ProtocolTestAdapter.CP_SQLCARD,
                codepoint);
        adapter.rReadByte(); // Skip null indicator.
        //cheating here and using readNetworkInt since the byteorder is the same
        int code = adapter.rReadNetworkInt();
        assertEquals("Expected " + Integer.toHexString(sqlCode) + ", got " +
                Integer.toHexString(code), sqlCode, code);
        String state = adapter.rReadString(5, "UTF-8");
        assertEquals("Wrong SQL state", sqlState, state);
        // skip the rest of the SQLCARD
        adapter.rSkipBytes();
    }

    /**
     * Calculates the current line number from the source file.
     * <p>
     * The intention is to be able to print which line number the test failed
     * on, so that the source of the error can be easily located.
     *
     * @param st processing stream tokenizer
     * @return The calculated current line number.
     */
    private int ln(StreamTokenizer st) {
        return (this.startLine + st.lineno() -1);
    }

    /**
     * Delete the database with the name 'name'
     * @param name Name of the database to delete
     */
    private void deleteDatabase(String name) {
        String shutdownUrl = "jdbc:derby:"+name+";shutdown=true";
        try {
            DriverManager.getConnection(shutdownUrl);
        } catch (SQLException sqle) {
            // ignore shutdown exception
            BaseJDBCTestCase.assertSQLState("08006", sqle);
        }
        removeDirectory(getSystemProperty("derby.system.home") +
                File.separator + name);
    }

    /**
     * Creates a suite of tests dynamically from a file describing protocol
     * tests.
     *
     * @return A suite of tests.
     * @throws Exception if creating the suite fails for some reason
     */
    public static Test suite()
            throws Exception {
        BaseTestSuite suite = new BaseTestSuite("Derby DRDA protocol tests");
        // Process the list of files and create test cases for the sub-tests.
        // NOTE: We cannot assume anything about the order in which the tests
        //      are executed.
        final String testFile = PREFIX + "protocol.tests";
        final URL testFileURL = BaseTestCase.getTestResource(testFile);
        BufferedReader bIn = new BufferedReader(
                new InputStreamReader(
                    openTestResource(testFileURL),
                    Charset.forName("UTF-8")));

        // Split the tests into individual tests.
        final String END_TEST = ProtocolTestGrammar.END_TEST.toCmdString();
        int currentLine = 1;
        int startLine = 1; // First line is line number one.
        ArrayList<String> cmdLines = new ArrayList<String>();
        StringBuilder str = new StringBuilder();
        String line;
        // Iterate until the end of test token is reached.
        while ((line = bIn.readLine()) != null) {
            cmdLines.add(line);
            str.append(line).append(NL);
            if (line.toLowerCase(Locale.ENGLISH).startsWith(END_TEST)) {
                // Create a new test case.
                suite.addTest(new ProtocolTest(
                        "protocol.tests",
                        str.toString(),
                        startLine,
                        currentLine - startLine));
                cmdLines.clear();
                str.setLength(0);
                startLine = currentLine +1;
            }
            currentLine++;
        }
        bIn.close();

        // Install a security policy and copy the required include files.
        final String resourcePath = "functionTests/tests/derbynet";
        return new SecurityManagerSetup(
                TestConfiguration.clientServerDecorator(
                    new SupportFilesSetup(suite, new String[] {
                        resourcePath + "/connect.inc",
                        resourcePath + "/excsat_accsecrd1.inc",
                        resourcePath + "/excsat_accsecrd2.inc",
                        resourcePath + "/excsat_accsecrd_nordb.inc",
                        resourcePath + "/excsat_secchk_nordbonaccsec.inc",
                        resourcePath + "/excsat_secchk.inc",
                        resourcePath + "/values1.inc",
                        resourcePath + "/values64kblksz.inc",
                    })),
                PREFIX + "ProtocolTest.policy",
                true);
    }
}