@Test
public void testReadWrite() {
  for (final Order ord : new Order[] { Order.ASCENDING, Order.DESCENDING }) {
    final RawString type =
        Order.ASCENDING == ord ? new RawString(Order.ASCENDING) : new RawString(Order.DESCENDING);
    for (final String val : VALUES) {
      final PositionedByteRange buff =
          new SimplePositionedMutableByteRange(Bytes.toBytes(val).length);
      assertEquals(buff.getLength(), type.encode(buff, val));
      final byte[] expected = Bytes.toBytes(val);
      ord.apply(expected);
      assertArrayEquals(expected, buff.getBytes());
      buff.setPosition(0);
      assertEquals(val, type.decode(buff));
      buff.setPosition(0);
      assertEquals(buff.getLength(), type.skip(buff));
      assertEquals(buff.getLength(), buff.getPosition());
    }
  }
}
 

@Test
public void testReadWriteNonSkippable() {
  PositionedByteRange buff = new SimplePositionedMutableByteRange(12);
  for (Order ord : new Order[] { Order.ASCENDING, Order.DESCENDING }) {
    for (byte[] term : TERMINATORS) {
      for (byte[] val : VALUES_BYTES) {
        buff.setPosition(0);
        DataType<byte[]> type = new TerminatedWrapper<>(new RawBytes(ord), term);
        assertEquals(val.length + term.length, type.encode(buff, val));
        buff.setPosition(0);
        assertArrayEquals(val, type.decode(buff));
        assertEquals(val.length + term.length, buff.getPosition());
      }
    }
  }
}
 

@Test
public void testSkipNonSkippable() {
  PositionedByteRange buff = new SimplePositionedMutableByteRange(12);
  for (Order ord : new Order[] { Order.ASCENDING, Order.DESCENDING }) {
    for (byte[] term : TERMINATORS) {
      for (byte[] val : VALUES_BYTES) {
        buff.setPosition(0);
        DataType<byte[]> type = new TerminatedWrapper<>(new RawBytes(ord), term);
        int expected = type.encode(buff, val);
        buff.setPosition(0);
        assertEquals(expected, type.skip(buff));
        assertEquals(expected, buff.getPosition());
      }
    }
  }
}
 

@Test
public void testReadWriteSkippable() {
  final PositionedByteRange buff = new SimplePositionedMutableByteRange(14);
  for (final OrderedString t : new OrderedString[] {
    new OrderedString(Order.ASCENDING), new OrderedString(Order.DESCENDING)
  }) {
    for (final byte[] term : TERMINATORS) {
      for (final String val : VALUES_STRINGS) {
        buff.setPosition(0);
        final DataType<String> type = new TerminatedWrapper<>(t, term);
        assertEquals(val.length() + 2 + term.length, type.encode(buff, val));
        buff.setPosition(0);
        assertEquals(val, type.decode(buff));
        assertEquals(val.length() + 2 + term.length, buff.getPosition());
      }
    }
  }
}
 

@Test
public void testSkipSkippable() {
  final PositionedByteRange buff = new SimplePositionedMutableByteRange(14);
  for (final OrderedString t : new OrderedString[] {
    new OrderedString(Order.ASCENDING), new OrderedString(Order.DESCENDING)
  }) {
    for (final byte[] term : TERMINATORS) {
      for (final String val : VALUES_STRINGS) {
        buff.setPosition(0);
        final DataType<String> type = new TerminatedWrapper<>(t, term);
        final int expected = val.length() + 2 + term.length;
        assertEquals(expected, type.encode(buff, val));
        buff.setPosition(0);
        assertEquals(expected, type.skip(buff));
        assertEquals(expected, buff.getPosition());
      }
    }
  }
}
 

