[Jmri-commits] CVS: test/jmri/jmrix/cmri/serial SerialMessageTest.java,NONE,1.1 SerialTest.java,NONE,1.1 SerialTrafficControlScaffold.java,NONE,1.1 SerialTrafficControllerTest.java,NONE,1.1 SerialTurnoutManagerTest.java,NONE,1.1 SerialTurnoutTest.java,NONE,1.1

[Bob J. <jac...@us...>]

Update of /cvsroot/jmri/test/jmri/jmrix/cmri/serial
In directory sc8-pr-cvs1:/tmp/cvs-serv3467

Added Files:
	SerialMessageTest.java SerialTest.java 
	SerialTrafficControlScaffold.java 
	SerialTrafficControllerTest.java SerialTurnoutManagerTest.java 
	SerialTurnoutTest.java 
Log Message:
initial install

--- NEW FILE: SerialMessageTest.java ---
/**
 * SerialMessageTest.java
 *
 * Description:	    JUnit tests for the SerialMessage class
 * @author			Bob Jacobsen
 * @version			$Revision: 1.1 $
 */

package jmri.jmrix.cmri.serial;

import jmri.*;

import junit.framework.Test;
import junit.framework.Assert;
import junit.framework.TestCase;
import junit.framework.TestSuite;

public class SerialMessageTest extends TestCase {

	public void testCreate() {
		SerialMessage m = new SerialMessage(1);
	}

	public void testToBinaryString() {
		SerialMessage m = new SerialMessage(4);
		m.setOpCode(0x81);
		m.setElement(1, 0x02);
		m.setElement(2, 0xA2);
		m.setElement(3, 0x00);
		m.setBinary(true);
		Assert.assertEquals("string compare ", "81 02 a2 00", m.toString());
	}

	public void testToASCIIString() {
		SerialMessage m = new SerialMessage(5);
		m.setOpCode(0x54);
		m.setElement(1, 0x20);
		m.setElement(2, 0x32);
		m.setElement(3, 0x04);
		m.setElement(4, 0x05);
		m.setBinary(false);
		Assert.assertEquals("string compare ", "54 20 32 04 05", m.toString());
	}

	// from here down is testing infrastructure

	public SerialMessageTest(String s) {
		super(s);
	}

	// Main entry point
	static public void main(String[] args) {
		String[] testCaseName = {SerialMessageTest.class.getName()};
		junit.swingui.TestRunner.main(testCaseName);
	}

	// test suite from all defined tests
	public static Test suite() {
		TestSuite suite = new TestSuite(SerialMessageTest.class);
		return suite;
	}

}

--- NEW FILE: SerialTest.java ---
// SerialTest.java

package jmri.jmrix.cmri.serial;

import java.io.*;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.jdom.*;
import org.jdom.output.*;

/**
 * tests for the jmri.jmrix.cmri.serial package
 * @author			Bob Jacobsen
 * @version   $Revision: 1.1 $
 */
public class SerialTest extends TestCase {

    // from here down is testing infrastructure

    public SerialTest(String s) {
        super(s);
    }

    // a dummy test to avoid JUnit warning
    public void testDemo() {
        assertTrue(true);
    }

    // Main entry point
    static public void main(String[] args) {
        String[] testCaseName = {SerialTest.class.getName()};
        junit.swingui.TestRunner.main(testCaseName);
    }

    // test suite from all defined tests
    public static Test suite() {
        apps.tests.AllTest.initLogging();
        TestSuite suite = new TestSuite("jmri.jmrix.cmri.serial.SerialTest");
        suite.addTest(jmri.jmrix.cmri.serial.SerialTurnoutTest.suite());
        suite.addTest(jmri.jmrix.cmri.serial.SerialTurnoutManagerTest.suite());
        suite.addTest(jmri.jmrix.cmri.serial.SerialNodeTest.suite());
        suite.addTest(jmri.jmrix.cmri.serial.SerialMessageTest.suite());
        suite.addTest(jmri.jmrix.cmri.serial.SerialTrafficControllerTest.suite());
        return suite;
    }

}

--- NEW FILE: SerialTrafficControlScaffold.java ---
/**
 * SerialInterfaceScaffold.java
 *
 * Description:	    Stands in for the SerialTrafficController class
 * @author			Bob Jacobsen
 * @version			$Revision: 1.1 $
 */

