DaqTests.java

Go to the documentation of this file.

package dndtester;
import java.net.*;
import java.io.*;
import java.util.*;
import java.text.*;
import javax.swing.*;
import java.awt.*;

public class DaqTests{
    protected static int DATAPORT = 55056;

    protected static int COMMANDPORT = 55055;
    
    private InetAddress remoteAddr;
    
    private Socket dataSocket = null;

    private Socket commandSock = null;

    protected BufferedReader commReader = null;

    protected BufferedReader dataReader = null;

    protected PrintStream commPStream = null;

    private  boolean dialog = false;

    private boolean connection = false;

    protected boolean validConnect = false;

    protected Hashtable channelTable;

    public static final DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-DD'T'HH:mm:ss.SSS");
    
    private JProgressBar progressBar = null;

    private int increment = 0;

    public DaqTests(String hostname){
        channelTable = new Hashtable();
        try{
            // if the hostname is invalid then return
            remoteAddr = InetAddress.getByName(hostname);
        }catch(UnknownHostException e1){
            JOptionPane.showMessageDialog(null, "Unknown Host",
                                          "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }
        // Create two threads and start them
        DialogThread dialogThread = new DialogThread();
        ConnectingThread connectThread = new ConnectingThread(dialogThread);
        dialogThread.setToKill(connectThread);
        
        connectThread.start();

        dialogThread.start();
    }

    class ConnectingThread extends Thread{
        boolean killed = false;
        
        boolean failed = false;

        Thread toKill;

        public ConnectingThread(Thread tokill){
            toKill = tokill;
        }
        public void destroy(){
            killed = true;
        }
        
        public void run(){
            connection = true;
            try{
                InetSocketAddress inetCommandAddress = 
                    new InetSocketAddress(remoteAddr, COMMANDPORT);
                Socket temp = new Socket();

                try{
                    // give the dialog thread enought time to load the image
                    // otherwise it will not be able to interrupted completelly.
                    Thread.sleep(100);
                }catch(InterruptedException e2){}

                // Attempts to connect for 20 sec then it give up.
                temp.connect(inetCommandAddress, 20000);

                commandSock = temp;
                InetSocketAddress inetDataAddress = 
                    new InetSocketAddress(remoteAddr, DATAPORT);
                temp = new Socket();
                try{
                    // Must make this thread sleep for at least 1 sec since
                    // LabView 6.1 cannot accept connections without this delay.
                    Thread.sleep(1000);
                }catch(InterruptedException e2){}
                // Attempts to connect for 20 sec then it gives up.
                temp.connect(inetDataAddress, 20000);

                dataSocket = temp;

                // At this point all connections have been establish is time to
                // set the buffers for sending and receiving data.
                commReader = new BufferedReader (new InputStreamReader
                                                    (commandSock.getInputStream()));
                dataReader = new BufferedReader (new InputStreamReader
                                                 (dataSocket.getInputStream()));
                commPStream = new PrintStream (commandSock.getOutputStream());
                validConnect = true;
            }
            catch(IOException e2){
                failed = true;
                // If the DialogThread killed it.
                if(!killed){
                    // wait till the DialogThread is running.
                    while(!dialog){
                        try{
                            sleep(10);
                        }catch(InterruptedException e1){}
                    }

                    // to avoid having the interrupt() method interrupt the 'Trying to Connect'
                    // message right when is loading the image. Happends occationally.
                    yield();
                    // interruped the DialogThread
                    toKill.interrupt();
                    ((DialogThread)toKill).interrupted = true;
                    JOptionPane.showMessageDialog(null, "Connection Failed\n make sure DAQ is running",
                                                  "Error", JOptionPane.ERROR_MESSAGE);
                }
                // the connection failed is like if it was cancel.
                killed = true;
                return;
            }
            finally{
                if(killed){
                    validConnect = false;
                    DaqPanel.curDaqPanel.updateConnectionStatus();
                    return;
                }
            }
            
            while(!dialog){
                try{
                    // yield() might be a better option.
                    sleep(50);
                }catch(InterruptedException e1){
                    DaqPanel.curDaqPanel.updateConnectionStatus();
                    return;}
            }
            
            // to avoid having the interrupt() method interrupt the 'Trying to Connect'
            // message right when is loading the image. Happends occationally.
            yield();
            toKill.interrupt();

            ((DialogThread)toKill).interrupted = true;
            validConnect = true;
            DaqPanel.curDaqPanel.updateConnectionStatus();
        }
    }
    class DialogThread extends Thread{

        Thread toKill;

        boolean interrupted = false;

         protected void setToKill(Thread tokill){
            toKill = tokill;
        }

        public void run(){
            dialog = true;
            JOptionPane.showOptionDialog(null, "Connecting ...", "Trying to Connect", 
                                         JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, 
                                         null, new Object[] {"stop Connection"}, "stop Connection");

            // if it has not been interrupted by the ConnectingThread then it will try to kill it.
            if(!interrupted){
                toKill.interrupt();
                toKill.destroy();
            }
        }
    }

    public String testCommand(String command) throws TestSuiteException{
        return testingCommand(commPStream, 
                              commReader, command);
    }

    public TestResult testCommand(String command, String result)
        throws TestSuiteException{
        return testingCommand(commPStream, 
                              commReader, command, result);
    }
    
    public  TestResult testingCommand (PrintStream pstream, BufferedReader buf, 
                                      final String command, final String responce) throws TestSuiteException{
        pstream.print(command);
        TestResult result = new TestResult();

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return new TestResult();

            //must REPlACE
        }
        
        try{
            String str = buf.readLine();
            if(str == null){
                // readLine() blocks till a '\n' character. If it returns null is because there
                // is a problem with the buffer reader.
                throw new TestSuiteException(){
                        public void run(){
                            JOptionPane.showMessageDialog(null, "Connection was lost",
                                                          "Error", JOptionPane.ERROR_MESSAGE);
                            disconnect();
                        }
                    };
            }
            if(str.equalsIgnoreCase(responce)){
                result.pass = true;
            }
            else{
                result.pass = false;
                result.different = str;
            }
        }
        catch(IOException e3){
            throw new TestSuiteException(){
                    public void run(){
                        System.out.println("Here the error is");
                        JOptionPane.showMessageDialog(null, "Error while reading from command Socket",
                                                      "Error", JOptionPane.ERROR_MESSAGE);
                    }
                };
        }
        return result;
    }
    
    public String readingData() throws TestSuiteException{
        String str = null;
        try{
            str = dataReader.readLine();
            if(str == null){
                throw new TestSuiteException(){
                        public void run(){
                            JOptionPane.showMessageDialog(null, "Connection was lost",
                                                          "Error", JOptionPane.ERROR_MESSAGE);
                            disconnect();
                        }
                    };
            }
        }
        catch(IOException e3){
            throw new TestSuiteException(){
                    public void run(){
                        System.out.println("reading data");
                        JOptionPane.showMessageDialog(null, "Error while reading from data Socket",
                                                      "Error", JOptionPane.ERROR_MESSAGE);
                    }
                };
        }
        return str;
    }

    public String testingCommand(PrintStream pstream, BufferedReader buf, String command)
        throws TestSuiteException{
        pstream.print(command); 
        String str = null;
        try{
            str = buf.readLine();
            if(str == null){
                // readLine() blocks till a '\n' character. If it returns null is because there
                // is a problem with the buffer reader.
                throw new TestSuiteException(){
                        public void run(){
                            JOptionPane.showMessageDialog(null, "Connection was lost",
                                                          "Error", JOptionPane.ERROR_MESSAGE);
                            disconnect();
                        }
                    };
            }
        }
        catch(IOException e3){
            throw new TestSuiteException(){
                    public void run(){
                        System.out.println("third");
                        JOptionPane.showMessageDialog(null, "Error while reading from command Socket",
                                                      "Error", JOptionPane.ERROR_MESSAGE);
                    }
                };
        }
        return str;
    }
    
    public void disconnect(){
        try{
            if(dataSocket != null){
                dataSocket.close();
            }
            if(commandSock != null){
                commandSock.close();
            }
        }catch(IOException exception){
            System.out.println("Error in disconnect()");
        }
        validConnect = false;
    }

    public boolean openCloseBadPort(String command, DaqPanel repaintPanel, SSPanel sspanel) 
        throws TestSuiteException{
        TestResult responce;
        int index = sspanel.logString("Testing " + command + "-port on a bad channel");

        repaintPanel.repaint();
        // call testCommand() on an invalid channel
        responce = testCommand(command + "-port 9,,0\n",
                               "Invalid port '[bad port]'"); 

        // if the debug flag is set then log the debugging information
        if(DaqDriverTest.debug){
            sspanel.logDebugString("Send command: " + command + "-port 9,,0");
            if(responce.pass){
                sspanel.logDebugString("Expected response: Invalid port '9,,0'"); 
                sspanel.logDebugString("Actual response matches");
            }
            else{
                sspanel.logDebugString("Expected response: Invalid port '9,,0'"); 
                sspanel.logDebugString("Actual response: " + responce.different);
            }
        }

        // using index replace what was there to show the status, PASS or FAIL
        if(responce.pass){
            sspanel.replaceLog("Testing " + command + "-port on a bad channel    PASS", 
                               index);
        }
        else{
            sspanel.replaceLog("Testing " + command + "-port on a bad channel    FAIL", 
                               index);
        }
        repaintPanel.repaint();
        return responce.pass;
    }



    public boolean openClosePort(String command, String answer, DaqPanel repaintPanel, SSPanel sspanel)
        throws TestSuiteException{
        // temp variables used throughout
        String str, str2;
        boolean pass = true;
        TestResult responce;
        
        // we want to go through all elements in list-channels
        Enumeration iter = channelTable.elements();

        // counter is used to repeate same commands
        int counter = 0;
        
        // index is where the sspanel logged the string.  index is then used to update
        // the status.
        int index = sspanel.logString("Testing " + command + "-port on all channels");

        repaintPanel.repaint();

        
        // if channelTable has not elements that means that list-channels did not return valid
        // channels
        if(!iter.hasMoreElements()){
            throw new TestSuiteException(){
                    public void run(){
                        JOptionPane.showMessageDialog(null, "No Channels available",
                                                      "Error", JOptionPane.ERROR_MESSAGE);
                    }
                };
        }
        str = (String)iter.nextElement();
        
        // call testCommand() to test the first channel
        responce = testCommand(command + "-port " + str + "\n",
                               answer + str); 
        // updating progress bar
        if(progressBar != null){
            progressBar.setValue(progressBar.getValue() + increment);
        }

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }

        pass = pass && responce.pass;
        counter++;

        // if the debug flag is set then log the debugging information
        if(DaqDriverTest.debug){
            sspanel.logDebugString("Send command: " + command + "-port");
            if(responce.pass){
                    sspanel.logDebugString("Expected response: " + answer + str);
                    sspanel.logDebugString("Actual response matches");
            }
            else{
                sspanel.logDebugString("Expected response: " + answer + str); 
                    sspanel.logDebugString("Actual response: " + responce.different);
            }
        }

        str2 = str;
        responce = testCommand(command + "-port " + str + "\n",
                               answer + str); 
        pass = pass && responce.pass;

        // repeat the same command as above to insured that if the same channel is open
        // then it will cause no problems.
        if(DaqDriverTest.debug){
            sspanel.logDebugString("Send command: " + command + "-port");
            if(responce.pass){
                    sspanel.logDebugString("Expected response: " + answer + str);
                    sspanel.logDebugString("Actual response matches");
            }
            else{
                sspanel.logDebugString("Expected response: " + answer + str); 
                    sspanel.logDebugString("Actual response: " + responce.different);
            }
        }
        




        // same as above, this time we just iterate all the channels in the channelTable
        while(iter.hasMoreElements()){
            repaintPanel.repaint();
            str = (String)iter.nextElement();
            responce = testCommand(command + "-port " + str + "\n",
                                   answer + str); 
            
            // updating progress bar
            if(progressBar != null){
                progressBar.setValue(progressBar.getValue() + increment);
            }

            // check if the thread has been stopped
            if(((StopThread)Thread.currentThread()).isStopped()){
                return false;
            }

            pass = pass && responce.pass;
            if(DaqDriverTest.debug){
                sspanel.logDebugString("Send command: " + command + "-port");
                if(responce.pass){
                    sspanel.logDebugString("Expected response: " + answer + str);
                    sspanel.logDebugString("Actual response matches");
                }
                else{
                    sspanel.logDebugString("Expected response: " + answer + str); 
                    sspanel.logDebugString("Actual response: " + responce.different);
                }
            }
            // every 5 open/close ports, a repeated is used to make sure that it returns the correct
            // resutl
            if(counter % 5 == 0){
                responce = testCommand(command + "-port " + str2 + "\n",
                                       answer + str2); 
                pass = pass && responce.pass;
                if(DaqDriverTest.debug){
                    sspanel.logDebugString("Send command: " + command + "-port");
                    if(responce.pass){
                        sspanel.logDebugString("Expected response: " + answer + str2);
                    sspanel.logDebugString("Actual response matches");
                    }
                    else{
                        sspanel.logDebugString("Expected response: " + answer); 
                        sspanel.logDebugString("Actual response: " + responce.different);
                    }
                }
            }
            counter++;
        }
        
        // using index replace what was there to show the status, PASS or FAIL
        if(pass){
            sspanel.replaceLog("Testing " + command + "-port on all channels     PASS", 
                               index);
        }
        else{
            sspanel.replaceLog("Testing " + command + "-port on all channels     FAIL", 
                               index);
        }
        repaintPanel.repaint();
        return pass;
    }

