abstract T decodeDecreasing(OrderedCode orderedCode); }
@Override byte[] encodeDecreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytesDecreasing(bytesFromHexString(value())); return orderedCode.getEncodedBytes(); }
@Override byte[] encodeIncreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumIncreasing(value()); return orderedCode.getEncodedBytes(); }
/** * OrderedCode.log2Floor(long) is defined to return -1 given an input of zero (because that's what * Bits::Log2Floor64(uint64) does). */ @Test public void testLog2Floor_zero() { OrderedCode orderedCode = new OrderedCode(); assertEquals(-1, orderedCode.log2Floor(0)); }
@Override byte[] encodeIncreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytes(bytesFromHexString(value())); return orderedCode.getEncodedBytes(); }
@Test public void testLog2Floor_negative() { OrderedCode orderedCode = new OrderedCode(); try { orderedCode.log2Floor(-1); fail("Expected an IllegalArgumentException."); } catch (IllegalArgumentException expected) { // Expected! } }
@Override byte[] encodeDecreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumDecreasing(value()); return orderedCode.getEncodedBytes(); }
/** Ensures that numbers encoded as "decreasing" do indeed sort in reverse order. */ @Test public void testDecreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeSignedNumDecreasing(10L); byte[] ten = orderedCode.getEncodedBytes(); orderedCode = new OrderedCode(); orderedCode.writeSignedNumDecreasing(20L); byte[] twenty = orderedCode.getEncodedBytes(); // In decreasing order, twenty preceeds ten. assertTrue(compare(twenty, ten) < 0); }
/** * Assert that encoding the specified long via {@link OrderedCode#writeSignedNumIncreasing(long)} * results in the bytes represented by the specified string of hex digits. E.g. * assertSignedNumIncreasingEncodingEquals("3fbf", -65) asserts that -65 is encoded as { (byte) * 0x3f, (byte) 0xbf }. */ private static void assertSignedNumIncreasingEncodingEquals( String expectedHexEncoding, long num) { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeSignedNumIncreasing(num); assertEquals( "Unexpected encoding for " + num, expectedHexEncoding, bytesToHexString(orderedCode.getEncodedBytes())); }
@Test public void testOrderingInfinity() { OrderedCode inf = new OrderedCode(); inf.writeInfinity(); OrderedCode negInf = new OrderedCode(); negInf.writeInfinityDecreasing(); OrderedCode longValue = new OrderedCode(); longValue.writeSignedNumIncreasing(1); assertTrue(compare(inf.getEncodedBytes(), negInf.getEncodedBytes()) > 0); assertTrue(compare(longValue.getEncodedBytes(), negInf.getEncodedBytes()) > 0); assertTrue(compare(inf.getEncodedBytes(), longValue.getEncodedBytes()) > 0); }
/** * Assert that encoding (via {@link OrderedCode#writeSignedNumDecreasing(long)}) the specified * long value and then decoding (via {@link OrderedCode#readSignedNumDecreasing()}) results in the * original value. */ private static void assertSignedNumDecreasingWriteAndReadIsLossless(long num) { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeSignedNumDecreasing(num); assertEquals( "Unexpected result when decoding writeSignedNumDecreasing(" + num + ")", num, orderedCode.readSignedNumDecreasing()); assertFalse( "Unexpected remaining encoded bytes after decoding " + num, orderedCode.hasRemainingEncodedBytes()); }
/** * Assert that encoding (via {@link OrderedCode#writeSignedNumIncreasing(long)}) the specified * long value and then decoding (via {@link OrderedCode#readSignedNumIncreasing()}) results in the * original value. */ private static void assertSignedNumIncreasingWriteAndReadIsLossless(long num) { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeSignedNumIncreasing(num); assertEquals( "Unexpected result when decoding writeSignedNumIncreasing(" + num + ")", num, orderedCode.readSignedNumIncreasing()); assertFalse( "Unexpected remaining encoded bytes after decoding " + num, orderedCode.hasRemainingEncodedBytes()); }
/** * Assert that decoding (via {@link OrderedCode#readSignedNumIncreasing()}) the bytes represented * by the specified string of hex digits results in the expected long value. E.g. * assertDecodedSignedNumIncreasingEquals(-65, "3fbf") asserts that the byte array { (byte) 0x3f, * (byte) 0xbf } is decoded as -65. */ private static void assertDecodedSignedNumIncreasingEquals( long expectedNum, String encodedHexString) { OrderedCode orderedCode = new OrderedCode(bytesFromHexString(encodedHexString)); assertEquals( "Unexpected value when decoding 0x" + encodedHexString, expectedNum, orderedCode.readSignedNumIncreasing()); assertFalse( "Unexpected encoded bytes remain after decoding 0x" + encodedHexString, orderedCode.hasRemainingEncodedBytes()); }
@Test public void testWriteInfinity() { OrderedCode orderedCode = new OrderedCode(); try { orderedCode.readInfinity(); fail("Expected IllegalArgumentException."); } catch (IllegalArgumentException e) { // expected } orderedCode.writeInfinity(); assertTrue(orderedCode.readInfinity()); try { orderedCode.readInfinity(); fail("Expected IllegalArgumentException."); } catch (IllegalArgumentException e) { // expected } }
@Test public void testWriteInfinityDecreasing() { OrderedCode orderedCode = new OrderedCode(); try { orderedCode.readInfinityDecreasing(); fail("Expected IllegalArgumentException."); } catch (IllegalArgumentException e) { // expected } orderedCode.writeInfinityDecreasing(); assertTrue(orderedCode.readInfinityDecreasing()); try { orderedCode.readInfinityDecreasing(); fail("Expected IllegalArgumentException."); } catch (IllegalArgumentException e) { // expected } }
@Test public void testWriteNumDecreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumDecreasing(0); orderedCode.writeNumDecreasing(1); orderedCode.writeNumDecreasing(Long.MIN_VALUE); orderedCode.writeNumDecreasing(Long.MAX_VALUE); assertEquals(0, orderedCode.readNumDecreasing()); assertEquals(1, orderedCode.readNumDecreasing()); assertEquals(Long.MIN_VALUE, orderedCode.readNumDecreasing()); assertEquals(Long.MAX_VALUE, orderedCode.readNumDecreasing()); }
@Test public void testWriteNumIncreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumIncreasing(0); orderedCode.writeNumIncreasing(1); orderedCode.writeNumIncreasing(Long.MIN_VALUE); orderedCode.writeNumIncreasing(Long.MAX_VALUE); assertEquals(0, orderedCode.readNumIncreasing()); assertEquals(1, orderedCode.readNumIncreasing()); assertEquals(Long.MIN_VALUE, orderedCode.readNumIncreasing()); assertEquals(Long.MAX_VALUE, orderedCode.readNumIncreasing()); }
@Test public void testLog2Floor_Positive() { OrderedCode orderedCode = new OrderedCode(); assertEquals(0, orderedCode.log2Floor(1)); assertEquals(1, orderedCode.log2Floor(2)); assertEquals(1, orderedCode.log2Floor(3)); assertEquals(2, orderedCode.log2Floor(4)); assertEquals(5, orderedCode.log2Floor(63)); assertEquals(6, orderedCode.log2Floor(64)); assertEquals(62, orderedCode.log2Floor(Long.MAX_VALUE)); }
@Test public void testWriteNumIncreasing_unsignedInt() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumIncreasing(UnsignedInteger.fromIntBits(0)); orderedCode.writeNumIncreasing(UnsignedInteger.fromIntBits(1)); orderedCode.writeNumIncreasing(UnsignedInteger.fromIntBits(Integer.MIN_VALUE)); orderedCode.writeNumIncreasing(UnsignedInteger.fromIntBits(Integer.MAX_VALUE)); assertEquals(0, orderedCode.readNumIncreasing()); assertEquals(1, orderedCode.readNumIncreasing()); assertEquals((long) Integer.MAX_VALUE + 1L, orderedCode.readNumIncreasing()); assertEquals(Integer.MAX_VALUE, orderedCode.readNumIncreasing()); }
@Test public void testWriteNumDecreasing_unsignedInt() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumDecreasing(UnsignedInteger.fromIntBits(0)); orderedCode.writeNumDecreasing(UnsignedInteger.fromIntBits(1)); orderedCode.writeNumDecreasing(UnsignedInteger.fromIntBits(Integer.MIN_VALUE)); orderedCode.writeNumDecreasing(UnsignedInteger.fromIntBits(Integer.MAX_VALUE)); assertEquals(0, orderedCode.readNumDecreasing()); assertEquals(1, orderedCode.readNumDecreasing()); assertEquals((long) Integer.MAX_VALUE + 1L, orderedCode.readNumDecreasing()); assertEquals(Integer.MAX_VALUE, orderedCode.readNumDecreasing()); }