| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.carbondata.core.util; |
| |
| import junit.framework.TestCase; |
| |
| import org.apache.carbondata.core.constants.CarbonCommonConstants; |
| import org.apache.carbondata.core.util.ByteUtil.UnsafeComparer; |
| |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| import java.nio.ByteBuffer; |
| import java.nio.charset.Charset; |
| |
| /** |
| * This test will test the functionality of the Byte Util |
| * for the comparision of 2 byte buffers |
| */ |
| public class ByteUtilTest extends TestCase { |
| |
| String dimensionValue1 = "aaaaaaaa1235"; |
| String dimensionValue2 = "aaaaaaaa1234"; |
| private ByteBuffer buff1; |
| private ByteBuffer buff2; |
| |
| /** |
| * This method will form one single byte [] for all the high card dims. |
| * |
| * @param byteBufferArr ByteBuffer array |
| * @return byte array |
| */ |
| public static byte[] packByteBufferIntoSingleByteArray(ByteBuffer[] byteBufferArr) { |
| // for empty array means there is no data to remove dictionary. |
| if (null == byteBufferArr || byteBufferArr.length == 0) { |
| return null; |
| } |
| int noOfCol = byteBufferArr.length; |
| short toDetermineLengthOfByteArr = 2; |
| short offsetLen = (short) (noOfCol * 2 + toDetermineLengthOfByteArr); |
| int totalBytes = calculateTotalBytes(byteBufferArr) + offsetLen; |
| |
| ByteBuffer buffer = ByteBuffer.allocate(totalBytes); |
| |
| // write the length of the byte [] as first short |
| buffer.putShort((short) (totalBytes - toDetermineLengthOfByteArr)); |
| // writing the offset of the first element. |
| buffer.putShort(offsetLen); |
| |
| // prepare index for byte [] |
| for (int index = 0; index < byteBufferArr.length - 1; index++) { |
| ByteBuffer individualCol = byteBufferArr[index]; |
| // short lengthOfbytes = individualCol.getShort(); |
| int noOfBytes = individualCol.capacity(); |
| |
| buffer.putShort((short) (offsetLen + noOfBytes)); |
| offsetLen += noOfBytes; |
| individualCol.rewind(); |
| } |
| |
| // put actual data. |
| for (int index = 0; index < byteBufferArr.length; index++) { |
| ByteBuffer individualCol = byteBufferArr[index]; |
| buffer.put(individualCol.array()); |
| } |
| |
| buffer.rewind(); |
| return buffer.array(); |
| |
| } |
| |
| /** |
| * To calculate the total bytes in byte Buffer[]. |
| * |
| * @param byteBufferArr |
| * @return |
| */ |
| private static int calculateTotalBytes(ByteBuffer[] byteBufferArr) { |
| int total = 0; |
| for (int index = 0; index < byteBufferArr.length; index++) { |
| total += byteBufferArr[index].capacity(); |
| } |
| return total; |
| } |
| |
| /** |
| * @throws Exception |
| */ |
| @Before |
| public void setUp() throws Exception { |
| |
| } |
| |
| @Test |
| public void testLessThan() { |
| dimensionValue1 = "aaaaa6aa1235"; |
| dimensionValue2 = "aaaaa5aa1234"; |
| |
| prepareBuffers(); |
| assertFalse(UnsafeComparer.INSTANCE.compareTo(buff1, buff2) < 0); |
| } |
| |
| @Test |
| public void testIntConversion() { |
| byte[] data = new byte[4]; |
| ByteUtil.setInt(data, 0, 968); |
| assertEquals(ByteUtil.toInt(data, 0), 968); |
| } |
| |
| @Test |
| public void testEqualToCase() { |
| dimensionValue1 = "aaaaaaaa1234"; |
| dimensionValue2 = "aaaaaaaa1234"; |
| |
| prepareBuffers(); |
| assertTrue(UnsafeComparer.INSTANCE.compareTo(buff1, buff2) == 0); |
| } |
| |
| @Test |
| public void testLessThanInBoundaryCondition() { |
| dimensionValue1 = "aaaaaaaa12341"; |
| dimensionValue2 = "aaaaaaaa12344"; |
| |
| prepareBuffers(); |
| assertTrue(UnsafeComparer.INSTANCE.compareTo(buff1, buff2) < 0); |
| } |
| |
| /** |
| * This will prepare the byte buffers in the required format for comparision. |
| */ |
| private void prepareBuffers() { |
| ByteBuffer[] out1 = new ByteBuffer[1]; |
| ByteBuffer buffer = ByteBuffer.allocate(dimensionValue1.length()); |
| buffer.put(dimensionValue1.getBytes(Charset.forName(CarbonCommonConstants.DEFAULT_CHARSET))); |
| buffer.rewind(); |
| out1[0] = buffer; |
| |
| ByteBuffer[] out2 = new ByteBuffer[1]; |
| |
| ByteBuffer buffer2 = ByteBuffer.allocate(dimensionValue2.length()); |
| buffer2.put(dimensionValue2.getBytes(Charset.forName(CarbonCommonConstants.DEFAULT_CHARSET))); |
| buffer2.rewind(); |
| out2[0] = buffer2; |
| |
| byte[] arr1 = packByteBufferIntoSingleByteArray(out1); |
| byte[] arr2 = packByteBufferIntoSingleByteArray(out2); |
| |
| buff1 = ByteBuffer.wrap(arr1); |
| |
| buff1.position(4); |
| buff1.limit(buff1.position() + dimensionValue1.length()); |
| |
| buff2 = ByteBuffer.wrap(arr2); |
| buff2.position(4); |
| buff2.limit(buff2.position() + dimensionValue2.length()); |
| } |
| |
| @Test |
| public void testToBytes() { |
| assertTrue(ByteUtil.toBoolean(ByteUtil.toBytes(true))); |
| assertFalse(ByteUtil.toBoolean(ByteUtil.toBytes(false))); |
| |
| assertEquals(Short.MAX_VALUE, |
| ByteUtil.toShort(ByteUtil.toBytes(Short.MAX_VALUE), 0, 2)); |
| assertEquals((short) (Short.MAX_VALUE / 2), |
| ByteUtil.toShort(ByteUtil.toBytes((short) (Short.MAX_VALUE / 2)), 0, 2)); |
| assertEquals((short) 0, |
| ByteUtil.toShort(ByteUtil.toBytes((short) 0), 0, 2)); |
| assertEquals((short) (Short.MIN_VALUE / 2), |
| ByteUtil.toShort(ByteUtil.toBytes((short) (Short.MIN_VALUE / 2)), 0, 2)); |
| assertEquals(Short.MIN_VALUE, |
| ByteUtil.toShort(ByteUtil.toBytes(Short.MIN_VALUE), 0, 2)); |
| |
| assertEquals(Integer.MAX_VALUE, |
| ByteUtil.toInt(ByteUtil.toBytes(Integer.MAX_VALUE), 0, 4)); |
| assertEquals(Integer.MAX_VALUE / 2, |
| ByteUtil.toInt(ByteUtil.toBytes(Integer.MAX_VALUE / 2), 0, 4)); |
| assertEquals(0, |
| ByteUtil.toInt(ByteUtil.toBytes(0), 0, 4)); |
| assertEquals(Integer.MIN_VALUE / 2, |
| ByteUtil.toInt(ByteUtil.toBytes(Integer.MIN_VALUE / 2), 0, 4)); |
| assertEquals(Integer.MIN_VALUE, |
| ByteUtil.toInt(ByteUtil.toBytes(Integer.MIN_VALUE), 0, 4)); |
| |
| assertEquals(Long.MAX_VALUE, |
| ByteUtil.toLong(ByteUtil.toBytes(Long.MAX_VALUE), 0, 8)); |
| assertEquals(Long.MAX_VALUE / 2, |
| ByteUtil.toLong(ByteUtil.toBytes(Long.MAX_VALUE / 2), 0, 8)); |
| assertEquals(0L, |
| ByteUtil.toLong(ByteUtil.toBytes(0L), 0, 8)); |
| assertEquals(Long.MIN_VALUE / 2, |
| ByteUtil.toLong(ByteUtil.toBytes(Long.MIN_VALUE / 2), 0, 8)); |
| assertEquals(Long.MIN_VALUE, |
| ByteUtil.toLong(ByteUtil.toBytes(Long.MIN_VALUE), 0, 8)); |
| |
| assertEquals(Double.MAX_VALUE, |
| ByteUtil.toDouble(ByteUtil.toBytes(Double.MAX_VALUE), 0, 8)); |
| assertEquals(Double.MAX_VALUE / 2, |
| ByteUtil.toDouble(ByteUtil.toBytes(Double.MAX_VALUE / 2), 0, 8)); |
| assertEquals((double) 0, |
| ByteUtil.toDouble(ByteUtil.toBytes((double) 0), 0, 8)); |
| assertEquals(Double.MIN_VALUE / 2, |
| ByteUtil.toDouble(ByteUtil.toBytes(Double.MIN_VALUE / 2), 0, 8)); |
| assertEquals(Double.MIN_VALUE, |
| ByteUtil.toDouble(ByteUtil.toBytes(Double.MIN_VALUE), 0, 8)); |
| } |
| |
| @Test |
| public void testToXorBytes() { |
| assertEquals(Short.MAX_VALUE, |
| ByteUtil.toXorShort(ByteUtil.toXorBytes(Short.MAX_VALUE), 0, 2)); |
| assertEquals((short) (Short.MAX_VALUE / 2), |
| ByteUtil.toXorShort(ByteUtil.toXorBytes((short) (Short.MAX_VALUE / 2)), 0, 2)); |
| assertEquals((short) 0, |
| ByteUtil.toXorShort(ByteUtil.toXorBytes((short) 0), 0, 2)); |
| assertEquals((short) (Short.MIN_VALUE / 2), |
| ByteUtil.toXorShort(ByteUtil.toXorBytes((short) (Short.MIN_VALUE / 2)), 0, 2)); |
| assertEquals(Short.MIN_VALUE, |
| ByteUtil.toXorShort(ByteUtil.toXorBytes(Short.MIN_VALUE), 0, 2)); |
| |
| assertEquals(Integer.MAX_VALUE, |
| ByteUtil.toXorInt(ByteUtil.toXorBytes(Integer.MAX_VALUE), 0, 4)); |
| assertEquals(Integer.MAX_VALUE / 2, |
| ByteUtil.toXorInt(ByteUtil.toXorBytes(Integer.MAX_VALUE / 2), 0, 4)); |
| assertEquals(0, |
| ByteUtil.toXorInt(ByteUtil.toXorBytes(0), 0, 4)); |
| assertEquals(Integer.MIN_VALUE / 2, |
| ByteUtil.toXorInt(ByteUtil.toXorBytes(Integer.MIN_VALUE / 2), 0, 4)); |
| assertEquals(Integer.MIN_VALUE, |
| ByteUtil.toXorInt(ByteUtil.toXorBytes(Integer.MIN_VALUE), 0, 4)); |
| |
| assertEquals(Long.MAX_VALUE, |
| ByteUtil.toXorLong(ByteUtil.toXorBytes(Long.MAX_VALUE), 0, 8)); |
| assertEquals(Long.MAX_VALUE / 2, |
| ByteUtil.toXorLong(ByteUtil.toXorBytes(Long.MAX_VALUE / 2), 0, 8)); |
| assertEquals(0L, |
| ByteUtil.toXorLong(ByteUtil.toXorBytes(0L), 0, 8)); |
| assertEquals(Long.MIN_VALUE / 2, |
| ByteUtil.toXorLong(ByteUtil.toXorBytes(Long.MIN_VALUE / 2), 0, 8)); |
| assertEquals(Long.MIN_VALUE, |
| ByteUtil.toXorLong(ByteUtil.toXorBytes(Long.MIN_VALUE), 0, 8)); |
| |
| assertEquals(Double.MAX_VALUE, |
| ByteUtil.toXorDouble(ByteUtil.toXorBytes(Double.MAX_VALUE), 0, 8)); |
| assertEquals(Double.MAX_VALUE / 2, |
| ByteUtil.toXorDouble(ByteUtil.toXorBytes(Double.MAX_VALUE / 2), 0, 8)); |
| assertEquals((double) 0, |
| ByteUtil.toXorDouble(ByteUtil.toXorBytes((double) 0), 0, 8)); |
| assertEquals(Double.MIN_VALUE / 2, |
| ByteUtil.toXorDouble(ByteUtil.toXorBytes(Double.MIN_VALUE / 2), 0, 8)); |
| assertEquals(Double.MIN_VALUE, |
| ByteUtil.toXorDouble(ByteUtil.toXorBytes(Double.MIN_VALUE), 0, 8)); |
| } |
| |
| } |