    public static void setPorts(int commandPort){
        COMMANDPORT = commandPort;
        DATAPORT = COMMANDPORT + 1;
    }

    public boolean testStatus(String answer, DaqPanel repaintPanel, SSPanel sspanel)
        throws TestSuiteException{
        boolean pass = true;
        TestResult responce;
        int index = sspanel.logString("Testing daq-status");
        repaintPanel.repaint();
        responce = testCommand("daq-status\n", answer);
        pass = pass && responce.pass;
        
        if(DaqDriverTest.debug){
            sspanel.logDebugString("Send command: daq-status");
            if(responce.pass){
                sspanel.logDebugString("Expected response: " + answer);
                sspanel.logDebugString("Actual response matches");
            }
            else{
                sspanel.logDebugString("Expected response: " + answer); 
                sspanel.logDebugString("Actual response: " + responce.different);
            }
        } 

        if(pass){
            sspanel.replaceLog("Testing daq-status                                             PASS", index);
        }
        else{
            sspanel.replaceLog("Testing daq-status                                             FAIL", index);
        }
        return pass;
    }
    
    public boolean testingUnknownCommands(DaqPanel repaintPanel, SSPanel sspanel)
        throws TestSuiteException{
        boolean pass = true;
        TestResult responce[];
        int index = sspanel.logString("Testing Unknown Commands");
        repaintPanel.repaint();
        responce = new TestResult[2];
        String send[] = {"987978", "daq,status10"};
        for(int i = 0; i < responce.length; i++){
            responce[i] = testCommand(send[i] + "\n", "Unknown Command '" + send[i] + "'");
            
            if(DaqDriverTest.debug){
                sspanel.logDebugString("Send command: " + send[i]);
                if(responce[i].pass){
                    sspanel.logDebugString("Expected response: " + "Unknown Command '" + send[i] + 
                                           "'" + " Actual response: " + "Unknown Command '" + send[i] +"'");
                }
                else{
                    sspanel.logDebugString("Expected response: " + "Unknown Command '" + send[i] + 
                                           "'" + " Actual response: " + responce[i].different);
                }
            }
            pass = pass && responce[i].pass;
        }
        if(pass){
            sspanel.replaceLog("Testing Unknown Commands                             PASS", index);
        }
        else{
            sspanel.replaceLog("Testing Unknown Commands                             FAIL", index);
        }
        repaintPanel.repaint();
        return pass;
    }

