View Javadoc

1   /**
2    *
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *     http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing, software
14   * distributed under the License is distributed on an "AS IS" BASIS,
15   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   * See the License for the specific language governing permissions and
17   * limitations under the License.
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   * This class tests ParseFilter.java
36   * It tests the entire work flow from when a string is given by the user
37   * and how it is parsed to construct the corresponding Filter object
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      // Nothing to do.
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 testCompoundFilter5() throws IOException {
512     String filterStr = "(ValueFilter(!=, 'substring:pre'))";
513     ValueFilter valueFilter = doTestFilter(filterStr, ValueFilter.class);
514     assertTrue(valueFilter.getComparator() instanceof SubstringComparator);
515 
516     filterStr = "(ValueFilter(>=,'binary:x') AND (ValueFilter(<=,'binary:y')))"
517             + " OR ValueFilter(=,'binary:ab')";
518     filter = f.parseFilterString(filterStr);
519     assertTrue(filter instanceof FilterList);
520     List<Filter> list = ((FilterList) filter).getFilters();
521     assertEquals(2, list.size());
522     assertTrue(list.get(0) instanceof FilterList);
523     assertTrue(list.get(1) instanceof ValueFilter);
524   }
525 
526   @Test
527   public void testIncorrectCompareOperator() throws IOException {
528     String filterString = "RowFilter ('>>' , 'binary:region')";
529     try {
530       doTestFilter(filterString, RowFilter.class);
531       assertTrue(false);
532     } catch (IllegalArgumentException e) {
533       System.out.println("Incorrect compare operator >>");
534     }
535   }
536 
537   @Test
538   public void testIncorrectComparatorType () throws IOException {
539     String  filterString = "RowFilter ('>=' , 'binaryoperator:region')";
540     try {
541       doTestFilter(filterString, RowFilter.class);
542       assertTrue(false);
543     } catch (IllegalArgumentException e) {
544       System.out.println("Incorrect comparator type: binaryoperator");
545     }
546 
547     filterString = "RowFilter ('>=' 'regexstring:pre*')";
548     try {
549       doTestFilter(filterString, RowFilter.class);
550       assertTrue(false);
551     } catch (IllegalArgumentException e) {
552       System.out.println("RegexStringComparator can only be used with EQUAL or NOT_EQUAL");
553     }
554 
555     filterString = "SingleColumnValueFilter" +
556       " ('family', 'qualifier', '>=', 'substring:a', 'true', 'false')')";
557     try {
558       doTestFilter(filterString, RowFilter.class);
559       assertTrue(false);
560     } catch (IllegalArgumentException e) {
561       System.out.println("SubtringComparator can only be used with EQUAL or NOT_EQUAL");
562     }
563   }
564 
565   @Test
566   public void testPrecedence1() throws IOException {
567     String filterString = " (PrefixFilter ('realtime')AND  FirstKeyOnlyFilter()" +
568       " OR KeyOnlyFilter())";
569     FilterList filterList =
570       doTestFilter(filterString, FilterList.class);
571 
572     ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters();
573 
574     assertTrue(filters.get(0) instanceof FilterList);
575     assertTrue(filters.get(1) instanceof KeyOnlyFilter);
576 
577     filterList = (FilterList) filters.get(0);
578     filters = (ArrayList<Filter>) filterList.getFilters();
579 
580     assertTrue(filters.get(0) instanceof PrefixFilter);
581     assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter);
582 
583     PrefixFilter prefixFilter = (PrefixFilter)filters.get(0);
584     byte [] prefix = prefixFilter.getPrefix();
585     assertEquals(new String(prefix), "realtime");
586   }
587 
588   @Test
589   public void testPrecedence2() throws IOException {
590     String filterString = " PrefixFilter ('realtime')AND  SKIP FirstKeyOnlyFilter()" +
591       "OR KeyOnlyFilter()";
592     FilterList filterList =
593       doTestFilter(filterString, FilterList.class);
594     ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters();
595 
596     assertTrue(filters.get(0) instanceof FilterList);
597     assertTrue(filters.get(1) instanceof KeyOnlyFilter);
598 
599     filterList = (FilterList) filters.get(0);
600     filters = (ArrayList<Filter>) filterList.getFilters();
601 
602     assertTrue(filters.get(0) instanceof PrefixFilter);
603     assertTrue(filters.get(1) instanceof SkipFilter);
604 
605     PrefixFilter prefixFilter = (PrefixFilter)filters.get(0);
606     byte [] prefix = prefixFilter.getPrefix();
607     assertEquals(new String(prefix), "realtime");
608 
609     SkipFilter skipFilter = (SkipFilter)filters.get(1);
610     assertTrue(skipFilter.getFilter() instanceof FirstKeyOnlyFilter);
611   }
612 
613   @Test
614   public void testUnescapedQuote1 () throws IOException {
615     String filterString = "InclusiveStopFilter ('row''3')";
616     InclusiveStopFilter inclusiveStopFilter =
617       doTestFilter(filterString, InclusiveStopFilter.class);
618     byte [] stopRowKey = inclusiveStopFilter.getStopRowKey();
619     assertEquals(new String(stopRowKey), "row'3");
620   }
621 
622   @Test
623   public void testUnescapedQuote2 () throws IOException {
624     String filterString = "InclusiveStopFilter ('row''3''')";
625     InclusiveStopFilter inclusiveStopFilter =
626       doTestFilter(filterString, InclusiveStopFilter.class);
627     byte [] stopRowKey = inclusiveStopFilter.getStopRowKey();
628     assertEquals(new String(stopRowKey), "row'3'");
629   }
630 
631   @Test
632   public void testUnescapedQuote3 () throws IOException {
633     String filterString = "	InclusiveStopFilter ('''')";
634     InclusiveStopFilter inclusiveStopFilter =
635       doTestFilter(filterString, InclusiveStopFilter.class);
636     byte [] stopRowKey = inclusiveStopFilter.getStopRowKey();
637     assertEquals(new String(stopRowKey), "'");
638   }
639 
640   @Test
641   public void testIncorrectFilterString () throws IOException {
642     String filterString = "()";
643     byte [] filterStringAsByteArray = Bytes.toBytes(filterString);
644     try {
645       filter = f.parseFilterString(filterStringAsByteArray);
646       assertTrue(false);
647     } catch (IllegalArgumentException e) {
648       System.out.println(e.getMessage());
649     }
650   }
651 
652   @Test
653   public void testCorrectFilterString () throws IOException {
654     String filterString = "(FirstKeyOnlyFilter())";
655     FirstKeyOnlyFilter firstKeyOnlyFilter =
656       doTestFilter(filterString, FirstKeyOnlyFilter.class);
657   }
658   
659   @Test
660   public void testRegisterFilter() {
661     ParseFilter.registerFilter("MyFilter", "some.class");
662     
663     assertTrue(f.getSupportedFilters().contains("MyFilter"));
664   }
665 
666   private <T extends Filter> T doTestFilter(String filterString, Class<T> clazz) throws IOException {
667     byte [] filterStringAsByteArray = Bytes.toBytes(filterString);
668     filter = f.parseFilterString(filterStringAsByteArray);
669     assertEquals(clazz, filter.getClass());
670     return clazz.cast(filter);
671   }
672 
673 }
674