openflowplugin/src/test/java/org/opendaylight/openflowplugin/openflow/md/util/WrapperQueueImplTest.java

   1 package org.opendaylight.openflowplugin.openflow.md.util;
   2
   3 import java.util.Queue;
   4 import java.util.concurrent.ArrayBlockingQueue;
   5
   6 import org.junit.Assert;
   7 import org.junit.Before;
   8 import org.junit.Test;
   9 import org.junit.runner.RunWith;
  10 import org.mockito.Mock;
  11 import org.mockito.Mockito;
  12 import org.mockito.runners.MockitoJUnitRunner;
  13 import org.opendaylight.openflowplugin.api.openflow.md.core.ConnectionConductor;
  14 import org.opendaylight.openflowplugin.api.openflow.md.queue.WaterMarkListener;
  15 import org.opendaylight.openflowplugin.openflow.md.queue.WrapperQueueImpl;
  16 import org.slf4j.Logger;
  17 import org.slf4j.LoggerFactory;
  18
  19 @RunWith(MockitoJUnitRunner.class)
  20 public class WrapperQueueImplTest {
  21
  22     protected static final Logger LOG = LoggerFactory
  23             .getLogger(WrapperQueueImplTest.class);
  24
  25     @Mock
  26     private ConnectionConductor connectionConductor;
  27
  28     @Mock
  29     private WaterMarkListener waterMarkListener;
  30
  31     private WrapperQueueImpl<Integer> wrapperQueueImpl;
  32     private final int capacity = 100;
  33     private Queue<Integer> queueDefault;
  34     private int highWaterMark = 80;
  35     private int lowWaterMark = 65;
  36
  37     /**
  38      * Setup before tests
  39      */
  40     @Before
  41     public void setUp() {
  42         queueDefault = new ArrayBlockingQueue<>(capacity);
  43
  44         wrapperQueueImpl = new WrapperQueueImpl<>(capacity, queueDefault,
  45                 waterMarkListener);
  46     }
  47
  48     /**
  49      * Test for check if wrapper is not null
  50      */
  51     @Test
  52     public void testWrapperQueueImpl() {
  53         Assert.assertNotNull("Wrapper can not be null.", wrapperQueueImpl);
  54     }
  55
  56     /**
  57      * Test for set setAutoRead on false on high water mark
  58      */
  59     @Test
  60     public void testReadOnHighWaterMark() {
  61
  62         Assert.assertFalse("Wrapper must be not flooded at the start.",
  63                 wrapperQueueImpl.isFlooded());
  64
  65         push(79);
  66         Assert.assertFalse("Wrapper should not be flooded.",
  67                 wrapperQueueImpl.isFlooded());
  68         Mockito.verify(waterMarkListener, Mockito.times(0)).onHighWaterMark();
  69
  70         push(1);
  71         Assert.assertTrue("Wrapper should be flooded.",
  72                 wrapperQueueImpl.isFlooded());
  73         Mockito.verify(waterMarkListener, Mockito.times(1)).onHighWaterMark();
  74
  75         Assert.assertEquals(
  76                 "Size of queue has to be equals to 80% of capacity of queue",
  77                 highWaterMark, queueDefault.size());
  78     }
  79
  80     /**
  81      *
  82      */
  83     private void push(int size) {
  84         for (int i = 0; i < size; i++) {
  85             try {
  86                 wrapperQueueImpl.offer(i);
  87             } catch (Exception e) {
  88                 LOG.error("Failed to offer item to queue.", e);
  89             }
  90         }
  91     }
  92
  93     /**
  94      * Test for setAutoRead on true on low water mark
  95      */
  96     @Test
  97     public void testReadOnLowWaterMark() {
  98         Mockito.verify(waterMarkListener, Mockito.times(0)).onHighWaterMark();
  99         push(80);
 100         Assert.assertTrue("Wrapper should be flooded.",
 101                 wrapperQueueImpl.isFlooded());
 102         Mockito.verify(waterMarkListener, Mockito.times(1)).onHighWaterMark();
 103
 104         Assert.assertEquals(
 105                 "Size of queue has to be equals to 80% of capacity of queue",
 106                 highWaterMark, queueDefault.size());
 107
 108         poll(14);
 109         Mockito.verify(waterMarkListener, Mockito.times(0)).onLowWaterMark();
 110         Assert.assertTrue("Wrapper should be still flooded.",
 111                 wrapperQueueImpl.isFlooded());
 112
 113         poll(1);
 114         Mockito.verify(waterMarkListener, Mockito.times(1)).onLowWaterMark();
 115
 116         Assert.assertEquals(
 117                 "Size of queue has to be equals to 65% on lowWaterMark.",
 118                 lowWaterMark, queueDefault.size());
 119         Assert.assertFalse("Wrapped should be not flooded.",
 120                 wrapperQueueImpl.isFlooded());
 121     }
 122
 123     /**
 124      * Polling messages
 125      */
 126     private void poll(int size) {
 127
 128         for (int i = 0; i < size; i++) {
 129             wrapperQueueImpl.poll();
 130         }
 131     }
 132
 133     /**
 134      * Test for one cycle.
 135      */
 136     @Test
 137     public void testEndReadOnHWMStartOnLWM() {
 138
 139         Assert.assertFalse("Wrapper should not be flooded",
 140                 wrapperQueueImpl.isFlooded());
 141         Mockito.verify(waterMarkListener, Mockito.times(0)).onLowWaterMark();
 142         Mockito.verify(waterMarkListener, Mockito.times(0)).onHighWaterMark();
 143
 144         push(81);
 145         Assert.assertTrue("Wrapper should be flooded",
 146                 wrapperQueueImpl.isFlooded());
 147         Mockito.verify(waterMarkListener, Mockito.times(0)).onLowWaterMark();
 148         Mockito.verify(waterMarkListener, Mockito.times(1)).onHighWaterMark();
 149
 150         poll(17);
 151         Assert.assertFalse("Wrapper should not be flooded",
 152                 wrapperQueueImpl.isFlooded());
 153         Mockito.verify(waterMarkListener, Mockito.times(1)).onLowWaterMark();
 154         Mockito.verify(waterMarkListener, Mockito.times(1)).onHighWaterMark();
 155
 156         push(18);
 157         Assert.assertTrue("Wrapper should be flooded",
 158                 wrapperQueueImpl.isFlooded());
 159
 160         Mockito.verify(waterMarkListener, Mockito.times(1)).onLowWaterMark();
 161         Mockito.verify(waterMarkListener, Mockito.times(2)).onHighWaterMark();
 162     }
 163 }