clientimpltest.java

是离开的肌肤了卡机是离开的就富利卡及是了的开发及拉考试及的福利科技阿斯利康的肌肤莱卡及时的离开福建阿斯顿发

package org.mortbay.cometd;

import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import junit.framework.TestCase;

import org.cometd.Client;
import org.cometd.DeliverListener;
import org.cometd.Message;
import org.cometd.MessageListener;
import org.cometd.QueueListener;

/**
 * @author athena
 *
 */
public class ClientImplTest extends TestCase
{
    protected StandaloneClient _client;
    protected Message _message;
    
    
    protected void setUp() throws Exception
    {
        _client = new StandaloneClient();
        _message = new MessageImpl();
    }

    /*
     * QueueListener examples
     */
    public void testDeleteWhenFullQueue() throws Exception
    {
        Message delete =  m("delete", "a");
        Message keep = m("keep", "b"); 
        Message add = m("add", "c");
        
        _client.setMaxQueue(2);
        _client.addListener(new DeleteWhenFullQueueListener());

        _client.deliver(delete);
        _client.deliver(keep);
        _client.deliver(add);
     
        assertEquals(resultsList(keep,add), _client.takeMessages());
    }
    
    public void testDiscardNewMessageQueue() throws Exception
    {     
        Message keep1 = m("keep1", "a");
        Message keep2 = m("keep2", "b");
        Message discard = m("discard", "c");
        
        _client.setMaxQueue(2);
        _client.addListener(new DiscardNewMessageQueueListener());
        
        _client.deliver(keep1);
        _client.deliver(keep2);
        _client.deliver(discard);
        
        assertEquals(resultsList(keep1, keep2), _client.takeMessages());
    }
    
    public void testModifyExistingMessagesQueue() throws Exception
    {
        Message keep = m("keep", "a");
        Message delete = m("delete", "b");
        Message add = m("add", "c");
                
        _client.setMaxQueue(2);
        _client.addListener(new ModifyExistingMessagesQueueListener());
        
        _client.deliver(keep);
        _client.deliver(delete);
        _client.deliver(add);
        
        assertEquals(resultsList(keep, add), _client.takeMessages());
    }

    // TODO: improve this test?
    public void testTakeWhileQueueing() throws Exception 
    {
        _client.setMaxQueue(2);
        _client.addListener(new DeleteWhenFullQueueListener());
        
        Message[] m = new Message[5];
        for (int i = 0; i < m.length; ++i)
        {
            m[i] = m(i + "", i+""); 
        }
        
        (new Thread() {
            public void run()
            {
                while (true ) {
                    _client.getQueue().poll();
                    try
                    {
                        Thread.sleep(100);
                    }
                    catch (Exception e) {}
                }
            }
        }).start();
        
        for (Message message : m)
        {
            _client.deliver(message);
        }
        
        assertEquals(resultsList(m[m.length-2], m[m.length-1]),_client.takeMessages());
    }
    
    public void testId() throws Exception
    {
        AbstractBayeux bayeux = new BayeuxStub();
        //bayeux.setNodeId("nodeid");
        _client = new StandaloneClient(bayeux);
        
        // TODO
    }
     
    public void testMessageListener() throws Exception
    {
        _message.put("key","value");

        _client.addListener(new CheckMessageListener(_message));
        _client.addListener(new CheckMessageListener(_message));
        
        _client.deliver(_message);
    }
    
    public void testRemoveListener() throws Exception
    {
        // TODO
    }

