View Javadoc

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