- test package renamed

- export only ch.ntb.usb in manifest file

git-svn-id: https://svn.code.sf.net/p/libusbjava/code/trunk@196 94ad28fe-ef68-46b1-9651-e7ae4fcf1c4c

java/test/ch/ntb/usb/test/AT90USB1287.java

@@ -0,0 +1,23 @@
+package ch.ntb.usb.test;
+
+import ch.ntb.usb.USB;
+
+public class AT90USB1287 extends AbstractDeviceInfo {
+
+	@Override
+	public void initValues() {
+		setIdVendor((short) 0x8235);
+		setIdProduct((short) 0x0222);
+		setTimeout(2000);
+		setConfiguration(1);
+		setInterface(0);
+		setAltinterface(-1);
+		setOUT_EP_BULK(0x01);
+		setIN_EP_BULK(0x82);
+		setOUT_EP_INT(0x03);
+		setIN_EP_INT(0x84);
+		setSleepTimeout(2000);
+		setMaxDataSize(USB.FULLSPEED_MAX_BULK_PACKET_SIZE);
+		setMode(WriteMode.Bulk);
+	}
+}

java/test/ch/ntb/usb/test/AbstractDeviceInfo.java

@@ -0,0 +1,145 @@
+package ch.ntb.usb.test;
+
+public abstract class AbstractDeviceInfo {
+
+	private short IdVendor;
+
+	private short IdProduct;
+
+	private int Timeout;
+
+	private int Configuration;
+
+	private int Interface;
+
+	private int Altinterface;
+
+	private int OUT_EP_BULK;
+
+	private int IN_EP_BULK;
+
+	private int OUT_EP_INT;
+
+	private int IN_EP_INT;
+
+	private int SleepTimeout;
+
+	private int MaxDataSize;
+
+	private WriteMode mode;
+
+	public static enum WriteMode {
+		Bulk, Interrupt
+	}
+
+	public AbstractDeviceInfo() {
+		initValues();
+	}
+
+	abstract public void initValues();
+
+	public int getAltinterface() {
+		return Altinterface;
+	}
+
+	public int getConfiguration() {
+		return Configuration;
+	}
+
+	public short getIdProduct() {
+		return IdProduct;
+	}
+
+	public short getIdVendor() {
+		return IdVendor;
+	}
+
+	public int getIN_EP_BULK() {
+		return IN_EP_BULK;
+	}
+
+	public int getIN_EP_INT() {
+		return IN_EP_INT;
+	}
+
+	public int getInterface() {
+		return Interface;
+	}
+
+	public int getMaxDataSize() {
+		return MaxDataSize;
+	}
+
+	public int getOUT_EP_BULK() {
+		return OUT_EP_BULK;
+	}
+
+	public int getOUT_EP_INT() {
+		return OUT_EP_INT;
+	}
+
+	public int getSleepTimeout() {
+		return SleepTimeout;
+	}
+
+	public int getTimeout() {
+		return Timeout;
+	}
+
+	public void setAltinterface(int altinterface) {
+		Altinterface = altinterface;
+	}
+
+	public void setConfiguration(int configuration) {
+		Configuration = configuration;
+	}
+
+	public void setIdProduct(short idProduct) {
+		IdProduct = idProduct;
+	}
+
+	public void setIdVendor(short idVendor) {
+		IdVendor = idVendor;
+	}
+
+	public void setIN_EP_BULK(int in_ep_bulk) {
+		IN_EP_BULK = in_ep_bulk;
+	}
+
+	public void setIN_EP_INT(int in_ep_int) {
+		IN_EP_INT = in_ep_int;
+	}
+
+	public void setInterface(int interface1) {
+		Interface = interface1;
+	}
+
+	public void setMaxDataSize(int maxDataSize) {
+		MaxDataSize = maxDataSize;
+	}
+
+	public void setOUT_EP_BULK(int out_ep_bulk) {
+		OUT_EP_BULK = out_ep_bulk;
+	}
+
+	public void setOUT_EP_INT(int out_ep_int) {
+		OUT_EP_INT = out_ep_int;
+	}
+
+	public void setSleepTimeout(int sleepTimeout) {
+		SleepTimeout = sleepTimeout;
+	}
+
+	public void setTimeout(int timeout) {
+		Timeout = timeout;
+	}
+
+	public WriteMode getMode() {
+		return mode;
+	}
+
+	public void setMode(WriteMode mode) {
+		this.mode = mode;
+	}
+
+}

