1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.hadoop.hbase.filter;
21
22 import static org.junit.Assert.assertTrue;
23
24 import java.util.LinkedList;
25 import java.util.TreeSet;
26
27 import org.apache.hadoop.hbase.SmallTests;
28 import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
29 import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
30 import org.apache.hadoop.hbase.util.Bytes;
31 import org.apache.hadoop.hbase.util.Pair;
32 import org.junit.Test;
33 import org.junit.experimental.categories.Category;
34
35 @Category(SmallTests.class)
36 public class TestFilterSerialization {
37
38 @Test
39 public void testColumnCountGetFilter() throws Exception {
40 ColumnCountGetFilter columnCountGetFilter = new ColumnCountGetFilter(1);
41 assertTrue(columnCountGetFilter.areSerializedFieldsEqual(
42 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnCountGetFilter))));
43 }
44
45 @Test
46 public void testColumnPaginationFilter() throws Exception {
47 ColumnPaginationFilter columnPaginationFilter = new ColumnPaginationFilter(1,7);
48 assertTrue(columnPaginationFilter.areSerializedFieldsEqual(
49 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPaginationFilter))));
50 }
51
52 @Test
53 public void testColumnPrefixFilter() throws Exception {
54
55 ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes(""));
56 assertTrue(columnPrefixFilter.areSerializedFieldsEqual(
57 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter))));
58
59
60 columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes(""));
61 assertTrue(columnPrefixFilter.areSerializedFieldsEqual(
62 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter))));
63 }
64
65 @Test
66 public void testColumnRangeFilter() throws Exception {
67
68 ColumnRangeFilter columnRangeFilter = new ColumnRangeFilter(null, true, null, false);
69 assertTrue(columnRangeFilter.areSerializedFieldsEqual(
70 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter))));
71
72
73 columnRangeFilter = new ColumnRangeFilter(Bytes.toBytes("a"), false, Bytes.toBytes("b"), true);
74 assertTrue(columnRangeFilter.areSerializedFieldsEqual(
75 ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter))));
76 }
77
78 @Test
79 public void testDependentColumnFilter() throws Exception {
80
81 DependentColumnFilter dependentColumnFilter = new DependentColumnFilter(null, null);
82 assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
83 ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));
84
85
86 dependentColumnFilter = new DependentColumnFilter(Bytes.toBytes("family"),
87 Bytes.toBytes("qual"), true, CompareOp.GREATER_OR_EQUAL,
88 new BitComparator(Bytes.toBytes("bitComparator"), BitComparator.BitwiseOp.OR));
89 assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
90 ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));
91 }
92
93 @Test
94 public void testFamilyFilter() throws Exception {
95 FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL,
96 new BinaryPrefixComparator(Bytes.toBytes("testValueOne")));
97 assertTrue(familyFilter.areSerializedFieldsEqual(
98 ProtobufUtil.toFilter(ProtobufUtil.toFilter(familyFilter))));
99 }
100
101 @Test
102 public void testFilterList() throws Exception {
103
104 FilterList filterList = new FilterList(new LinkedList<Filter>());
105 assertTrue(filterList.areSerializedFieldsEqual(
106 ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList))));
107
108
109 LinkedList<Filter> list = new LinkedList<Filter>();
110 list.add(new ColumnCountGetFilter(1));
111 list.add(new RowFilter(CompareFilter.CompareOp.EQUAL,
112 new SubstringComparator("testFilterList")));
113 assertTrue(filterList.areSerializedFieldsEqual(
114 ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList))));
115 }
116
117 @Test
118 public void testFilterWrapper() throws Exception {
119 FilterWrapper filterWrapper =
120 new FilterWrapper(
121 new ColumnRangeFilter(Bytes.toBytes("e"), false, Bytes.toBytes("f"), true));
122 assertTrue(filterWrapper.areSerializedFieldsEqual(
123 ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterWrapper))));
124 }
125
126 @Test
127 public void testFirstKeyValueMatchingQualifiersFilter() throws Exception {
128
129 TreeSet<byte []> set = new TreeSet<byte []>(Bytes.BYTES_COMPARATOR);
130 FirstKeyValueMatchingQualifiersFilter firstKeyValueMatchingQualifiersFilter =
131 new FirstKeyValueMatchingQualifiersFilter(set);
132 assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
133 ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
134
135
136 set.add(Bytes.toBytes("col0"));
137 set.add(Bytes.toBytes("col1"));
138 firstKeyValueMatchingQualifiersFilter =
139 new FirstKeyValueMatchingQualifiersFilter(set);
140 assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
141 ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
142 }
143
144 @Test
145 public void testFirstKeyOnlyFilter() throws Exception {
146 FirstKeyOnlyFilter firstKeyOnlyFilter = new FirstKeyOnlyFilter();
147 assertTrue(firstKeyOnlyFilter.areSerializedFieldsEqual(
148 ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyOnlyFilter))));
149 }
150
151 @Test
152 public void testFuzzyRowFilter() throws Exception {
153 LinkedList<Pair<byte[], byte[]>> fuzzyList = new LinkedList<Pair<byte[], byte[]>>();
154 fuzzyList.add(new Pair<byte[], byte[]>(Bytes.toBytes("999"),new byte[] {0, 0, 1}));
155 fuzzyList.add(new Pair<byte[], byte[]>(Bytes.toBytes("abcd"),new byte[] {1, 0, 1, 1}));
156 FuzzyRowFilter fuzzyRowFilter = new FuzzyRowFilter(fuzzyList);
157 assertTrue(fuzzyRowFilter.areSerializedFieldsEqual(
158 ProtobufUtil.toFilter(ProtobufUtil.toFilter(fuzzyRowFilter))));
159 }
160
161 @Test
162 public void testInclusiveStopFilter() throws Exception {
163
164 InclusiveStopFilter inclusiveStopFilter = new InclusiveStopFilter(null);
165 assertTrue(inclusiveStopFilter.areSerializedFieldsEqual(
166 ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
167
168
169 inclusiveStopFilter = new InclusiveStopFilter(Bytes.toBytes("inclusiveStopFilter"));
170 assertTrue(inclusiveStopFilter.areSerializedFieldsEqual(
171 ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
172 }
173
174 @Test
175 public void testKeyOnlyFilter() throws Exception {
176
177 KeyOnlyFilter keyOnlyFilter = new KeyOnlyFilter(true);
178 assertTrue(keyOnlyFilter.areSerializedFieldsEqual(
179 ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
180
181
182 keyOnlyFilter = new KeyOnlyFilter();
183 assertTrue(keyOnlyFilter.areSerializedFieldsEqual(
184 ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
185 }
186
187 @Test
188 public void testMultipleColumnPrefixFilter() throws Exception {
189
190 byte [][] prefixes = null;
191 MultipleColumnPrefixFilter multipleColumnPrefixFilter =
192 new MultipleColumnPrefixFilter(prefixes);
193 assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
194 ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
195
196
197 prefixes = new byte[2][];
198 prefixes[0] = Bytes.toBytes("a");
199 prefixes[1] = Bytes.toBytes("");
200 multipleColumnPrefixFilter = new MultipleColumnPrefixFilter(prefixes);
201 assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
202 ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
203 }
204
205 @Test
206 public void testPageFilter() throws Exception {
207 PageFilter pageFilter = new PageFilter(6);
208 assertTrue(pageFilter.areSerializedFieldsEqual(
209 ProtobufUtil.toFilter(ProtobufUtil.toFilter(pageFilter))));
210 }
211
212 @Test
213 public void testPrefixFilter() throws Exception {
214
215 PrefixFilter prefixFilter = new PrefixFilter(null);
216 assertTrue(prefixFilter.areSerializedFieldsEqual(
217 ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
218
219
220 prefixFilter = new PrefixFilter(Bytes.toBytes("abc"));
221 assertTrue(prefixFilter.areSerializedFieldsEqual(
222 ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
223 }
224
225 @Test
226 public void testQualifierFilter() throws Exception {
227 QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL,
228 new NullComparator());
229 assertTrue(qualifierFilter.areSerializedFieldsEqual(
230 ProtobufUtil.toFilter(ProtobufUtil.toFilter(qualifierFilter))));
231 }
232
233 @Test
234 public void testRandomRowFilter() throws Exception {
235 RandomRowFilter randomRowFilter = new RandomRowFilter((float)0.1);
236 assertTrue(randomRowFilter.areSerializedFieldsEqual(
237 ProtobufUtil.toFilter(ProtobufUtil.toFilter(randomRowFilter))));
238 }
239
240 @Test
241 public void testRowFilter() throws Exception {
242 RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL,
243 new SubstringComparator("testRowFilter"));
244 assertTrue(rowFilter.areSerializedFieldsEqual(
245 ProtobufUtil.toFilter(ProtobufUtil.toFilter(rowFilter))));
246 }
247
248 @Test
249 public void testSingleColumnValueExcludeFilter() throws Exception {
250
251 SingleColumnValueExcludeFilter singleColumnValueExcludeFilter =
252 new SingleColumnValueExcludeFilter(null, null,
253 CompareFilter.CompareOp.GREATER_OR_EQUAL, Bytes.toBytes("value"));
254 assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
255 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
256
257
258 singleColumnValueExcludeFilter =
259 new SingleColumnValueExcludeFilter(Bytes.toBytes("fam"), Bytes.toBytes("qual"),
260 CompareFilter.CompareOp.LESS_OR_EQUAL, new NullComparator(), false, false);
261 assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
262 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
263 }
264
265 @Test
266 public void testSingleColumnValueFilter() throws Exception {
267
268 SingleColumnValueFilter singleColumnValueFilter =
269 new SingleColumnValueFilter(null, null,
270 CompareFilter.CompareOp.LESS, Bytes.toBytes("value"));
271 assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
272 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
273
274
275 singleColumnValueFilter =
276 new SingleColumnValueFilter(Bytes.toBytes("family"), Bytes.toBytes("qualifier"),
277 CompareFilter.CompareOp.NOT_EQUAL, new NullComparator(), true, true);
278 assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
279 ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
280 }
281
282 @Test
283 public void testSkipFilter() throws Exception {
284 SkipFilter skipFilter = new SkipFilter(new PageFilter(6));
285 assertTrue(skipFilter.areSerializedFieldsEqual(
286 ProtobufUtil.toFilter(ProtobufUtil.toFilter(skipFilter))));
287 }
288
289 @Test
290 public void testTimestampsFilter() throws Exception {
291
292 TimestampsFilter timestampsFilter = new TimestampsFilter(new LinkedList<Long>());
293 assertTrue(timestampsFilter.areSerializedFieldsEqual(
294 ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
295
296
297 LinkedList<Long> list = new LinkedList<Long>();
298 list.add(new Long(System.currentTimeMillis()));
299 list.add(new Long(System.currentTimeMillis()));
300 timestampsFilter = new TimestampsFilter(list);
301 assertTrue(timestampsFilter.areSerializedFieldsEqual(
302 ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
303 }
304
305 @Test
306 public void testValueFilter() throws Exception {
307 ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.NO_OP,
308 new BinaryComparator(Bytes.toBytes("testValueOne")));
309 assertTrue(valueFilter.areSerializedFieldsEqual(
310 ProtobufUtil.toFilter(ProtobufUtil.toFilter(valueFilter))));
311 }
312
313 @Test
314 public void testWhileMatchFilter() throws Exception {
315 WhileMatchFilter whileMatchFilter =
316 new WhileMatchFilter(
317 new ColumnRangeFilter(Bytes.toBytes("c"), false, Bytes.toBytes("d"), true));
318 assertTrue(whileMatchFilter.areSerializedFieldsEqual(
319 ProtobufUtil.toFilter(ProtobufUtil.toFilter(whileMatchFilter))));
320 }
321
322 }