@Test
public void testEncodedLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final DataType<Byte> type : new OrderedInt8[] { new OrderedInt8(Order.ASCENDING),
    new OrderedInt8(Order.DESCENDING) }) {
    for (final Byte val : VALUES) {
      buffer.setPosition(0);
      type.encode(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedLongLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final OrderedNumeric type : new OrderedNumeric[] { new OrderedNumeric(Order.ASCENDING),
    new OrderedNumeric(Order.DESCENDING) }) {
    for (final Long val : LONG_VALUES) {
      buffer.setPosition(0);
      type.encodeLong(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final DataType<Integer> type : new OrderedInt32[] { new OrderedInt32(Order.ASCENDING),
    new OrderedInt32(Order.DESCENDING) }) {
    for (final Integer val : VALUES) {
      buffer.setPosition(0);
      type.encode(buffer, val);
      assertEquals(
          "encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedBigIntegerLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final DataType<Number> type : new OrderedNumeric[] { new OrderedNumeric(Order.ASCENDING),
    new OrderedNumeric(Order.DESCENDING) }) {
    for (final Number val : BIG_INTEGER_VALUES) {
      buffer.setPosition(0);
      type.encode(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Override
public String decode(PositionedByteRange src) {
  if (Order.ASCENDING == this.order) {
    // avoid unnecessary array copy for ASC case.
    String val =
        Bytes.toString(src.getBytes(), src.getOffset() + src.getPosition(), src.getRemaining());
    src.setPosition(src.getLength());
    return val;
  } else {
    byte[] b = new byte[src.getRemaining()];
    src.get(b);
    order.apply(b, 0, b.length);
    return Bytes.toString(b);
  }
}
 

@Test
public void testEncodedFloatLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final OrderedInt32 type : new OrderedInt32[] { new OrderedInt32(Order.ASCENDING),
    new OrderedInt32(Order.DESCENDING) }) {
    for (final Integer val : VALUES) {
      buffer.setPosition(0);
      type.encodeInt(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodeNoSupportForNull() {
  exception.expect(IllegalArgumentException.class);

  final DataType<Byte> type = new OrderedInt8(Order.ASCENDING);

  type.encode(new SimplePositionedMutableByteRange(20), null);
}
 

@Test
public void testEncodedLength() {
  PositionedByteRange buff = new SimplePositionedMutableByteRange(20);
  for (final DataType<byte[]> type : new OrderedBlob[] { new OrderedBlob(Order.ASCENDING),
    new OrderedBlob(Order.DESCENDING) }) {
    for (final byte[] val : VALUES) {
      buff.setPosition(0);
      type.encode(buff, val);
      assertEquals("encodedLength does not match actual, " + Bytes.toStringBinary(val),
        buff.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final DataType<Double> type : new OrderedFloat64[] { new OrderedFloat64(Order.ASCENDING),
    new OrderedFloat64(Order.DESCENDING) }) {
    for (final Double val : VALUES) {
      buffer.setPosition(0);
      type.encode(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodeNoSupportForNull() {
  exception.expect(IllegalArgumentException.class);

  final DataType<Double> type = new OrderedFloat64(Order.ASCENDING);

  type.encode(new SimplePositionedMutableByteRange(20), null);
}
 

@Test
public void testEncodedFloatLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final OrderedInt16 type : new OrderedInt16[] { new OrderedInt16(Order.ASCENDING),
    new OrderedInt16(Order.DESCENDING) }) {
    for (final Short val : VALUES) {
      buffer.setPosition(0);
      type.encodeShort(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedLength() {
  final PositionedByteRange buff = new SimplePositionedMutableByteRange(20);
  for (final DataType<byte[]> type :
    new OrderedBlobVar[] { new OrderedBlobVar(Order.ASCENDING),
      new OrderedBlobVar(Order.DESCENDING) }) {
    for (final byte[] val : VALUES) {
      buff.setPosition(0);
      type.encode(buff, val);
      assertEquals("encodedLength does not match actual, " + Bytes.toStringBinary(val),
        buff.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final DataType<Float> type : new OrderedFloat32[] { new OrderedFloat32(Order.ASCENDING),
    new OrderedFloat32(Order.DESCENDING) }) {
    for (final Float val : VALUES) {
      buffer.setPosition(0);
      type.encode(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedFloatLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final OrderedInt64 type : new OrderedInt64[] { new OrderedInt64(Order.ASCENDING),
    new OrderedInt64(Order.DESCENDING) }) {
    for (final Long val : VALUES) {
      buffer.setPosition(0);
      type.encodeLong(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedFloatLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final OrderedFloat32 type : new OrderedFloat32[] { new OrderedFloat32(Order.ASCENDING),
    new OrderedFloat32(Order.DESCENDING) }) {
    for (final Float val : VALUES) {
      buffer.setPosition(0);
      type.encodeFloat(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final DataType<byte[]> type : new RawBytes[] { new RawBytes(Order.ASCENDING),
    new RawBytes(Order.DESCENDING) }) {
    for (final byte[] val : VALUES) {
      buffer.setPosition(0);
      type.encode(buffer, val);
      assertEquals("encodedLength does not match actual, " + Arrays.toString(val),
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedLength() {
  PositionedByteRange buff = new SimplePositionedMutableByteRange(20);
  for (final DataType<String> type : new OrderedString[] { new OrderedString(Order.ASCENDING),
    new OrderedString(Order.DESCENDING) }) {
    for (final String val : VALUES) {
      buff.setPosition(0);
      type.encode(buff, val);
      assertEquals("encodedLength does not match actual, " + val,
        buff.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final DataType<Short> type : new OrderedInt16[] { new OrderedInt16(Order.ASCENDING),
    new OrderedInt16(Order.DESCENDING) }) {
    for (final Short val : VALUES) {
      buffer.setPosition(0);
      type.encode(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test(expected = IllegalArgumentException.class)
public void testEncodedValueContainsTerm() {
  final DataType<byte[]> type = new TerminatedWrapper<>(new RawBytes(Order.ASCENDING), "foo");
  final PositionedByteRange buff = new SimplePositionedMutableByteRange(16);
  type.encode(buff, Bytes.toBytes("hello foobar!"));
}
 

@Override
public Order getOrder() {
  return Order.ASCENDING;
}
 

@Override
public Order getOrder() {
  return Order.ASCENDING;
}
 

@Override
public Order getOrder() {
  return null;
}
 

/**
 * Create a {@code RawBytesFixedLength} of the specified {@code length}.
 */
public RawBytesFixedLength(int length) {
  super(new RawBytes(Order.ASCENDING), length);
}
 

@Override
public Order getOrder() {
  return null;
}
 

@Override
public Order getOrder() {
  return base.getOrder();
}