activemq的代码测试小结

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.activemq.transport.http;

import java.net.URISyntaxException;
import java.util.concurrent.atomic.AtomicInteger;
import javax.jms.BytesMessage;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import javax.jms.StreamMessage;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerService;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class HttpJMSMessagesWithCompressionTest {

    private static final AtomicInteger counter = new AtomicInteger(1);

    enum DESTINATION_TYPE { TOPIC, QUEUE };

    protected BrokerService broker;
    protected Connection connection;
    protected DESTINATION_TYPE destinationType = DESTINATION_TYPE.QUEUE;

    @Before
    public void setUp() throws Exception {
        broker = createBroker();
        broker.start();
        WaitForJettyListener.waitForJettySocketToAccept(getBrokerURL());
        ConnectionFactory factory = createConnectionFactory();
        connection = factory.createConnection();
    }

    @After
    public void tearDown() throws Exception {
        if (connection != null) {
            connection.close();
        }
        if (broker != null) {
            broker.stop();
        }
    }

    protected ConnectionFactory createConnectionFactory() throws URISyntaxException {
        ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(getBrokerURL());
        return factory;
    }

    protected String getBrokerURL() {
        return "http://localhost:8161?useCompression=true";
    }

    protected BrokerService createBroker() throws Exception {
        BrokerService answer = new BrokerService();
        answer.setPersistent(false);
        answer.setUseJmx(false);
        answer.setManagementContext(null);
        answer.addConnector(getBrokerURL());
        return answer;
    }

    protected Destination createDestination(Session session, DESTINATION_TYPE destinationType) throws JMSException {
        switch(destinationType) {
        case TOPIC:
            return session.createTopic("TOPIC." + counter.getAndIncrement());
        case QUEUE:
            return session.createQueue("QUEUE." + counter.getAndIncrement());
        }
        Assert.fail("Invalid destination type: " + destinationType);
        return null;
    }

    abstract class MessageCommand
 
   {

        public final void assertMessage(M message) throws JMSException {
            Assert.assertNotNull(message);
            completeCheck(message);
        }

        public abstract void completeCheck(M message) throws JMSException;

        public abstract M createMessage(Session session) throws JMSException;
    }

    @SuppressWarnings("unchecked")
    private 
  
    void executeTest(MessageCommand
   
     messageCommand) throws JMSException { // Receive a message with the JMS API connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination destination = createDestination(session, destinationType); MessageConsumer consumer = session.createConsumer(destination); MessageProducer producer = session.createProducer(destination); { E message = messageCommand.createMessage(session); producer.send(message); } { E message = (E)consumer.receive(1000); messageCommand.assertMessage(message); } Assert.assertNull(consumer.receiveNoWait()); } @Test public void testTextMessage() throws Exception { executeTest(new MessageCommand
    
     () { private String textString = "This is a simple text string"; public TextMessage createMessage(Session session) throws JMSException { return session.createTextMessage(textString); } public void completeCheck(TextMessage message) throws JMSException { Assert.assertEquals("The returned text string was different", textString, message.getText()); } }); } @Test public void testBytesMessage() throws Exception { executeTest(new MessageCommand
     
      () { private byte[] bytes = "This is a simple text string".getBytes(); public BytesMessage createMessage(Session session) throws JMSException { BytesMessage message = session.createBytesMessage(); message.writeBytes(bytes); return message; } public void completeCheck(BytesMessage message) throws JMSException { byte[] result = new byte[bytes.length]; message.readBytes(result); Assert.assertArrayEquals("The returned byte array was different", bytes, result); } }); } @Test public void testMapMessage() throws Exception { executeTest(new MessageCommand
      
       () { public MapMessage createMessage(Session session) throws JMSException { MapMessage message = session.createMapMessage(); message.setInt("value", 13); return message; } public void completeCheck(MapMessage message) throws JMSException { Assert.assertEquals("The returned mapped value was different", 13, message.getInt("value")); } }); } @Test public void testObjectMessage() throws Exception { executeTest(new MessageCommand
       
        () { private Long value = new Long(101); public ObjectMessage createMessage(Session session) throws JMSException { return session.createObjectMessage(value); } public void completeCheck(ObjectMessage message) throws JMSException { Assert.assertEquals("The returned object was different", value, message.getObject()); } }); } @Test public void testStreamMessage() throws Exception { executeTest(new MessageCommand
        
         () { private Long value = new Long(1013); public StreamMessage createMessage(Session session) throws JMSException { StreamMessage message = session.createStreamMessage(); message.writeObject(value); return message; } public void completeCheck(StreamMessage message) throws JMSException { Assert.assertEquals("The returned stream object was different", value, message.readObject()); } }); } }