View Javadoc

1   /**
2    * 
3    *  Licensed under the Apache License, Version 2.0 (the "License");
4    *  you may not use this file except in compliance with the License.
5    *  You may obtain a copy of the License at
6    * 
7    *       http://www.apache.org/licenses/LICENSE-2.0
8    * 
9    *  Unless required by applicable law or agreed to in writing, software
10   *  distributed under the License is distributed on an "AS IS" BASIS,
11   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12   *  See the License for the specific language governing permissions and
13   *  limitations under the License.
14   *  under the License.
15   */
16  package org.apache.hadoop.hbase.filter;
17  
18  import org.apache.hadoop.hbase.testclassification.SmallTests;
19  import org.junit.Test;
20  import org.junit.experimental.categories.Category;
21  
22  import static org.junit.Assert.assertEquals;
23  
24  /**
25   * Tests for the bit comparator
26   */
27  @Category(SmallTests.class)
28  public class TestBitComparator {
29  
30    private static byte[] zeros = new byte[]{0, 0, 0, 0, 0, 0};
31    private static byte[] ones = new byte[]{1, 1, 1, 1, 1, 1};
32    private static byte[] data0 = new byte[]{0, 1, 2, 4, 8, 15};
33    private static byte[] data1 = new byte[]{15, 0, 0, 0, 0, 0};
34    private static byte[] data2 = new byte[]{0, 0, 0, 0, 0, 15};
35    private static byte[] data3 = new byte[]{15, 15, 15, 15, 15};
36    
37    // data for testing compareTo method with offset and length parameters
38    private static byte[] data1_2 = new byte[]{15, 15, 0, 0, 0, 0, 0, 15};
39    private static byte[] data2_2 = new byte[]{15, 0, 0, 0, 0, 0, 15, 15};
40    
41    private final int Equal = 0;
42    private final int NotEqual = 1;
43  
44    @Test
45    public void testANDOperation() {
46      testOperation(zeros, ones, BitComparator.BitwiseOp.AND, NotEqual);
47      testOperation(data1, ones, BitComparator.BitwiseOp.AND, Equal);
48      testOperation(data1, data0, BitComparator.BitwiseOp.AND, NotEqual);
49      testOperation(data2, data1, BitComparator.BitwiseOp.AND, NotEqual);
50      testOperation(ones, data0, BitComparator.BitwiseOp.AND, Equal);
51      testOperation(ones, data3, BitComparator.BitwiseOp.AND, NotEqual);
52    }
53  
54    @Test
55    public void testOROperation() {
56      testOperation(ones, zeros, BitComparator.BitwiseOp.OR, Equal);
57      testOperation(zeros, zeros, BitComparator.BitwiseOp.OR, NotEqual);
58      testOperation(data1, zeros, BitComparator.BitwiseOp.OR, Equal);
59      testOperation(data2, data1, BitComparator.BitwiseOp.OR, Equal);
60      testOperation(ones, data3, BitComparator.BitwiseOp.OR, NotEqual);
61    }
62  
63    @Test
64    public void testXOROperation() {
65      testOperation(ones, zeros, BitComparator.BitwiseOp.XOR, Equal);
66      testOperation(zeros, zeros, BitComparator.BitwiseOp.XOR, NotEqual);
67      testOperation(ones, ones, BitComparator.BitwiseOp.XOR, NotEqual);
68      testOperation(data2, data1, BitComparator.BitwiseOp.XOR, Equal);
69      testOperation(ones, data3, BitComparator.BitwiseOp.XOR, NotEqual);
70    }
71  
72    private void testOperation(byte[] data, byte[] comparatorBytes, BitComparator.BitwiseOp operator, int expected) {
73      BitComparator comparator = new BitComparator(comparatorBytes, operator);
74      assertEquals(comparator.compareTo(data), expected);
75    }
76  
77    @Test
78    public void testANDOperationWithOffset() {
79      testOperationWithOffset(data1_2, ones, BitComparator.BitwiseOp.AND, Equal);
80      testOperationWithOffset(data1_2, data0, BitComparator.BitwiseOp.AND, NotEqual);
81      testOperationWithOffset(data2_2, data1, BitComparator.BitwiseOp.AND, NotEqual);
82    }
83  
84    @Test
85    public void testOROperationWithOffset() {
86      testOperationWithOffset(data1_2, zeros, BitComparator.BitwiseOp.OR, Equal);
87      testOperationWithOffset(data2_2, data1, BitComparator.BitwiseOp.OR, Equal);
88    }
89  
90    @Test
91    public void testXOROperationWithOffset() {
92      testOperationWithOffset(data2_2, data1, BitComparator.BitwiseOp.XOR, Equal);
93    }
94  
95    private void testOperationWithOffset(byte[] data, byte[] comparatorBytes, BitComparator.BitwiseOp operator, int expected) {
96      BitComparator comparator = new BitComparator(comparatorBytes, operator);
97      assertEquals(comparator.compareTo(data, 1, comparatorBytes.length), expected);
98    }
99  }
100