KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > test > jbossmq > test > SelectorSyntaxUnitTestCase


1 /*
2   * JBoss, Home of Professional Open Source
3   * Copyright 2005, JBoss Inc., and individual contributors as indicated
4   * by the @authors tag. See the copyright.txt in the distribution for a
5   * full listing of individual contributors.
6   *
7   * This is free software; you can redistribute it and/or modify it
8   * under the terms of the GNU Lesser General Public License as
9   * published by the Free Software Foundation; either version 2.1 of
10   * the License, or (at your option) any later version.
11   *
12   * This software is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15   * Lesser General Public License for more details.
16   *
17   * You should have received a copy of the GNU Lesser General Public
18   * License along with this software; if not, write to the Free
19   * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20   * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
21   */

22 package org.jboss.test.jbossmq.test;
23
24 import junit.framework.TestCase;
25
26 import org.jboss.mq.SpyMessage;
27 import org.jboss.mq.selectors.Selector;
28
29 /**
30  * Tests the complinace with the JMS Selector syntax.
31  *
32  * <p>Needs a lot of work...
33  *
34  * @author <a HREF="mailto:jason@planet57.com">Jason Dillon</a>
35  * @version $Revision: 37406 $
36  */

37 public class SelectorSyntaxUnitTestCase
38    extends TestCase
39 {
40    private Selector selector;
41    private SpyMessage message;
42    
43    public SelectorSyntaxUnitTestCase(String JavaDoc name)
44    {
45       super(name);
46    }
47    
48    protected void setUp() throws Exception JavaDoc
49    {
50       super.setUp();
51       message = new SpyMessage();
52    }
53    
54    public void testBooleanTrue() throws Exception JavaDoc
55    {
56       selector = new Selector("MyBoolean=true");
57       testBoolean("MyBoolean", true);
58    }
59    
60    public void testBooleanFalse() throws Exception JavaDoc
61    {
62       selector = new Selector("MyBoolean=false");
63       testBoolean("MyBoolean", false);
64    }
65    
66    private void testBoolean(String JavaDoc name, boolean flag) throws Exception JavaDoc
67    {
68       message.setBooleanProperty(name, flag);
69       assertTrue(selector.test(message));
70       
71       message.setBooleanProperty(name, !flag);
72       assertTrue(!selector.test(message));
73    }
74    
75    public void testStringEquals() throws Exception JavaDoc
76    {
77       // First, simple test of string equality and inequality
78
selector = new Selector("MyString='astring'");
79       
80       message.setStringProperty("MyString", "astring");
81       assertTrue(selector.test(message));
82       
83       message.setStringProperty("MyString", "NOTastring");
84       assertTrue(!selector.test(message));
85       
86       // test empty string
87
selector = new Selector("MyString=''");
88       
89       message.setStringProperty("MyString", "");
90       assertTrue("test 1", selector.test(message));
91       
92       message.setStringProperty("MyString", "NOTastring");
93       assertTrue("test 2", !selector.test(message));
94       
95       // test literal apostrophes (which are escaped using two apostrophes
96
// in selectors)
97
selector = new Selector("MyString='test JBoss''s selector'");
98       
99       // note: apostrophes are not escaped in string properties
100
message.setStringProperty("MyString", "test JBoss's selector");
101       // this test fails -- bug 530120
102
//assertTrue("test 3", selector.test(message));
103

104       message.setStringProperty("MyString", "NOTastring");
105       assertTrue("test 4", !selector.test(message));
106       
107    }
108    
109    public void testStringLike() throws Exception JavaDoc
110    {
111       // test LIKE operator with no wildcards
112
selector = new Selector("MyString LIKE 'astring'");
113       
114       // test where LIKE operand matches
115
message.setStringProperty("MyString", "astring");
116       assertTrue(selector.test(message));
117       
118       // test one character string
119
selector = new Selector("MyString LIKE 'a'");
120       message.setStringProperty("MyString","a");
121       assertTrue(selector.test(message));
122       
123       // test empty string
124
selector = new Selector("MyString LIKE ''");
125       message.setStringProperty("MyString", "");
126       assertTrue(selector.test(message));
127       
128       // tests where operand does not match
129
selector = new Selector("MyString LIKE 'astring'");
130       
131       // test with extra characters at beginning
132
message.setStringProperty("MyString", "NOTastring");
133       assertTrue(!selector.test(message));
134       
135       // test with extra characters at end
136
message.setStringProperty("MyString", "astringNOT");
137       assertTrue(!selector.test(message));
138       
139       // test with extra characters in the middle
140
message.setStringProperty("MyString", "astNOTring");
141       assertTrue(!selector.test(message));
142       
143       // test where operand is entirely different
144
message.setStringProperty("MyString", "totally different");
145       assertTrue(!selector.test(message));
146       
147       // test case sensitivity
148
message.setStringProperty("MyString", "ASTRING");
149       assertTrue(!selector.test(message));
150       
151       // test empty string
152
message.setStringProperty("MyString", "");
153       assertTrue(!selector.test(message));
154       
155       
156       // test lower-case 'like' operator?
157
}
158    
159    public void testStringLikeUnderbarWildcard() throws Exception JavaDoc
160    {
161       // test LIKE operator with the _ wildcard, which
162
// matches any single character
163

164       // first, some tests with the wildcard by itself
165
selector = new Selector("MyString LIKE '_'");
166       
167       // test match against single character
168
message.setStringProperty("MyString", "a");
169       assertTrue(selector.test(message));
170       
171       // test match failure against multiple characters
172
message.setStringProperty("MyString", "aaaaa");
173       assertTrue(!selector.test(message));
174       
175       // test match failure against the empty string
176
message.setStringProperty("MyString", "");
177       assertTrue(!selector.test(message));
178       
179       
180       // next, tests with wildcard at the beginning of the string
181
selector = new Selector("MyString LIKE '_bcdf'");
182       
183       // test match at beginning of string
184
message.setStringProperty("MyString", "abcdf");
185       assertTrue(selector.test(message));
186       
187       // match failure in first character after wildcard
188
message.setStringProperty("MyString", "aXcdf");
189       assertTrue(!selector.test(message));
190       
191       // match failure in middle character
192
message.setStringProperty("MyString", "abXdf");
193       assertTrue(!selector.test(message));
194       
195       // match failure in last character
196
message.setStringProperty("MyString", "abcdX");
197       assertTrue(!selector.test(message));
198       
199       // match failure with empty string
200
message.setStringProperty("MyString", "");
201       assertTrue(!selector.test(message));
202       
203       // match failure due to extra characters at beginning
204
message.setStringProperty("MyString", "XXXabcdf");
205       assertTrue(!selector.test(message));
206       
207       // match failure due to extra characters at the end
208
message.setStringProperty("MyString", "abcdfXXX");
209       assertTrue(!selector.test(message));
210       
211       // test that the _ wildcard does not match the 'empty' character
212
message.setStringProperty("MyString", "bcdf");
213       assertTrue(!selector.test(message));
214       
215       // next, tests with wildcard at the end of the string
216
selector = new Selector("MyString LIKE 'abcd_'");
217       
218       // test match at end of string
219
message.setStringProperty("MyString", "abcdf");
220       assertTrue(selector.test(message));
221       
222       // match failure in first character before wildcard
223
message.setStringProperty("MyString", "abcXf");
224       assertTrue(!selector.test(message));
225       
226       // match failure in middle character
227
message.setStringProperty("MyString", "abXdf");
228       assertTrue(!selector.test(message));
229       
230       // match failure in first character
231
message.setStringProperty("MyString", "Xbcdf");
232       assertTrue(!selector.test(message));
233       
234       // match failure with empty string
235
message.setStringProperty("MyString", "");
236       assertTrue(!selector.test(message));
237       
238       // match failure due to extra characters at beginning
239
message.setStringProperty("MyString", "XXXabcdf");
240       assertTrue(!selector.test(message));
241       
242       // match failure due to extra characters at the end
243
message.setStringProperty("MyString", "abcdfXXX");
244       assertTrue(!selector.test(message));
245       
246       // test that the _ wildcard does not match the 'empty' character
247
message.setStringProperty("MyString", "abcd");
248       assertTrue(!selector.test(message));
249       
250       // test match in middle of string
251

252       // next, tests with wildcard in the middle of the string
253
selector = new Selector("MyString LIKE 'ab_df'");
254       
255       // test match in the middle of string
256
message.setStringProperty("MyString", "abcdf");
257       assertTrue(selector.test(message));
258       
259       // match failure in first character before wildcard
260
message.setStringProperty("MyString", "aXcdf");
261       assertTrue(!selector.test(message));
262       
263       // match failure in first character after wildcard
264
message.setStringProperty("MyString", "abcXf");
265       assertTrue(!selector.test(message));
266       
267       // match failure in last character
268
message.setStringProperty("MyString", "abcdX");
269       assertTrue(!selector.test(message));
270       
271       // match failure with empty string
272
message.setStringProperty("MyString", "");
273       assertTrue(!selector.test(message));
274       
275       // match failure due to extra characters at beginning
276
message.setStringProperty("MyString", "XXXabcdf");
277       assertTrue(!selector.test(message));
278       
279       // match failure due to extra characters at the end
280
message.setStringProperty("MyString", "abcdfXXX");
281       assertTrue(!selector.test(message));
282       
283       // test that the _ wildcard does not match the 'empty' character
284
message.setStringProperty("MyString", "abdf");
285       assertTrue(!selector.test(message));
286       
287       // test match failures
288
}
289    
290    public void testStringLikePercentWildcard() throws Exception JavaDoc
291    {
292       // test LIKE operator with the % wildcard, which
293
// matches any sequence of characters
294
// note many of the tests are similar to those for _
295

296       
297       // first, some tests with the wildcard by itself
298
selector = new Selector("MyString LIKE '%'");
299       
300       // test match against single character
301
message.setStringProperty("MyString", "a");
302       assertTrue(selector.test(message));
303       
304       // test match against multiple characters
305
message.setStringProperty("MyString", "aaaaa");
306       assertTrue(selector.test(message));
307       
308       message.setStringProperty("MyString", "abcdf");
309       assertTrue(selector.test(message));
310       
311       // test match against the empty string
312
message.setStringProperty("MyString", "");
313       assertTrue(selector.test(message));
314       
315       
316       // next, tests with wildcard at the beginning of the string
317
selector = new Selector("MyString LIKE '%bcdf'");
318       
319       // test match with single character at beginning of string
320
message.setStringProperty("MyString", "Xbcdf");
321       assertTrue(selector.test(message));
322       
323       // match with multiple characters at beginning
324
message.setStringProperty("MyString", "XXbcdf");
325       assertTrue(selector.test(message));
326       
327       // match failure in middle character
328
message.setStringProperty("MyString", "abXdf");
329       assertTrue(!selector.test(message));
330       
331       // match failure in last character
332
message.setStringProperty("MyString", "abcdX");
333       assertTrue(!selector.test(message));
334       
335       // match failure with empty string
336
message.setStringProperty("MyString", "");
337       assertTrue(!selector.test(message));
338       
339       // match failure due to extra characters at the end
340
message.setStringProperty("MyString", "abcdfXXX");
341       assertTrue(!selector.test(message));
342       
343       // test that the % wildcard matches the empty string
344
message.setStringProperty("MyString", "bcdf");
345       assertTrue(selector.test(message));
346       
347       // next, tests with wildcard at the end of the string
348
selector = new Selector("MyString LIKE 'abcd%'");
349       
350       // test match of single character at end of string
351
message.setStringProperty("MyString", "abcdf");
352       assertTrue(selector.test(message));
353       
354       // test match of multiple characters at end of string
355
message.setStringProperty("MyString", "abcdfgh");
356       assertTrue(selector.test(message));
357       
358       // match failure in first character before wildcard
359
message.setStringProperty("MyString", "abcXf");
360       assertTrue(!selector.test(message));
361       
362       // match failure in middle character
363
message.setStringProperty("MyString", "abXdf");
364       assertTrue(!selector.test(message));
365       
366       // match failure in first character
367
message.setStringProperty("MyString", "Xbcdf");
368       assertTrue(!selector.test(message));
369       
370       // match failure with empty string
371
message.setStringProperty("MyString", "");
372       assertTrue(!selector.test(message));
373       
374       // match failure due to extra characters at beginning
375
message.setStringProperty("MyString", "XXXabcdf");
376       assertTrue(!selector.test(message));
377       
378       // test that the % wildcard matches the empty string
379
message.setStringProperty("MyString", "abcd");
380       assertTrue(selector.test(message));
381       
382       // next, tests with wildcard in the middle of the string
383
selector = new Selector("MyString LIKE 'ab%df'");
384       
385       // test match with single character in the middle of string
386
message.setStringProperty("MyString", "abXdf");
387       assertTrue(selector.test(message));
388       
389       // test match with multiple characters in the middle of string
390
message.setStringProperty("MyString", "abXXXdf");
391       assertTrue(selector.test(message));
392       
393       // match failure in first character before wildcard
394
message.setStringProperty("MyString", "aXcdf");
395       assertTrue(!selector.test(message));
396       
397       // match failure in first character after wildcard
398
message.setStringProperty("MyString", "abcXf");
399       assertTrue(!selector.test(message));
400       
401       // match failure in last character
402
message.setStringProperty("MyString", "abcdX");
403       assertTrue(!selector.test(message));
404       
405       // match failure with empty string
406
message.setStringProperty("MyString", "");
407       assertTrue(!selector.test(message));
408       
409       // match failure due to extra characters at beginning
410
message.setStringProperty("MyString", "XXXabcdf");
411       assertTrue(!selector.test(message));
412       
413       // match failure due to extra characters at the end
414
message.setStringProperty("MyString", "abcdfXXX");
415       assertTrue(!selector.test(message));
416       
417       // test that the % wildcard matches the empty string
418
message.setStringProperty("MyString", "abdf");
419       assertTrue(selector.test(message));
420       
421    }
422    
423    public void testStringLikePunctuation() throws Exception JavaDoc
424    {
425       // test proper handling of some punctuation characters.
426
// non-trivial since the underlying implementation might
427
// (and in fact currently does) use a general-purpose
428
// RE library, which has a different notion of which
429
// characters are wildcards
430

431       // the particular tests here are motivated by the
432
// wildcards of the current underlying RE engine,
433
// GNU regexp.
434

435       selector = new Selector("MyString LIKE 'a^$b'");
436       message.setStringProperty("MyString", "a^$b");
437       assertTrue(selector.test(message));
438       
439       // this one has a double backslash since backslash
440
// is interpreted specially by Java
441
selector = new Selector("MyString LIKE 'a\\dc'");
442       message.setStringProperty("MyString", "a\\dc");
443       assertTrue(selector.test(message));
444       
445       selector = new Selector("MyString LIKE 'a.c'");
446       message.setStringProperty("MyString", "abc");
447       assertTrue(!selector.test(message));
448       
449       selector = new Selector("MyString LIKE '[abc]'");
450       message.setStringProperty("MyString", "[abc]");
451       assertTrue(selector.test(message));
452       
453       selector = new Selector("MyString LIKE '[^abc]'");
454       message.setStringProperty("MyString", "[^abc]");
455       assertTrue(selector.test(message));
456       
457       selector = new Selector("MyString LIKE '[a-c]'");
458       message.setStringProperty("MyString", "[a-c]");
459       assertTrue(selector.test(message));
460       
461       selector = new Selector("MyString LIKE '[:alpha]'");
462       message.setStringProperty("MyString", "[:alpha]");
463       assertTrue(selector.test(message));
464       
465       selector = new Selector("MyString LIKE '(abc)'");
466       message.setStringProperty("MyString", "(abc)");
467       assertTrue(selector.test(message));
468       
469       selector = new Selector("MyString LIKE 'a|bc'");
470       message.setStringProperty("MyString", "a|bc");
471       assertTrue(selector.test(message));
472       
473       selector = new Selector("MyString LIKE '(abc)?'");
474       message.setStringProperty("MyString", "(abc)?");
475       assertTrue(selector.test(message));
476       
477       selector = new Selector("MyString LIKE '(abc)*'");
478       message.setStringProperty("MyString", "(abc)*");
479       assertTrue(selector.test(message));
480       
481       selector = new Selector("MyString LIKE '(abc)+'");
482       message.setStringProperty("MyString", "(abc)+");
483       assertTrue(selector.test(message));
484       
485       selector = new Selector("MyString LIKE '(abc){3}'");
486       message.setStringProperty("MyString", "(abc){3}");
487       assertTrue(selector.test(message));
488       
489       selector = new Selector("MyString LIKE '(abc){3,5}'");
490       message.setStringProperty("MyString", "(abc){3,5}");
491       assertTrue(selector.test(message));
492       
493       selector = new Selector("MyString LIKE '(abc){3,}'");
494       message.setStringProperty("MyString", "(abc){3,}");
495       assertTrue(selector.test(message));
496       
497       selector = new Selector("MyString LIKE '(?=abc)'");
498       message.setStringProperty("MyString", "(?=abc)");
499       assertTrue(selector.test(message));
500       
501       selector = new Selector("MyString LIKE '(?!abc)'");
502       message.setStringProperty("MyString", "(?!abc)");
503       assertTrue(selector.test(message));
504    }
505 }
506
Popular Tags