Esempio n. 1
0
 @Test
 public void testSixLong() {
   byte[] b = new byte[8];
   for (long i = 0; i >>> 48 == 0; i = i + 1 + i / 10000) {
     DataIO.putSixLong(b, 2, i);
     assertEquals(i, DataIO.getSixLong(b, 2));
   }
 }
Esempio n. 2
0
 @Test
 public void testPackLongSize() {
   assertEquals(
       "packLongSize should have returned 1 since number 1 can be represented using 1 byte when packed",
       1,
       DataIO.packLongSize(1));
   assertEquals(
       "packLongSize should have returned 2 since 1 << 7 can be represented using 2 bytes when packed",
       2,
       DataIO.packLongSize(1 << 7));
   assertEquals(
       "packLongSize should have returned 10 since 1 << 63 can be represented using 10 bytes when packed",
       10,
       DataIO.packLongSize(1 << 63));
 }
Esempio n. 3
0
 @Test
 public void testPackLong_WithStreams() throws IOException {
   for (long valueToPack = 0;
       valueToPack < Long.MAX_VALUE && valueToPack >= 0;
       valueToPack = random.nextInt(2) + valueToPack * 2) {
     ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
     DataIO.packLong(outputStream, valueToPack);
     DataIO.packLong(outputStream, -valueToPack);
     ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
     long unpackedLong = DataIO.unpackLong(inputStream);
     assertEquals("Packed and unpacked values do not match", valueToPack, unpackedLong);
     unpackedLong = DataIO.unpackLong(inputStream);
     assertEquals("Packed and unpacked values do not match", -valueToPack, unpackedLong);
   }
 }
Esempio n. 4
0
 @Test(expected = EOFException.class)
 public void testReadFully_throws_exception_if_not_enough_data() throws IOException {
   InputStream inputStream = new ByteArrayInputStream(new byte[0]);
   DataIO.readFully(inputStream, new byte[1]);
   fail(
       "An EOFException should have occurred by now since there are not enough bytes to read from the InputStream");
 }
Esempio n. 5
0
 @Test(expected = EOFException.class)
 public void testUnpackLong_withInputStream_throws_exception_when_stream_is_empty()
     throws IOException {
   DataIO.unpackLong(new ByteArrayInputStream(new byte[0]));
   fail(
       "An EOFException should have occurred by now since there are no bytes to read from the InputStream");
 }
Esempio n. 6
0
  @Test
  public void packInt() throws IOException {
    DataInputByteArray in = new DataInputByteArray(new byte[20]);
    DataOutputByteArray out = new DataOutputByteArray();
    out.buf = in.buf;
    for (int i = 0; i > 0; i = i + 1 + i / 10000) {
      in.pos = 10;
      out.pos = 10;

      DataIO.packInt((DataOutput) out, i);
      long i2 = DataIO.unpackInt(in);

      assertEquals(i, i2);
      assertEquals(in.pos, out.pos);
    }
  }
Esempio n. 7
0
 @Test
 public void testFillLowBits() {
   for (int bitCount = 0; bitCount < 64; bitCount++) {
     assertEquals(
         "fillLowBits should return a long value with 'bitCount' least significant bits set to one",
         (1L << bitCount) - 1,
         DataIO.fillLowBits(bitCount));
   }
 }
Esempio n. 8
0
  @Test
  public void commitChecksum() {
    WriteAheadLog wal = new WriteAheadLog(null);
    wal.open(WriteAheadLog.NOREPLAY);
    wal.startNextFile();

    wal.walPutLong(111L, 1000);
    wal.commit();
    long offset1 = wal.fileOffset - 5;
    int checksum1 = DataIO.longHash(wal.curVol.hash(16, offset1 - 16, 111L));

    assertEquals(checksum1, wal.curVol.getInt(offset1 + 1));
    wal.walPutLong(111L, 1000);
    wal.commit();
    long offset2 = wal.fileOffset - 5;
    int checksum2 =
        checksum1 + DataIO.longHash(wal.curVol.hash(offset1 + 5, offset2 - offset1 - 5, 111L));
    assertEquals(checksum2, wal.curVol.getInt(offset2 + 1));
  }
