org.apache.hadoop.hbase.util.Order#DESCENDING源码实例Demo

@Test
public void testReadWrite() {
  for (int limit : limits) {
    PositionedByteRange buff = new SimplePositionedMutableByteRange(limit);
    for (Order ord : new Order[] { Order.ASCENDING, Order.DESCENDING }) {
      for (byte[] val : VALUES) {
        buff.setPosition(0);
        DataType<byte[]> type = new FixedLengthWrapper<>(new RawBytes(ord), limit);
        assertEquals(limit, type.encode(buff, val));
        buff.setPosition(0);
        byte[] actual = type.decode(buff);
        assertTrue("Decoding output differs from expected",
          Bytes.equals(val, 0, val.length, actual, 0, val.length));
        buff.setPosition(0);
        assertEquals(limit, type.skip(buff));
      }
    }
  }
}
 

@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 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 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 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 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 testEncodedFloatLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final OrderedFloat64 type : new OrderedFloat64[] { new OrderedFloat64(Order.ASCENDING),
    new OrderedFloat64(Order.DESCENDING) }) {
    for (final Double val : VALUES) {
      buffer.setPosition(0);
      type.encodeDouble(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

@Test
public void testEncodedBigDecimalLength() {
  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_DECIMAL_VALUES) {
      buffer.setPosition(0);
      type.encode(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<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 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 testEncodedDoubleLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final OrderedNumeric type : new OrderedNumeric[] { new OrderedNumeric(Order.ASCENDING),
    new OrderedNumeric(Order.DESCENDING) }) {
    for (final Double val : DOUBLE_VALUES) {
      buffer.setPosition(0);
      type.encodeDouble(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 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 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 testEncodedFloatLength() {
  final PositionedByteRange buffer = new SimplePositionedMutableByteRange(20);
  for (final OrderedInt8 type : new OrderedInt8[] { new OrderedInt8(Order.ASCENDING),
    new OrderedInt8(Order.DESCENDING) }) {
    for (final Byte val : VALUES) {
      buffer.setPosition(0);
      type.encodeByte(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<Long> type : new OrderedInt64[] { new OrderedInt64(Order.ASCENDING),
    new OrderedInt64(Order.DESCENDING) }) {
    for (final Long 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 testEncodedLength() {
  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 : DOUBLE_VALUES) {
      buffer.setPosition(0);
      type.encode(buffer, val);
      assertEquals("encodedLength does not match actual, " + val,
          buffer.getPosition(), type.encodedLength(val));
    }
  }
}
 

public SampleUnion1() {
  super(new RawInteger(), new RawStringTerminated(Order.DESCENDING, "."));
}