1
2
3
4
5
6
7
8
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
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
147
148
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 }