package jmri.jmrix.cmri.serial;

import jmri.*;

import java.util.Vector;

public class SerialTrafficControlScaffold extends SerialTrafficController {
	public SerialTrafficControlScaffold() {
		if (log.isDebugEnabled()) log.debug("setting instance: "+this);
		self = this;
	}

	// override some SerialTrafficController methods for test purposes

	public boolean status() {
		return true;
	}

	/**
	 * record messages sent, provide access for making sure they are OK
	 */
	public Vector outbound = new Vector();  // public OK here, so long as this is a test class
	public void sendSerialMessage(SerialMessage m, SerialListener reply) {
		if (log.isDebugEnabled()) log.debug("sendSerialMessage ["+m+"]");
		// save a copy
		outbound.addElement(m);
		// we don't return an echo so that the processing before the echo can be
		// separately tested
	}

	// test control member functions

	/**
	 * forward a message to the listeners, e.g. test receipt
	 */
	protected void sendTestMessage(SerialMessage m, SerialListener l) {
		// forward a test message to NceListeners
		if (log.isDebugEnabled()) log.debug("sendTestMessage    ["+m+"]");
		notifyMessage(m, l);
		return;
	}

	/*
	* Check number of listeners, used for testing dispose()
	*/

	public int numListeners() {
		return cmdListeners.size();
	}

	static org.apache.log4j.Category log = org.apache.log4j.Category.getInstance(SerialTrafficControlScaffold.class.getName());

}

--- NEW FILE: SerialTrafficControllerTest.java ---
/**
 * SerialTrafficControllerTest.java
 *
 * Description:	    JUnit tests for the SerialTrafficController class
 * @author			Bob Jacobsen
 * @version $Revision: 1.1 $
 */

package jmri.jmrix.cmri.serial;

import jmri.*;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

import junit.framework.Test;
import junit.framework.Assert;
import junit.framework.TestCase;
import junit.framework.TestSuite;

public class SerialTrafficControllerTest extends TestCase {

    public void testCreate() {
        SerialTrafficController m = new SerialTrafficController();
    }
    
    public void testSendAscii() throws Exception {
        SerialTrafficController c = new SerialTrafficController();
        
        // connect to iostream via port controller
        SerialPortControllerScaffold p = new SerialPortControllerScaffold();
        c.connectPort(p);
        
        // send a message
        SerialMessage m = new SerialMessage(3);
        m.setBinary(false);
        m.setOpCode('0');
        m.setElement(1, '1');
        m.setElement(2, '2');
        c.sendSerialMessage(m, new SerialListenerScaffold());
        Assert.assertEquals("total length ", 4, tostream.available());
        Assert.assertEquals("Char 0", '0', tostream.readByte());
        Assert.assertEquals("Char 1", '1', tostream.readByte());
        Assert.assertEquals("Char 2", '2', tostream.readByte());
        Assert.assertEquals("EOM", 0x0d, tostream.readByte());
        Assert.assertEquals("remaining ", 0, tostream.available());
    }
    
    public void testSendBinary() throws Exception {
        SerialTrafficController c = new SerialTrafficController();
        
        // connect to iostream via port controller
        SerialPortControllerScaffold p = new SerialPortControllerScaffold();
        c.connectPort(p);
        
        // send a message
        SerialMessage m = new SerialMessage(3);
        m.setBinary(true);
        m.setOpCode(0x81);
        m.setElement(1, 0x12);
        m.setElement(2, 0x34);
        c.sendSerialMessage(m, new SerialListenerScaffold());
        Assert.assertEquals("total length ", 3, tostream.available());
        Assert.assertEquals("Char 0", 0x81, 0xFF & tostream.readByte());
        Assert.assertEquals("Char 1", 0x12, tostream.readByte());
        Assert.assertEquals("Char 2", 0x34, tostream.readByte());
        Assert.assertEquals("remaining ", 0, tostream.available());
    }
    
