View Javadoc

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