diff -r 000000000000 -r c6b0df440bee genericunixprotocols/ftpsrv/test/src/FTPTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericunixprotocols/ftpsrv/test/src/FTPTest.java	Tue Mar 02 10:33:16 2010 +0530
@@ -0,0 +1,1194 @@
+//
+// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import junit.framework.TestCase;
+
+import org.apache.commons.net.ftp.FTP;
+import org.apache.commons.net.ftp.FTPClient;
+import org.apache.commons.net.ftp.FTPFile;
+import org.apache.commons.net.ftp.FTPReply;
+
+
+
+
+/** 
+ * @author JavierM
+ * 
+ */
+public abstract class FTPTest extends TestCase {
+
+	/* (non-Javadoc)
+	 * @see junit.framework.TestCase#setUp()
+	 */
+	FTPClient ftpClient = new FTPClient();
+	
+	protected void setUp() throws Exception {
+		super.setUp();
+		
+		String address = System.getProperty("address");
+		
+		ftpClient.connect(/*"10.16.160.35"*/address);
+		ftpClient.user("me");
+		ftpClient.pass("friend");
+		
+		ftpClient.setBufferSize(1460*10);
+		
+		setPassive();
+	}
+
+	protected void setPassive()
+	{
+		ftpClient.enterLocalActiveMode();
+	}
+	
+	/* (non-Javadoc)
+	 * @see junit.framework.TestCase#tearDown()
+	 */
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		
+		ftpClient.logout();
+		ftpClient.disconnect();
+	}
+	
+	
+//	public void testUploadFileInSmallChunks() throws IOException
+//	{
+//		
+//		byte b[] = new byte[1];
+//		
+//		String sentence = new String(b);//"El veloz murciélago hind?comía feliz cardillo y kiwi\r\n";
+//		int times =  10000;
+//		
+//		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+//		
+//		//BINARY
+//		
+//		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+//		
+//		OutputStream out = ftpClient.storeFileStream("test.txt");
+//		assertNotNull(out);
+//		
+//		for (int i = 0; i < times; i++) {
+//			out.write(sentence.getBytes());	
+//			out.flush();
+//			System.out.print(".");
+//		}
+//		
+//		out.close();
+//		assertTrue(ftpClient.completePendingCommand());
+//		
+//		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/test.txt")));
+//		assertEquals(times*sentence.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+//		
+//		ftpClient.deleteFile("/C/test.txt");
+//		
+//		//ASCII
+//		
+//		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+//		
+//		out = ftpClient.storeFileStream("test.txt");
+//		assertNotNull(out);
+//		
+//		for (int i = 0; i < times; i++) {
+//			out.write(sentence.getBytes());	
+//		}
+//		
+//		out.close();
+//		assertTrue(ftpClient.completePendingCommand());
+//		
+//		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/test.txt")));
+//		assertEquals(times*sentence.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+//		
+//		ftpClient.deleteFile("/C/test.txt");
+//		
+//	}
+	
+	
+	public void testSyst()  throws IOException
+	{
+		String name = ftpClient.getSystemName();
+		assertEquals(name,"UNIX Type: L8");
+		
+	}
+	
+	
+	
+	public void testListDrives()  throws IOException{
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		FTPFile[] drives = ftpClient.listFiles();
+		
+		assertNotNull(drives);
+		
+		for (int i = 0; i < drives.length; i++) {
+			
+			String driveName  = drives[i].getName();
+			
+			assertTrue(driveName.length()==1 && 
+					   driveName.charAt(0) >= 'A' && 
+					   driveName.charAt(0) <= 'Z');
+		}
+		
+		String[] names = ftpClient.listNames();
+		
+		assertNotNull(names);
+		
+		for (int i = 0; i < drives.length; i++) {
+			
+			String driveName  = names[i];
+			
+			assertTrue(driveName.length()==1 && 
+					   driveName.charAt(0) >= 'A' && 
+					   driveName.charAt(0) <= 'Z');
+		}
+		
+		
+	}
+	
+	public void testListFiles()  throws IOException{
+		
+		FTPFile[] files;
+			
+		//UNIX parseable contents on C	
+			
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		files = ftpClient.listFiles();
+		
+		assertNotNull(files);
+		
+		//UNIX parseable contents on Z	
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/Z")));
+		files = ftpClient.listFiles();
+		assertNotNull(files); 
+		
+	}
+	
+public void testListLocation() throws IOException{
+		
+		
+		FTPFile[] files1;
+		FTPFile[] files2;
+		
+		//UNIX parseable contents on /C/System	
+			
+		files1 = ftpClient.listFiles("/C/System");
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/System")));
+		files2 = ftpClient.listFiles();
+		
+		assertEquals(files2.length, files1.length);
+
+		
+		
+		//UNIX parseable contents on root	
+		
+ 		files1 = ftpClient.listFiles("/");
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		files2 = ftpClient.listFiles();
+		
+		assertEquals(files2.length, files1.length);
+		
+		//UNIX parseable contents on /C	
+		
+		files1 = ftpClient.listFiles("/C");
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		files2 = ftpClient.listFiles();
+		
+		assertEquals(files2.length, files1.length);
+
+	
+	}
+	
+	
+	public void testCreateDeleteFolder() throws IOException
+	{
+		//clean up
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		ftpClient.removeDirectory("testFolder");
+		
+		
+		assertTrue(ftpClient.makeDirectory("testFolder"));
+		ftpClient.removeDirectory("testFolder");
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertTrue(ftpClient.makeDirectory("/C/testFolder"));
+		assertTrue(ftpClient.removeDirectory("/C/testFolder"));
+		
+		
+		//clean up
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		ftpClient.removeDirectory("testFolder");
+		
+		
+	}
+	
+	
+	public void testStoreBinaryFile() throws IOException
+	{
+		
+		//for (int i = 0; i < 20; i++) {
+			assertTrue(ftpClient.storeFile("/C/testDriver_TEF_0x10210D31.sis", new FileInputStream("d:\\testDriver_TEF_0x10210D32.sis")));
+			ftpClient.deleteFile("/C/testDriver_TEF_0x10210D31.sis");
+		//	System.out.println(i);
+		//}
+	}
+	
+	public void testStoreAsciiFile() throws IOException
+	{
+		
+		//for (int i = 0; i < 20; i++) {
+		//	assertTrue(ftpClient.storeFile("/C/donquixote.txt", new FileInputStream("./data/donquixote.txt")));
+			ftpClient.deleteFile("/C/donquixote.txt");
+		//	System.out.println(i);
+		//}
+	}
+	
+	
+	public void testCreateDeleteFile() throws IOException
+	{
+		
+		//clean possible previous failed tests
+		ftpClient.deleteFile("/C/test.txt");
+		
+		//from same location
+		
+		OutputStream out = ftpClient.storeFileStream("/C/test.txt");
+		assertNotNull(out);
+		out.write("test file".getBytes());
+		out.close();
+		ftpClient.completePendingCommand();
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		assertTrue(ftpClient.deleteFile("test.txt"));
+		
+		//from different location
+		
+		out = ftpClient.storeFileStream("/C/test.txt");
+		assertNotNull(out);
+		out.write("test file".getBytes());
+		out.close();
+		ftpClient.completePendingCommand();
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertTrue(ftpClient.deleteFile("/C/test.txt"));
+		
+	}
+	
+	public void testRename() throws IOException {
+		
+		OutputStream out = ftpClient.storeFileStream("/C/test.txt");
+		assertNotNull(out);
+		out.write("test file".getBytes());
+		out.close();
+		ftpClient.completePendingCommand();
+		
+		//from directory to same directory
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		assertTrue(ftpClient.rename("test.txt", "test2.txt"));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size test2.txt")));
+		
+		//from different directory
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertTrue(ftpClient.rename("/C/test2.txt", "/C/test.txt"));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size test.txt")));
+		
+		assertTrue(ftpClient.deleteFile("/C/test.txt"));
+		
+	}
+	
+	public void testMove() throws IOException {
+		
+		OutputStream out = ftpClient.storeFileStream("/C/test.txt");
+		assertNotNull(out);
+		out.write("test file".getBytes());
+		out.close();
+		ftpClient.completePendingCommand();
+		
+		assertTrue(ftpClient.makeDirectory("/C/testFolder"));
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertTrue(ftpClient.rename("/C/test.txt", "/C/testFolder/test.txt"));
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/testFolder")));
+		assertTrue(ftpClient.rename("test.txt", "/C/test.txt"));
+		assertTrue(ftpClient.rename("/C/test.txt", "test.txt"));
+		
+		assertTrue(ftpClient.deleteFile("/C/testFolder/test.txt"));
+		assertTrue(ftpClient.removeDirectory("/C/testFolder"));
+		
+	}
+	
+	public void testCdup() throws IOException {
+		
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/system")));
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cdup()));
+		assertEquals("/C", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cdup()));
+		assertEquals("/", ftpClient.printWorkingDirectory());
+		
+	}
+	
+	public void testBrowse() throws IOException {
+	
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertEquals("/", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("C")));
+		assertEquals("/C", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("system")));
+		assertEquals("/C/system", ftpClient.printWorkingDirectory());
+	
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertEquals("/", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/system")));
+		assertEquals("/C/system", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertEquals("/", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/system/.././system")));
+		assertEquals("/C/system", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("..")));
+		assertEquals("/C", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("..")));
+		assertEquals("/", ftpClient.printWorkingDirectory());
+		
+			
+		
+	}
+	
+	public void testHelp() throws IOException {
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("help")));
+		
+	}
+	
+	public void testStat() throws IOException {
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.stat()));
+		
+	}
+	
+	public void testWrongCommands() throws IOException {
+		
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.sendCommand("!\"?%^&*())__+")));
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.sendCommand("asdasdasdasdsdjkklahsdjkajkhsdkhajksdasjkdjkasjkdhasjkdhasdhjkashdjkhasjkdhasjdhjkashdjkhasjkdhjkashashdhasjdhjashdjhasjkhdjkashdhjkashdjkashdhasdkhasdjkahskdajkshdjkashdjkashdjkashdjkashjkdhasjkdhkashkdhasdjkahsjkdhasjkhdjkashdjkhaskdjhajkshdjkahsdjkahsdkjahksdh")));
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.sendCommand("asda sda sda sd sdj kk  l   \t	ahs \n \r")));
+		
+	}
+	
+	public void testGetSystemDrive() throws IOException{
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.stat()));
+		String s = ftpClient.getReplyString();
+		assertNotNull(s);
+		
+		Pattern p = Pattern.compile(".*System Drive: (\\w).*", Pattern.DOTALL); //Pattern.DOTALL => '.' includes end of line
+		Matcher m = p.matcher(s);
+		assertTrue(m.matches());
+		
+	}
+	
+	public void testSize() throws IOException {
+		
+		//try{
+		String testString = "test file";
+		
+		OutputStream out = ftpClient.storeFileStream("/C/test.txt");
+		assertNotNull(out);
+		out.write(testString.getBytes());
+		out.close();
+		ftpClient.completePendingCommand();
+		
+		//absolute
+		//file
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/test.txt")));
+		assertEquals(testString.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		
+		//folder
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.sendCommand("size /C/system")));
+		assertTrue(ftpClient.getReplyString().matches(".*not a plain file.*\r\n"));
+		
+		
+		//relative
+		//file
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size test.txt")));
+		assertEquals(testString.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		
+		//folder
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.sendCommand("size system")));
+		assertTrue(ftpClient.getReplyString().matches(".*not a plain file.*\r\n"));
+		
+		ftpClient.deleteFile("/C/test.txt");
+	}
+	
+	
+	//FTP&Telnet-File Transfer-001
+	//To Transfer a file of size 0 from Pc to device (H2 /H4) from current working directory
+	
+	public void testFTP_Telnet_File_Transfer_001() throws IOException {
+		
+		String fileUnderTest = "emptyFile";
+		
+		File f = new File("./data/"+fileUnderTest);
+		
+		if(!f.exists())
+		{
+			f.createNewFile();
+		}
+		
+		//ASCII
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		ftpClient.deleteFile("/C/"+fileUnderTest);
+		
+		//BINARY
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		ftpClient.deleteFile("/C/"+fileUnderTest);
+		
+	}
+	
+	//FTP&Telnet-File Transfer-002
+	//To Transfer a file of normal size  from Pc to device (H2 /H4) from current working directory
+	
+	public void testFTP_Telnet_File_Transfer_002_ASCII() throws IOException {
+		
+		String fileUnderTest = "smallfile.txt";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//ASCII
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+		//BINARY
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+	}
+	
+	//FTP&Telnet-File Transfer-002
+	//To Transfer a file of normal size  from Pc to device (H2 /H4) from current working directory
+	
+	public void testFTP_Telnet_File_Transfer_002_BINARY() throws IOException {
+		
+		String fileUnderTest = "smallfile.bin";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//ASCII
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertTrue(f.length() != Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+		//BINARY
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+	}
+	
+	
+	//FTP&Telnet-File Transfer-003
+	//To Transfer a file of Large size  from Pc to device (H2 /H4) from current working directory
+	
+	public void testFTP_Telnet_File_Transfer_003_ASCII() throws IOException {
+		
+		String fileUnderTest = "bigfile.txt";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//ASCII
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+		//BINARY
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+	}
+	
+	public void testFTP_Telnet_File_Transfer_003_BINARY() throws IOException {
+		
+		String fileUnderTest = "bigfile.bin";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//ASCII
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertTrue(f.length() != Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+		//BINARY
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+	}
+	
+	//FTP&Telnet-Connection-003
+	//To change the mode of transfer from remote host to Device (H2/H4)
+	public void testFTP_Telnet_Connection_Execution_003() throws IOException
+	{
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+	}
+	
+	//FTP&Telnet-File Transfer-007
+	//To Transfer a file from Pc to device (H2 /H4) from  working directory to non Existence directory
+	public void testFTP_Telnet_File_Transfer_007_ASCII_Mode() throws IOException
+	{
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		assertFalse(ftpClient.storeFile("/C/nonexistingfolder/smallfile.txt", new FileInputStream("./data/smallfile.txt")));
+	}
+	
+	//FTP&Telnet-File Transfer-007
+	//To Transfer a file from Pc to device (H2 /H4) from  working directory to non Existence directory
+	public void testFTP_Telnet_File_Transfer_007_BINARY_Mode() throws IOException
+	{
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		assertFalse(ftpClient.storeFile("/C/nonexistingfolder/smallfile.txt", new FileInputStream("./data/smallfile.txt")));
+	}
+	
+	//FTP&Telnet-File Retrieve-001
+	//To Retrieve a file of size 0 from device to PC
+	
+	public void testFTP_Telnet_File_Retrieve_001() throws IOException {
+		
+		String fileUnderTest = "emptyFile";
+		
+		File f = new File("./data/"+fileUnderTest);
+		
+		if(!f.exists())
+			f.createNewFile();
+		
+		f.deleteOnExit();
+		
+		//upload and verify correctly uploaded
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		
+		
+		//download file
+		
+		File f2 = File.createTempFile("FTP_Telnet_File_Retrieve_001",".txt");
+		File f3 = File.createTempFile("FTP_Telnet_File_Retrieve_001",".bin");
+		f2.deleteOnExit();
+		f3.deleteOnExit();
+		
+		//ASCII download
+		
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f2)));
+		assertEquals(f.length(), f2.length());
+		
+		//BINARY download
+		
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f3)));
+		assertEquals(f.length(), f3.length());
+		
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+	}
+	
+	//FTP&Telnet-File Retrieve-002
+	//To Retrieve a file of normal size  from device to Pc 
+	
+	public void testFTP_Telnet_File_Retrieve_002_ASCII() throws IOException {
+		
+		String fileUnderTest = "smallfile.txt";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//ASCII
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		
+		//download file
+		
+		File f2 = File.createTempFile("FTP_Telnet_File_Retrieve_002_ASCII",".txt");
+		File f3 = File.createTempFile("FTP_Telnet_File_Retrieve_002_ASCII",".bin");
+		f3.deleteOnExit();
+		f2.deleteOnExit();
+		
+		//ASCII download
+		
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f2)));
+		assertEquals(f.length(), f2.length());
+		
+		//BINARY download
+		
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f3)));
+		assertEquals(f.length(), f3.length());
+		
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+	}
+	
+	//FTP&Telnet-File Retrieve-002
+	//To Transfer a file of normal size  from  device to pc
+	
+	public void testFTP_Telnet_File_Retrieve_002_BINARY() throws IOException {
+		
+		String fileUnderTest = "smallfile.bin";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//BINARY
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		
+		//download file
+		
+		File f2 = File.createTempFile("FTP_Telnet_File_Retrieve_002_BINARY",".txt");
+		File f3 = File.createTempFile("FTP_Telnet_File_Retrieve_002_BINARY",".bin");
+		f2.deleteOnExit();
+		f3.deleteOnExit();
+		
+		//ASCII download
+		
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f2)));
+		assertEquals(f.length() , f2.length());
+		
+		//BINARY download
+		
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f3)));
+		assertEquals(f.length(), f3.length());
+		
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+		
+		
+	}
+	
+	
+	//FTP&Telnet-File Retrieve-003
+	//To Transfer a file of Large size  from device to pc
+	
+	public void testFTP_Telnet_File_Retrieve_003_ASCII() throws IOException {
+		
+		String fileUnderTest = "bigfile.txt";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//ASCII
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+	
+		//download file
+		
+		File f2 = File.createTempFile("testFTP_Telnet_File_Retrieve_003_ASCII",".txt");
+		File f3 = File.createTempFile("testFTP_Telnet_File_Retrieve_003_ASCII",".bin");
+		f2.deleteOnExit();
+		
+		//ASCII download
+		
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f2)));
+		assertEquals(f.length(), f2.length());
+		
+		//BINARY download
+		
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f3)));
+		assertEquals(f.length(), f3.length());
+		
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+	}
+	
+	//FTP&Telnet-File Retrieve-003
+	//To Transfer a file of Large size from device to pc
+	
+	
+	public void testFTP_Telnet_File_Retrieve_003_BINARY() throws IOException {
+		
+		String fileUnderTest = "bigfile.bin";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//BINARY
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		
+		//download file
+		
+		File f2 = File.createTempFile("FTP_Telnet_File_Retrieve_003_BINARY",".txt");
+		File f3 = File.createTempFile("FTP_Telnet_File_Retrieve_003_BINARY",".bin");
+		f2.deleteOnExit();
+		f3.deleteOnExit();
+		
+		//ASCII download
+		
+		assertTrue(ftpClient.setFileType(FTP.ASCII_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f2)));
+		assertEquals(f.length() , f2.length());
+		
+		//BINARY download
+		
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		assertTrue(ftpClient.retrieveFile("/C/"+fileUnderTest, new FileOutputStream(f3)));
+		assertEquals(f.length(), f3.length());
+		
+		
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+	}
+	
+  	//FTP&Telnet-File Retrieve-009
+	//retrieve from non-existing directory
+	
+	public void testFTP_Telnet_File_Retrieve_009() throws IOException {
+		
+		assertFalse(ftpClient.retrieveFile("/C/nonexisting", System.out));
+		
+	}
+	
+	//FTP&Telnet-File Retrieve-016
+	//To Retrieve  a Directory from  device (H2 /H4) to PC
+	
+	public void testFTP_Telnet_File_Retrieve_016() throws IOException {
+		
+		assertFalse(ftpClient.retrieveFile("/C/system", System.out));
+		
+	}
+	
+	//FTP&Telnet-File Delete-001
+	//To Delete  a file of size 0 from Pc
+	
+	public void testFTP_Telnet_File_Delete_001() throws IOException {
+		
+		String fileUnderTest = "emptyFile";
+		
+		File f = new File("./data/"+fileUnderTest);
+		
+		//upload and verify correctly uploaded
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+	}
+	
+	//FTP&Telnet-File Delete-003
+	//To Delete a file of normal size on Device (H2/H4)  from Pc
+	public void testFTP_Telnet_File_Delete_003() throws IOException {
+		
+		String fileUnderTest = "smallfile.bin";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//BINARY
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+	}
+	
+	//FTP&Telnet-File Delete-004
+	//To Delete a file of Large size on Device (H2/H4)  from Pc
+	public void testFTP_Telnet_File_Delete_004() throws IOException {
+		
+		String fileUnderTest = "bigfile.bin";
+		File f = new File("./data/"+fileUnderTest);
+		
+		//BINARY
+		assertTrue(ftpClient.setFileType(FTP.BINARY_FILE_TYPE));
+		
+		assertTrue(ftpClient.storeFile("/C/"+fileUnderTest, new FileInputStream(f)));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+		assertEquals(f.length(), Integer.parseInt(ftpClient.getReplyString().substring(4).trim()));
+		
+		assertTrue(ftpClient.deleteFile("/C/"+fileUnderTest));
+		
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.sendCommand("size /C/"+fileUnderTest)));
+	}
+	
+	//FTP&Telnet-File Delete-006
+	//To Delete a non existent  file on Device (H2/H4)  from Pc
+	public void testFTP_Telnet_File_Delete_006() throws IOException {
+		
+		assertFalse(ftpClient.deleteFile("/C/nonexistingfile"));
+	}
+	
+	//FTP&Telnet-File Retrieve-018
+	//To Retrieve a drive listing on Device (H2/H4)  from Pc
+	public void testFTP_Telnet_File_Retrieve_018() throws IOException {
+
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		FTPFile[] drives = ftpClient.listFiles();
+
+		assertNotNull(drives);
+
+		for (int i = 0; i < drives.length; i++) {
+
+			String driveName = drives[i].getName();
+
+			assertTrue(driveName.length() == 1 && driveName.charAt(0) >= 'A'
+					&& driveName.charAt(0) <= 'Z');
+		}
+
+	}
+	
+	
+	// FTP&Telnet-File Retrieve-019
+	//To Retrieve a directory listing on Device (H2/H4)  from Pc
+	
+	public void testFTP_Telnet_File_Retrieve_019()  throws IOException{
+		
+		FTPFile[] files;
+			
+		//UNIX parseable contents on C	
+			
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		files = ftpClient.listFiles();
+		
+		assertNotNull(files);
+		
+		//UNIX parseable contents on Z	
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/Z")));
+		files = ftpClient.listFiles();
+		assertNotNull(files); 
+		
+	}
+	
+	//FTP&Telnet-File Retrieve-020
+	//To check a particular file/Folder on Device (H2/H4)  from Pc
+	
+	public void testFTP_Telnet_File_Retrieve_020()  throws IOException{
+		
+		FTPFile[] files;
+		String[] names;
+		
+		boolean found = false;
+		
+		//folder
+		//List C:\System
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		files = ftpClient.listFiles();
+		
+		for (int i = 0; i < files.length; i++) {
+			if(files[i].getName().equalsIgnoreCase("System") && files[i].isDirectory())
+				found = true;
+		}
+		
+		assertTrue(found);
+		
+		found = false;
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		
+		names = ftpClient.listNames();
+		
+		for (int i = 0; i < names.length; i++) {
+			if(names[i].equalsIgnoreCase("System"))
+				found = true;
+		}
+		
+		assertTrue(found);
+		
+		found = false;
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		
+		files = ftpClient.listFiles("/C");
+		
+		for (int i = 0; i < files.length; i++) {
+			if(files[i].getName().equalsIgnoreCase("System") && files[i].isDirectory())
+				found = true;
+		}
+		
+		assertTrue(found);
+		
+		
+		found = false;
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		
+		names = ftpClient.listNames("/C");
+		
+		for (int i = 0; i < names.length; i++) {
+			if(names[i].equalsIgnoreCase("System"))
+				found = true;
+		}
+		
+		assertTrue(found);
+		
+		
+		found = false;
+		
+		//file
+		//List C:\System\System.ini	
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/System")));
+		files = ftpClient.listFiles();
+		
+		for (int i = 0; i < files.length; i++) {
+			if(files[i].getName().equalsIgnoreCase("System.ini") && files[i].isFile())
+				found = true;
+		}
+		
+		assertTrue(found);
+		
+		found = false;
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/System")));
+		
+		names = ftpClient.listNames();
+		
+		for (int i = 0; i < names.length; i++) {
+			if(names[i].equalsIgnoreCase("System.ini"))
+				found = true;
+		}
+		
+		assertTrue(found);
+		
+		found = false;
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		files = ftpClient.listFiles("/C/System");
+		
+		for (int i = 0; i < files.length; i++) {
+			if(files[i].getName().equalsIgnoreCase("System.ini") && files[i].isFile())
+				found = true;
+		}
+		
+		assertTrue(found);
+		
+		
+		found = false;
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		
+		names = ftpClient.listNames("/C/System");
+		
+		for (int i = 0; i < names.length; i++) {
+			if(names[i].equalsIgnoreCase("System.ini"))
+				found = true;
+		}
+		
+		assertTrue(found);
+		
+		
+	}
+	
+	//FTP&Telnet-Directory-001 + 002
+	//To create a  Directory on device(H2/H4) from PC Side
+	//To Remove a  Directory on device(H2/H4) from PC Side
+	
+	public void testFTP_Telnet_Directory_001()  throws IOException{
+		
+		boolean found = false;
+		
+		//create folder
+		assertTrue(ftpClient.makeDirectory("/C/newFolder"));
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		FTPFile[] files = ftpClient.listFiles();
+		
+		for (int i = 0; i < files.length; i++) {
+			if(files[i].getName().equalsIgnoreCase("newFolder") && files[i].isDirectory())
+				found = true;
+		}
+		
+		assertTrue(found);
+		
+		found = false;
+		
+		//delete folder
+		assertTrue(ftpClient.removeDirectory("/C/newFolder"));
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		files = ftpClient.listFiles();
+		
+		for (int i = 0; i < files.length; i++) {
+			if(files[i].getName().equalsIgnoreCase("newFolder") && files[i].isDirectory())
+				found = true;
+		}
+		
+		assertFalse(found);
+				
+	}
+	
+	//FTP&Telnet-Directory-003
+	//To Rename a  file on device(H2/H4) from PC Side
+	
+	public void testFTP_Telnet_Directory_003()  throws IOException{
+		
+		OutputStream out = ftpClient.storeFileStream("/C/test.txt");
+		assertNotNull(out);
+		out.write("test file".getBytes());
+		out.close();
+		ftpClient.completePendingCommand();
+		
+		//from directory to same directory
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C")));
+		assertTrue(ftpClient.rename("test.txt", "test2.txt"));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size test2.txt")));
+		
+		//from different directory
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertTrue(ftpClient.rename("/C/test2.txt", "/C/test.txt"));
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.sendCommand("size test.txt")));
+		
+		assertTrue(ftpClient.deleteFile("/C/test.txt"));
+	}
+	
+	//FTP&Telnet-Directory-004
+	//To Move a  file on device(H2/H4) from PC Side
+	
+	public void testFTP_Telnet_Directory_004()  throws IOException{
+		OutputStream out = ftpClient.storeFileStream("/C/test.txt");
+		assertNotNull(out);
+		out.write("test file".getBytes());
+		out.close();
+		ftpClient.completePendingCommand();
+		
+		assertTrue(ftpClient.makeDirectory("/C/testFolder"));
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertTrue(ftpClient.rename("/C/test.txt", "/C/testFolder/test.txt"));
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/testFolder")));
+		assertTrue(ftpClient.rename("test.txt", "/C/test.txt"));
+		assertTrue(ftpClient.rename("/C/test.txt", "test.txt"));
+		
+		assertTrue(ftpClient.deleteFile("/C/testFolder/test.txt"));
+		assertTrue(ftpClient.removeDirectory("/C/testFolder"));
+	}
+	
+	//FTP&Telnet-Directory-006
+	//To Change the current directory  on device(H2/H4) from PC Side
+	public void testFTP_Telnet_Directory_006()  throws IOException{
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertEquals("/", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("C")));
+		assertEquals("/C", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("system")));
+		assertEquals("/C/system", ftpClient.printWorkingDirectory());
+	
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertEquals("/", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/system")));
+		assertEquals("/C/system", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/")));
+		assertEquals("/", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("/C/system/.././system")));
+		assertEquals("/C/system", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("..")));
+		assertEquals("/C", ftpClient.printWorkingDirectory());
+		
+		assertTrue(FTPReply.isPositiveCompletion(ftpClient.cwd("..")));
+		assertEquals("/", ftpClient.printWorkingDirectory());
+
+	}
+	
+	//FTP&Telnet-Directory-007
+	//To change a current working directory from a valid directory to a non existence directory from PC to Device(H2/H4)
+	public void testFTP_Telnet_Directory_007()  throws IOException{
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.cwd("/ajdaskldjklasdjlasjdlasldjklasjdl")));
+		assertTrue(FTPReply.isNegativePermanent(ftpClient.cwd("/C/ajdaskldjklasdjlasjdlasldjklasjdl")));
+	}
+	
+	//FTP&Telnet-Directory-008
+	//To change a current working directory from a valid directory to a non existence directory of different drive from PC to Device(H2/H4)
+	
+	
+}