    public void testMonitor() throws Exception {
        SerialTrafficController c = new SerialTrafficController();
        
        // connect to iostream via port controller
        SerialPortControllerScaffold p = new SerialPortControllerScaffold();
        c.connectPort(p);
        
        // start monitor
        rcvdMsg = null;
        SerialListenerScaffold s = new SerialListenerScaffold();
        c.addSerialListener(s);
        
        // send a message
        SerialMessage m = new SerialMessage(3);
        m.setOpCode('0');
        m.setElement(1, '1');
        m.setElement(2, '2');
        c.sendSerialMessage(m, new SerialListenerScaffold());
        
        // check it arrived at monitor
        Assert.assertTrue("message not null", rcvdMsg != null);
        Assert.assertEquals("total length ", 4, tostream.available());
        Assert.assertEquals("Char 0", '0', tostream.readByte());
        Assert.assertEquals("Char 1", '1', tostream.readByte());
        Assert.assertEquals("Char 2", '2', tostream.readByte());
        Assert.assertEquals("EOM", 0x0d, tostream.readByte());
        Assert.assertEquals("remaining ", 0, tostream.available());
    }
    
    public void testRcvReply() throws Exception {
        SerialTrafficController c = new SerialTrafficController();
        
        // connect to iostream via port controller
        SerialPortControllerScaffold p = new SerialPortControllerScaffold();
        c.connectPort(p);
        
        // object to receive reply
        SerialListener l = new SerialListenerScaffold();
        c.addSerialListener(l);
        
        // send a message
        SerialMessage m = new SerialMessage(3);
        m.setOpCode('0');
        m.setElement(1, '1');
        m.setElement(2, '2');
        c.sendSerialMessage(m, l);
        // that's already tested, so don't do here.
        
        // now send reply
        tistream.write('R');
        tistream.write(0x0d);
        tistream.write('C');
        tistream.write('O');
        tistream.write('M');
        tistream.write('M');
        tistream.write('A');
        tistream.write('N');
        tistream.write('D');
        tistream.write(':');
        tistream.write(' ');
        
        // drive the mechanism
        c.handleOneIncomingReply();
        Assert.assertTrue("reply received ", waitForReply());
        Assert.assertEquals("first char of reply ", 'R', rcvdReply.getOpCode());
    }
    
    
    private boolean waitForReply() {
        // wait for reply (normally, done by callback; will check that later)
        int i = 0;
        while ( rcvdReply == null && i++ < 100  )  {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
            }
        }
        if (log.isDebugEnabled()) log.debug("past loop, i="+i
                                            +" reply="+rcvdReply);
        if (i==0) log.warn("waitForReply saw an immediate return; is threading right?");
        return i<100;
    }
    
    // internal class to simulate a NceListener
    class SerialListenerScaffold implements jmri.jmrix.cmri.serial.SerialListener {
        public SerialListenerScaffold() {
            rcvdReply = null;
            rcvdMsg = null;
        }
        public void message(SerialMessage m) {rcvdMsg = m;}
        public void reply(SerialReply r) {rcvdReply = r;}
    }
    SerialReply rcvdReply;
    SerialMessage rcvdMsg;
    
    // internal class to simulate a NcePortController
    class SerialPortControllerScaffold extends SerialPortController {
        protected SerialPortControllerScaffold() throws Exception {
            PipedInputStream tempPipe;
            tempPipe = new PipedInputStream();
            tostream = new DataInputStream(tempPipe);
            ostream = new DataOutputStream(new PipedOutputStream(tempPipe));
            tempPipe = new PipedInputStream();
            istream = new DataInputStream(tempPipe);
            tistream = new DataOutputStream(new PipedOutputStream(tempPipe));
        }
        
        // returns the InputStream from the port
        public DataInputStream getInputStream() { return istream; }
        
        // returns the outputStream to the port
        public DataOutputStream getOutputStream() { return ostream; }
        
        // check that this object is ready to operate
        public boolean status() { return true; }
    }
    static DataOutputStream ostream;  // Traffic controller writes to this
    static DataInputStream  tostream; // so we can read it from this
    
    static DataOutputStream tistream; // tests write to this
    static DataInputStream  istream;  // so the traffic controller can read from this
    
    // from here down is testing infrastructure
    
    public SerialTrafficControllerTest(String s) {
        super(s);
    }
    
    // Main entry point
    static public void main(String[] args) {
        String[] testCaseName = {SerialTrafficControllerTest.class.getName()};
        junit.swingui.TestRunner.main(testCaseName);
    }
    
    // test suite from all defined tests
    public static Test suite() {
        TestSuite suite = new TestSuite(SerialTrafficControllerTest.class);
        return suite;
    }
    
    static org.apache.log4j.Category log = org.apache.log4j.Category.getInstance(SerialTrafficControllerTest.class.getName());
    
}

