001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *     http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018package org.apache.hadoop.hbase.filter;
019
020import static org.junit.jupiter.api.Assertions.assertEquals;
021
022import java.nio.ByteBuffer;
023import org.apache.hadoop.hbase.testclassification.FilterTests;
024import org.apache.hadoop.hbase.testclassification.SmallTests;
025import org.junit.jupiter.api.Tag;
026import org.junit.jupiter.api.Test;
027
028/**
029 * Tests for the bit comparator
030 */
031@Tag(FilterTests.TAG)
032@Tag(SmallTests.TAG)
033public class TestBitComparator {
034
035  private static byte[] zeros = new byte[] { 0, 0, 0, 0, 0, 0 };
036  private static ByteBuffer zeros_bb = ByteBuffer.wrap(zeros);
037  private static byte[] ones = new byte[] { 1, 1, 1, 1, 1, 1 };
038  private static ByteBuffer ones_bb = ByteBuffer.wrap(ones);
039  private static byte[] data0 = new byte[] { 0, 1, 2, 4, 8, 15 };
040  private static byte[] data1 = new byte[] { 15, 0, 0, 0, 0, 0 };
041  private static ByteBuffer data1_bb = ByteBuffer.wrap(data1);
042  private static byte[] data2 = new byte[] { 0, 0, 0, 0, 0, 15 };
043  private static ByteBuffer data2_bb = ByteBuffer.wrap(data2);
044  private static byte[] data3 = new byte[] { 15, 15, 15, 15, 15 };
045
046  // data for testing compareTo method with offset and length parameters
047  private static byte[] data1_2 = new byte[] { 15, 15, 0, 0, 0, 0, 0, 15 };
048  private static ByteBuffer data1_2_bb = ByteBuffer.wrap(data1_2);
049  private static byte[] data2_2 = new byte[] { 15, 0, 0, 0, 0, 0, 15, 15 };
050  private static ByteBuffer data2_2_bb = ByteBuffer.wrap(data2_2);
051
052  private final int Equal = 0;
053  private final int NotEqual = 1;
054
055  @Test
056  public void testANDOperation() {
057    testOperation(zeros, ones, BitComparator.BitwiseOp.AND, NotEqual);
058    testOperation(data1, ones, BitComparator.BitwiseOp.AND, Equal);
059    testOperation(data1, data0, BitComparator.BitwiseOp.AND, NotEqual);
060    testOperation(data2, data1, BitComparator.BitwiseOp.AND, NotEqual);
061    testOperation(ones, data0, BitComparator.BitwiseOp.AND, Equal);
062    testOperation(ones, data3, BitComparator.BitwiseOp.AND, NotEqual);
063
064    testOperation(zeros_bb, ones, BitComparator.BitwiseOp.AND, NotEqual);
065    testOperation(data1_bb, ones, BitComparator.BitwiseOp.AND, Equal);
066    testOperation(data1_bb, data0, BitComparator.BitwiseOp.AND, NotEqual);
067    testOperation(data2_bb, data1, BitComparator.BitwiseOp.AND, NotEqual);
068    testOperation(ones_bb, data0, BitComparator.BitwiseOp.AND, Equal);
069    testOperation(ones_bb, data3, BitComparator.BitwiseOp.AND, NotEqual);
070  }
071
072  @Test
073  public void testOROperation() {
074    testOperation(ones, zeros, BitComparator.BitwiseOp.OR, Equal);
075    testOperation(zeros, zeros, BitComparator.BitwiseOp.OR, NotEqual);
076    testOperation(data1, zeros, BitComparator.BitwiseOp.OR, Equal);
077    testOperation(data2, data1, BitComparator.BitwiseOp.OR, Equal);
078    testOperation(ones, data3, BitComparator.BitwiseOp.OR, NotEqual);
079
080    testOperation(ones_bb, zeros, BitComparator.BitwiseOp.OR, Equal);
081    testOperation(zeros_bb, zeros, BitComparator.BitwiseOp.OR, NotEqual);
082    testOperation(data1_bb, zeros, BitComparator.BitwiseOp.OR, Equal);
083    testOperation(data2_bb, data1, BitComparator.BitwiseOp.OR, Equal);
084    testOperation(ones_bb, data3, BitComparator.BitwiseOp.OR, NotEqual);
085  }
086
087  @Test
088  public void testXOROperation() {
089    testOperation(ones, zeros, BitComparator.BitwiseOp.XOR, Equal);
090    testOperation(zeros, zeros, BitComparator.BitwiseOp.XOR, NotEqual);
091    testOperation(ones, ones, BitComparator.BitwiseOp.XOR, NotEqual);
092    testOperation(data2, data1, BitComparator.BitwiseOp.XOR, Equal);
093    testOperation(ones, data3, BitComparator.BitwiseOp.XOR, NotEqual);
094
095    testOperation(ones_bb, zeros, BitComparator.BitwiseOp.XOR, Equal);
096    testOperation(zeros_bb, zeros, BitComparator.BitwiseOp.XOR, NotEqual);
097    testOperation(ones_bb, ones, BitComparator.BitwiseOp.XOR, NotEqual);
098    testOperation(data2_bb, data1, BitComparator.BitwiseOp.XOR, Equal);
099    testOperation(ones_bb, data3, BitComparator.BitwiseOp.XOR, NotEqual);
100  }
101
102  private void testOperation(byte[] data, byte[] comparatorBytes, BitComparator.BitwiseOp operator,
103    int expected) {
104    BitComparator comparator = new BitComparator(comparatorBytes, operator);
105    assertEquals(expected, comparator.compareTo(data));
106  }
107
108  private void testOperation(ByteBuffer data, byte[] comparatorBytes,
109    BitComparator.BitwiseOp operator, int expected) {
110    BitComparator comparator = new BitComparator(comparatorBytes, operator);
111    assertEquals(expected, comparator.compareTo(data, 0, data.capacity()));
112  }
113
114  @Test
115  public void testANDOperationWithOffset() {
116    testOperationWithOffset(data1_2, ones, BitComparator.BitwiseOp.AND, Equal);
117    testOperationWithOffset(data1_2, data0, BitComparator.BitwiseOp.AND, NotEqual);
118    testOperationWithOffset(data2_2, data1, BitComparator.BitwiseOp.AND, NotEqual);
119
120    testOperationWithOffset(data1_2_bb, ones, BitComparator.BitwiseOp.AND, Equal);
121    testOperationWithOffset(data1_2_bb, data0, BitComparator.BitwiseOp.AND, NotEqual);
122    testOperationWithOffset(data2_2_bb, data1, BitComparator.BitwiseOp.AND, NotEqual);
123  }
124
125  @Test
126  public void testOROperationWithOffset() {
127    testOperationWithOffset(data1_2, zeros, BitComparator.BitwiseOp.OR, Equal);
128    testOperationWithOffset(data2_2, data1, BitComparator.BitwiseOp.OR, Equal);
129
130    testOperationWithOffset(data1_2_bb, zeros, BitComparator.BitwiseOp.OR, Equal);
131    testOperationWithOffset(data2_2_bb, data1, BitComparator.BitwiseOp.OR, Equal);
132  }
133
134  @Test
135  public void testXOROperationWithOffset() {
136    testOperationWithOffset(data2_2, data1, BitComparator.BitwiseOp.XOR, Equal);
137
138    testOperationWithOffset(data2_2_bb, data1, BitComparator.BitwiseOp.XOR, Equal);
139  }
140
141  private void testOperationWithOffset(byte[] data, byte[] comparatorBytes,
142    BitComparator.BitwiseOp operator, int expected) {
143    BitComparator comparator = new BitComparator(comparatorBytes, operator);
144    assertEquals(expected, comparator.compareTo(data, 1, comparatorBytes.length));
145  }
146
147  private void testOperationWithOffset(ByteBuffer data, byte[] comparatorBytes,
148    BitComparator.BitwiseOp operator, int expected) {
149    BitComparator comparator = new BitComparator(comparatorBytes, operator);
150    assertEquals(expected, comparator.compareTo(data, 1, comparatorBytes.length));
151  }
152}