microeditiontest.java

java开源的企业总线.xmlBlaster

package org.xmlBlaster.test.classtest;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Hashtable;
import java.util.Vector;

import java.util.logging.Logger;
import java.util.logging.Level;
import org.xmlBlaster.client.protocol.http.common.BufferedInputStreamMicro;
import org.xmlBlaster.client.protocol.http.common.Msg;
import org.xmlBlaster.client.protocol.http.common.MsgHolder;
import org.xmlBlaster.client.protocol.http.common.ObjectInputStreamMicro;
import org.xmlBlaster.client.protocol.http.common.ObjectOutputStreamMicro;
import org.xmlBlaster.util.Global;

import junit.framework.*;

/**
 * Test ConnectQos. 
 * <p />
 * All methods starting with 'test' and without arguments are invoked automatically
 * <p />
 * Invoke: java -Djava.compiler= junit.textui.TestRunner -noloading org.xmlBlaster.test.classtest.MicroEditionTest
 */
public class MicroEditionTest extends TestCase {
   
   public class Sender extends Thread {
      
      private int port;
      private byte[] content;
      private long delay;
      private InetAddress addr;
      
      public Sender(InetAddress addr, int port, byte[] content, long delay) {
         super();
         this.port = port;
         this.content = content;
         this.delay = delay;
         this.addr = addr;
         start();   
      }
      
      public void run() {
         try {
            Socket sock = new Socket(this.addr, this.port);
            OutputStream out = sock.getOutputStream();
            for (int i=0; i < this.content.length; i++) {
               out.write(this.content[i]);
               Thread.sleep(this.delay);
            }
            out.flush();
            sock.close();            
         }
         catch (Exception ex) {
            ex.printStackTrace();
         }
      }
      
   }
   
   public class Receiver extends Thread {
      
      private int port;
      private Vector lines = new Vector();
      private ServerSocket serverSocket;
      private boolean isMicro;
      private boolean finished;
      
      public Receiver(int port, boolean isMicro) throws IOException {
         super();
         this.port = port;
         this.serverSocket = new ServerSocket(this.port);
      }
      
      public InetAddress startListener() {
         start();
         return this.serverSocket.getInetAddress();
      }

      public String[] getLines() {
         return (String[])this.lines.toArray(new String[this.lines.size()]);
      }

      public boolean isFinished() {
         return this.finished;
      }

      public void run() {
         System.out.println("starting thread");
         try {
            Socket sock = this.serverSocket.accept();
            InputStream in = sock.getInputStream();
            
            if (this.isMicro) {
               BufferedInputStreamMicro br = new BufferedInputStreamMicro(in);
               while (true) {
                  String line = br.readLine();
                  if (line != null) this.lines.add(line);
                  else break;
               }
            }
            else {
               BufferedReader br = new BufferedReader(new InputStreamReader(in));
               while (true) {
                  String line = br.readLine();
                  if (line != null) this.lines.add(line);
                  else break;
               }
            }
            sock.close();            
         }
         catch (Exception ex) {
            ex.printStackTrace();
         }
         this.finished = true;
      }
      
   }
   
   final static String ME = "MicroEditionTest";
   protected Global glob;
   private static Logger log = Logger.getLogger(MicroEditionTest.class.getName());
   int counter = 0;

   public MicroEditionTest(String name, String[] args) {
      super(name);
      this.glob = Global.instance();
      this.glob.init(args);

   }

   public MicroEditionTest(String name) {
      super(name);
      this.glob = Global.instance();

   }

   protected void setUp() {
   }

   protected void tearDown() {
   }

   private void assertHashtableContent(String key, Hashtable ref, Hashtable is) {
      Object val1 = ref.get(key);
      Object val2 = is.get(key);
      assertEquals("wrong value for key '" + key + "'", val1, val2);
   }

