KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jacorb > test > notification > InterFilterGroupOperatorTest


1 package org.jacorb.test.notification;
2
3 /*
4  * JacORB - a free Java ORB
5  *
6  * Copyright (C) 1999-2003 Gerald Brose
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public
19  * License along with this library; if not, write to the Free
20  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  *
22  */
23
24 import junit.framework.Test;
25
26 import org.jacorb.test.notification.common.NotifyServerTestCase;
27 import org.jacorb.test.notification.common.NotifyServerTestSetup;
28 import org.omg.CORBA.Any JavaDoc;
29 import org.omg.CosNotification.EventType;
30 import org.omg.CosNotifyChannelAdmin.ConsumerAdmin;
31 import org.omg.CosNotifyChannelAdmin.EventChannel;
32 import org.omg.CosNotifyChannelAdmin.SupplierAdmin;
33 import org.omg.CosNotifyFilter.ConstraintExp;
34 import org.omg.CosNotifyFilter.Filter;
35
36 /**
37  * Test the various InterFilterGroupOperator settings.
38  * naming scheme for the testMethods:
39  *
40  * test[PCF][IFGOp][SAF]_[CAF][IFGOp][PSF]()
41  *
42  * where
43  * <ul>
44  * <li>PCF: ProxyConsumerFilter (True/False)
45  * <li>IFGOp: InterFilterGroupOperator (OR/AND)
46  * <li>SAF: SupplierAdminFilter (True/False)
47  * <li>CAF: ConsumerAdminFilter (True/False)
48  * <li>PSF: ProxySupplierFilter (True/False)
49  * </ul>
50  *
51  * for example testTrueOrTrue_FalseAndTrue() means
52  * ProxyConsumerFilter set to TRUE, SupplierAdminFilter set to TRUE
53  * and InterFilterGroupOperator set to OR.
54  * ConsumerAdminFilter set to FALSE and InterFilterGroupOperator set
55  * to AND. ProxySupplierfilter set to TRUE.
56  *
57  * @author Alphonse Bendt
58  */
59 public class InterFilterGroupOperatorTest extends NotifyServerTestCase
60 {
61     Any JavaDoc testPerson_;
62     EventChannel channel_;
63     SupplierAdmin supplierAdmin_;
64     ConsumerAdmin consumerAdmin_;
65     Filter trueFilter_;
66     Filter falseFilter_;
67
68     public void setUpTest() throws Exception JavaDoc
69     {
70         testPerson_ = new NotificationTestUtils(getClientORB()).getTestPersonAny();
71
72         channel_ = getDefaultChannel();
73
74         trueFilter_ = channel_.default_filter_factory().create_filter("EXTENDED_TCL");
75
76         ConstraintExp[] _constraintExp = new ConstraintExp[1];
77         EventType[] _eventType = new EventType[1];
78         _eventType[0] = new EventType("*", "*");
79         String JavaDoc _expression = "TRUE";
80         _constraintExp[0] = new ConstraintExp(_eventType, _expression);
81         trueFilter_.add_constraints(_constraintExp);
82
83         falseFilter_ = channel_.default_filter_factory().create_filter("EXTENDED_TCL");
84         _constraintExp = new ConstraintExp[1];
85         _eventType = new EventType[1];
86         _eventType[0] = new EventType("*", "*");
87         
88         _constraintExp[0] = new ConstraintExp(_eventType, "FALSE");
89        falseFilter_.add_constraints(_constraintExp);
90         
91         assertTrue(trueFilter_.match(testPerson_));
92         assertFalse(falseFilter_.match(testPerson_));
93     }
94
95
96     public void testTrueORFalse_NoneOrNone() throws Exception JavaDoc
97     {
98         AnyPushSender _sender = new AnyPushSender(getClientORB(), testPerson_);
99         AnyPushReceiver _receiver = new AnyPushReceiver(getClientORB());
100
101         _sender.connect(channel_, true);
102         _receiver.connect(channel_, true);
103         _sender.addProxyFilter(trueFilter_);
104         _sender.addAdminFilter(falseFilter_);
105
106         Thread JavaDoc _senderThread = new Thread JavaDoc(_sender);
107         Thread JavaDoc _receiverThread = new Thread JavaDoc(_receiver);
108
109         _receiverThread.start();
110         _senderThread.start();
111
112         _senderThread.join();
113         _receiverThread.join();
114
115         assertTrue("Error while sending", !_sender.error_);
116         assertTrue("Should have received something", _receiver.isEventHandled());
117     }
118
119
120     public void testFalseORTrue_NoneOrNone() throws Exception JavaDoc
121     {
122         AnyPushSender _sender = new AnyPushSender(getClientORB(), testPerson_);
123         AnyPushReceiver _receiver = new AnyPushReceiver(getClientORB());
124         _sender.connect(channel_, true);
125         _receiver.connect(channel_, true);
126
127         _sender.addProxyFilter(falseFilter_);
128         _sender.addAdminFilter(trueFilter_);
129
130         Thread JavaDoc _senderThread = new Thread JavaDoc(_sender);
131         Thread JavaDoc _receiverThread = new Thread JavaDoc(_receiver);
132
133         _receiverThread.start();
134         _senderThread.start();
135
136         _senderThread.join();
137         _receiverThread.join();
138
139         assertTrue("Error while sending", !_sender.error_);
140         assertTrue("Should have received something", _receiver.isEventHandled());
141     }
142
143     
144     public void testTrueANDFalse_NoneOrNone() throws Exception JavaDoc
145     {
146         AnyPushSender _sender = new AnyPushSender(getClientORB(), testPerson_);
147         AnyPushReceiver _receiver = new AnyPushReceiver(getClientORB());
148         _sender.connect(channel_, false);
149         _receiver.connect(channel_, true);
150
151         _sender.addProxyFilter(trueFilter_);
152         _sender.addAdminFilter(falseFilter_);
153
154         Thread JavaDoc _senderThread = new Thread JavaDoc(_sender);
155         Thread JavaDoc _receiverThread = new Thread JavaDoc(_receiver);
156
157         _receiverThread.start();
158         _senderThread.start();
159
160         _senderThread.join();
161         _receiverThread.join();
162
163         assertTrue("Error while sending", !_sender.error_);
164         assertTrue("Should have received something", !_receiver.isEventHandled());
165     }
166
167
168     public void testFalseANDTrue_NoneOrNone() throws Exception JavaDoc
169     {
170         AnyPushSender _sender = new AnyPushSender(getClientORB(), testPerson_);
171         AnyPushReceiver _receiver = new AnyPushReceiver(getClientORB());
172         _sender.connect(channel_, false);
173         _receiver.connect(channel_, true);
174
175         _sender.addProxyFilter(falseFilter_);
176         _sender.addAdminFilter(trueFilter_);
177
178         Thread JavaDoc _senderThread = new Thread JavaDoc(_sender);
179         Thread JavaDoc _receiverThread = new Thread JavaDoc(_receiver);
180
181         _receiverThread.start();
182         _senderThread.start();
183
184         _senderThread.join();
185         _receiverThread.join();
186
187         assertTrue("Error while sending", !_sender.error_);
188         assertTrue("Should have received something", !_receiver.isEventHandled());
189     }
190
191
192     public void testNoneOrNone_TrueORFalse() throws Exception JavaDoc
193     {
194         AnyPushSender _sender = new AnyPushSender(getClientORB(), testPerson_);
195         AnyPushReceiver _receiver = new AnyPushReceiver(getClientORB());
196         _sender.connect(channel_, true);
197         _receiver.connect(channel_, true);
198
199         _receiver.addProxyFilter(falseFilter_);
200         _receiver.addAdminFilter(trueFilter_);
201
202         Thread JavaDoc _senderThread = new Thread JavaDoc(_sender);
203         Thread JavaDoc _receiverThread = new Thread JavaDoc(_receiver);
204
205         _receiverThread.start();
206         _senderThread.start();
207
208         _senderThread.join();
209         _receiverThread.join();
210
211         assertTrue("Error while sending", !_sender.error_);
212         assertTrue("Should have received something", _receiver.isEventHandled());
213     }
214     
215
216     public void testNoneOrNone_FalseORTrue() throws Exception JavaDoc
217     {
218         AnyPushSender _sender = new AnyPushSender(getClientORB(), testPerson_);
219         AnyPushReceiver _receiver = new AnyPushReceiver(getClientORB());
220         _sender.connect(channel_, true);
221         _receiver.connect(channel_, true);
222
223         _receiver.addProxyFilter(trueFilter_);
224         _receiver.addAdminFilter(falseFilter_);
225
226         Thread JavaDoc _senderThread = new Thread JavaDoc(_sender);
227         Thread JavaDoc _receiverThread = new Thread JavaDoc(_receiver);
228
229         _receiverThread.start();
230         _senderThread.start();
231
232         _senderThread.join();
233         _receiverThread.join();
234
235         assertTrue("Error while sending", !_sender.error_);
236         assertTrue("Should have received something", _receiver.isEventHandled());
237     }
238
239
240     public void testNoneOrNone_TrueANDFalse() throws Exception JavaDoc
241     {
242         AnyPushSender _sender = new AnyPushSender(getClientORB(), testPerson_);
243         AnyPushReceiver _receiver = new AnyPushReceiver(getClientORB());
244
245         _sender.connect(channel_, true);
246
247         _receiver.connect(channel_, false);
248
249         _receiver.addProxyFilter(falseFilter_);
250         _receiver.addAdminFilter(trueFilter_);
251
252         Thread JavaDoc _senderThread = new Thread JavaDoc(_sender);
253         Thread JavaDoc _receiverThread = new Thread JavaDoc(_receiver);
254
255         _receiverThread.start();
256         _senderThread.start();
257
258         _senderThread.join();
259         _receiverThread.join();
260
261         assertTrue("Error while sending", !_sender.error_);
262         assertTrue("Should have received something", !_receiver.isEventHandled());
263     }
264
265
266     public void testNoneOrNone_FalseANDTrue() throws Exception JavaDoc
267     {
268         AnyPushSender _sender = new AnyPushSender(getClientORB(), testPerson_);
269         AnyPushReceiver _receiver = new AnyPushReceiver(getClientORB());
270
271         _sender.connect(channel_, true);
272
273         _receiver.connect(channel_, false);
274
275         _receiver.addProxyFilter(trueFilter_);
276         _receiver.addAdminFilter(falseFilter_);
277
278         Thread JavaDoc _senderThread = new Thread JavaDoc(_sender);
279         Thread JavaDoc _receiverThread = new Thread JavaDoc(_receiver);
280
281         _receiverThread.start();
282         _senderThread.start();
283
284         _senderThread.join();
285         _receiverThread.join();
286
287         assertTrue("Error while sending", !_sender.error_);
288         assertTrue(_receiver + " should have received something", !_receiver.isEventHandled());
289     }
290
291     
292     public InterFilterGroupOperatorTest (String JavaDoc name, NotifyServerTestSetup setup)
293     {
294         super(name, setup);
295     }
296
297     
298     public static Test suite() throws Exception JavaDoc
299     {
300         return NotifyServerTestCase.suite("Test of InterFilterGroupOperator Functionality",
301                                           InterFilterGroupOperatorTest.class);
302     }
303 }
304
Popular Tags