git.gag.com Git - debian/openrocket/blob - test/net/sf/openrocket/logging/CyclicBufferTest.java

   1 package net.sf.openrocket.logging;
   2
   3 import static org.junit.Assert.*;
   4
   5 import java.util.Iterator;
   6 import java.util.LinkedList;
   7 import java.util.List;
   8 import java.util.NoSuchElementException;
   9 import java.util.Random;
  10
  11 import org.junit.Test;
  12
  13
  14 public class CyclicBufferTest {
  15
  16         @Test
  17         public void testBasic() {
  18                 CyclicBuffer<Integer> buffer = new CyclicBuffer<Integer>(5);
  19                 LinkedList<Integer> correct = new LinkedList<Integer>();
  20
  21                 Random rnd = new Random();
  22                 for (int i=0; i<50; i++) {
  23                         int n = rnd.nextInt();
  24                         buffer.add(n);
  25                         correct.add(n);
  26                         if (correct.size() > 5)
  27                                 correct.remove();
  28                         assertEquals(correct, buffer.asList());
  29                 }
  30         }
  31
  32         @Test
  33         public void testComplex() {
  34                 CyclicBuffer<Integer> buffer = new CyclicBuffer<Integer>(5);
  35
  36                 testContents(buffer);
  37                 assertEquals(0, buffer.getOverwriteCount());
  38
  39                 buffer.offer(1);
  40                 testContents(buffer, 1);
  41                 assertEquals(0, buffer.getOverwriteCount());
  42
  43                 buffer.add(2);
  44                 testContents(buffer, 1, 2);
  45                 assertEquals(0, buffer.getOverwriteCount());
  46
  47                 buffer.add(3);
  48                 testContents(buffer, 1, 2, 3);
  49                 assertEquals(0, buffer.getOverwriteCount());
  50
  51                 assertEquals(1, (int)buffer.remove());
  52                 testContents(buffer, 2, 3);
  53                 assertEquals(0, buffer.getOverwriteCount());
  54
  55                 assertEquals(2, (int)buffer.peek());
  56                 testContents(buffer, 2, 3);
  57                 assertEquals(0, buffer.getOverwriteCount());
  58
  59                 buffer.offer(-2);
  60                 testContents(buffer, 2, 3, -2);
  61                 assertEquals(0, buffer.getOverwriteCount());
  62
  63                 buffer.offer(-3);
  64                 testContents(buffer, 2, 3, -2, -3);
  65                 assertEquals(0, buffer.getOverwriteCount());
  66
  67                 buffer.offer(-4);
  68                 testContents(buffer, 2, 3, -2, -3, -4);
  69                 assertEquals(0, buffer.getOverwriteCount());
  70
  71                 buffer.offer(5);
  72                 testContents(buffer, 3, -2, -3, -4, 5);
  73                 assertEquals(1, buffer.getOverwriteCount());
  74
  75                 buffer.offer(6);
  76                 testContents(buffer, -2, -3, -4, 5, 6);
  77                 assertEquals(2, buffer.getOverwriteCount());
  78
  79                 assertEquals(-2, (int)buffer.peek());
  80                 testContents(buffer, -2, -3, -4, 5, 6);
  81                 assertEquals(2, buffer.getOverwriteCount());
  82
  83                 assertEquals(-2, (int)buffer.remove());
  84                 testContents(buffer, -3, -4, 5, 6);
  85                 assertEquals(2, buffer.getOverwriteCount());
  86
  87                 assertEquals(-3, (int)buffer.remove());
  88                 testContents(buffer, -4, 5, 6);
  89                 assertEquals(2, buffer.getOverwriteCount());
  90
  91                 assertEquals(-4, (int)buffer.poll());
  92                 testContents(buffer, 5, 6);
  93                 assertEquals(2, buffer.getOverwriteCount());
  94
  95                 assertEquals(5, (int)buffer.remove());
  96                 testContents(buffer, 6);
  97                 assertEquals(2, buffer.getOverwriteCount());
  98
  99                 assertEquals(6, (int)buffer.poll());
 100                 testContents(buffer);
 101                 assertEquals(2, buffer.getOverwriteCount());
 102
 103                 assertNull(buffer.peek());
 104                 assertNull(buffer.poll());
 105                 testContents(buffer);
 106                 assertEquals(2, buffer.getOverwriteCount());
 107         }
 108
 109
 110         @Test
 111         public void testRandom() {
 112                 CyclicBuffer<Integer> buffer = new CyclicBuffer<Integer>(4);
 113                 LinkedList<Integer> correct = new LinkedList<Integer>();
 114
 115                 Random rnd = new Random();
 116                 for (int i=0; i<500; i++) {
 117
 118                         if (rnd.nextBoolean()) {
 119                                 int n = rnd.nextInt();
 120                                 buffer.add(n);
 121                                 correct.add(n);
 122                                 if (correct.size() > 4)
 123                                         correct.remove();
 124                         } else {
 125                                 Integer n = buffer.poll();
 126                                 if (correct.size() > 0) {
 127                                         assertEquals(correct.remove(), n);
 128                                 } else {
 129                                         assertNull(n);
 130                                 }
 131                         }
 132
 133                         assertEquals(correct, buffer.asList());
 134                 }
 135         }
 136
 137
 138         private void testContents(CyclicBuffer<Integer> buffer, int ... values) {
 139
 140                 // Test using iterator
 141                 Iterator<Integer> iterator = buffer.iterator();
 142                 for (int v: values) {
 143                         assertTrue(iterator.hasNext());
 144                         assertEquals(v, (int)iterator.next());
 145                 }
 146                 assertFalse(iterator.hasNext());
 147                 try {
 148                         iterator.next();
 149                         fail();
 150                 } catch (NoSuchElementException ignore) { }
 151
 152                 // Test using list
 153                 List<Integer> list = buffer.asList();
 154                 assertEquals("List: " + list, values.length, list.size());
 155                 for (int i=0; i<values.length; i++) {
 156                         assertEquals(values[i], (int)list.get(i));
 157                 }
 158
 159         }
 160
 161
 162 }