   public void testVectorIO() {
      try {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         ObjectOutputStreamMicro oosm = new ObjectOutputStreamMicro(baos);
         
         Hashtable key = new Hashtable();
         key.put("one", "1");
         key.put("two", "2");
         key.put("three", "3");
         key.put("four", "4");
         
         Hashtable qos = new Hashtable();
         qos.put("one-qos", "1");
         qos.put("two-qos", "2");
         qos.put("three-qos", "3");
         
         byte[] content = "This is the content".getBytes();
         Msg msg = new Msg(key, content, qos);
         Vector inVec = new Vector();
         inVec.add(key);
         inVec.add(qos);
         inVec.add(content);
         inVec.add(key);
         inVec.add(qos);
         inVec.add(content);
         oosm.writeObject(inVec);
         
         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
         ObjectInputStreamMicro oism = new ObjectInputStreamMicro(bais);
         Object obj = oism.readObject();
         assertTrue("hashtable is not of type 'Vector', it is " + obj.getClass().getName(), obj instanceof Vector);
         Vector vec = (Vector)obj;
         assertEquals("wrong number of entries in vector", 6, vec.size());
         Hashtable keyOut = (Hashtable)vec.get(0);
         Hashtable qosOut = (Hashtable)vec.get(1);
         byte[] contentOut = (byte[])vec.get(2);
         assertHashtableContent("one", key, keyOut);
         assertHashtableContent("two", key, keyOut);
         assertHashtableContent("three", key, keyOut);
         assertHashtableContent("four", key, keyOut);
         assertHashtableContent("one-qos", qos, qosOut);
         assertHashtableContent("two-qos", qos, qosOut);
         assertHashtableContent("three-qos", qos, qosOut);
         
         keyOut = (Hashtable)vec.get(3);
         qosOut = (Hashtable)vec.get(4);
         contentOut = (byte[])vec.get(5);
         assertHashtableContent("one", key, keyOut);
         assertHashtableContent("two", key, keyOut);
         assertHashtableContent("three", key, keyOut);
         assertHashtableContent("four", key, keyOut);
         assertHashtableContent("one-qos", qos, qosOut);
         assertHashtableContent("two-qos", qos, qosOut);
         assertHashtableContent("three-qos", qos, qosOut);
         log.info("testVectorIO successfully completed");
      }
      catch (Exception ex) {
         ex.printStackTrace();         
         assertTrue("exception occured: " + ex.getMessage(), false);
      }
      
   }

   public void testHashtableIO() {
      try {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         ObjectOutputStreamMicro oosm = new ObjectOutputStreamMicro(baos);
         
         Hashtable hashtable = new Hashtable();
         hashtable.put("one", "1");
         hashtable.put("two", "2");
         hashtable.put("three", "3");
         hashtable.put("four", "4");
         
         oosm.writeObject(hashtable);
         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
         ObjectInputStreamMicro oism = new ObjectInputStreamMicro(bais);
         Object obj = oism.readObject();
         assertTrue("hashtable is not of type 'Hashtable', it is " + obj.getClass().getName(), obj instanceof Hashtable);
         Hashtable table = (Hashtable)obj;
         assertEquals("wrong number of entries in hashtable", hashtable.size(), table.size());
         assertHashtableContent("one", hashtable, table);
         assertHashtableContent("two", hashtable, table);
         assertHashtableContent("three", hashtable, table);
         assertHashtableContent("four", hashtable, table);
         log.info("testHashtableIO successfully completed");
      }
      catch (Exception ex) {
         ex.printStackTrace();         
         assertTrue("exception occured: " + ex.getMessage(), false);
      }
      
   }

   public void testStringIO() {
      try {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         ObjectOutputStreamMicro oosm = new ObjectOutputStreamMicro(baos);
         
         String testString = "this is\n\na simple\nmultiline string\n";
         oosm.writeObject(testString);
         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
         ObjectInputStreamMicro oism = new ObjectInputStreamMicro(bais);
         Object obj = oism.readObject();
         assertTrue("string is not of type 'String', it is " + obj.getClass().getName(), obj instanceof String);
         String response = (String)obj;
         assertEquals("wrong content for the string", testString, response);
         log.info("testStringIO successfully completed");
      }
      catch (Exception ex) {
         ex.printStackTrace();         
         assertTrue("exception occured: " + ex.getMessage(), false);
      }
   }

   public void testReadLine() {
      try {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         PrintStream ps = new PrintStream(baos);
         ps.println("first line");
         ps.println("");
         ps.println("");
         ps.println("");
         ps.println("second line");
         ps.println("third line");
         ps.println("");
         ps.println("");
         ps.close();
         byte[] buf = baos.toByteArray();
         byte[] buf1 = new byte[buf.length];
         for (int i=0; i < buf.length; i++) buf1[i] = buf[i];
         
         BufferedInputStreamMicro bism = new BufferedInputStreamMicro(new ByteArrayInputStream(buf));
         BufferedReader br = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(buf1)));
         while (true) {
            String referenceLine = br.readLine(); // of the normal reader
            if (referenceLine == null) 
               break;
            String lineToCheck = bism.readLine(); // must be the same as the corresponding reference since we expect same behaviour
            if (lineToCheck == null) 
               assertTrue("the line to be checked is unexpectedly null", false);
            assertEquals("wrong content", referenceLine, lineToCheck);
         }
         
