queuetest.java

来自「JGRoups源码」· Java 代码 · 共 1,041 行 · 第 1/2 页

// $Id: QueueTest.java,v 1.23 2006/09/14 13:24:33 belaban Exp $

package org.jgroups.tests;


import junit.framework.TestCase;
import org.jgroups.TimeoutException;
import org.jgroups.util.Queue;
import org.jgroups.util.QueueClosedException;
import org.jgroups.util.Util;

import java.util.LinkedList;
import java.util.ArrayList;


public class QueueTest extends TestCase {
    private Queue queue=null;

    public QueueTest(String Name_) {
        super(Name_);
    }

    public void setUp() throws Exception {
        super.setUp();
        queue=new Queue();
    }


    public void tearDown() throws Exception {
        super.tearDown();
        if(queue != null) {
            queue.reset();
        }
    }


    public void testQueue() {
        try {
            queue.add("Q1");
            queue.add("Q2");
            queue.add("Q3");

            assertEquals("Q1", queue.peek());
            assertEquals("Q1", queue.remove());

            assertEquals("Q2", queue.peek());
            assertEquals("Q2", queue.remove());

            queue.addAtHead("Q4");
            queue.add("Q5");
            assertEquals("Q4", queue.peek());
            assertEquals("Q4", queue.remove());

            queue.close(true);

            try {
                queue.add("Q6");
                fail("should not get here");
            }
            catch(org.jgroups.util.QueueClosedException qc) {
                assertTrue(true);
            }

            int size=queue.size();
            queue.removeElement("Q5");
            assertEquals((size - 1), queue.size());

            assertEquals("Q3", queue.peek());
            assertEquals("Q3", queue.remove());
            assertTrue(queue.closed());
            System.out.println("Everything is ok");
        }
        catch(Exception x) {
            System.out.println(x);
            fail();
        }
    }


    public void testCloseWithoutFlush() {
        queue.close(false);
        try {
            queue.remove();
            fail("we should have gotten a QueueClosedException trying to remove an element from a closed queue");
        }
        catch(QueueClosedException e) {
            assertTrue("queue is closed, this is okay", queue.closed());
        }
    }


    public void testCloseWithFlush() {
        queue.close(true);
        try {
            queue.remove();
            fail("we should have gotten a QueueClosedException trying to remove an element from a closed queue");
        }
        catch(QueueClosedException e) {
            assertTrue("queue is closed, this is okay", queue.closed());
        }
    }


    public void testCloseWithFlush2() throws QueueClosedException {
        queue.add(new Integer(1));
        queue.add(new Integer(2));
        queue.add(new Integer(3));
        queue.close(true);
        try {
            for(int i=1; i <= 3; i++) {
                Object obj=queue.remove();
                assertNotNull(obj);
                assertEquals(obj, new Integer(i));
            }
            queue.remove();
            fail("we should have gotten a QueueClosedException trying to remove an element from a closed queue");
        }
        catch(QueueClosedException e) {
            assertTrue("queue is closed, this is okay", queue.closed());
        }
    }


    public void testValues() throws QueueClosedException {
        queue.add(new Integer(1));
        queue.add(new Integer(3));
        queue.add(new Integer(99));
        queue.add(new Integer(8));
        System.out.println("queue: " + Util.dumpQueue(queue));
        int size=queue.size();
        assertEquals(4, size);
        LinkedList values=queue.values();
        assertEquals(size, values.size());
    }


    public void testLargeInsertion() {
        String element="MyElement";
        long start, stop;

        try {
            System.out.println("Inserting 100000 elements");
            start=System.currentTimeMillis();
            for(int i=0; i < 100000; i++)
                queue.add(element);
            stop=System.currentTimeMillis();
            System.out.println("Took " + (stop - start) + " msecs");

            System.out.println("Removing 100000 elements");
            start=System.currentTimeMillis();
            while(queue.size() > 0)
                queue.remove();
            stop=System.currentTimeMillis();
            System.out.println("Took " + (stop - start) + " msecs");
        }
        catch(Exception ex) {
            System.err.println(ex);
            fail();
        }
    }


    public void testEmptyQueue() {
        assertNull(queue.getFirst());
        assertNull(queue.getLast());
        assertEquals(queue.getFirst(), queue.getLast()); // both are null; they're equal
    }