    public void testDeliverListener() throws Exception
    {
        final boolean[] called = {false};
        _client.addListener(new DeliverListener()
        {
            public void deliver(Client client, Queue<Message> queue)
            {
                called[0]=true;
            }
        });

        Message ping = m("ping", "hello");
        _client.deliver(ping);
        assertFalse(called[0]);
        
        _client.doDeliverListeners();

        assertTrue(called[0]);
    }
    
/*  // TODO: make sure this works properly. I think there's a chance of a deadlock
    public void testTakeMessage() throws Exception
    {
        Message[] messages = {
                m("a", "apple"),
                m("b", "bapple"),
                m("c", "capple"),
                m("d", "dapple"),
                m("e", "eapple"),
                m("f", "fapple")
        };
            
        final CountDownLatch todo = new CountDownLatch(messages.length); 

        // temporary variable to avoid error with abstract lists not implementing remove
        List<Message> messageList = new ArrayList<Message>();
        messageList.addAll(Arrays.asList(messages));
        _client.returnMessages(messageList);
                
        final ClientImpl threadClient = _client;
        for(int i = 0; i < _client.getMessages(); ++i)
        {
            final int x = i;
            (new Thread() {
                public void run()
                {
                    try
                    {
                        int sleep = 10;
                        Thread.sleep(sleep);
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                    
                    Message message = threadClient.takeMessage();
                    todo.countDown();
                    // System.out.print(todo.getCount() + " -- ");
                    // System.out.println(x + " in thread client: " + message + "; "+threadClient.getMessages() + " left");
                    
                    
                }
            }).start();
        }

        todo.await(5, TimeUnit.SECONDS);
    }
*/    
    
    private Message m(String key, String value)
    {
        Message message = new MessageImpl();
        message.put(key, value);
        return message;
    }
    
    private List<Message> resultsList(Message m1, Message m2)
    {
        return Arrays.asList(new Message[] {m1, m2});
    }
    
    class StandaloneClient extends ClientImpl
    {
        public StandaloneClient()
        {
            super(new BayeuxStub(), "standalone");
        }
        
        public StandaloneClient(AbstractBayeux bayeux)
        {
            super(bayeux, "standalone");
        }
        
        /*
         * Warn for methods that require a proper Bayeux object
         */
        @Override
        public void deliver(Client from, String toChannel, Object data, String id)
        {
            System.err.println("Method unsupported!");
        }
        
        public void deliver(Message message)
        {
            doDelivery(null, message);
        }
        
        @Override
        public void remove(boolean timeout)
        {
            System.err.println("Method unsupported!");
        }
        
        @Override
        public void setBrowserId(String id)
        {
            System.err.println("Method unsupported!");
        }
    }
    
    /*
     * stub out and use to initialize a "standalone" client 
     */
    static class BayeuxStub extends AbstractBayeux
    {
        public BayeuxStub()
        {
            try
            {
                _random=SecureRandom.getInstance("SHA1PRNG");
            }
            catch (Exception e)
            {
                _random=new Random();
            }
            // lacks the context hashcode from AbstractBayeux#initialize()
            _random.setSeed(_random.nextLong()^hashCode()^Runtime.getRuntime().freeMemory());
        }
         
        public ClientImpl newRemoteClient()
        {
            return null;
        }
    }
    
    static class DeleteWhenFullQueueListener implements QueueListener
    {
        public boolean queueMaxed(Client from, Client client, Message message)
        {
            client.getQueue().poll();
            return true;
        }

    }
    
    static class DiscardNewMessageQueueListener implements QueueListener
    {
        public boolean queueMaxed(Client from, Client client, Message message)
        {
            return false;
        }

    }
    
    static class ModifyExistingMessagesQueueListener implements QueueListener
    {        
        public boolean queueMaxed(Client from, Client client, Message message)
        {
            Iterator<Message> queueIterator = client.getQueue().iterator();
            boolean removed = false;
            while(queueIterator.hasNext())
            {
                Message m = queueIterator.next();
                if(m.get("delete")!=null)
                {
                    queueIterator.remove();
                    removed=true;
                }
            }
            
            return removed;
        }
    }
    
    static class CheckMessageListener implements MessageListener
    {
        Message _message;
        public CheckMessageListener(Message message)
        {
            _message = message;
        }
        
        public void deliver(Client fromClient, Client toClient, Message msg)
        {
            assertEquals(_message, msg);
        }
    }
}