QueueListTestSupport xref

    1   /***
    2    *
    3    * Copyright 2004 Protique Ltd
    4    *
    5    * Licensed under the Apache License, Version 2.0 (the "License");
    6    * you may not use this file except in compliance with the License.
    7    * You may obtain a copy of the License at
    8    *
    9    * http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   *
    17   **/
    18  package org.codehaus.activemq.service;
    19
    20  import com.sleepycat.db.DbException;
    21  import junit.framework.TestCase;
    22
    23  import javax.jms.JMSException;
    24
    25  /***
    26   * @version $Revision: 1.6 $
    27   */
    28  public abstract class QueueListTestSupport extends TestCase {
    29      protected QueueList list;
    30
    31      public void testAddFirst() throws Exception {
    32          beginTransaction();
    33
    34          list.clear();
    35          assertTrue(list.isEmpty());
    36
    37          list.addFirst("D");
    38          list.addFirst("C");
    39          list.add(0, "B");
    40          list.add(0, "A");
    41
    42          assertListEquals(list, new Object[]{"A", "B", "C", "D"});
    43
    44          QueueListEntry entry = list.getFirstEntry();
    45          assertEquals("A", entry.getElement());
    46          entry = list.getNextEntry(entry);
    47          assertEquals("B", entry.getElement());
    48          entry = list.getNextEntry(entry);
    49          assertEquals("C", entry.getElement());
    50          entry = list.getNextEntry(entry);
    51          assertEquals("D", entry.getElement());
    52          entry = list.getNextEntry(entry);
    53          assertEquals(null, entry);
    54
    55          entry = list.getLastEntry();
    56          assertEquals("D", entry.getElement());
    57          entry = list.getPrevEntry(entry);
    58          assertEquals("C", entry.getElement());
    59          entry = list.getPrevEntry(entry);
    60          assertEquals("B", entry.getElement());
    61          entry = list.getPrevEntry(entry);
    62          assertEquals("A", entry.getElement());
    63          entry = list.getPrevEntry(entry);
    64          assertEquals(null, entry);
    65
    66          list.set(0, "X");
    67          list.set(1, "Y");
    68          list.set(2, "Z");
    69          list.set(3, "!");
    70          assertListEquals(list, new Object[]{"X", "Y", "Z", "!"});
    71
    72          list.clear();
    73          assertTrue("List should now be empty", list.isEmpty());
    74
    75          commitTransaction();
    76      }
    77
    78
    79      public void testAddAndAddLast() throws Exception {
    80          beginTransaction();
    81
    82          list.clear();
    83          assertTrue(list.isEmpty());
    84
    85          list.add("A");
    86          list.add("B");
    87          list.addLast("C");
    88          list.addLast("D");
    89
    90          assertListEquals(list, new Object[]{"A", "B", "C", "D"});
    91
    92          QueueListEntry entry = list.getFirstEntry();
    93          assertEquals("A", entry.getElement());
    94          entry = list.getNextEntry(entry);
    95          assertEquals("B", entry.getElement());
    96          entry = list.getNextEntry(entry);
    97          assertEquals("C", entry.getElement());
    98          entry = list.getNextEntry(entry);
    99          assertEquals("D", entry.getElement());
    100         entry = list.getNextEntry(entry);
    101         assertEquals(null, entry);
    102
    103         entry = list.getLastEntry();
    104         assertEquals("D", entry.getElement());
    105         entry = list.getPrevEntry(entry);
    106         assertEquals("C", entry.getElement());
    107         entry = list.getPrevEntry(entry);
    108         assertEquals("B", entry.getElement());
    109         entry = list.getPrevEntry(entry);
    110         assertEquals("A", entry.getElement());
    111         entry = list.getPrevEntry(entry);
    112         assertEquals(null, entry);
    113
    114         list.clear();
    115         assertTrue("List should now be empty", list.isEmpty());
    116
    117         commitTransaction();
    118     }
    119
    120     public void testAddAtFrontBackAndMiddle() throws Exception {
    121         beginTransaction();
    122
    123         list.clear();
    124         assertTrue(list.isEmpty());
    125
    126         list.add("A");
    127         list.add("B");
    128         list.addFirst("C");
    129         list.addLast("D");
    130         list.add(1, "E");
    131         list.add(5, "F");
    132
    133         assertListEquals(list, new Object[]{"C", "E", "A", "B", "D", "F"});
    134
    135         assertEquals("C", list.getFirst());
    136         assertEquals("F", list.getLast());
    137
    138         QueueListEntry entry = list.getLastEntry();
    139         assertEquals("F", entry.getElement());
    140         entry = list.getPrevEntry(entry);
    141         assertEquals("D", entry.getElement());
    142         entry = list.getPrevEntry(entry);
    143         assertEquals("B", entry.getElement());
    144         entry = list.getPrevEntry(entry);
    145         assertEquals("A", entry.getElement());
    146         entry = list.getPrevEntry(entry);
    147         assertEquals("E", entry.getElement());
    148         entry = list.getPrevEntry(entry);
    149         assertEquals("C", entry.getElement());
    150         entry = list.getPrevEntry(entry);
    151         assertEquals(null, entry);
    152
    153
    154         entry = list.getFirstEntry();
    155         assertEquals("C", entry.getElement());
    156         entry = list.getNextEntry(entry);
    157         assertEquals("E", entry.getElement());
    158         entry = list.getNextEntry(entry);
    159         assertEquals("A", entry.getElement());
    160         entry = list.getNextEntry(entry);
    161         assertEquals("B", entry.getElement());
    162         entry = list.getNextEntry(entry);
    163         assertEquals("D", entry.getElement());
    164         entry = list.getNextEntry(entry);
    165         assertEquals("F", entry.getElement());
    166         entry = list.getNextEntry(entry);
    167         assertEquals(null, entry);
    168
    169         assertTrue(list.contains("C"));
    170         assertTrue(list.contains("F"));
    171         assertTrue(list.contains("B"));
    172         assertTrue(!list.contains("Z"));
    173
    174         assertTrue(!list.isEmpty());
    175         assertEquals(6, list.size());
    176
    177         list.removeFirst();
    178         assertEquals("E", list.getFirst());
    179         list.removeLast();
    180         assertEquals("D", list.getLast());
    181
    182         list.clear();
    183         assertTrue("List should now be empty", list.isEmpty());
    184
    185         commitTransaction();
    186     }
    187
    188     public void testEmptyList() throws Exception {
    189         beginTransaction();
    190
    191         list.clear();
    192         assertTrue(list.isEmpty());
    193         assertEquals(0, list.size());
    194
    195         assertEquals(null, list.getFirst());
    196         assertEquals(null, list.getLast());
    197         assertEquals(-1, list.indexOf("foo"));
    198         assertEquals(-1, list.lastIndexOf("foo"));
    199
    200         commitTransaction();
    201     }
    202
    203     public void testIndexOf() throws Exception {
    204         beginTransaction();
    205
    206         list.clear();
    207
    208         list.add("A");
    209         list.add("B");
    210         list.add("C");
    211         list.add("B");
    212         list.add("D");
    213
    214         assertListEquals(list, new Object[]{"A", "B", "C", "B", "D"});
    215
    216         assertEquals(0, list.indexOf("A"));
    217         assertEquals(1, list.indexOf("B"));
    218         assertEquals(2, list.indexOf("C"));
    219         assertEquals(4, list.indexOf("D"));
    220         assertEquals(-1, list.indexOf("cheese"));
    221
    222         assertEquals(0, list.lastIndexOf("A"));
    223         assertEquals(3, list.lastIndexOf("B"));
    224         assertEquals(2, list.lastIndexOf("C"));
    225         assertEquals(4, list.lastIndexOf("D"));
    226         assertEquals(-1, list.lastIndexOf("cheese"));
    227
    228         commitTransaction();
    229     }
    230
    231     protected void beginTransaction() throws DbException {
    232     }
    233
    234     protected void commitTransaction() throws JMSException {
    235     }
    236
    237     protected void setUp() throws Exception {
    238         super.setUp();
    239         list = createQueueList();
    240     }
    241
    242     protected abstract QueueList createQueueList() throws JMSException;
    243
    244     protected void assertListEquals(QueueList list, Object[] expected) throws JMSException {
    245         assertArrayEquals(expected, list.toArray());
    246
    247         for (int i = 0; i < expected.length; i++) {
    248             Object expectedValue = expected[i];
    249             Object value = list.get(i);
    250             assertEquals("get(int) at index: " + i, expectedValue, value);
    251         }
    252
    253         QueueListEntry entry = list.getFirstEntry();
    254         for (int i = 0; i < expected.length; i++) {
    255             //System.out.println("Entry: " + entry);
    256             Object expectedValue = expected[i];
    257             assertTrue("Should have an entry for index: " + i, entry != null);
    258             assertEquals("element for entry at index: " + i, expectedValue, entry.getElement());
    259             entry = list.getNextEntry(entry);
    260         }
    261         assertTrue("entry should now be null", entry == null);
    262
    263         entry = list.getLastEntry();
    264         for (int i = expected.length - 1; i >= 0; i--) {
    265             Object expectedValue = expected[i];
    266             assertTrue("Should have an entry for index: " + i, entry != null);
    267             assertEquals("element for entry at index: " + i, expectedValue, entry.getElement());
    268             entry = list.getPrevEntry(entry);
    269         }
    270         assertTrue("entry should now be null", entry == null);
    271
    272         if (expected.length > 0) {
    273             assertEquals("first value", expected[0], list.getFirst());
    274             assertEquals("last value", expected[expected.length - 1], list.getLast());
    275             assertTrue("Should not be empty!", !list.isEmpty());
    276         }
    277         else {
    278             assertTrue("Should be empty!", list.isEmpty());
    279         }
    280     }
    281
    282     protected void assertArrayEquals(Object[] expected, Object[] objects) {
    283         String expectedText = asText(expected);
    284         String valueText = asText(objects);
    285         assertEquals("Sizes wrong. Expected: " + expectedText + " was: " + valueText, expected.length, objects.length);
    286         for (int i = 0; i < expected.length; i++) {
    287             Object expectedValue = expected[i];
    288             Object value = objects[i];
    289             assertEquals("Value at index: " + i + ". Expected: " + expectedText + " was: " + valueText, expectedValue, value);
    290         }
    291     }
    292
    293     protected String asText(Object[] objects) {
    294         StringBuffer buffer = new StringBuffer("[ ");
    295         for (int i = 0; i < objects.length; i++) {
    296             if (i > 0) {
    297                 buffer.append(", ");
    298             }
    299             buffer.append(objects[i]);
    300         }
    301         buffer.append(" ]");
    302         return buffer.toString();
    303     }
    304 }