    public void testAddAll() throws QueueClosedException {
        ArrayList l=new ArrayList();
        l.add("one");
        l.add("two");
        l.add("three");
        queue.addAll(l);
        System.out.println("queue is " + queue);
        assertEquals(3, queue.size());
        assertEquals("one", queue.remove());
        assertEquals(2, queue.size());
        assertEquals("two", queue.remove());
        assertEquals(1, queue.size());
        assertEquals("three", queue.remove());
        assertEquals(0, queue.size());
    }

    public void testInsertionAndRemoval() throws Exception {
        String s1="Q1", s2="Q2";

        queue.add(s1);
        assertTrue(queue.getFirst() != null);
        assertTrue(queue.getLast() != null);
        assertEquals(queue.getFirst(), queue.getLast());

        queue.add(s2);
        assertTrue(queue.getFirst() != queue.getLast());

        Object o1=queue.peek();
        Object o2=queue.getFirst();

        System.out.println("o1=" + o1 + ", o2=" + o2 + ", o1.equals(o2)=" + o1.equals(o2));

        assertEquals(queue.peek(), queue.getFirst());
        queue.remove();

        assertEquals(1, queue.size());
        assertEquals(queue.getFirst(), queue.getLast());
        queue.remove();

        assertEquals(0, queue.size());
        assertTrue(queue.getFirst() == null);
        assertTrue(queue.getLast() == null);
    }


    public void testWaitUntilClosed() {
        queue.close(true);
        queue.waitUntilClosed(0);
        assertEquals(0, queue.size());
    }

    public void testWaitUntilClosed2() {
        queue.close(true);
        try {
            queue.peek();
            fail("peek() should throw a QueueClosedException");
        }
        catch(QueueClosedException e) {
            assertTrue(e != null);
        }
        assertEquals(0, queue.size());
    }

    public void testWaitUntilClosed3() throws QueueClosedException {
        queue.add("one");
        queue.close(true);
        Object obj=queue.peek();
        assertEquals("one", obj);
        assertEquals(1, queue.size());
        queue.remove();
        try {
            queue.peek();
            fail("peek() should throw a QueueClosedException");
        }
        catch(QueueClosedException e) {
            assertTrue(e != null);
        }
        assertEquals(0, queue.size());
    }

    public void testWaitUntilClosed4() throws QueueClosedException {
        for(int i=0; i < 10; i++)
            queue.add(new Integer(i));
        new Thread() {
            public void run() {
                while(!queue.closed()) {
                    try {
                        System.out.println("-- removed " + queue.remove());
                        Util.sleep(200);
                    }
                    catch(QueueClosedException e) {
                        break;
                    }
                }
            }
        }.start();
        queue.close(true);
        queue.waitUntilClosed(0);
        assertEquals(0, queue.size());
    }


    public void testWaitUntilClosed5() throws QueueClosedException {
        for(int i=0; i < 10; i++)
            queue.add(new Integer(i));
        new Thread() {
            public void run() {
                while(!queue.closed()) {
                    try {
                        System.out.println("-- removed " + queue.remove());
                        Util.sleep(200);
                    }
                    catch(QueueClosedException e) {
                        System.out.println("-- queue is closed, cannot remove element");
                        break;
                    }
                }
            }
        }.start();

        Util.sleep(600);
        queue.close(false);
        queue.waitUntilClosed(0);
        assertTrue(queue.size() > 0);
    }



    public void testRemoveElementNoElement() {
        String s1="Q1";

        try {
            queue.removeElement(s1);
            assertFalse(queue.closed());
            assertEquals(0, queue.size());
        }
        catch(QueueClosedException ex) {
            fail(ex.toString());
        }
    }


    public void testRemoveElementOneElement() {
        String s1="Q1";

        try {
            queue.add(s1);
            queue.removeElement(s1);
            assertEquals(0, queue.size());
            assertTrue(queue.getFirst() == null);
            assertTrue(queue.getLast() == null);
        }
        catch(QueueClosedException ex) {
            fail(ex.toString());
        }
    }

    public void testRemoveElementTwoElementsFirstFound() {
        String s1="Q1", s2="Q2";

        try {
            queue.add(s1);
            queue.add(s2);
            queue.removeElement(s1);
            assertEquals(1, queue.size());
            assertEquals(queue.getFirst(), s2);
            assertEquals(queue.getLast(), s2);
            assertEquals(queue.getFirst(), queue.getLast());
        }
        catch(QueueClosedException ex) {
            fail(ex.toString());
        }
    }

