1
2
3
4
5
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
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
143
144
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 }