    public void flushBuffers(DaqPanel repaintPanel, SSPanel sspanel, boolean block) throws TestSuiteException{
        // we want to go through all elements in list-channels
        Enumeration iter = channelTable.elements();
        String str = "";
        if(block){
            while(iter.hasMoreElements()){
            repaintPanel.repaint();
            str = (String)iter.nextElement();
            testCommand("close-port " + str + "\n", "Stopping data on data channel from port "+ str); 
            }
        }
        try{
            if(block){
                Thread.sleep(500);
            }
            while(commReader.ready()){
                commReader.read();
            }

            while(dataReader.ready()){
                dataReader.read();
            }
            // double make sure that the DAQ had enough time to send all and everything is flushed
            if(block){
                Thread.sleep(500);
                while(commReader.ready()){
                    commReader.read();
                }
                
                while(dataReader.ready()){
                    dataReader.read();
                }
            }


        }
        catch(IOException e5){
            if(DaqDriverTest.debug){
                sspanel.logDebugString("Error While flushing");
                repaintPanel.repaint();
            }
        }
        catch(InterruptedException e1){
            System.out.println("I WAS INTERRUPTED");
        }
        channelTable = new Hashtable();
    }
    
    public boolean testSuite(DaqPanel repaintPanel, SSPanel sspanel, JProgressBar bar, int runs) throws TestSuiteException{
        String str = "", str2 = "";
        Graphics graphics;
        int i;
        TestResult responce = null;
        boolean pass = true;
        int testNumber = 0, testFail = 0;
        progressBar = bar;
        
        // this is in case the connection is still active while
        // the thread was stopped by the user some things should be flush
        flushBuffers(repaintPanel, sspanel, false);
        channelTable = new Hashtable();
        
        //Testing daq-status
        testNumber++;
        if(!testStatus("Running", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }
        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }

        //Testing unknown commands
        testNumber++;
        if(!testingUnknownCommands(repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }

        //Testing format of listing channels
        int index = sspanel.logString("Testing list-channels");
        testNumber++;
        repaintPanel.repaint();
        String channels = testCommand("list-channels\n");

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }

        StringTokenizer tokens = new StringTokenizer(channels, ",", true);
        str = ",";
        while(true){
            
            // check if the thread has been stopped
            if(((StopThread)Thread.currentThread()).isStopped()){
                return false;
            }
            
            if(tokens.hasMoreTokens()){
                if(str.equals(",")){
                    str = tokens.nextToken();
                    if(str.equals(",") || 
                       (str.equals(",") && !tokens.hasMoreTokens())){
                        pass = false;
                        break;
                    }
                    else{
                        //add to hash table
                        if(channelTable.contains(str)){
                            pass = false;
                            if(DaqDriverTest.debug){
                                sspanel.logDebugString("the channel " + str+" is already in channelTable");
                            }
                            break;
                        }
                        channelTable.put(str, str);
                    }
                }
                else{
                    str = tokens.nextToken();
                    //add to hash table
                    if(channelTable.contains(str)){
                        if(DaqDriverTest.debug){
                            sspanel.logDebugString("the channel" + str+" is already in channelTable");
                        }
                        pass = false;
                        break;
                    }
                    if(!str.equals(",")){
                        channelTable.put(str, str);
                    }
                }
            }
            else{
                break;
            }
        }
        
        if(DaqDriverTest.debug){
            sspanel.logDebugString("Send command: list-channels");
            sspanel.logDebugString(" Actual response: " + channels);
        }

        if(pass){
            sspanel.replaceLog("Testing list-channels                                         PASS", index);
        }
        else{
            sspanel.replaceLog("Testing list-channels                                         FAIL", index);
            testFail++;
            pass = true;
            progressBar.setForeground(Color.red);
        }
        
        // updating progress bar
        if(progressBar != null){
            if(progressBar.getForeground() != Color.red){
                progressBar.setForeground(Color.green);
            }
            progressBar.setMaximum((10 + 5 *channelTable.size() + (int)(channelTable.size() * 1.05)) * runs);
            increment = 1;
            progressBar.setValue(progressBar.getValue() + 3 + channelTable.size());
        }

        //Testing open-port
        testNumber++;

        if (!openClosePort("open", "Streaming data on data channel from port ", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }
        
        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }

        //Testing daq-status
        testNumber++;

        if(!testStatus("Running", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }

        //Testing daq-status\ndaq-status
        index = sspanel.logString("Testing daq-status\ndaq-status");
        testNumber++;
        repaintPanel.repaint();
        responce = testCommand("daq-status\ndaq-status\n", "Running");
        pass = pass && responce.pass;
        
        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }

        if(pass){
            sspanel.replaceLog("Testing daq-status\\ndaq-status                          PASS", index);
        }
        else{
            sspanel.replaceLog("Testing daq-status\\ndaq-status                          FAIL", index);
            testFail++;
            progressBar.setForeground(Color.red);
        }

        responce = testCommand("", "Running");

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }

