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