         String lineToCheck = bism.readLine(); // must be the same as the corresponding reference since we expect same behaviour
         assertTrue("The line to check must also be null", lineToCheck == null);
         
         log.info("testReadLine successfully completed");
      }
      catch (Exception ex) {
         ex.printStackTrace();         
         assertTrue("exception occured: " + ex.getMessage(), false);
      }
   }

   public void testReadLineDelayed() {
      try {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         PrintStream ps = new PrintStream(baos);
         ps.println("first line");
         ps.println("");
         ps.println("");
         ps.println("");
         ps.println("second line");
         ps.println("third line");
         ps.println("");
         ps.println("");
         ps.close();
         byte[] buf = baos.toByteArray();
         
         int port1 = 26666;
         int port2 = 26667;
         Receiver receiver1 = new Receiver(port1, false);
         Receiver receiver2 = new Receiver(port2, true);
         
         log.info("testReadLineDelayed create sender 1");
         Sender sender1 = new Sender(receiver1.startListener(), port1, buf, 1L);
         log.info("testReadLineDelayed create sender 2");
         Sender sender2 = new Sender(receiver2.startListener(), port2, buf, 10L);

         while (!receiver1.isFinished() || !receiver2.isFinished()) {
            Thread.sleep(200L);
         }
         
         String[] resp1 = receiver1.getLines();
         String[] resp2 = receiver2.getLines();
         
         assertEquals("wrong number of lines returned", resp1.length, resp2.length);
         for (int i=0; i < resp1.length; i++) {
            log.info(".testReadLineDelayed '" + resp1[i] + "' '" + resp2[i] + "'");
         }
         for (int i=0; i < resp1.length; i++) {
            assertEquals("wrong content of line " + i, resp1[i], resp2[i]);
         }
         
      }
      catch (Exception ex) {
         ex.printStackTrace();         
         assertTrue("exception occured: " + ex.getMessage(), false);
      }
   }

   public void testMessageIO() {
      try {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         ObjectOutputStreamMicro oosm = new ObjectOutputStreamMicro(baos);

         String oid = "someOid";         
         String key = "<key oid='100'></key>";
         String qos = "<qos><persistent/></qos>";
         byte[] content = "This is the content".getBytes();
         
         int length = ObjectOutputStreamMicro.writeMessage(baos, oid, key, qos, content);
         assertEquals("wrong length returned", oid.length() + key.length() + qos.length() + content.length + 3, length);
         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
         ObjectInputStreamMicro oism = new ObjectInputStreamMicro(bais);

         int size = bais.available();
         assertEquals("wrong length of bytes available", length, size);
         byte[] msg = new byte[size];
         bais.read(msg);
         MsgHolder msgHolder = ObjectInputStreamMicro.readMessage(msg);
         
         assertEquals("wrong content for the oid", oid, msgHolder.getOid());
         assertEquals("wrong content for the key", key, msgHolder.getKey());
         assertEquals("wrong content for the qos", qos, msgHolder.getQos());
         assertEquals("wrong content for the content", new String(content), new String(msgHolder.getContent()));
         
         log.info("testMessageIO successfully completed");
      }
      catch (Exception ex) {
         ex.printStackTrace();         
         assertTrue("exception occured: " + ex.getMessage(), false);
      }
   }

   /**
    * <pre>
    *  java org.xmlBlaster.test.classtest.MicroEditionTest
    * </pre>
    */
   public static void main(String args[])
   {
      MicroEditionTest test = new MicroEditionTest("MicroEditionTest", args);

      test.setUp();
      test.testStringIO();
      test.tearDown();

      test.setUp();
      test.testHashtableIO();
      test.tearDown();

      test.setUp();
      test.testVectorIO();
      test.tearDown();

      test.setUp();
      test.testReadLine();
      test.tearDown();

      test.setUp();
      test.testReadLineDelayed();
      test.tearDown();

      test.setUp();
      test.testMessageIO();
      test.tearDown();
   }
}