Esempio n. 9
0
 @Test
 public void testPutLong() throws IOException {
   for (long valueToPut = 0;
       valueToPut < Long.MAX_VALUE && valueToPut >= 0;
       valueToPut = random.nextInt(2) + valueToPut * 2) {
     byte[] buffer = new byte[20];
     DataIO.putLong(buffer, 2, valueToPut);
     long returned = DataIO.getLong(buffer, 2);
     assertEquals(
         "The value that was put and the value returned from getLong do not match",
         valueToPut,
         returned);
     DataIO.putLong(buffer, 2, -valueToPut);
     returned = DataIO.getLong(buffer, 2);
     assertEquals(
         "The value that was put and the value returned from getLong do not match",
         -valueToPut,
         returned);
   }
 }
Esempio n. 10
0
 @Test
 public void testReadFully_with_data_length_same_as_buffer_length() throws IOException {
   byte[] inputBuffer = new byte[] {1, 2, 3, 4};
   InputStream in = new ByteArrayInputStream(inputBuffer);
   byte[] outputBuffer = new byte[4];
   DataIO.readFully(in, outputBuffer);
   assertArrayEquals(
       "The passed buffer should be filled with the whole content of the InputStream"
           + " since the buffer length is exactly same as the data length",
       inputBuffer,
       outputBuffer);
 }
Esempio n. 11
0
 @Test
 public void testReadFully_with_too_much_data() throws IOException {
   byte[] inputBuffer = new byte[] {1, 2, 3, 4};
   InputStream in = new ByteArrayInputStream(inputBuffer);
   byte[] outputBuffer = new byte[3];
   DataIO.readFully(in, outputBuffer);
   byte[] expected = new byte[] {1, 2, 3};
   assertArrayEquals(
       "The passed buffer should be filled with the first three bytes read from the InputStream",
       expected,
       outputBuffer);
 }
Esempio n. 12
0
  @Test
  public void testNextPowTwo() {
    assertEquals(1, DataIO.nextPowTwo(1));
    assertEquals(2, DataIO.nextPowTwo(2));
    assertEquals(4, DataIO.nextPowTwo(3));
    assertEquals(4, DataIO.nextPowTwo(4));

    assertEquals(64, DataIO.nextPowTwo(33));
    assertEquals(64, DataIO.nextPowTwo(61));

    assertEquals(1024, DataIO.nextPowTwo(777));
    assertEquals(1024, DataIO.nextPowTwo(1024));

    assertEquals(1073741824, DataIO.nextPowTwo(1073741824 - 100));
    assertEquals(1073741824, DataIO.nextPowTwo((int) (1073741824 * 0.7)));
    assertEquals(1073741824, DataIO.nextPowTwo(1073741824));
  }
Esempio n. 13
0
 @Test
 public void testHexaConversion() {
   byte[] b = new byte[] {11, 112, 11, 0, 39, 90};
   assertTrue(Serializer.BYTE_ARRAY.equals(b, DataIO.fromHexa(DataIO.toHexa(b))));
 }
Esempio n. 14
0
  @Test
  public void testNextPowTwoLong() {
    assertEquals(1, DataIO.nextPowTwo(1L));
    assertEquals(2, DataIO.nextPowTwo(2L));
    assertEquals(4, DataIO.nextPowTwo(3L));
    assertEquals(4, DataIO.nextPowTwo(4L));

    assertEquals(64, DataIO.nextPowTwo(33L));
    assertEquals(64, DataIO.nextPowTwo(61L));

    assertEquals(1024, DataIO.nextPowTwo(777L));
    assertEquals(1024, DataIO.nextPowTwo(1024L));

    assertEquals(1073741824, DataIO.nextPowTwo(1073741824L - 100));
    assertEquals(1073741824, DataIO.nextPowTwo((long) (1073741824 * 0.7)));
    assertEquals(1073741824, DataIO.nextPowTwo(1073741824L));
  }