--- NEW FILE: SerialTurnoutManagerTest.java ---
// SerialTurnoutManagerTest.java

package jmri.jmrix.cmri.serial;

import java.io.*;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import jmri.*;

/**
 * SerialTurnoutManagerTest.java
 *
 * Description:	    tests for the jmri.jmrix.nce.NceTurnoutManager class
 * @author			Bob Jacobsen
 * @version  $Revision: 1.1 $
 */
public class SerialTurnoutManagerTest extends jmri.AbstractTurnoutMgrTest  {

	public void setUp() {
		// create and register the manager object
		l = new SerialTurnoutManager();
		jmri.InstanceManager.setTurnoutManager(l);
		assertTrue(l == jmri.InstanceManager.turnoutManagerInstance());

	}

	public String getSystemName(int n) {
		return "CT"+n;
	}

	public void testAsAbstractFactory () {
		// ask for a Turnout, and check type
		Turnout o = l.newTurnout("CT21", "my name");


		if (log.isDebugEnabled()) log.debug("received turnout value "+o);
		assertTrue( null != (SerialTurnout)o);

		// make sure loaded into tables
		if (log.isDebugEnabled()) log.debug("by system name: "+l.getBySystemName("CT21"));
		if (log.isDebugEnabled()) log.debug("by user name:   "+l.getByUserName("my name"));

		assertTrue(null != l.getBySystemName("CT21"));
		assertTrue(null != l.getByUserName("my name"));

	}


	// from here down is testing infrastructure

	public SerialTurnoutManagerTest(String s) {
		super(s);
	}

	// Main entry point
	static public void main(String[] args) {
		String[] testCaseName = {SerialTurnoutManager.class.getName()};
		junit.swingui.TestRunner.main(testCaseName);
	}

	// test suite from all defined tests
	public static Test suite() {
		apps.tests.AllTest.initLogging();
		TestSuite suite = new TestSuite(SerialTurnoutManagerTest.class);
		return suite;
	}

	 static org.apache.log4j.Category log = org.apache.log4j.Category.getInstance(SerialTurnoutManagerTest.class.getName());

}

--- NEW FILE: SerialTurnoutTest.java ---
// SerialTurnoutTest.java

package jmri.jmrix.cmri.serial;

import java.io.*;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.framework.Assert;

import jmri.AbstractTurnoutTest;

/**
 * SerialTurnoutTest.java
 *
 * Description:	    tests for the jmri.jmrix.cmri.serial.SerialTurnout class
 * @author			Bob Jacobsen
 * @version			$Revision: 1.1 $
 */
public class SerialTurnoutTest extends AbstractTurnoutTest {

	private SerialTrafficControlScaffold tcis = null;

	public void setUp() {
		// prepare an interface
		tcis = new SerialTrafficControlScaffold();

		t = new SerialTurnout(4);
	}

	public int numListeners() { return tcis.numListeners(); }

	public void checkThrownMsgSent() {
		Assert.assertTrue("message sent", tcis.outbound.size()>0);
		Assert.assertEquals("content", "S C02 81 fe 7f", tcis.outbound.elementAt(tcis.outbound.size()-1).toString());  // THROWN message
	}

	public void checkClosedMsgSent() {
		Assert.assertTrue("message sent", tcis.outbound.size()>0);
		Assert.assertEquals("content", "S C02 81 ff 7e", tcis.outbound.elementAt(tcis.outbound.size()-1).toString());  // CLOSED message
	}

	// from here down is testing infrastructure

	public SerialTurnoutTest(String s) {
		super(s);
	}

	// Main entry point
	static public void main(String[] args) {
		String[] testCaseName = {SerialTurnoutTest.class.getName()};
		junit.swingui.TestRunner.main(testCaseName);
	}

	// test suite from all defined tests
	public static Test suite() {
		TestSuite suite = new TestSuite(SerialTurnoutTest.class);
		return suite;
	}

	 static org.apache.log4j.Category log = org.apache.log4j.Category.getInstance(SerialTurnoutTest.class.getName());

}