@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); }
/** * Builds a lexicographically sortable binary key based on a primary key descriptor. * * @param m a spanner mutation. * @return a binary string that preserves the ordering of the primary key. */ public byte[] encodeTableNameAndKey(Mutation m) { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytes(m.getTable().getBytes(StandardCharsets.UTF_8)); if (m.getOperation() == Op.DELETE) { if (isPointDelete(m)) { Key next = m.getKeySet().getKeys().iterator().next(); encodeKey(orderedCode, m.getTable(), next); } else { // The key is left empty for non-point deletes, since there is no general way to batch them. } } else { encodeKey(orderedCode, m); } return orderedCode.getEncodedBytes(); }
@Override byte[] encodeIncreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytes(bytesFromHexString(value())); return orderedCode.getEncodedBytes(); }
@Override byte[] encodeIncreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumIncreasing(value()); return orderedCode.getEncodedBytes(); }
@Override byte[] encodeDecreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytesDecreasing(bytesFromHexString(value())); return orderedCode.getEncodedBytes(); }
@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 testWriteTrailingBytes() { byte[] escapeChars = new byte[] { OrderedCode.ESCAPE1, OrderedCode.NULL_CHARACTER, OrderedCode.SEPARATOR, OrderedCode.ESCAPE2, OrderedCode.INFINITY, OrderedCode.FF_CHARACTER }; byte[] anotherArray = new byte[] {'a', 'b', 'c', 'd', 'e'}; OrderedCode orderedCode = new OrderedCode(); orderedCode.writeTrailingBytes(escapeChars); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), escapeChars)); assertTrue(Arrays.equals(orderedCode.readTrailingBytes(), escapeChars)); try { orderedCode.readInfinity(); fail("Expected IllegalArgumentException."); } catch (IllegalArgumentException e) { // expected } orderedCode = new OrderedCode(); orderedCode.writeTrailingBytes(anotherArray); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), anotherArray)); assertTrue(Arrays.equals(orderedCode.readTrailingBytes(), anotherArray)); }
@Test public void testWriteBytesDecreasing() { byte[] first = {'a', 'b', 'c'}; byte[] second = {'d', 'e', 'f'}; byte[] last = {'x', 'y', 'z'}; OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytesDecreasing(first); byte[] firstEncoded = orderedCode.getEncodedBytes(); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), first)); orderedCode.writeBytesDecreasing(first); orderedCode.writeBytesDecreasing(second); orderedCode.writeBytesDecreasing(last); byte[] allEncoded = orderedCode.getEncodedBytes(); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), first)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), second)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), last)); orderedCode = new OrderedCode(firstEncoded); orderedCode.writeBytesDecreasing(second); orderedCode.writeBytesDecreasing(last); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), allEncoded)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), first)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), second)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), last)); orderedCode = new OrderedCode(allEncoded); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), first)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), second)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), last)); }
@Test public void testWriteBytes() { byte[] first = {'a', 'b', 'c'}; byte[] second = {'d', 'e', 'f'}; byte[] last = {'x', 'y', 'z'}; OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytes(first); byte[] firstEncoded = orderedCode.getEncodedBytes(); assertTrue(Arrays.equals(orderedCode.readBytes(), first)); orderedCode.writeBytes(first); orderedCode.writeBytes(second); orderedCode.writeBytes(last); byte[] allEncoded = orderedCode.getEncodedBytes(); assertTrue(Arrays.equals(orderedCode.readBytes(), first)); assertTrue(Arrays.equals(orderedCode.readBytes(), second)); assertTrue(Arrays.equals(orderedCode.readBytes(), last)); orderedCode = new OrderedCode(firstEncoded); orderedCode.writeBytes(second); orderedCode.writeBytes(last); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), allEncoded)); assertTrue(Arrays.equals(orderedCode.readBytes(), first)); assertTrue(Arrays.equals(orderedCode.readBytes(), second)); assertTrue(Arrays.equals(orderedCode.readBytes(), last)); orderedCode = new OrderedCode(allEncoded); assertTrue(Arrays.equals(orderedCode.readBytes(), first)); assertTrue(Arrays.equals(orderedCode.readBytes(), second)); assertTrue(Arrays.equals(orderedCode.readBytes(), last)); }
assertTrue( Arrays.equals( orderedCode.getEncodedBytes(), Bytes.concat( ffCharEncoded,
orderedCode.writeSignedNumIncreasing(Long.MAX_VALUE); orderedCode.writeTrailingBytes(escapeChars); byte[] allEncoded = orderedCode.getEncodedBytes(); assertTrue(Arrays.equals(orderedCode.readBytes(), first)); assertTrue(Arrays.equals(orderedCode.readBytes(), second)); assertEquals(Long.MIN_VALUE, orderedCode.readSignedNumIncreasing()); assertEquals(Long.MAX_VALUE, orderedCode.readSignedNumIncreasing()); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), escapeChars)); assertTrue(Arrays.equals(orderedCode.readTrailingBytes(), escapeChars)); assertEquals(Long.MIN_VALUE, orderedCode.readSignedNumIncreasing()); assertEquals(Long.MAX_VALUE, orderedCode.readSignedNumIncreasing()); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), escapeChars)); assertTrue(Arrays.equals(orderedCode.readTrailingBytes(), escapeChars));