1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.filter;
20
21 import static org.junit.Assert.*;
22
23 import java.io.IOException;
24 import java.util.ArrayList;
25 import java.util.List;
26
27 import org.apache.hadoop.hbase.testclassification.SmallTests;
28 import org.apache.hadoop.hbase.util.Bytes;
29 import org.junit.After;
30 import org.junit.Before;
31 import org.junit.Test;
32 import org.junit.experimental.categories.Category;
33
34
35
36
37
38
39 @Category(SmallTests.class)
40 public class TestParseFilter {
41
42 ParseFilter f;
43 Filter filter;
44
45 @Before
46 public void setUp() throws Exception {
47 f = new ParseFilter();
48 }
49
50 @After
51 public void tearDown() throws Exception {
52
53 }
54
55 @Test
56 public void testKeyOnlyFilter() throws IOException {
57 String filterString = "KeyOnlyFilter()";
58 doTestFilter(filterString, KeyOnlyFilter.class);
59
60 String filterString2 = "KeyOnlyFilter ('') ";
61 byte [] filterStringAsByteArray2 = Bytes.toBytes(filterString2);
62 try {
63 filter = f.parseFilterString(filterStringAsByteArray2);
64 assertTrue(false);
65 } catch (IllegalArgumentException e) {
66 System.out.println(e.getMessage());
67 }
68 }
69
70 @Test
71 public void testFirstKeyOnlyFilter() throws IOException {
72 String filterString = " FirstKeyOnlyFilter( ) ";
73 doTestFilter(filterString, FirstKeyOnlyFilter.class);
74
75 String filterString2 = " FirstKeyOnlyFilter ('') ";
76 byte [] filterStringAsByteArray2 = Bytes.toBytes(filterString2);
77 try {
78 filter = f.parseFilterString(filterStringAsByteArray2);
79 assertTrue(false);
80 } catch (IllegalArgumentException e) {
81 System.out.println(e.getMessage());
82 }
83 }
84
85 @Test
86 public void testPrefixFilter() throws IOException {
87 String filterString = " PrefixFilter('row' ) ";
88 PrefixFilter prefixFilter = doTestFilter(filterString, PrefixFilter.class);
89 byte [] prefix = prefixFilter.getPrefix();
90 assertEquals(new String(prefix), "row");
91
92
93 filterString = " PrefixFilter(row)";
94 try {
95 doTestFilter(filterString, PrefixFilter.class);
96 assertTrue(false);
97 } catch (IllegalArgumentException e) {
98 System.out.println(e.getMessage());
99 }
100 }
101
102 @Test
103 public void testColumnPrefixFilter() throws IOException {
104 String filterString = " ColumnPrefixFilter('qualifier' ) ";
105 ColumnPrefixFilter columnPrefixFilter =
106 doTestFilter(filterString, ColumnPrefixFilter.class);
107 byte [] columnPrefix = columnPrefixFilter.getPrefix();
108 assertEquals(new String(columnPrefix), "qualifier");
109 }
110
111 @Test
112 public void testMultipleColumnPrefixFilter() throws IOException {
113 String filterString = " MultipleColumnPrefixFilter('qualifier1', 'qualifier2' ) ";
114 MultipleColumnPrefixFilter multipleColumnPrefixFilter =
115 doTestFilter(filterString, MultipleColumnPrefixFilter.class);
116 byte [][] prefixes = multipleColumnPrefixFilter.getPrefix();
117 assertEquals(new String(prefixes[0]), "qualifier1");
118 assertEquals(new String(prefixes[1]), "qualifier2");
119 }
120
121 @Test
122 public void testColumnCountGetFilter() throws IOException {
123 String filterString = " ColumnCountGetFilter(4)";
124 ColumnCountGetFilter columnCountGetFilter =
125 doTestFilter(filterString, ColumnCountGetFilter.class);
126 int limit = columnCountGetFilter.getLimit();
127 assertEquals(limit, 4);
128
129 filterString = " ColumnCountGetFilter('abc')";
130 try {
131 doTestFilter(filterString, ColumnCountGetFilter.class);
132 assertTrue(false);
133 } catch (IllegalArgumentException e) {
134 System.out.println(e.getMessage());
135 }
136
137 filterString = " ColumnCountGetFilter(2147483648)";
138 try {
139 doTestFilter(filterString, ColumnCountGetFilter.class);
140 assertTrue(false);
141 } catch (IllegalArgumentException e) {
142 System.out.println(e.getMessage());
143 }
144 }
145
146 @Test
147 public void testPageFilter() throws IOException {
148 String filterString = " PageFilter(4)";
149 PageFilter pageFilter =
150 doTestFilter(filterString, PageFilter.class);
151 long pageSize = pageFilter.getPageSize();
152 assertEquals(pageSize, 4);
153
154 filterString = " PageFilter('123')";
155 try {
156 doTestFilter(filterString, PageFilter.class);
157 assertTrue(false);
158 } catch (IllegalArgumentException e) {
159 System.out.println("PageFilter needs an int as an argument");
160 }
161 }
162
163 @Test
164 public void testColumnPaginationFilter() throws IOException {
165 String filterString = "ColumnPaginationFilter(4, 6)";
166 ColumnPaginationFilter columnPaginationFilter =
167 doTestFilter(filterString, ColumnPaginationFilter.class);
168 int limit = columnPaginationFilter.getLimit();
169 assertEquals(limit, 4);
170 int offset = columnPaginationFilter.getOffset();
171 assertEquals(offset, 6);
172
173 filterString = " ColumnPaginationFilter('124')";
174 try {
175 doTestFilter(filterString, ColumnPaginationFilter.class);
176 assertTrue(false);
177 } catch (IllegalArgumentException e) {
178 System.out.println("ColumnPaginationFilter needs two arguments");
179 }
180
181 filterString = " ColumnPaginationFilter('4' , '123a')";
182 try {
183 doTestFilter(filterString, ColumnPaginationFilter.class);
184 assertTrue(false);
185 } catch (IllegalArgumentException e) {
186 System.out.println("ColumnPaginationFilter needs two ints as arguments");
187 }
188
189 filterString = " ColumnPaginationFilter('4' , '-123')";
190 try {
191 doTestFilter(filterString, ColumnPaginationFilter.class);
192 assertTrue(false);
193 } catch (IllegalArgumentException e) {
194 System.out.println("ColumnPaginationFilter arguments should not be negative");
195 }
196 }
197
198 @Test
199 public void testInclusiveStopFilter() throws IOException {
200 String filterString = "InclusiveStopFilter ('row 3')";
201 InclusiveStopFilter inclusiveStopFilter =
202 doTestFilter(filterString, InclusiveStopFilter.class);
203 byte [] stopRowKey = inclusiveStopFilter.getStopRowKey();
204 assertEquals(new String(stopRowKey), "row 3");
205 }
206
207
208 @Test
209 public void testTimestampsFilter() throws IOException {
210 String filterString = "TimestampsFilter(9223372036854775806, 6)";
211 TimestampsFilter timestampsFilter =
212 doTestFilter(filterString, TimestampsFilter.class);
213 List<Long> timestamps = timestampsFilter.getTimestamps();
214 assertEquals(timestamps.size(), 2);
215 assertEquals(timestamps.get(0), new Long(6));
216
217 filterString = "TimestampsFilter()";
218 timestampsFilter = doTestFilter(filterString, TimestampsFilter.class);
219 timestamps = timestampsFilter.getTimestamps();
220 assertEquals(timestamps.size(), 0);
221
222 filterString = "TimestampsFilter(9223372036854775808, 6)";
223 try {
224 doTestFilter(filterString, ColumnPaginationFilter.class);
225 assertTrue(false);
226 } catch (IllegalArgumentException e) {
227 System.out.println("Long Argument was too large");
228 }
229
230 filterString = "TimestampsFilter(-45, 6)";
231 try {
232 doTestFilter(filterString, ColumnPaginationFilter.class);
233 assertTrue(false);
234 } catch (IllegalArgumentException e) {
235 System.out.println("Timestamp Arguments should not be negative");
236 }
237 }
238
239 @Test
240 public void testRowFilter() throws IOException {
241 String filterString = "RowFilter ( =, 'binary:regionse')";
242 RowFilter rowFilter =
243 doTestFilter(filterString, RowFilter.class);
244 assertEquals(CompareFilter.CompareOp.EQUAL, rowFilter.getOperator());
245 assertTrue(rowFilter.getComparator() instanceof BinaryComparator);
246 BinaryComparator binaryComparator = (BinaryComparator) rowFilter.getComparator();
247 assertEquals("regionse", new String(binaryComparator.getValue()));
248 }
249
250 @Test
251 public void testFamilyFilter() throws IOException {
252 String filterString = "FamilyFilter(>=, 'binaryprefix:pre')";
253 FamilyFilter familyFilter =
254 doTestFilter(filterString, FamilyFilter.class);
255 assertEquals(CompareFilter.CompareOp.GREATER_OR_EQUAL, familyFilter.getOperator());
256 assertTrue(familyFilter.getComparator() instanceof BinaryPrefixComparator);
257 BinaryPrefixComparator binaryPrefixComparator =
258 (BinaryPrefixComparator) familyFilter.getComparator();
259 assertEquals("pre", new String(binaryPrefixComparator.getValue()));
260 }
261
262 @Test
263 public void testQualifierFilter() throws IOException {
264 String filterString = "QualifierFilter(=, 'regexstring:pre*')";
265 QualifierFilter qualifierFilter =
266 doTestFilter(filterString, QualifierFilter.class);
267 assertEquals(CompareFilter.CompareOp.EQUAL, qualifierFilter.getOperator());
268 assertTrue(qualifierFilter.getComparator() instanceof RegexStringComparator);
269 RegexStringComparator regexStringComparator =
270 (RegexStringComparator) qualifierFilter.getComparator();
271 assertEquals("pre*", new String(regexStringComparator.getValue()));
272 }
273
274 @Test
275 public void testValueFilter() throws IOException {
276 String filterString = "ValueFilter(!=, 'substring:pre')";
277 ValueFilter valueFilter =
278 doTestFilter(filterString, ValueFilter.class);
279 assertEquals(CompareFilter.CompareOp.NOT_EQUAL, valueFilter.getOperator());
280 assertTrue(valueFilter.getComparator() instanceof SubstringComparator);
281 SubstringComparator substringComparator =
282 (SubstringComparator) valueFilter.getComparator();
283 assertEquals("pre", new String(substringComparator.getValue()));
284 }
285
286 @Test
287 public void testColumnRangeFilter() throws IOException {
288 String filterString = "ColumnRangeFilter('abc', true, 'xyz', false)";
289 ColumnRangeFilter columnRangeFilter =
290 doTestFilter(filterString, ColumnRangeFilter.class);
291 assertEquals("abc", new String(columnRangeFilter.getMinColumn()));
292 assertEquals("xyz", new String(columnRangeFilter.getMaxColumn()));
293 assertTrue(columnRangeFilter.isMinColumnInclusive());
294 assertFalse(columnRangeFilter.isMaxColumnInclusive());
295 }
296
297 @Test
298 public void testDependentColumnFilter() throws IOException {
299 String filterString = "DependentColumnFilter('family', 'qualifier', true, =, 'binary:abc')";
300 DependentColumnFilter dependentColumnFilter =
301 doTestFilter(filterString, DependentColumnFilter.class);
302 assertEquals("family", new String(dependentColumnFilter.getFamily()));
303 assertEquals("qualifier", new String(dependentColumnFilter.getQualifier()));
304 assertTrue(dependentColumnFilter.getDropDependentColumn());
305 assertEquals(CompareFilter.CompareOp.EQUAL, dependentColumnFilter.getOperator());
306 assertTrue(dependentColumnFilter.getComparator() instanceof BinaryComparator);
307 BinaryComparator binaryComparator = (BinaryComparator)dependentColumnFilter.getComparator();
308 assertEquals("abc", new String(binaryComparator.getValue()));
309 }
310
311 @Test
312 public void testSingleColumnValueFilter() throws IOException {
313 String filterString = "SingleColumnValueFilter " +
314 "('family', 'qualifier', >=, 'binary:a', true, false)";
315 SingleColumnValueFilter singleColumnValueFilter =
316 doTestFilter(filterString, SingleColumnValueFilter.class);
317 assertEquals("family", new String(singleColumnValueFilter.getFamily()));
318 assertEquals("qualifier", new String(singleColumnValueFilter.getQualifier()));
319 assertEquals(singleColumnValueFilter.getOperator(), CompareFilter.CompareOp.GREATER_OR_EQUAL);
320 assertTrue(singleColumnValueFilter.getComparator() instanceof BinaryComparator);
321 BinaryComparator binaryComparator = (BinaryComparator) singleColumnValueFilter.getComparator();
322 assertEquals(new String(binaryComparator.getValue()), "a");
323 assertTrue(singleColumnValueFilter.getFilterIfMissing());
324 assertFalse(singleColumnValueFilter.getLatestVersionOnly());
325
326
327 filterString = "SingleColumnValueFilter ('family', 'qualifier', >, 'binaryprefix:a')";
328 singleColumnValueFilter = doTestFilter(filterString, SingleColumnValueFilter.class);
329 assertEquals("family", new String(singleColumnValueFilter.getFamily()));
330 assertEquals("qualifier", new String(singleColumnValueFilter.getQualifier()));
331 assertEquals(singleColumnValueFilter.getOperator(), CompareFilter.CompareOp.GREATER);
332 assertTrue(singleColumnValueFilter.getComparator() instanceof BinaryPrefixComparator);
333 BinaryPrefixComparator binaryPrefixComparator =
334 (BinaryPrefixComparator) singleColumnValueFilter.getComparator();
335 assertEquals(new String(binaryPrefixComparator.getValue()), "a");
336 assertFalse(singleColumnValueFilter.getFilterIfMissing());
337 assertTrue(singleColumnValueFilter.getLatestVersionOnly());
338 }
339
340 @Test
341 public void testSingleColumnValueExcludeFilter() throws IOException {
342 String filterString =
343 "SingleColumnValueExcludeFilter ('family', 'qualifier', <, 'binaryprefix:a')";
344 SingleColumnValueExcludeFilter singleColumnValueExcludeFilter =
345 doTestFilter(filterString, SingleColumnValueExcludeFilter.class);
346 assertEquals(singleColumnValueExcludeFilter.getOperator(), CompareFilter.CompareOp.LESS);
347 assertEquals("family", new String(singleColumnValueExcludeFilter.getFamily()));
348 assertEquals("qualifier", new String(singleColumnValueExcludeFilter.getQualifier()));
349 assertEquals(new String(singleColumnValueExcludeFilter.getComparator().getValue()), "a");
350 assertFalse(singleColumnValueExcludeFilter.getFilterIfMissing());
351 assertTrue(singleColumnValueExcludeFilter.getLatestVersionOnly());
352
353 filterString = "SingleColumnValueExcludeFilter " +
354 "('family', 'qualifier', <=, 'binaryprefix:a', true, false)";
355 singleColumnValueExcludeFilter =
356 doTestFilter(filterString, SingleColumnValueExcludeFilter.class);
357 assertEquals("family", new String(singleColumnValueExcludeFilter.getFamily()));
358 assertEquals("qualifier", new String(singleColumnValueExcludeFilter.getQualifier()));
359 assertEquals(singleColumnValueExcludeFilter.getOperator(),
360 CompareFilter.CompareOp.LESS_OR_EQUAL);
361 assertTrue(singleColumnValueExcludeFilter.getComparator() instanceof BinaryPrefixComparator);
362 BinaryPrefixComparator binaryPrefixComparator =
363 (BinaryPrefixComparator) singleColumnValueExcludeFilter.getComparator();
364 assertEquals(new String(binaryPrefixComparator.getValue()), "a");
365 assertTrue(singleColumnValueExcludeFilter.getFilterIfMissing());
366 assertFalse(singleColumnValueExcludeFilter.getLatestVersionOnly());
367 }
368
369 @Test
370 public void testSkipFilter() throws IOException {
371 String filterString = "SKIP ValueFilter( =, 'binary:0')";
372 SkipFilter skipFilter =
373 doTestFilter(filterString, SkipFilter.class);
374 assertTrue(skipFilter.getFilter() instanceof ValueFilter);
375 ValueFilter valueFilter = (ValueFilter) skipFilter.getFilter();
376
377 assertEquals(CompareFilter.CompareOp.EQUAL, valueFilter.getOperator());
378 assertTrue(valueFilter.getComparator() instanceof BinaryComparator);
379 BinaryComparator binaryComparator = (BinaryComparator) valueFilter.getComparator();
380 assertEquals("0", new String(binaryComparator.getValue()));
381 }
382
383 @Test
384 public void testWhileFilter() throws IOException {
385 String filterString = " WHILE RowFilter ( !=, 'binary:row1')";
386 WhileMatchFilter whileMatchFilter =
387 doTestFilter(filterString, WhileMatchFilter.class);
388 assertTrue(whileMatchFilter.getFilter() instanceof RowFilter);
389 RowFilter rowFilter = (RowFilter) whileMatchFilter.getFilter();
390
391 assertEquals(CompareFilter.CompareOp.NOT_EQUAL, rowFilter.getOperator());
392 assertTrue(rowFilter.getComparator() instanceof BinaryComparator);
393 BinaryComparator binaryComparator = (BinaryComparator) rowFilter.getComparator();
394 assertEquals("row1", new String(binaryComparator.getValue()));
395 }
396
397 @Test
398 public void testCompoundFilter1() throws IOException {
399 String filterString = " (PrefixFilter ('realtime')AND FirstKeyOnlyFilter())";
400 FilterList filterList =
401 doTestFilter(filterString, FilterList.class);
402 ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters();
403
404 assertTrue(filters.get(0) instanceof PrefixFilter);
405 assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter);
406 PrefixFilter PrefixFilter = (PrefixFilter) filters.get(0);
407 byte [] prefix = PrefixFilter.getPrefix();
408 assertEquals(new String(prefix), "realtime");
409 FirstKeyOnlyFilter firstKeyOnlyFilter = (FirstKeyOnlyFilter) filters.get(1);
410 }
411
412 @Test
413 public void testCompoundFilter2() throws IOException {
414 String filterString = "(PrefixFilter('realtime') AND QualifierFilter (>=, 'binary:e'))" +
415 "OR FamilyFilter (=, 'binary:qualifier') ";
416 FilterList filterList =
417 doTestFilter(filterString, FilterList.class);
418 ArrayList<Filter> filterListFilters = (ArrayList<Filter>) filterList.getFilters();
419 assertTrue(filterListFilters.get(0) instanceof FilterList);
420 assertTrue(filterListFilters.get(1) instanceof FamilyFilter);
421 assertEquals(filterList.getOperator(), FilterList.Operator.MUST_PASS_ONE);
422
423 filterList = (FilterList) filterListFilters.get(0);
424 FamilyFilter familyFilter = (FamilyFilter) filterListFilters.get(1);
425
426 filterListFilters = (ArrayList<Filter>)filterList.getFilters();
427 assertTrue(filterListFilters.get(0) instanceof PrefixFilter);
428 assertTrue(filterListFilters.get(1) instanceof QualifierFilter);
429 assertEquals(filterList.getOperator(), FilterList.Operator.MUST_PASS_ALL);
430
431 assertEquals(CompareFilter.CompareOp.EQUAL, familyFilter.getOperator());
432 assertTrue(familyFilter.getComparator() instanceof BinaryComparator);
433 BinaryComparator binaryComparator = (BinaryComparator) familyFilter.getComparator();
434 assertEquals("qualifier", new String(binaryComparator.getValue()));
435
436 PrefixFilter prefixFilter = (PrefixFilter) filterListFilters.get(0);
437 byte [] prefix = prefixFilter.getPrefix();
438 assertEquals(new String(prefix), "realtime");
439
440 QualifierFilter qualifierFilter = (QualifierFilter) filterListFilters.get(1);
441 assertEquals(CompareFilter.CompareOp.GREATER_OR_EQUAL, qualifierFilter.getOperator());
442 assertTrue(qualifierFilter.getComparator() instanceof BinaryComparator);
443 binaryComparator = (BinaryComparator) qualifierFilter.getComparator();
444 assertEquals("e", new String(binaryComparator.getValue()));
445 }
446
447 @Test
448 public void testCompoundFilter3() throws IOException {
449 String filterString = " ColumnPrefixFilter ('realtime')AND " +
450 "FirstKeyOnlyFilter() OR SKIP FamilyFilter(=, 'substring:hihi')";
451 FilterList filterList =
452 doTestFilter(filterString, FilterList.class);
453 ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters();
454
455 assertTrue(filters.get(0) instanceof FilterList);
456 assertTrue(filters.get(1) instanceof SkipFilter);
457
458 filterList = (FilterList) filters.get(0);
459 SkipFilter skipFilter = (SkipFilter) filters.get(1);
460
461 filters = (ArrayList<Filter>) filterList.getFilters();
462 assertTrue(filters.get(0) instanceof ColumnPrefixFilter);
463 assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter);
464
465 ColumnPrefixFilter columnPrefixFilter = (ColumnPrefixFilter) filters.get(0);
466 byte [] columnPrefix = columnPrefixFilter.getPrefix();
467 assertEquals(new String(columnPrefix), "realtime");
468
469 FirstKeyOnlyFilter firstKeyOnlyFilter = (FirstKeyOnlyFilter) filters.get(1);
470
471 assertTrue(skipFilter.getFilter() instanceof FamilyFilter);
472 FamilyFilter familyFilter = (FamilyFilter) skipFilter.getFilter();
473
474 assertEquals(CompareFilter.CompareOp.EQUAL, familyFilter.getOperator());
475 assertTrue(familyFilter.getComparator() instanceof SubstringComparator);
476 SubstringComparator substringComparator =
477 (SubstringComparator) familyFilter.getComparator();
478 assertEquals("hihi", new String(substringComparator.getValue()));
479 }
480
481 @Test
482 public void testCompoundFilter4() throws IOException {
483 String filterString = " ColumnPrefixFilter ('realtime') OR " +
484 "FirstKeyOnlyFilter() OR SKIP FamilyFilter(=, 'substring:hihi')";
485 FilterList filterList =
486 doTestFilter(filterString, FilterList.class);
487 ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters();
488
489 assertTrue(filters.get(0) instanceof ColumnPrefixFilter);
490 assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter);
491 assertTrue(filters.get(2) instanceof SkipFilter);
492
493 ColumnPrefixFilter columnPrefixFilter = (ColumnPrefixFilter) filters.get(0);
494 FirstKeyOnlyFilter firstKeyOnlyFilter = (FirstKeyOnlyFilter) filters.get(1);
495 SkipFilter skipFilter = (SkipFilter) filters.get(2);
496
497 byte [] columnPrefix = columnPrefixFilter.getPrefix();
498 assertEquals(new String(columnPrefix), "realtime");
499
500 assertTrue(skipFilter.getFilter() instanceof FamilyFilter);
501 FamilyFilter familyFilter = (FamilyFilter) skipFilter.getFilter();
502
503 assertEquals(CompareFilter.CompareOp.EQUAL, familyFilter.getOperator());
504 assertTrue(familyFilter.getComparator() instanceof SubstringComparator);
505 SubstringComparator substringComparator =
506 (SubstringComparator) familyFilter.getComparator();
507 assertEquals("hihi", new String(substringComparator.getValue()));
508 }
509
510 @Test
511 public void testIncorrectCompareOperator() throws IOException {
512 String filterString = "RowFilter ('>>' , 'binary:region')";
513 try {
514 doTestFilter(filterString, RowFilter.class);
515 assertTrue(false);
516 } catch (IllegalArgumentException e) {
517 System.out.println("Incorrect compare operator >>");
518 }
519 }
520
521 @Test
522 public void testIncorrectComparatorType () throws IOException {
523 String filterString = "RowFilter ('>=' , 'binaryoperator:region')";
524 try {
525 doTestFilter(filterString, RowFilter.class);
526 assertTrue(false);
527 } catch (IllegalArgumentException e) {
528 System.out.println("Incorrect comparator type: binaryoperator");
529 }
530
531 filterString = "RowFilter ('>=' 'regexstring:pre*')";
532 try {
533 doTestFilter(filterString, RowFilter.class);
534 assertTrue(false);
535 } catch (IllegalArgumentException e) {
536 System.out.println("RegexStringComparator can only be used with EQUAL or NOT_EQUAL");
537 }
538
539 filterString = "SingleColumnValueFilter" +
540 " ('family', 'qualifier', '>=', 'substring:a', 'true', 'false')')";
541 try {
542 doTestFilter(filterString, RowFilter.class);
543 assertTrue(false);
544 } catch (IllegalArgumentException e) {
545 System.out.println("SubtringComparator can only be used with EQUAL or NOT_EQUAL");
546 }
547 }
548
549 @Test
550 public void testPrecedence1() throws IOException {
551 String filterString = " (PrefixFilter ('realtime')AND FirstKeyOnlyFilter()" +
552 " OR KeyOnlyFilter())";
553 FilterList filterList =
554 doTestFilter(filterString, FilterList.class);
555
556 ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters();
557
558 assertTrue(filters.get(0) instanceof FilterList);
559 assertTrue(filters.get(1) instanceof KeyOnlyFilter);
560
561 filterList = (FilterList) filters.get(0);
562 filters = (ArrayList<Filter>) filterList.getFilters();
563
564 assertTrue(filters.get(0) instanceof PrefixFilter);
565 assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter);
566
567 PrefixFilter prefixFilter = (PrefixFilter)filters.get(0);
568 byte [] prefix = prefixFilter.getPrefix();
569 assertEquals(new String(prefix), "realtime");
570 }
571
572 @Test
573 public void testPrecedence2() throws IOException {
574 String filterString = " PrefixFilter ('realtime')AND SKIP FirstKeyOnlyFilter()" +
575 "OR KeyOnlyFilter()";
576 FilterList filterList =
577 doTestFilter(filterString, FilterList.class);
578 ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters();
579
580 assertTrue(filters.get(0) instanceof FilterList);
581 assertTrue(filters.get(1) instanceof KeyOnlyFilter);
582
583 filterList = (FilterList) filters.get(0);
584 filters = (ArrayList<Filter>) filterList.getFilters();
585
586 assertTrue(filters.get(0) instanceof PrefixFilter);
587 assertTrue(filters.get(1) instanceof SkipFilter);
588
589 PrefixFilter prefixFilter = (PrefixFilter)filters.get(0);
590 byte [] prefix = prefixFilter.getPrefix();
591 assertEquals(new String(prefix), "realtime");
592
593 SkipFilter skipFilter = (SkipFilter)filters.get(1);
594 assertTrue(skipFilter.getFilter() instanceof FirstKeyOnlyFilter);
595 }
596
597 @Test
598 public void testUnescapedQuote1 () throws IOException {
599 String filterString = "InclusiveStopFilter ('row''3')";
600 InclusiveStopFilter inclusiveStopFilter =
601 doTestFilter(filterString, InclusiveStopFilter.class);
602 byte [] stopRowKey = inclusiveStopFilter.getStopRowKey();
603 assertEquals(new String(stopRowKey), "row'3");
604 }
605
606 @Test
607 public void testUnescapedQuote2 () throws IOException {
608 String filterString = "InclusiveStopFilter ('row''3''')";
609 InclusiveStopFilter inclusiveStopFilter =
610 doTestFilter(filterString, InclusiveStopFilter.class);
611 byte [] stopRowKey = inclusiveStopFilter.getStopRowKey();
612 assertEquals(new String(stopRowKey), "row'3'");
613 }
614
615 @Test
616 public void testUnescapedQuote3 () throws IOException {
617 String filterString = " InclusiveStopFilter ('''')";
618 InclusiveStopFilter inclusiveStopFilter =
619 doTestFilter(filterString, InclusiveStopFilter.class);
620 byte [] stopRowKey = inclusiveStopFilter.getStopRowKey();
621 assertEquals(new String(stopRowKey), "'");
622 }
623
624 @Test
625 public void testIncorrectFilterString () throws IOException {
626 String filterString = "()";
627 byte [] filterStringAsByteArray = Bytes.toBytes(filterString);
628 try {
629 filter = f.parseFilterString(filterStringAsByteArray);
630 assertTrue(false);
631 } catch (IllegalArgumentException e) {
632 System.out.println(e.getMessage());
633 }
634 }
635
636 @Test
637 public void testCorrectFilterString () throws IOException {
638 String filterString = "(FirstKeyOnlyFilter())";
639 FirstKeyOnlyFilter firstKeyOnlyFilter =
640 doTestFilter(filterString, FirstKeyOnlyFilter.class);
641 }
642
643 @Test
644 public void testRegisterFilter() {
645 ParseFilter.registerFilter("MyFilter", "some.class");
646
647 assertTrue(f.getSupportedFilters().contains("MyFilter"));
648 }
649
650 private <T extends Filter> T doTestFilter(String filterString, Class<T> clazz) throws IOException {
651 byte [] filterStringAsByteArray = Bytes.toBytes(filterString);
652 filter = f.parseFilterString(filterStringAsByteArray);
653 assertEquals(clazz, filter.getClass());
654 return clazz.cast(filter);
655 }
656
657 }
658