View Javadoc
1   /*
2    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
3    * The software in this package is published under the terms of the CPAL v1.0
4    * license, a copy of which has been included with this distribution in the
5    * LICENSE.txt file.
6    */
7   package org.mule.util.counters;
8   
9   import org.mule.tck.junit4.AbstractMuleTestCase;
10  import org.mule.util.counters.CounterFactory.Type;
11  
12  import java.util.Iterator;
13  
14  import org.junit.Test;
15  
16  import static org.junit.Assert.assertEquals;
17  import static org.junit.Assert.assertNotNull;
18  import static org.junit.Assert.assertNull;
19  import static org.junit.Assert.assertTrue;
20  import static org.junit.Assert.fail;
21  
22  public class CountersTestCase extends AbstractMuleTestCase
23  {
24  
25      private static final double delta = 1E-10;
26  
27      @Test
28      public void testCreate()
29      {
30          assertNotNull(CounterFactory.createCounter("create1", Type.NUMBER));
31          assertNotNull(CounterFactory.createCounter("create2", Type.NUMBER, false));
32          assertNotNull(CounterFactory.createCounter("create3", "create1", Type.MIN));
33          assertNotNull(CounterFactory.createCounter("create4", "create1", Type.MIN, false));
34          assertNotNull(CounterFactory.createCounter("create5", "create1", "create2", Type.PLUS));
35          assertNotNull(CounterFactory.createCounter("create6", "create1", "create2", Type.PLUS, false));
36  
37          assertNotNull(CounterFactory.getCounter("create1"));
38          assertNull(CounterFactory.getCounter("zzz"));
39  
40          for (Iterator it = CounterFactory.getCounters(); it.hasNext();)
41          {
42              Counter ct = (Counter)it.next();
43              assertNotNull(ct);
44          }
45  
46          try
47          {
48              CounterFactory.createCounter("create1", Type.NUMBER);
49              fail("The creation of a duplicate counter should have failed");
50          }
51          catch (IllegalStateException e)
52          {
53              // expected
54          }
55      }
56  
57      @Test
58      public void testNumber()
59      {
60          Counter ct = CounterFactory.createCounter("testNumber", Type.NUMBER);
61  
62          assertEquals("Default value", 0.0, ct.nextValue(), delta);
63          ct.setRawValue(10.0);
64          assertEquals("setRawValue", 10.0, ct.nextValue(), delta);
65          ct.increment();
66          assertEquals("increment", 11.0, ct.nextValue(), delta);
67          ct.incrementBy(2.0);
68          assertEquals("incrementBy", 13.0, ct.nextValue(), delta);
69          ct.decrement();
70          assertEquals("decrement", 12.0, ct.nextValue(), delta);
71      }
72  
73      @Test
74      public void testMinMax()
75      {
76          Counter ct = CounterFactory.createCounter("testMinMax", Type.NUMBER);
77          Counter min = CounterFactory.createCounter("testMinMax.min", "testMinMax", Type.MIN);
78          Counter max = CounterFactory.createCounter("testMinMax.max", "testMinMax", Type.MAX);
79  
80          assertEquals("Min default value", Double.MAX_VALUE, min.nextValue(), delta);
81          assertEquals("Max default value", Double.MIN_VALUE, max.nextValue(), delta);
82          ct.setRawValue(10.0);
83          ct.setRawValue(12.0);
84          ct.setRawValue(18.0);
85          ct.setRawValue(16.0);
86          assertEquals("Min", 10.0, min.nextValue(), delta);
87          assertEquals("Max", 18.0, max.nextValue(), delta);
88      }
89  
90      @Test
91      public void testDelta()
92      {
93          Counter ct = CounterFactory.createCounter("testDelta", Type.NUMBER);
94          Counter dt = CounterFactory.createCounter("testDelta.delta", "testDelta", Type.DELTA);
95  
96          assertEquals("Default value", 0.0, dt.nextValue(), delta);
97          ct.setRawValue(10.0);
98          assertEquals("First value", 10.0, dt.nextValue(), delta);
99          ct.setRawValue(12.0);
100         assertEquals("Delta", 2.0, dt.nextValue(), delta);
101         ct.setRawValue(18.0);
102         assertEquals("Delta", 6.0, dt.nextValue(), delta);
103         ct.setRawValue(16.0);
104         assertEquals("Delta", 0.0, dt.nextValue(), delta);
105     }
106 
107     @Test
108     public void testSum()
109     {
110         Counter ct = CounterFactory.createCounter("testSum", Type.NUMBER);
111         Counter sum = CounterFactory.createCounter("testSum.sum", "testSum", Type.SUM);
112 
113         assertEquals("Default value", 0.0, sum.nextValue(), delta);
114         ct.setRawValue(10.0);
115         assertEquals("First value", 10.0, sum.nextValue(), delta);
116         ct.setRawValue(12.0);
117         assertEquals("Sum", 22.0, sum.nextValue(), delta);
118         ct.setRawValue(18.0);
119         assertEquals("Sum", 40.0, sum.nextValue(), delta);
120         ct.setRawValue(16.0);
121         assertEquals("Sum", 56.0, sum.nextValue(), delta);
122     }
123 
124     @Test
125     public void testAverage()
126     {
127         Counter ct = CounterFactory.createCounter("testAverage", Type.NUMBER);
128         Counter avg = CounterFactory.createCounter("testAverage.avg", "testAverage", Type.AVERAGE);
129 
130         assertEquals("Default value", 0.0, avg.nextValue(), delta);
131         ct.setRawValue(10.0);
132         assertEquals("First value", 10.0, avg.nextValue(), delta);
133         ct.setRawValue(12.0);
134         assertEquals("Average", 11.0, avg.nextValue(), delta);
135         ct.setRawValue(18.0);
136         assertEquals("Average", 40.0 / 3.0, avg.nextValue(), delta);
137         ct.setRawValue(16.0);
138         assertEquals("Average", 14.0, avg.nextValue(), delta);
139     }
140 
141     /**
142      * Serious non-portable timing issues :(
143      * 
144      * @throws InterruptedException
145      */
146     public void _disabled_testInstantRate() throws InterruptedException
147     {
148         Counter ct = CounterFactory.createCounter("testRate", Type.NUMBER);
149         Counter rate = CounterFactory.createCounter("testRate.rate", "testRate", Type.INSTANT_RATE);
150 
151         assertTrue("InstantRate", Double.isNaN(rate.nextValue()));
152         Thread.sleep(10);
153         ct.setRawValue(1);
154         assertTrue("InstantRate", Double.isNaN(rate.nextValue()));
155         Thread.sleep(100);
156         ct.setRawValue(20);
157         assertEquals("InstantRate", 200, rate.nextValue(), 200 * 0.20);
158         Thread.sleep(300);
159         ct.setRawValue(30);
160         assertEquals("InstantRate", 100, rate.nextValue(), 100 * 0.20);
161         ct.setRawValue(30);
162         ct.setRawValue(30);
163         assertTrue("InstantRate", Double.isNaN(rate.nextValue()));
164     }
165 
166     @Test
167     public void testRatePerUnit() throws InterruptedException
168     {
169         Counter ct = CounterFactory.createCounter("testRatePerUnit", Type.NUMBER);
170         assertNotNull(ct);
171 
172         Counter rsec = CounterFactory.createCounter("testRatePerUnit.rate.sec", "testRatePerUnit",
173             Type.RATE_PER_SECOND);
174         assertNotNull(rsec);
175 
176         Counter rmin = CounterFactory.createCounter("testRatePerUnit.rate.min", "testRatePerUnit",
177             Type.RATE_PER_MINUTE);
178         assertNotNull(rmin);
179 
180         assertEquals("Rate", 0.0, rsec.nextValue(), delta);
181 
182         for (int i = 0; i < 5; i++)
183         {
184             ct.setRawValue(10);
185             Thread.sleep(1000);
186         }
187 
188         assertEquals("RatePerSecond", 10.0, rsec.nextValue(), 10.0 * 0.20);
189         assertEquals("RatePerMinute", 50.0, rmin.nextValue(), 10.0 * 0.20);
190     }
191 }