java/test/ch/ntb/usb/test/CY7C68013A.java

@@ -0,0 +1,23 @@
+package ch.ntb.usb.test;
+
+import ch.ntb.usb.USB;
+
+public class CY7C68013A extends AbstractDeviceInfo {
+
+	@Override
+	public void initValues() {
+		setIdVendor((short) 0x8235);
+		setIdProduct((short) 0x0222);
+		setTimeout(2000);
+		setConfiguration(1);
+		setInterface(0);
+		setAltinterface(-1);
+		setOUT_EP_INT(0x02);
+		setIN_EP_INT(0x86);
+		setOUT_EP_BULK(0x04);
+		setIN_EP_BULK(0x88);
+		setSleepTimeout(2000);
+		setMaxDataSize(USB.HIGHSPEED_MAX_BULK_PACKET_SIZE);
+		setMode(WriteMode.Bulk);
+	}
+}

java/test/ch/ntb/usb/test/DeviceTest.java

@@ -0,0 +1,255 @@
+package ch.ntb.usb.test;
+
+import static org.junit.Assert.fail;
+
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.util.Properties;
+
+import junit.framework.Assert;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import ch.ntb.usb.Device;
+import ch.ntb.usb.LibusbWin;
+import ch.ntb.usb.USB;
+import ch.ntb.usb.USBException;
+import ch.ntb.usb.test.AbstractDeviceInfo.WriteMode;
+
+public class DeviceTest {
+
+	private static final String testdevicePropertiesFile = "testdevice.properties";
+
+	private static final String deviceInfoKey = "testdeviceInfo";
+
+	private static AbstractDeviceInfo devinfo;
+
+	private static byte[] testData;
+
+	private static byte[] readData;
+
+	private static Device dev;
+
+	@BeforeClass
+	public static void setUp() throws Exception {
+		// load the device info class with the key
+		// from 'testdevice.properties'
+		InputStream propInputStream = new FileInputStream(
+				testdevicePropertiesFile);
+		Properties devInfoProp = new Properties();
+		devInfoProp.load(propInputStream);
+		String devInfoClazzName = devInfoProp.getProperty(deviceInfoKey);
+		if (devInfoClazzName == null) {
+			throw new IllegalArgumentException("property " + deviceInfoKey
+					+ "not found in file " + testdevicePropertiesFile);
+		}
+		Class devInfoClazz = Class.forName(devInfoClazzName);
+		devinfo = (AbstractDeviceInfo) devInfoClazz.newInstance();
+		// devinfo = new CY7C68013A();
+		// setup test data
+		testData = new byte[devinfo.getMaxDataSize()];
+		readData = new byte[testData.length];
+		// initialise the device
+		LibusbWin.usb_set_debug(255);
+		dev = USB.getDevice(devinfo.getIdVendor(), devinfo.getIdProduct());
+	}
+
+	@Test
+	public void initalReset() throws Exception {
+		doOpen();
+		dev.reset();
+		timeout();
+	}
+
+	@Test(expected = USBException.class)
+	public void testClose() throws Exception {
+		doOpen();
+		doClose();
+		// this call must throw an exception, because the device is closed
+		dev.writeBulk(devinfo.getOUT_EP_BULK(), testData, testData.length,
+				devinfo.getTimeout(), false);
+	}
+
+	@Test(expected = USBException.class)
+	public void testReset1() throws Exception {
+		doOpen();
+		dev.reset();
+		timeout();
+		// this call must throw an exception, because the device is closed
+		dev.writeBulk(devinfo.getOUT_EP_BULK(), testData, testData.length,
+				devinfo.getTimeout(), false);
+	}
+
+	@Test(expected = USBException.class)
+	public void testReset2() throws Exception {
+		doOpen();
+		dev.reset();
+		timeout();
+		// this call must throw an exception, because the device can't be closed
+		doClose();
+	}
+
+	@Test
+	public void bulkWriteRead() throws Exception {
+		devinfo.setMode(WriteMode.Bulk);
+		doOpenWriteReadClose();
+	}
+
+	@Test
+	public void interruptWriteRead() throws Exception {
+		devinfo.setMode(WriteMode.Interrupt);
+		doOpenWriteReadClose();
+	}
+
+	@Test
+	public void bulkWriteReadMultiple() throws Exception {
+		final int NumberOfIterations = 100;
+
+		devinfo.setMode(WriteMode.Bulk);
+		doOpen();
+		for (int i = 0; i < NumberOfIterations; i++) {
+			initTestData();
+			doWriteRead();
+			compare(testData, readData);
+		}
+		doClose();
+	}
+
+	@Test
+	public void multipleOpenCloseWithBulkWrite() throws Exception {
+		devinfo.setMode(WriteMode.Bulk);
+		for (int i = 0; i < 5; i++) {
+			doOpen();
+			doClose();
+		}
+		doOpenWriteReadClose();
+		for (int i = 0; i < 10; i++) {
+			doOpen();
+			doWriteRead();
+			doClose();
+		}
+		doOpenWriteReadClose();
+		for (int i = 0; i < 5; i++) {
+			doOpen();
+			doClose();
+		}
+	}
+
+	@Test
+	public void bulkAndInterrupt() throws Exception {
+		doOpen();
+		// BULK
+		devinfo.setMode(WriteMode.Bulk);
+		doWriteRead();
+		// INTERRUPT
+		devinfo.setMode(WriteMode.Interrupt);
+		doWriteRead();
+		doClose();
+	}
+
+	@Test
+	public void bulkAndInterruptMultiple() throws Exception {
+		for (int i = 0; i < 20; i++) {
+			devinfo.setMode(WriteMode.Bulk);
+			doOpenWriteReadClose();
+			devinfo.setMode(WriteMode.Interrupt);
+			doOpenWriteReadClose();
+		}
+	}
+
+	@Test
+	public void testGetIdProduct() {
+		Assert.assertEquals(dev.getIdProduct(), devinfo.getIdProduct());
+	}
+
+	@Test
+	public void testGetIdVendor() {
+		Assert.assertEquals(dev.getIdVendor(), devinfo.getIdVendor());
+	}
+
+	@Test
+	public void testGetAltinterface() {
+		Assert.assertEquals(dev.getAltinterface(), devinfo.getAltinterface());
+	}
+
+	@Test
+	public void testGetConfiguration() {
+		Assert.assertEquals(dev.getConfiguration(), devinfo.getConfiguration());
+	}
+
+	@Test
+	public void testGetInterface() {
+		Assert.assertEquals(dev.getInterface(), devinfo.getInterface());
+	}
+
+	@Test
+	public void testGetMaxPacketSize() throws USBException {
+		doOpen();
+		Assert.assertEquals(dev.getMaxPacketSize(), devinfo.getMaxDataSize());
+		doClose();
+	}
+
+	@AfterClass
+	public static void tearDown() throws Exception {
+		if (dev != null && dev.isOpen()) {
+			dev.close();
+		}
+	}
+
+	private void doOpen() throws USBException {
+		dev.open(devinfo.getConfiguration(), devinfo.getInterface(), devinfo
+				.getAltinterface());
+	}
+
+	private void doClose() throws USBException {
+		dev.close();
+	}
+
+	private void doOpenWriteReadClose() throws Exception {
+		doOpen();
+		doWriteRead();
+		compare(testData, readData);
+		doClose();
+	}
+
+	private void doWriteRead() throws Exception {
+		initTestData();
+		if (devinfo.getMode().equals(WriteMode.Bulk)) {
+			dev.writeBulk(devinfo.getOUT_EP_BULK(), testData, testData.length,
+					devinfo.getTimeout(), false);
+			dev.readBulk(devinfo.getIN_EP_BULK(), readData, readData.length,
+					devinfo.getTimeout(), false);
+		} else if (devinfo.getMode().equals(WriteMode.Interrupt)) {
+			dev.writeInterrupt(devinfo.getOUT_EP_INT(), testData,
+					testData.length, devinfo.getTimeout(), false);
+			dev.readInterrupt(devinfo.getIN_EP_INT(), readData,
+					readData.length, devinfo.getTimeout(), false);
+		}
+		compare(testData, readData);
+	}
+
+	private static void compare(byte[] d1, byte[] d2) {
+		int minLength = Math.min(d1.length, d2.length);
+		for (int i = 0; i < minLength; i++) {
+			if (d1[i] != d2[i])
+				fail("received data not equal to sent data");
+		}
+	}
+
+	private static void timeout() {
+		try {
+			Thread.sleep(devinfo.getSleepTimeout());
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+	}
+
+	private static void initTestData() {
+		for (int i = 0; i < testData.length; i++) {
+			testData[i] = (byte) (Math.random() * 0xff);
+			readData[i] = 0;
+		}
+	}
+}