    public void testRemoveElementTwoElementsSecondFound() {
        String s1="Q1", s2="Q2";

        try {
            queue.add(s1);
            queue.add(s2);
            queue.removeElement(s2);
            assertEquals(1, queue.size());
            assertEquals(queue.getFirst(), s1);
            assertEquals(queue.getLast(), s1);
            assertEquals(queue.getFirst(), queue.getLast());
        }
        catch(QueueClosedException ex) {
            fail(ex.toString());
        }
    }

    public void testRemoveElementThreeElementsFirstFound() {
        String s1="Q1", s2="Q2", s3="Q3";

        try {
            queue.add(s1);
            queue.add(s2);
            queue.add(s3);
            queue.removeElement(s1);
            assertEquals(2, queue.size());
            assertEquals(queue.getFirst(), s2);
            assertEquals(queue.getLast(), s3);
        }
        catch(QueueClosedException ex) {
            fail(ex.toString());
        }
    }

    public void testRemoveElementThreeElementsSecondFound() {
        String s1="Q1", s2="Q2", s3="Q3";

        try {
            queue.add(s1);
            queue.add(s2);
            queue.add(s3);
            queue.removeElement(s2);
            assertEquals(2, queue.size());
            assertEquals(queue.getFirst(), s1);
            assertEquals(queue.getLast(), s3);
        }
        catch(QueueClosedException ex) {
            fail(ex.toString());
        }
    }

    public void testRemoveElementThreeElementsThirdFound() {
        String s1="Q1", s2="Q2", s3="Q3";

        try {
            queue.add(s1);
            queue.add(s2);
            queue.add(s3);
            queue.removeElement(s3);
            assertEquals(2, queue.size());
            assertEquals(queue.getFirst(), s1);
            assertEquals(queue.getLast(), s2);
        }
        catch(QueueClosedException ex) {
            fail(ex.toString());
        }
    }


    public void testRemoveAndClose() {
        try {
            new Thread() {
                public void run() {
                    Util.sleep(1000);
                    queue.close(true); // close gracefully
                }
            }.start();

            queue.remove();
            fail("we should not be able to remove an object from a closed queue");
        }
        catch(QueueClosedException ex) {
            assertTrue(ex instanceof QueueClosedException); // of course, stupid comparison...
        }
    }


    public void testRemoveAndCloseWithTimeout() throws TimeoutException {
        try {
            new Thread() {
                public void run() {
                    Util.sleep(1000);
                    queue.close(true); // close gracefully
                }
            }.start();

            queue.remove(5000);
            fail("we should not be able to remove an object from a closed queue");
        }
        catch(QueueClosedException ex) {
            assertTrue(ex instanceof QueueClosedException); // of course, stupid comparison...
        }
        catch(TimeoutException timeout) {
            fail("we should not get a TimeoutException, but a QueueClosedException here");
        }
    }


    public void testInterruptAndRemove() throws QueueClosedException {
        Thread.currentThread().interrupt();
        Object el=null;
        try {
            el=queue.remove(2000);
            fail("we should not get here");
        }
        catch(TimeoutException e) {
            assertNull(el);
        }
    }


    public void testRemoveAndInterrupt() {

        Thread closer=new Thread() {
            public void run() {
                Util.sleep(1000);
                System.out.println("-- closing queue");
                queue.close(false);
            }
        };
        closer.start();

        System.out.println("-- removing element");
        try {
            queue.remove();
            fail("we should not get here, as the queue is closed");
        }
        catch(QueueClosedException e) {
            System.out.println("-- received queue closed exception - as expected");
        }

    }

    public void testClear() throws QueueClosedException {
        queue.add("one");
        queue.add("two");
        assertEquals(2, queue.size());
        queue.close(true);
        assertEquals(2, queue.size());
        queue.clear();
        assertEquals(0, queue.size());
        queue=new Queue();
        queue.add("one");
        queue.add("two");
        queue.clear();
        assertEquals(0, queue.size());
        queue.add("one");
        queue.add("two");
        assertEquals(2, queue.size());
        queue.clear();
        assertEquals(0, queue.size());
    }


//    public void testWaitUntilEmpty() {
//        try {
//            queue.add("one");
//            queue.add("two");
//            queue.add("three");
//
//            new Thread() {
//                public void run() {
//                    try {
//                        sleep(1000);
//                        queue.remove();
//                        queue.remove();
//                        queue.remove();
//                    }
//                    catch(Exception e) {