MonitorTestCase


1   /*
2    * JBoss, the OpenSource J2EE webOS
3    *
4    * Distributable under LGPL license.
5    * See terms of license at gnu.org.
6    */
7   
8   package test.compliance.monitor;
9   
10  import java.io.ByteArrayInputStream;
11  import java.io.ByteArrayOutputStream;
12  import java.io.ObjectInputStream;
13  import java.io.ObjectOutputStream;
14  import java.util.ArrayList;
15  import java.util.HashSet;
16  import java.util.Iterator;
17  
18  import javax.management.Attribute;
19  import javax.management.MBeanNotificationInfo;
20  import javax.management.MBeanServer;
21  import javax.management.MBeanServerFactory;
22  import javax.management.Notification;
23  import javax.management.NotificationListener;
24  import javax.management.ObjectName;
25  import javax.management.monitor.CounterMonitor;
26  import javax.management.monitor.GaugeMonitor;
27  import javax.management.monitor.Monitor;
28  import javax.management.monitor.MonitorNotification;
29  import javax.management.monitor.StringMonitor;
30  
31  import junit.framework.AssertionFailedError;
32  import junit.framework.TestCase;
33  import test.compliance.monitor.support.CounterSupport;
34  import test.compliance.monitor.support.GaugeSupport;
35  import test.compliance.monitor.support.MonitorSupport;
36  import test.compliance.monitor.support.StringSupport;
37  
38  /**
39   * Monitor Notification Tests
40   *
41   * @author  <a HREF="mailto:Adrian.Brock@HappeningTimes.com">Adrian Brock</a>.
42   */
43  public class MonitorTestCase
44     extends TestCase
45     implements NotificationListener
46  {
47     // Constants ---------------------------------------------------------------
48  
49     // Attributes --------------------------------------------------------------
50  
51     /**
52      * The MBeanServer
53      */
54     MBeanServer server;
55  
56     /**
57      * The object name of the monitor service
58      */
59     ObjectName monitorName;
60  
61     /**
62      * The monitor
63      */
64     Monitor monitor;
65  
66     /**
67      * The object name of the mbean monitored
68      */
69     ObjectName monitoredName;
70  
71     /**
72      * The monitored mbean
73      */
74     MonitorSupport monitored;
75  
76     /**
77      * The notifications
78      */
79     ArrayList notifications = new ArrayList();
80  
81     // Constructor -------------------------------------------------------------
82  
83     /**
84      * Construct the test
85      */
86     public MonitorTestCase(String s)
87     {
88        super(s);
89     }
90  
91     // Tests -------------------------------------------------------------------
92  
93     /**
94      * Test notification types differ
95      */
96     public void testNotificationTypes()
97     {
98        assertEquals(MonitorNotification.OBSERVED_ATTRIBUTE_ERROR,
99                     "jmx.monitor.error.attribute");
100       assertEquals(MonitorNotification.OBSERVED_ATTRIBUTE_TYPE_ERROR,
101                    "jmx.monitor.error.type");
102       assertEquals(MonitorNotification.OBSERVED_OBJECT_ERROR,
103                    "jmx.monitor.error.mbean");
104       assertEquals(MonitorNotification.RUNTIME_ERROR,
105                    "jmx.monitor.error.runtime");
106       assertEquals(MonitorNotification.STRING_TO_COMPARE_VALUE_DIFFERED,
107                    "jmx.monitor.string.differs");
108       assertEquals(MonitorNotification.STRING_TO_COMPARE_VALUE_MATCHED,
109                    "jmx.monitor.string.matches");
110       assertEquals(MonitorNotification.THRESHOLD_ERROR,
111                    "jmx.monitor.error.threshold");
112       assertEquals(MonitorNotification.THRESHOLD_HIGH_VALUE_EXCEEDED,
113                    "jmx.monitor.gauge.high");
114       assertEquals(MonitorNotification.THRESHOLD_LOW_VALUE_EXCEEDED,
115                    "jmx.monitor.gauge.low");
116       assertEquals(MonitorNotification.THRESHOLD_VALUE_EXCEEDED,
117                    "jmx.monitor.counter.threshold");
118    }
119 
120    // Counter monitor notification info ---------------------------------------
121 
122    /**
123     * Test the notification info of the counter
124     */
125    public void testCounterNotificationInfo()
126       throws Exception
127    {
128       HashSet expected = new HashSet();
129       expected.add(MonitorNotification.OBSERVED_ATTRIBUTE_ERROR);
130       expected.add(MonitorNotification.OBSERVED_ATTRIBUTE_TYPE_ERROR);
131       expected.add(MonitorNotification.OBSERVED_OBJECT_ERROR);
132       expected.add(MonitorNotification.RUNTIME_ERROR);
133       expected.add(MonitorNotification.THRESHOLD_ERROR);
134       expected.add(MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
135 
136       MBeanNotificationInfo[] mbni = new CounterMonitor().getNotificationInfo();
137       checkNotificationInfo("Counter", mbni, expected);
138    }
139 
140    // Counter normal no offset no modulus tests -------------------------------
141 
142    /**
143     * Test normal counter threshold no offset no modulus
144     */
145    public void testNormalCounterThresholdExceededEarlyNoOffsetNoModulus()
146       throws Exception
147    {
148       initTest();
149       try
150       {
151          initCounterMonitor(true, new Integer(10),
152                             false, new Integer(0), new Integer(0));
153          expectStartMonitor(new Integer(10),
154             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
155       }
156       finally
157       {
158          stopMonitor();
159          MBeanServerFactory.releaseMBeanServer(server);
160       }
161    }
162 
163    /**
164     * Test normal counter threshold no offset no modulus
165     */
166    public void testNormalCounterThresholdExceededLateNoOffsetNoModulus()
167       throws Exception
168    {
169       initTest();
170       try
171       {
172          initCounterMonitor(true, new Integer(10),
173                             false, new Integer(0), new Integer(0));
174          dontExpectStartMonitor(new Integer(0));
175          expect(new Integer(10),
176             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
177       }
178       finally
179       {
180          stopMonitor();
181          MBeanServerFactory.releaseMBeanServer(server);
182       }
183    }
184 
185    /**
186     * Test normal counter threshold no offset no modulus
187     */
188    public void testNormalCounterThresholdExceededManyNoOffsetNoModulus()
189       throws Exception
190    {
191       initTest();
192       try
193       {
194          initCounterMonitor(true, new Integer(10),
195                             false, new Integer(0), new Integer(0));
196          dontExpectStartMonitor(new Integer(0));
197          expect(new Integer(10),
198             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
199          dontExpect(new Integer(0));
200          expect(new Integer(11),
201             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
202       }
203       finally
204       {
205          stopMonitor();
206          MBeanServerFactory.releaseMBeanServer(server);
207       }
208    }
209 
210    /**
211     * Test normal counter threshold no offset no modulus
212     */
213    public void testNormalCounterThresholdNotExceededNoOffsetNoModulus()
214       throws Exception
215    {
216       initTest();
217       try
218       {
219          initCounterMonitor(true, new Integer(10),
220                             false, new Integer(0), new Integer(0));
221          dontExpectStartMonitor(new Integer(0));
222          dontExpect(new Integer(1));
223          dontExpect(new Integer(-1));
224          dontExpect(new Integer(9));
225          expect(new Integer(10),
226             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
227          dontExpect(new Integer(10));
228          dontExpect(new Integer(11));
229          dontExpect(new Integer(9));
230          expect(new Integer(10),
231             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
232          dontExpect(new Integer(9));
233       }
234       finally
235       {
236          stopMonitor();
237          MBeanServerFactory.releaseMBeanServer(server);
238       }
239    }
240 
241    /**
242     * Test normal counter threshold no offset no modulus
243     */
244    public void testNormalCounterThresholdExceededNoneNoOffsetNoModulus()
245       throws Exception
246    {
247       initTest();
248       try
249       {
250          initCounterMonitor(false, new Integer(10),
251                             false, new Integer(0), new Integer(0));
252          dontExpectStartMonitor(new Integer(0));
253          dontExpect(new Integer(10));
254          dontExpect(new Integer(0));
255          dontExpect(new Integer(10));
256       }
257       finally
258       {
259          stopMonitor();
260          MBeanServerFactory.releaseMBeanServer(server);
261       }
262    }
263 
264    // Counter normal offset no modulus tests ----------------------------------
265 
266    /**
267     * Test normal counter threshold offset no modulus
268     */
269    public void testNormalCounterThresholdExceededEarlyOffsetNoModulus()
270       throws Exception
271    {
272       initTest();
273       try
274       {
275          initCounterMonitor(true, new Integer(10),
276                             false, new Integer(10), new Integer(0));
277          expectStartMonitor(new Integer(10),
278             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
279       }
280       finally
281       {
282          stopMonitor();
283          MBeanServerFactory.releaseMBeanServer(server);
284       }
285    }
286 
287    /**
288     * Test normal counter threshold offset no modulus
289     */
290    public void testNormalCounterThresholdExceededLateOffsetNoModulus()
291       throws Exception
292    {
293       initTest();
294       try
295       {
296          initCounterMonitor(true, new Integer(10),
297                             false, new Integer(10), new Integer(0));
298          dontExpectStartMonitor(new Integer(0));
299          expect(new Integer(10),
300             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
301       }
302       finally
303       {
304          stopMonitor();
305          MBeanServerFactory.releaseMBeanServer(server);
306       }
307    }
308 
309    /**
310     * Test normal counter threshold offset no modulus
311     */
312    public void testNormalCounterThresholdExceededManyOffsetNoModulus()
313       throws Exception
314    {
315       initTest();
316       try
317       {
318          initCounterMonitor(true, new Integer(10),
319                             false, new Integer(10), new Integer(0));
320          dontExpectStartMonitor(new Integer(0));
321          expect(new Integer(10),
322             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
323          dontExpect(new Integer(0));
324          dontExpect(new Integer(11));
325          expect(new Integer(20),
326             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
327          dontExpect(new Integer(29));
328          expect(new Integer(30),
329             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
330          expect(new Integer(40),
331             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
332       }
333       finally
334       {
335          stopMonitor();
336          MBeanServerFactory.releaseMBeanServer(server);
337       }
338    }
339 
340    /**
341     * Test normal counter threshold offset no modulus
342     */
343    public void testNormalCounterThresholdNotExceededOffsetNoModulus()
344       throws Exception
345    {
346       initTest();
347       try
348       {
349          initCounterMonitor(true, new Integer(10),
350                             false, new Integer(10), new Integer(0));
351          dontExpectStartMonitor(new Integer(0));
352          dontExpect(new Integer(1));
353          dontExpect(new Integer(-1));
354          dontExpect(new Integer(9));
355          expect(new Integer(10),
356             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
357          dontExpect(new Integer(10));
358          dontExpect(new Integer(11));
359          dontExpect(new Integer(9));
360          expect(new Integer(20),
361             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
362          dontExpect(new Integer(19));
363       }
364       finally
365       {
366          stopMonitor();
367          MBeanServerFactory.releaseMBeanServer(server);
368       }
369    }
370 
371    /**
372     * Test normal counter threshold offset no modulus
373     */
374    public void testNormalCounterThresholdExceededNoneOffsetNoModulus()
375       throws Exception
376    {
377       initTest();
378       try
379       {
380          initCounterMonitor(false, new Integer(10),
381                             false, new Integer(10), new Integer(0));
382          dontExpectStartMonitor(new Integer(0));
383          dontExpect(new Integer(10));
384          dontExpect(new Integer(0));
385          dontExpect(new Integer(20));
386       }
387       finally
388       {
389          stopMonitor();
390          MBeanServerFactory.releaseMBeanServer(server);
391       }
392    }
393 
394    // Counter normal no offset modulus tests ---------------------------------
395 
396    /**
397     * Test normal counter threshold no offset modulus
398     */
399    public void testNormalCounterThresholdExceededEarlyNoOffsetModulus()
400       throws Exception
401    {
402       initTest();
403       try
404       {
405          initCounterMonitor(true, new Integer(10),
406                             false, new Integer(0), new Integer(10));
407          expectStartMonitor(new Integer(10),
408             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
409       }
410       finally
411       {
412          stopMonitor();
413          MBeanServerFactory.releaseMBeanServer(server);
414       }
415    }
416 
417    /**
418     * Test normal counter threshold no offset modulus
419     */
420    public void testNormalCounterThresholdExceededLateNoOffsetModulus()
421       throws Exception
422    {
423       initTest();
424       try
425       {
426          initCounterMonitor(true, new Integer(10),
427                             false, new Integer(0), new Integer(10));
428          dontExpectStartMonitor(new Integer(0));
429          expect(new Integer(10),
430             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
431       }
432       finally
433       {
434          stopMonitor();
435          MBeanServerFactory.releaseMBeanServer(server);
436       }
437    }
438 
439    /**
440     * Test normal counter threshold no offset modulus
441     */
442    public void testNormalCounterThresholdExceededManyNoOffsetModulus()
443       throws Exception
444    {
445       initTest();
446       try
447       {
448          initCounterMonitor(true, new Integer(10),
449                             false, new Integer(0), new Integer(10));
450          dontExpectStartMonitor(new Integer(0));
451          expect(new Integer(10),
452             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
453          dontExpect(new Integer(0));
454          expect(new Integer(11),
455             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
456          expect(new Integer(12),
457             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
458          dontExpect(new Integer(0));
459          expect(new Integer(10),
460             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
461       }
462       catch (AssertionFailedError e)
463       {
464          fail("FAILS IN RI: Modulus ignored with no offset???");
465       }
466       finally
467       {
468          stopMonitor();
469          MBeanServerFactory.releaseMBeanServer(server);
470       }
471    }
472 
473    /**
474     * Test normal counter threshold no offset modulus
475     */
476    public void testNormalCounterThresholdNotExceededNoOffsetModulus()
477       throws Exception
478    {
479       initTest();
480       try
481       {
482          initCounterMonitor(true, new Integer(10),
483                             false, new Integer(0), new Integer(10));
484          dontExpectStartMonitor(new Integer(0));
485          dontExpect(new Integer(1));
486          dontExpect(new Integer(-1));
487          dontExpect(new Integer(9));
488          expect(new Integer(10),
489             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
490          dontExpect(new Integer(9));
491          expect(new Integer(10),
492             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
493          dontExpect(new Integer(9));
494       }
495       finally
496       {
497          stopMonitor();
498          MBeanServerFactory.releaseMBeanServer(server);
499       }
500    }
501 
502    /**
503     * Test normal counter threshold no offset modulus
504     */
505    public void testNormalCounterThresholdExceededNoneNoOffsetModulus()
506       throws Exception
507    {
508       initTest();
509       try
510       {
511          initCounterMonitor(false, new Integer(10),
512                             false, new Integer(0), new Integer(10));
513          dontExpectStartMonitor(new Integer(0));
514          dontExpect(new Integer(10));
515          dontExpect(new Integer(0));
516          dontExpect(new Integer(10));
517       }
518       finally
519       {
520          stopMonitor();
521          MBeanServerFactory.releaseMBeanServer(server);
522       }
523    }
524 
525    // Counter normal offset modulus tests -------------------------------------
526 
527    /**
528     * Test normal counter threshold offset modulus
529     */
530    public void testNormalCounterThresholdExceededEarlyOffsetModulus()
531       throws Exception
532    {
533       initTest();
534       try
535       {
536          initCounterMonitor(true, new Integer(10),
537                             false, new Integer(10), new Integer(10));
538          expectStartMonitor(new Integer(10),
539             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
540       }
541       finally
542       {
543          stopMonitor();
544          MBeanServerFactory.releaseMBeanServer(server);
545       }
546    }
547 
548    /**
549     * Test normal counter threshold offset modulus
550     */
551    public void testNormalCounterThresholdExceededLateOffsetModulus()
552       throws Exception
553    {
554       initTest();
555       try
556       {
557          initCounterMonitor(true, new Integer(10),
558                             false, new Integer(10), new Integer(10));
559          dontExpectStartMonitor(new Integer(0));
560          expect(new Integer(10),
561             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
562       }
563       finally
564       {
565          stopMonitor();
566          MBeanServerFactory.releaseMBeanServer(server);
567       }
568    }
569 
570    /**
571     * Test normal counter threshold offset modulus
572     */
573    public void testNormalCounterThresholdExceededManyOffsetModulus()
574       throws Exception
575    {
576       initTest();
577       try
578       {
579          initCounterMonitor(true, new Integer(10),
580                             false, new Integer(10), new Integer(20));
581          dontExpectStartMonitor(new Integer(0));
582          expect(new Integer(10),
583             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
584          dontExpect(new Integer(0));
585          dontExpect(new Integer(12));
586          expect(new Integer(20),
587             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
588          if (((CounterMonitor)monitor).getThreshold().equals(new Integer(30)))
589            fail("FAILS IN RI: Threshold 10, Offset 10, Modulus 20 should " +
590                 " never get a threshold of 30");
591          expect(new Integer(10),
592             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
593          dontExpect(new Integer(10));
594          expect(new Integer(20),
595             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
596          expect(new Integer(20),
597             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
598          expect(new Integer(30),
599             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
600       }
601       finally
602       {
603          stopMonitor();
604          MBeanServerFactory.releaseMBeanServer(server);
605       }
606    }
607 
608    /**
609     * Test normal counter threshold offset modulus
610     */
611    public void testNormalCounterThresholdNotExceededOffsetModulus()
612       throws Exception
613    {
614       initTest();
615       try
616       {
617          initCounterMonitor(true, new Integer(10),
618                             false, new Integer(10), new Integer(20));
619          dontExpectStartMonitor(new Integer(0));
620          dontExpect(new Integer(1));
621          dontExpect(new Integer(-1));
622          dontExpect(new Integer(9));
623          expect(new Integer(10),
624             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
625          dontExpect(new Integer(10));
626          dontExpect(new Integer(11));
627          dontExpect(new Integer(9));
628          expect(new Integer(20),
629             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
630          if (((CounterMonitor)monitor).getThreshold().equals(new Integer(30)))
631            fail("FAILS IN RI: Threshold 10, Offset 10, Modulus 20 should " +
632                 " never get a threshold of 30");
633          expect(new Integer(19),
634             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
635       }
636       finally
637       {
638          stopMonitor();
639          MBeanServerFactory.releaseMBeanServer(server);
640       }
641    }
642 
643    /**
644     * Test normal counter threshold offset modulus
645     */
646    public void testNormalCounterThresholdExceededNoneOffsetModulus()
647       throws Exception
648    {
649       initTest();
650       try
651       {
652          initCounterMonitor(false, new Integer(10),
653                             false, new Integer(10), new Integer(10));
654          dontExpectStartMonitor(new Integer(0));
655          dontExpect(new Integer(10));
656          dontExpect(new Integer(0));
657          dontExpect(new Integer(20));
658       }
659       finally
660       {
661          stopMonitor();
662          MBeanServerFactory.releaseMBeanServer(server);
663       }
664    }
665 
666    // Counter difference no offset no modulus tests ---------------------------
667 
668    /**
669     * Test difference counter threshold no offset no modulus
670     */
671    public void testDiffCounterThresholdExceededNoOffsetNoModulus()
672       throws Exception
673    {
674       initTest();
675       try
676       {
677          initCounterMonitor(true, new Integer(10),
678                             true, new Integer(0), new Integer(0));
679          dontExpectStartMonitor(new Integer(0));
680          expect(new Integer(10),
681             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
682       }
683       finally
684       {
685          stopMonitor();
686          MBeanServerFactory.releaseMBeanServer(server);
687       }
688    }
689 
690    /**
691     * Test difference counter threshold no offset no modulus
692     */
693    public void testDiffCounterThresholdExceededManyNoOffsetNoModulus()
694       throws Exception
695    {
696       initTest();
697       try
698       {
699          initCounterMonitor(true, new Integer(10),
700                             true, new Integer(0), new Integer(0));
701          dontExpectStartMonitor(new Integer(0));
702          expect(new Integer(10),
703             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
704          expectDiff(new Integer(0), new Integer(11),
705             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
706       }
707       finally
708       {
709          stopMonitor();
710          MBeanServerFactory.releaseMBeanServer(server);
711       }
712    }
713 
714    /**
715     * Test difference counter threshold no offset no modulus
716     */
717    public void testDiffCounterThresholdNotExceededNoOffsetNoModulus()
718       throws Exception
719    {
720       initTest();
721       try
722       {
723          initCounterMonitor(true, new Integer(10),
724                             true, new Integer(0), new Integer(0));
725          dontExpectStartMonitorDiff(new Integer(0), new Integer(1));
726          dontExpectDiff(new Integer(0), new Integer(9));
727          dontExpectDiff(new Integer(1), new Integer(10));
728          dontExpectDiff(new Integer(9), new Integer(11));
729          dontExpectDiff(new Integer(9), new Integer(0));
730       }
731       finally
732       {
733          stopMonitor();
734          MBeanServerFactory.releaseMBeanServer(server);
735       }
736    }
737 
738    /**
739     * Test difference counter threshold no offset no modulus
740     */
741    public void testDiffCounterThresholdExceededNoneNoOffsetNoModulus()
742       throws Exception
743    {
744       initTest();
745       try
746       {
747          initCounterMonitor(false, new Integer(10),
748                             true, new Integer(0), new Integer(0));
749          dontExpectStartMonitorDiff(new Integer(0), new Integer(10));
750          dontExpectDiff(new Integer(0), new Integer(-10));
751          dontExpectDiff(new Integer(0), new Integer(100));
752       }
753       finally
754       {
755          stopMonitor();
756          MBeanServerFactory.releaseMBeanServer(server);
757       }
758    }
759 
760    // Counter difference offset no modulus tests ------------------------------
761 
762    /**
763     * Test difference counter threshold offset no modulus
764     */
765    public void testDiffCounterThresholdExceededOffsetNoModulus()
766       throws Exception
767    {
768       initTest();
769       try
770       {
771          initCounterMonitor(true, new Integer(10),
772                             true, new Integer(10), new Integer(0));
773          dontExpectStartMonitor(new Integer(0));
774          expect(new Integer(10),
775             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
776       }
777       finally
778       {
779          stopMonitor();
780          MBeanServerFactory.releaseMBeanServer(server);
781       }
782    }
783 
784    /**
785     * Test difference counter threshold offset no modulus
786     */
787    public void testDiffCounterThresholdExceededManyOffsetNoModulus()
788       throws Exception
789    {
790       initTest();
791       try
792       {
793          initCounterMonitor(true, new Integer(10),
794                             true, new Integer(10), new Integer(0));
795          dontExpectStartMonitor(new Integer(0));
796          expect(new Integer(10),
797             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
798          expectDiff(new Integer(0), new Integer(10),
799             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
800          expectDiff(new Integer(10), new Integer(30),
801             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
802          expectDiff(new Integer(30), new Integer(60),
803             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
804          expectDiff(new Integer(60), new Integer(100),
805             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
806          expectDiff(new Integer(0), new Integer(10),
807             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
808       }
809       finally
810       {
811          stopMonitor();
812          MBeanServerFactory.releaseMBeanServer(server);
813       }
814    }
815 
816    /**
817     * Test difference counter threshold offset no modulus
818     */
819    public void testDiffCounterThresholdNotExceededOffsetNoModulus()
820       throws Exception
821    {
822       initTest();
823       try
824       {
825          initCounterMonitor(true, new Integer(10),
826                             true, new Integer(10), new Integer(0));
827          dontExpectStartMonitorDiff(new Integer(0), new Integer(1));
828          expectDiff(new Integer(0), new Integer(10),
829             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
830          dontExpectDiff(new Integer(10), new Integer(20));
831          expectDiff(new Integer(20), new Integer(40),
832             MonitorNotification.THRESHOLD_VALUE_EXCEEDED);
833          dontExpectDiff(new Integer(40), new Integer(69));
834       }
835       finally
836       {
837          stopMonitor();
838          MBeanServerFactory.releaseMBeanServer(server);
839       }
840    }
841 
842    /**
843     * Test difference counter threshold offset no modulus
844     */
845    public void testDiffCounterThresholdExceededNoneOffsetNoModulus()
846       throws Exception
847    {
848       initTest();
849       try
850       {
851          initCounterMonitor(false, new Integer(10),
852                             true, new Integer(10), new Integer(0));
853          dontExpectStartMonitorDiff(new Integer(0), new Integer(1));
854          dontExpectDiff(new Integer(0), new Integer(10));
855          dontExpectDiff(new Integer(10), new Integer(20));
856          dontExpectDiff(new Integer(20), new Integer(40));
857          dontExpectDiff(new Integer(40), new Integer(69));
858       }
859       finally
860       {
861          stopMonitor();
862          MBeanServerFactory.releaseMBeanServer(server);
863       }
864    }
865 
866    // Counter difference no offset modulus tests ------------------------------
867 
868    /**
869 <