| /* |
| * Copyright 2017 HugeGraph Authors |
| * |
| * 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 com.baidu.hugegraph.unit.util; |
| |
| import java.math.BigDecimal; |
| import java.text.ParseException; |
| import java.text.SimpleDateFormat; |
| import java.util.Date; |
| import java.util.Random; |
| import java.util.TimeZone; |
| |
| import org.junit.Test; |
| |
| import com.baidu.hugegraph.testutil.Assert; |
| import com.baidu.hugegraph.unit.BaseUnitTest; |
| import com.baidu.hugegraph.util.Bytes; |
| import com.baidu.hugegraph.util.LongEncoding; |
| import com.baidu.hugegraph.util.NumericUtil; |
| |
| public class LongEncodingTest extends BaseUnitTest { |
| |
| @Test |
| public void testValidB64Char() { |
| Assert.assertTrue(LongEncoding.validB64Char('0')); |
| Assert.assertTrue(LongEncoding.validB64Char('1')); |
| Assert.assertTrue(LongEncoding.validB64Char('9')); |
| Assert.assertTrue(LongEncoding.validB64Char('A')); |
| Assert.assertTrue(LongEncoding.validB64Char('Z')); |
| Assert.assertTrue(LongEncoding.validB64Char('_')); |
| Assert.assertTrue(LongEncoding.validB64Char('a')); |
| Assert.assertTrue(LongEncoding.validB64Char('z')); |
| Assert.assertTrue(LongEncoding.validB64Char('~')); |
| |
| Assert.assertFalse(LongEncoding.validB64Char('`')); |
| Assert.assertFalse(LongEncoding.validB64Char('!')); |
| Assert.assertFalse(LongEncoding.validB64Char('@')); |
| Assert.assertFalse(LongEncoding.validB64Char('#')); |
| Assert.assertFalse(LongEncoding.validB64Char('$')); |
| Assert.assertFalse(LongEncoding.validB64Char('%')); |
| Assert.assertFalse(LongEncoding.validB64Char('^')); |
| Assert.assertFalse(LongEncoding.validB64Char('&')); |
| Assert.assertFalse(LongEncoding.validB64Char('*')); |
| Assert.assertFalse(LongEncoding.validB64Char('(')); |
| Assert.assertFalse(LongEncoding.validB64Char(')')); |
| Assert.assertFalse(LongEncoding.validB64Char('-')); |
| Assert.assertFalse(LongEncoding.validB64Char('+')); |
| Assert.assertFalse(LongEncoding.validB64Char('=')); |
| Assert.assertFalse(LongEncoding.validB64Char('[')); |
| Assert.assertFalse(LongEncoding.validB64Char(']')); |
| Assert.assertFalse(LongEncoding.validB64Char('{')); |
| Assert.assertFalse(LongEncoding.validB64Char('}')); |
| Assert.assertFalse(LongEncoding.validB64Char('|')); |
| Assert.assertFalse(LongEncoding.validB64Char('\\')); |
| Assert.assertFalse(LongEncoding.validB64Char(';')); |
| Assert.assertFalse(LongEncoding.validB64Char(':')); |
| Assert.assertFalse(LongEncoding.validB64Char('\'')); |
| Assert.assertFalse(LongEncoding.validB64Char('\"')); |
| Assert.assertFalse(LongEncoding.validB64Char('<')); |
| Assert.assertFalse(LongEncoding.validB64Char(',')); |
| Assert.assertFalse(LongEncoding.validB64Char('>')); |
| Assert.assertFalse(LongEncoding.validB64Char('.')); |
| Assert.assertFalse(LongEncoding.validB64Char('?')); |
| Assert.assertFalse(LongEncoding.validB64Char('/')); |
| Assert.assertFalse(LongEncoding.validB64Char('\t')); |
| Assert.assertFalse(LongEncoding.validB64Char('\b')); |
| } |
| |
| @Test |
| public void testEncode() { |
| String val0 = LongEncoding.encodeB64(0); |
| Assert.assertEquals("0", val0); |
| |
| String val1 = LongEncoding.encodeB64(1); |
| Assert.assertEquals("1", val1); |
| |
| String val9 = LongEncoding.encodeB64(9); |
| Assert.assertEquals("9", val9); |
| |
| String val10 = LongEncoding.encodeB64(10); |
| Assert.assertEquals("A", val10); |
| |
| String val35 = LongEncoding.encodeB64(35); |
| Assert.assertEquals("Z", val35); |
| |
| String val36 = LongEncoding.encodeB64(36); |
| Assert.assertEquals("_", val36); |
| |
| String val37 = LongEncoding.encodeB64(37); |
| Assert.assertEquals("a", val37); |
| |
| String val62 = LongEncoding.encodeB64(62); |
| Assert.assertEquals("z", val62); |
| |
| String val63 = LongEncoding.encodeB64(63); |
| Assert.assertEquals("~", val63); |
| } |
| |
| @Test |
| public void testEncodeWithMultiString() { |
| Assert.assertEquals("0", LongEncoding.encode(0L, "0123456789")); |
| Assert.assertEquals("1", LongEncoding.encode(1L, "0123456789")); |
| Assert.assertEquals("123", LongEncoding.encode(123L, "0123456789")); |
| Assert.assertEquals("13579", LongEncoding.encode(13579L, "0123456789")); |
| Assert.assertEquals("24680", LongEncoding.encode(24680L, "0123456789")); |
| |
| String val64 = LongEncoding.encodeB64(64); |
| Assert.assertEquals("10", val64); |
| |
| String val65 = LongEncoding.encodeB64(65); |
| Assert.assertEquals("11", val65); |
| |
| String val99 = LongEncoding.encodeB64(99); |
| Assert.assertEquals("1Z", val99); |
| |
| String val100 = LongEncoding.encodeB64(100); |
| Assert.assertEquals("1_", val100); |
| |
| String val126 = LongEncoding.encodeB64(126); |
| Assert.assertEquals("1z", val126); |
| |
| String val127 = LongEncoding.encodeB64(127); |
| Assert.assertEquals("1~", val127); |
| |
| String val128 = LongEncoding.encodeB64(128); |
| Assert.assertEquals("20", val128); |
| |
| String val200 = LongEncoding.encodeB64(200); |
| Assert.assertEquals("38", val200); |
| |
| String val1000 = LongEncoding.encodeB64(1000); |
| Assert.assertEquals("Fd", val1000); |
| |
| String val1234 = LongEncoding.encodeB64(1234); |
| Assert.assertEquals("JI", val1234); |
| |
| String val10000 = LongEncoding.encodeB64(10000); |
| Assert.assertEquals("2SG", val10000); |
| |
| String val12345 = LongEncoding.encodeB64(12345); |
| Assert.assertEquals("30u", val12345); |
| |
| String val22345 = LongEncoding.encodeB64(22345); |
| Assert.assertEquals("5T9", val22345); |
| |
| String val92345 = LongEncoding.encodeB64(92345); |
| Assert.assertEquals("MYu", val92345); |
| |
| String val12345678 = LongEncoding.encodeB64(12345678); |
| Assert.assertEquals("k65E", val12345678); |
| |
| String val112345678 = LongEncoding.encodeB64(112345678); |
| Assert.assertEquals("6h_9E", val112345678); |
| |
| String valIntMax = LongEncoding.encodeB64(Integer.MAX_VALUE); |
| Assert.assertEquals("1~~~~~", valIntMax); |
| |
| String valLongMax = LongEncoding.encodeB64(Long.MAX_VALUE); |
| Assert.assertEquals("7~~~~~~~~~~", valLongMax); |
| } |
| |
| @Test |
| public void testEncodeWithError() { |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.encode(1, ""); |
| }, e -> { |
| Assert.assertEquals("The symbols parameter can't be empty", |
| e.getMessage()); |
| }); |
| |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.encode(-1, ""); |
| }, e -> { |
| Assert.assertContains("Expected non-negative number", |
| e.getMessage()); |
| }); |
| |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.encodeB64(-1); |
| }, e -> { |
| Assert.assertContains("Expected non-negative number", |
| e.getMessage()); |
| }); |
| |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.encodeB64(Long.MIN_VALUE); |
| }, e -> { |
| Assert.assertContains("Expected non-negative number", |
| e.getMessage()); |
| }); |
| } |
| |
| @Test |
| public void testDecode() { |
| long valEmpty = LongEncoding.decodeB64(""); |
| Assert.assertEquals(0, valEmpty); |
| |
| long val0 = LongEncoding.decodeB64("0"); |
| Assert.assertEquals(0, val0); |
| |
| long val1 = LongEncoding.decodeB64("1"); |
| Assert.assertEquals(1, val1); |
| |
| long val9 = LongEncoding.decodeB64("9"); |
| Assert.assertEquals(9, val9); |
| |
| long val10 = LongEncoding.decodeB64("A"); |
| Assert.assertEquals(10, val10); |
| |
| long val35 = LongEncoding.decodeB64("Z"); |
| Assert.assertEquals(35, val35); |
| |
| long val36 = LongEncoding.decodeB64("_"); |
| Assert.assertEquals(36, val36); |
| |
| long val37 = LongEncoding.decodeB64("a"); |
| Assert.assertEquals(37, val37); |
| |
| long val62 = LongEncoding.decodeB64("z"); |
| Assert.assertEquals(62, val62); |
| |
| long val63 = LongEncoding.decodeB64("~"); |
| Assert.assertEquals(63, val63); |
| } |
| |
| @Test |
| public void testDecodeWithMultiString() { |
| Assert.assertEquals(0L, LongEncoding.decode("0", "0123456789")); |
| Assert.assertEquals(1L, LongEncoding.decode("1", "0123456789")); |
| Assert.assertEquals(123L, LongEncoding.decode("123", "0123456789")); |
| Assert.assertEquals(13579L, LongEncoding.decode("13579", "0123456789")); |
| Assert.assertEquals(24680L, LongEncoding.decode("24680", "0123456789")); |
| |
| long val64 = LongEncoding.decodeB64("10"); |
| Assert.assertEquals(64, val64); |
| |
| long val65 = LongEncoding.decodeB64("11"); |
| Assert.assertEquals(65, val65); |
| |
| long val99 = LongEncoding.decodeB64("1Z"); |
| Assert.assertEquals(99, val99); |
| |
| long val100 = LongEncoding.decodeB64("1_"); |
| Assert.assertEquals(100, val100); |
| |
| long val126 = LongEncoding.decodeB64("1z"); |
| Assert.assertEquals(126, val126); |
| |
| long val127 = LongEncoding.decodeB64("1~"); |
| Assert.assertEquals(127, val127); |
| |
| long val128 = LongEncoding.decodeB64("20"); |
| Assert.assertEquals(128, val128); |
| |
| long val200 = LongEncoding.decodeB64("38"); |
| Assert.assertEquals(200, val200); |
| |
| long val1000 = LongEncoding.decodeB64("Fd"); |
| Assert.assertEquals(1000, val1000); |
| |
| long val1234 = LongEncoding.decodeB64("JI"); |
| Assert.assertEquals(1234, val1234); |
| |
| long val10000 = LongEncoding.decodeB64("2SG"); |
| Assert.assertEquals(10000, val10000); |
| |
| long val12345 = LongEncoding.decodeB64("30u"); |
| Assert.assertEquals(12345, val12345); |
| |
| long val22345 = LongEncoding.decodeB64("5T9"); |
| Assert.assertEquals(22345, val22345); |
| |
| long val92345 = LongEncoding.decodeB64("MYu"); |
| Assert.assertEquals(92345, val92345); |
| |
| long val12345678 = LongEncoding.decodeB64("k65E"); |
| Assert.assertEquals(12345678, val12345678); |
| |
| long val112345678 = LongEncoding.decodeB64("6h_9E"); |
| Assert.assertEquals(112345678, val112345678); |
| |
| long valIntMax = LongEncoding.decodeB64("1~~~~~"); |
| Assert.assertEquals(Integer.MAX_VALUE, valIntMax); |
| |
| long valLongMax = LongEncoding.decodeB64("7~~~~~~~~~~"); |
| Assert.assertEquals(Long.MAX_VALUE, valLongMax); |
| } |
| |
| @Test |
| public void testDecodeWithError() { |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.decode("1", ""); |
| }, e -> { |
| Assert.assertEquals("The symbols parameter can't be empty", |
| e.getMessage()); |
| }); |
| |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.decode("1a", "0123456789"); |
| }, e -> { |
| Assert.assertEquals("Can't decode symbol 'a' in string '1a'", |
| e.getMessage()); |
| }); |
| } |
| |
| @Test |
| public void testEncodeSignedB64() { |
| String val1234 = LongEncoding.encodeSignedB64(1234); |
| Assert.assertEquals("JI", val1234); |
| |
| String val23 = LongEncoding.encodeSignedB64(23); |
| Assert.assertEquals("N", val23); |
| |
| String valIntMax = LongEncoding.encodeSignedB64(Integer.MAX_VALUE); |
| Assert.assertEquals("1~~~~~", valIntMax); |
| |
| String valLongMax = LongEncoding.encodeSignedB64(Long.MAX_VALUE); |
| Assert.assertEquals("7~~~~~~~~~~", valLongMax); |
| |
| String val0 = LongEncoding.encodeSignedB64(0); |
| Assert.assertEquals("0", val0); |
| |
| String valNeg1 = LongEncoding.encodeSignedB64(-1); |
| Assert.assertEquals("-1", valNeg1); |
| |
| String valIntMinP1 = LongEncoding.encodeSignedB64(Integer.MIN_VALUE + |
| 1L); |
| Assert.assertEquals("-1~~~~~", valIntMinP1); |
| |
| String valIntMin = LongEncoding.encodeSignedB64(Integer.MIN_VALUE); |
| Assert.assertEquals("-200000", valIntMin); |
| |
| String valLongMinPlus1 = LongEncoding.encodeSignedB64(Long.MIN_VALUE + |
| 1L); |
| Assert.assertEquals("-7~~~~~~~~~~", valLongMinPlus1); |
| |
| String valLongMin = LongEncoding.encodeSignedB64(Long.MIN_VALUE); |
| Assert.assertEquals("-80000000000", valLongMin); |
| } |
| |
| @Test |
| public void testDecodeSignedB64() { |
| long val1234 = LongEncoding.decodeSignedB64("JI"); |
| Assert.assertEquals(1234, val1234); |
| |
| long val23 = LongEncoding.decodeSignedB64("N"); |
| Assert.assertEquals(23, val23); |
| |
| long valIntMax = LongEncoding.decodeSignedB64("1~~~~~"); |
| Assert.assertEquals(Integer.MAX_VALUE, valIntMax); |
| |
| long valLongMax = LongEncoding.decodeSignedB64("7~~~~~~~~~~"); |
| Assert.assertEquals(Long.MAX_VALUE, valLongMax); |
| |
| long val0 = LongEncoding.decodeSignedB64("0"); |
| Assert.assertEquals(0, val0); |
| |
| long valn1 = LongEncoding.decodeSignedB64("-1"); |
| Assert.assertEquals(-1, valn1); |
| |
| long valIntMinPlus1 = LongEncoding.decodeSignedB64("-1~~~~~"); |
| Assert.assertEquals(Integer.MIN_VALUE + 1L, valIntMinPlus1); |
| |
| long valIntMin = LongEncoding.decodeSignedB64("-200000"); |
| Assert.assertEquals(Integer.MIN_VALUE, valIntMin); |
| |
| long valLongMinPlus1 = LongEncoding.decodeSignedB64("-7~~~~~~~~~~"); |
| Assert.assertEquals(Long.MIN_VALUE + 1L, valLongMinPlus1); |
| |
| long valLongMin = LongEncoding.decodeSignedB64("-80000000000"); |
| Assert.assertEquals(Long.MIN_VALUE, valLongMin); |
| } |
| |
| @Test |
| public void testDecodeSignedB64Overflow() { |
| long valOverflow = LongEncoding.decodeSignedB64("80000000000"); |
| Assert.assertEquals(Long.MIN_VALUE, valOverflow); |
| |
| long valOverflow2 = LongEncoding.decodeSignedB64("80000000001"); |
| Assert.assertEquals(Long.MIN_VALUE + 1L, valOverflow2); |
| |
| long valOverflow3 = LongEncoding.decodeSignedB64("800000000001"); |
| Assert.assertEquals(1L, valOverflow3); |
| |
| long valOverflow4 = LongEncoding.decodeSignedB64("80000000000JI"); |
| Assert.assertEquals(1234L, valOverflow4); |
| |
| long valOverflow5 = LongEncoding.decodeSignedB64("80000000000N"); |
| Assert.assertEquals(23L, valOverflow5); |
| |
| long valOverflow6 = LongEncoding.decodeSignedB64("80000000000" + |
| "7~~~~~~~~~~"); |
| Assert.assertEquals(Long.MAX_VALUE, valOverflow6); |
| } |
| |
| @Test |
| public void testEncodeSortable() { |
| String val1234 = LongEncoding.encodeSortable(1234); |
| Assert.assertEquals("2JI", val1234); |
| |
| String val23 = LongEncoding.encodeSortable(23); |
| Assert.assertEquals("1N", val23); |
| |
| String valIntMax = LongEncoding.encodeSortable(Integer.MAX_VALUE); |
| Assert.assertEquals("61~~~~~", valIntMax); |
| |
| String valLongMax = LongEncoding.encodeSortable(Long.MAX_VALUE); |
| Assert.assertEquals("B7~~~~~~~~~~", valLongMax); |
| |
| String val0 = LongEncoding.encodeSortable(0); |
| Assert.assertEquals("10", val0); |
| |
| String valNeg1 = LongEncoding.encodeSortable(-1); |
| Assert.assertEquals("0B7~~~~~~~~~~", valNeg1); |
| |
| String valIntMin = LongEncoding.encodeSortable(Integer.MIN_VALUE); |
| Assert.assertEquals("0B7~~~~z00000", valIntMin); |
| |
| String valLongMin = LongEncoding.encodeSortable(Long.MIN_VALUE); |
| Assert.assertEquals("010", valLongMin); |
| } |
| |
| @Test |
| public void testDecodeSortable() { |
| long val1234 = LongEncoding.decodeSortable("2JI"); |
| Assert.assertEquals(1234, val1234); |
| |
| long val23 = LongEncoding.decodeSortable("1N"); |
| Assert.assertEquals(23, val23); |
| |
| long valIntMax = LongEncoding.decodeSortable("61~~~~~"); |
| Assert.assertEquals(Integer.MAX_VALUE, valIntMax); |
| |
| long valLongMax = LongEncoding.decodeSortable("B7~~~~~~~~~~"); |
| Assert.assertEquals(Long.MAX_VALUE, valLongMax); |
| |
| long val0 = LongEncoding.decodeSortable("10"); |
| Assert.assertEquals(0, val0); |
| |
| long valn1 = LongEncoding.decodeSortable("0B7~~~~~~~~~~"); |
| Assert.assertEquals(-1, valn1); |
| |
| long valIntMin = LongEncoding.decodeSortable("0B7~~~~z00000"); |
| Assert.assertEquals(Integer.MIN_VALUE, valIntMin); |
| |
| long valLongMin = LongEncoding.decodeSortable("010"); |
| Assert.assertEquals(Long.MIN_VALUE, valLongMin); |
| } |
| |
| @Test |
| public void testDecodeIllegalSortable() { |
| // Length is 1, actual length is 0 |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.decodeSortable("1"); |
| }); |
| |
| // Length is 1, actual length is 2 |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.decodeSortable("123"); |
| }); |
| |
| // Length is 1, actual length is 0 |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.decodeSortable("01"); |
| }); |
| |
| // Length is 1, actual length is 2 |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| LongEncoding.decodeSortable("0123"); |
| }); |
| } |
| |
| @Test |
| public void testEncodeNumber() throws ParseException { |
| String l1234 = LongEncoding.encodeNumber(1234); |
| Assert.assertEquals("2JI", l1234); |
| |
| String d1234 = LongEncoding.encodeNumber(1.234); |
| Assert.assertEquals("B3~okcR8i3aO", d1234); |
| |
| String d21 = LongEncoding.encodeNumber(2.1); |
| Assert.assertEquals("B400oCoCoCoD", d21); |
| |
| String dpi = LongEncoding.encodeNumber(3.1415926); |
| Assert.assertEquals("B4098ViD4iXA", dpi); |
| |
| String fpi = LongEncoding.encodeNumber(3.1415926f); |
| Assert.assertEquals("610IG~Q", fpi); |
| |
| String fn1 = LongEncoding.encodeNumber(-1.0f); |
| Assert.assertEquals("0B7~~~~~0V~~~", fn1); |
| |
| String bMax = LongEncoding.encodeNumber(Byte.MAX_VALUE); |
| Assert.assertEquals("21~", bMax); |
| |
| String bMin = LongEncoding.encodeNumber(Byte.MIN_VALUE); |
| Assert.assertEquals("0B7~~~~~~~~z0", bMin); |
| |
| String sMax = LongEncoding.encodeNumber(Short.MAX_VALUE); |
| Assert.assertEquals("37~~", sMax); |
| |
| String sMin = LongEncoding.encodeNumber(Short.MIN_VALUE); |
| Assert.assertEquals("0B7~~~~~~~t00", sMin); |
| |
| String iMax = LongEncoding.encodeNumber(Integer.MAX_VALUE); |
| Assert.assertEquals("61~~~~~", iMax); |
| |
| String iMin = LongEncoding.encodeNumber(Integer.MIN_VALUE); |
| Assert.assertEquals("0B7~~~~z00000", iMin); |
| |
| String lMax = LongEncoding.encodeNumber(Long.MAX_VALUE); |
| Assert.assertEquals("B7~~~~~~~~~~", lMax); |
| |
| String lMin = LongEncoding.encodeNumber(Long.MIN_VALUE); |
| Assert.assertEquals("010", lMin); |
| |
| String fMax = LongEncoding.encodeNumber(Float.MAX_VALUE); |
| Assert.assertEquals("61~V~~~", fMax); |
| |
| String fMin = LongEncoding.encodeNumber(Float.MIN_VALUE); |
| Assert.assertEquals("11", fMin); |
| |
| String dMax = LongEncoding.encodeNumber(Double.MAX_VALUE); |
| Assert.assertEquals("B7~k~~~~~~~~", dMax); |
| |
| String dMin = LongEncoding.encodeNumber(Double.MIN_VALUE); |
| Assert.assertEquals("11", dMin); |
| |
| String bdLong = LongEncoding.encodeNumber(new BigDecimal("1234")); |
| Assert.assertEquals("2JI", bdLong); |
| |
| String bdFLong = LongEncoding.encodeNumber(new BigDecimal("1234.00")); |
| Assert.assertEquals("2JI", bdFLong); |
| |
| String bdDouble = LongEncoding.encodeNumber(new BigDecimal("1.234")); |
| Assert.assertEquals("B3~okcR8i3aO", bdDouble); |
| |
| SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); |
| dateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai")); |
| Date time = dateFormat.parse("2018-12-18"); |
| String date = LongEncoding.encodeNumber(time); |
| Assert.assertEquals("7MUxuK00", date); |
| } |
| |
| @Test |
| public void testDecodeNumber() { |
| Number l1234 = LongEncoding.decodeNumber("2JI", Long.class); |
| Assert.assertEquals(1234L, l1234); |
| |
| Number d1234 = LongEncoding.decodeNumber("B3~okcR8i3aO", Double.class); |
| Assert.assertEquals(1.234, d1234); |
| |
| Number d21 = LongEncoding.decodeNumber("B400oCoCoCoD", Double.class); |
| Assert.assertEquals(2.1, d21); |
| |
| Number dpi = LongEncoding.decodeNumber("B4098ViD4iXA", Double.class); |
| Assert.assertEquals(3.1415926, dpi); |
| |
| Number fpi = LongEncoding.decodeNumber("610IG~Q", Float.class); |
| Assert.assertEquals(3.1415926f, fpi); |
| |
| Number fn1 = LongEncoding.decodeNumber("0B7~~~~~0V~~~", Float.class); |
| Assert.assertEquals(-1.0f, fn1); |
| |
| Number bMax = LongEncoding.decodeNumber("21~", Byte.class); |
| Assert.assertEquals(Byte.MAX_VALUE, bMax); |
| |
| Number bMin = LongEncoding.decodeNumber("0B7~~~~~~~~z0", Byte.class); |
| Assert.assertEquals(Byte.MIN_VALUE, bMin); |
| |
| Number sMax = LongEncoding.decodeNumber("37~~", Short.class); |
| Assert.assertEquals(Short.MAX_VALUE, sMax); |
| |
| Number sMin = LongEncoding.decodeNumber("0B7~~~~~~~t00", Short.class); |
| Assert.assertEquals(Short.MIN_VALUE, sMin); |
| |
| Number iMax = LongEncoding.decodeNumber("61~~~~~", Integer.class); |
| Assert.assertEquals(Integer.MAX_VALUE, iMax); |
| |
| Number iMin = LongEncoding.decodeNumber("0B7~~~~z00000", Integer.class); |
| Assert.assertEquals(Integer.MIN_VALUE, iMin); |
| |
| Number lMax = LongEncoding.decodeNumber("B7~~~~~~~~~~", Long.class); |
| Assert.assertEquals(Long.MAX_VALUE, lMax); |
| |
| Number lMin = LongEncoding.decodeNumber("010", Long.class); |
| Assert.assertEquals(Long.MIN_VALUE, lMin); |
| |
| Number fMax = LongEncoding.decodeNumber("61~V~~~", Float.class); |
| Assert.assertEquals(Float.MAX_VALUE, fMax); |
| |
| Number fMin = LongEncoding.decodeNumber("11", Float.class); |
| Assert.assertEquals(Float.MIN_VALUE, fMin); |
| |
| Number dMax = LongEncoding.decodeNumber("B7~k~~~~~~~~", Double.class); |
| Assert.assertEquals(Double.MAX_VALUE, dMax); |
| |
| Number dMin = LongEncoding.decodeNumber("11", Double.class); |
| Assert.assertEquals(Double.MIN_VALUE, dMin); |
| } |
| |
| @Test |
| public void testEncodeSortableThenCompare() { |
| int count = 100000; |
| Random random1 = new Random(); |
| Random random2 = new Random(); |
| for (int i = 0; i < count; i++) { |
| long num1 = random1.nextLong(); |
| long num2 = random2.nextLong(); |
| |
| String encoded1 = LongEncoding.encodeSortable(num1); |
| String encoded2 = LongEncoding.encodeSortable(num2); |
| int cmp = Bytes.compare(encoded1.getBytes(), encoded2.getBytes()); |
| |
| if (num1 == num2) { |
| Assert.assertTrue(cmp == 0); |
| } else if (num1 > num2) { |
| Assert.assertTrue(cmp > 0); |
| } else { |
| assert num1 < num2; |
| Assert.assertTrue(cmp < 0); |
| } |
| } |
| } |
| |
| @Test |
| public void testEncodeNumberThenCompare() { |
| int count = 100000; |
| Random random1 = new Random(); |
| Random random2 = new Random(); |
| |
| for (int i = 0; i < count; i++) { |
| compareEncodedNumber(random1.nextInt(), random2.nextInt()); |
| } |
| for (int i = 0; i < count; i++) { |
| compareEncodedNumber(random1.nextLong(), random2.nextLong()); |
| } |
| |
| for (int i = 0; i < count; i++) { |
| compareEncodedNumber(random1.nextInt(), random2.nextLong()); |
| } |
| for (int i = 0; i < count; i++) { |
| compareEncodedNumber(random1.nextLong(), random2.nextInt()); |
| } |
| |
| for (int i = 0; i < count; i++) { |
| compareEncodedNumber(random1.nextFloat(), random2.nextFloat()); |
| } |
| for (int i = 0; i < count; i++) { |
| compareEncodedNumber(random1.nextDouble(), random2.nextDouble()); |
| } |
| } |
| |
| private static void compareEncodedNumber(Number num1, Number num2) { |
| int cmpExpected = NumericUtil.compareNumber(num1, num2); |
| |
| String encoded1 = LongEncoding.encodeNumber(num1); |
| String encoded2 = LongEncoding.encodeNumber(num2); |
| int cmp = Bytes.compare(encoded1.getBytes(), encoded2.getBytes()); |
| |
| if (cmpExpected == 0) { |
| Assert.assertTrue(cmp == 0); |
| } else if (cmpExpected > 0) { |
| Assert.assertTrue(cmp > 0); |
| } else { |
| assert cmpExpected < 0; |
| Assert.assertTrue(cmp < 0); |
| } |
| } |
| } |