        pass = pass && responce.pass;
        if(pass){
            sspanel.replaceLog("Testing daq-status\\ndaq-status                          PASS", index);
        }
        else{
            sspanel.replaceLog("Testing daq-status\\ndaq-status                          FAIL", index);
            testFail++;
            pass = true;
            progressBar.setForeground(Color.red);
        }

        //Testing close-port
        testNumber++;

        if (!openClosePort("close", "Stopping data on data channel from port ", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }

        //Testing daq-status
        testNumber++;

        if(!testStatus("Running", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }
        //Testing open-port
        testNumber++;

        if (!openClosePort("open", "Streaming data on data channel from port ", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }

        //testing data-format
        index = sspanel.logString("Testing data format");
        repaintPanel.repaint();
        testNumber++;

        // used to read one line of data
        String prueva = "";
        // used to parse a double, the one after each channel
        String number = "";
        StringTokenizer dataTokens = null;
        // keeps track of channels used in th readings
        Hashtable allChannelsUsed = new Hashtable();
        try{
            prueva = dataReader.readLine();
            if(prueva == null){
                // readLine() blocks till a '\n' character. If it returns null is because there
                // is a problem with the buffer reader.
                throw new TestSuiteException(){
                        public void run(){
                            JOptionPane.showMessageDialog(null, "Connection was lost",
                                                          "Error", JOptionPane.ERROR_MESSAGE);
                            disconnect();
                        }
                    };
            }
            dataTokens = new StringTokenizer(prueva, "\t");
        }
        catch(IOException e1){
            sspanel.logString("Problems reading from Data Socket");
            pass = false;}
        Date prev = null, current = null;
        // parse the first token it should be the date
        try{
            // check if the thread has been stopped
            if(((StopThread)Thread.currentThread()).isStopped()){
                return false;
            }
            prev = current = dateFormat.parse(((String)dataTokens.nextElement()).substring(0,22));
        }
        catch(ParseException e2){
            sspanel.logString("Data format is incorrect");
            if(DaqDriverTest.debug){
                sspanel.logDebugString("Data is:" + prueva);
            }
            pass = false;
        }

        // now that try to parse the channels with data
        while(dataTokens.hasMoreElements()){
            // check if the thread has been stopped
            if(((StopThread)Thread.currentThread()).isStopped()){
                return false;
            }

            str = (String)dataTokens.nextElement();
            // look for the chanel in the hashtable
            if(channelTable.containsKey(str)){
                allChannelsUsed.put(str,str);
            }
            else{
                sspanel.logString("Channel " + str + 
                                  " does not match any channel from \"list-channels\"");
                if(DaqDriverTest.debug){
                    sspanel.logDebugString("Data is:" + prueva);
                }
                pass = false;
            }

            // parse the readings that should be a double
            try{
                number = (String)dataTokens.nextElement();
                Double.parseDouble(number);
            }
            // it was not parse correctly into a double
            catch(NumberFormatException e3){
                if(DaqDriverTest.debug){
                    sspanel.logString("Bad string for int format: " + number);
                }
            }
            // there are no more elments this is an error
            catch(NoSuchElementException e4){
                sspanel.logString("Incorrect Data Format does not match "+
                                  "\"Date\\tchannel\\tvalue\"");
                if(DaqDriverTest.debug){
                    sspanel.logDebugString("Data is:" + prueva);
                }
            }
        }

        // try to read data 1.05 times the channels' size
        for(i = 0; i < channelTable.size() + channelTable.size() * 0.05; i++){
            // check if the thread has been stopped
            if(((StopThread)Thread.currentThread()).isStopped()){
                return false;
            }
            try{
                prueva = dataReader.readLine();

                // updating progress bar
                if(progressBar != null){
                    progressBar.setValue(progressBar.getValue() + increment);
                }
                if(prueva == null){
                    // readLine() blocks till a '\n' character. If it returns null is because there
                    // is a problem with the buffer reader.
                    throw new TestSuiteException(){
                            public void run(){
                                JOptionPane.showMessageDialog(null, "Connection was lost",
                                                              "Error", JOptionPane.ERROR_MESSAGE);
                                disconnect();
                            }
                        };
                }
                
                // make a token with \t as the seperator
                dataTokens = new StringTokenizer(prueva, "\t");
            }
            catch(IOException e1){
                // trying to read the date
                if(((StopThread)Thread.currentThread()).isStopped()){
                    return false;
                }
                sspanel.logString("Problems reading from Data Socket");
                pass = false;}
            try{
                // trying to read the date
                if(((StopThread)Thread.currentThread()).isStopped()){
                    return false;
                }
                current = dateFormat.parse(((String)dataTokens.nextElement()).substring(0,22));
            }
            catch(ParseException e2){
                sspanel.logString("Data format is incorrect");
                // date had wrong format log it
                if(DaqDriverTest.debug){
                    sspanel.logDebugString("Data is:" + prueva);
                }
                pass = false;
            }
            catch(StringIndexOutOfBoundsException e5){
                // date had wrong format log it
                sspanel.logString("Data format is incorrect");
                if(DaqDriverTest.debug){
                    sspanel.logDebugString("Data is:" + prueva);
                }
                pass = false;
            }
            if(pass && prev.compareTo(current) > 0){
                pass = false;
                sspanel.logString("Time Stamps are not chronologycal");
                if(DaqDriverTest.debug){
                    sspanel.logDebugString("previous: " + prev + " and current: " + current); 
                }
            }
            
            // now that the date should have been read make sure the data is correct
            while(dataTokens.hasMoreElements()){
                str = (String)dataTokens.nextElement();
                // check if the thread has been stopped
                if(((StopThread)Thread.currentThread()).isStopped()){
                    return false;
                }
                //look for the channel in the table
                if(channelTable.containsKey(str)){
                    allChannelsUsed.put(str,str);
                }
                else{
                    sspanel.logString("Channel " + str + 
                                      " does not match any channel from \"list-channels\"");
                    if(DaqDriverTest.debug){
                        sspanel.logDebugString("Data is:" + prueva);
                    }
                    pass = false;

                }
                // read the data after the channel
                try{
                    str2 = (String)dataTokens.nextElement();
                    Double.parseDouble(str2);
                }
                
                // could not parese into a double
                catch(NumberFormatException e3){
                    sspanel.logString("Incorrect Data Format does not match "+
                                      "\"Date\\tchannel\\tvalue\"NumberFormat");
                    sspanel.logString(prueva);
                    if(DaqDriverTest.debug){
                        sspanel.logDebugString("Data is:" + prueva);
                        sspanel.logDebugString("Bad number is : " + str2);
                    }
                }
                // there were no more lements but there should be
                catch(NoSuchElementException e4){
                    sspanel.logString("Incorrect Data Format does not match "+
                                      "\"Date\\tchannel\\tvalue\"NoSuchElement");
                    if(DaqDriverTest.debug){
                        sspanel.logDebugString("Data is:" + prueva);
                    }
                }
            }

            // make sure that data gives dates in chronological order
            prev = current;
            
            }
        
        str2  = "";
        Enumeration iter = channelTable.elements();

        // find out what channels were not used
        while(iter.hasMoreElements()){
            str = (String)iter.nextElement();   
            if(!allChannelsUsed.containsKey(str)){
                str2 += str + ",";
            }
        }


        // prints the channels not used
        if(str2 != ""){
            str2 = str2.substring(0, str2.length() - 2);
            sspanel.logString("The following Channels where not used: ");
            int sub = 0;
            while(true){
                if(sub + 60 >= str2.length() - 1){
                    sspanel.logString(str2.substring(sub));
                    break;
                }
                else{
                    sspanel.logString(str2.substring(sub, sub + 60));
                    sub += 60;
                }
            }
        }

        if(pass){
            sspanel.replaceLog("Testing data format                          PASS", index);
        }
        else{
            sspanel.replaceLog("Testing data format                          FAIL", index);
            testFail++;
            progressBar.setForeground(Color.red);
            pass = true;
        }
        
       

        // Testing close-port
        testNumber++;

        if (!openClosePort("close", "Stopping data on data channel from port ", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }
        
        // Testing daq-status
        testNumber++;
        if(!testStatus("Running", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }
        // updating progress bar
        if(progressBar != null){
            progressBar.setValue(progressBar.getValue() + increment);
        }
        // Testing open-port on bad port
        testNumber++;
        if(!openCloseBadPort("open", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }
        
        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }
        // updating progress bar
        if(progressBar != null){
            progressBar.setValue(progressBar.getValue() + increment);
        }
        // Testing close-port on bad port
        testNumber++;
        if(!openCloseBadPort("close", repaintPanel, sspanel)){
            testFail++;
            progressBar.setForeground(Color.red);
        }

        // check if the thread has been stopped
        if(((StopThread)Thread.currentThread()).isStopped()){
            return false;
        }
        
        // updating progress bar
        if(progressBar != null){
            progressBar.setValue(progressBar.getValue() + increment);
        }
 
        // RESUME results
        if(testFail == 0){
            sspanel.logString("Test Results " + testNumber + "/" + testNumber + " tests PASS"); 
        }
        else{
            sspanel.logString(testFail + " tests FAIL");
            sspanel.logString("Test Results " + (testNumber - testFail) 
                              + "/" + testNumber + " tests PASS"); 
        }
        
        flushBuffers(repaintPanel, sspanel, false);
        channelTable = new Hashtable();
        return testFail == 0;
    }    
    
}

class TestResult{
    public boolean pass = false;

    public String different;
}

class TestSuiteException extends Exception{
    public void run(){}
}

---