Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 61c4bc89 authored by Joe Onorato's avatar Joe Onorato Committed by android-build-merger
Browse files

Merge "Fix EncodedBuffer_test to run after making EncodedBuffer inherit from RefBase" into qt-dev 

am: e229a5b7

Change-Id: Icfc79127fc6ae975614545af3037e136961e0168
parents 6812c938 e229a5b7

libs/protoutil/tests/EncodedBuffer_test.cpp

+61 −61
Original line number Diff line number Diff line
@@ -29,101 +29,101 @@ static void expectPointer(EncodedBuffer::Pointer* p, size_t pos) { 
}



TEST(EncodedBufferTest, WriteSimple) {

    EncodedBuffer buffer(TEST_CHUNK_SIZE);

    EXPECT_EQ(buffer.size(), 0UL);

    expectPointer(buffer.wp(), 0);

    EXPECT_EQ(buffer.currentToWrite(), TEST_CHUNK_SIZE);

    sp<EncodedBuffer> buffer = new EncodedBuffer(TEST_CHUNK_SIZE);

    EXPECT_EQ(buffer->size(), 0UL);

    expectPointer(buffer->wp(), 0);

    EXPECT_EQ(buffer->currentToWrite(), TEST_CHUNK_SIZE);

    for (size_t i = 0; i < TEST_CHUNK_HALF_SIZE; i++) {

        buffer.writeRawByte(50 + i);

        buffer->writeRawByte(50 + i);

    }

    EXPECT_EQ(buffer.size(), TEST_CHUNK_HALF_SIZE);

    expectPointer(buffer.wp(), TEST_CHUNK_HALF_SIZE);

    EXPECT_EQ(buffer.currentToWrite(), TEST_CHUNK_HALF_SIZE);

    EXPECT_EQ(buffer->size(), TEST_CHUNK_HALF_SIZE);

    expectPointer(buffer->wp(), TEST_CHUNK_HALF_SIZE);

    EXPECT_EQ(buffer->currentToWrite(), TEST_CHUNK_HALF_SIZE);

    for (size_t i = 0; i < TEST_CHUNK_SIZE; i++) {

        buffer.writeRawByte(80 + i);

        buffer->writeRawByte(80 + i);

    }

    EXPECT_EQ(buffer.size(), TEST_CHUNK_SIZE + TEST_CHUNK_HALF_SIZE);

    expectPointer(buffer.wp(), TEST_CHUNK_SIZE + TEST_CHUNK_HALF_SIZE);

    EXPECT_EQ(buffer.currentToWrite(), TEST_CHUNK_HALF_SIZE);

    EXPECT_EQ(buffer->size(), TEST_CHUNK_SIZE + TEST_CHUNK_HALF_SIZE);

    expectPointer(buffer->wp(), TEST_CHUNK_SIZE + TEST_CHUNK_HALF_SIZE);

    EXPECT_EQ(buffer->currentToWrite(), TEST_CHUNK_HALF_SIZE);



    // verifies the buffer's data

    expectPointer(buffer.ep(), 0);

    expectPointer(buffer->ep(), 0);

    for (size_t i = 0; i < TEST_CHUNK_HALF_SIZE; i++) {

        EXPECT_EQ(buffer.readRawByte(), 50 + i);

        EXPECT_EQ(buffer->readRawByte(), 50 + i);

    }

    for (size_t i = 0; i < TEST_CHUNK_SIZE; i++) {

        EXPECT_EQ(buffer.readRawByte(), 80 + i);

        EXPECT_EQ(buffer->readRawByte(), 80 + i);

    }



    // clears the buffer

    buffer.clear();

    EXPECT_EQ(buffer.size(), 0UL);

    expectPointer(buffer.wp(), 0);

    buffer->clear();

    EXPECT_EQ(buffer->size(), 0UL);

    expectPointer(buffer->wp(), 0);

}



TEST(EncodedBufferTest, WriteVarint) {

    EncodedBuffer buffer(TEST_CHUNK_SIZE);

    sp<EncodedBuffer> buffer = new EncodedBuffer(TEST_CHUNK_SIZE);

    size_t expected_buffer_size = 0;

    EXPECT_EQ(buffer.writeRawVarint32(13), 1);

    EXPECT_EQ(buffer->writeRawVarint32(13), 1);

    expected_buffer_size += 1;

    EXPECT_EQ(buffer.size(), expected_buffer_size);

    EXPECT_EQ(buffer.writeRawVarint32(UINT32_C(-1)), 5);

    EXPECT_EQ(buffer->size(), expected_buffer_size);

    EXPECT_EQ(buffer->writeRawVarint32(UINT32_C(-1)), 5);

    expected_buffer_size += 5;

    EXPECT_EQ(buffer.size(), expected_buffer_size);

    EXPECT_EQ(buffer->size(), expected_buffer_size);



    EXPECT_EQ(buffer.writeRawVarint64(200), 2);

    EXPECT_EQ(buffer->writeRawVarint64(200), 2);

    expected_buffer_size += 2;

    EXPECT_EQ(buffer.size(), expected_buffer_size);

    EXPECT_EQ(buffer.writeRawVarint64(UINT64_C(-1)), 10);

    EXPECT_EQ(buffer->size(), expected_buffer_size);

    EXPECT_EQ(buffer->writeRawVarint64(UINT64_C(-1)), 10);

    expected_buffer_size += 10;

    EXPECT_EQ(buffer.size(), expected_buffer_size);

    EXPECT_EQ(buffer->size(), expected_buffer_size);



    buffer.writeRawFixed32(UINT32_C(-1));

    buffer->writeRawFixed32(UINT32_C(-1));

    expected_buffer_size += 4;

    EXPECT_EQ(buffer.size(), expected_buffer_size);

    buffer.writeRawFixed64(UINT64_C(-1));

    EXPECT_EQ(buffer->size(), expected_buffer_size);

    buffer->writeRawFixed64(UINT64_C(-1));

    expected_buffer_size += 8;

    EXPECT_EQ(buffer.size(), expected_buffer_size);

    EXPECT_EQ(buffer->size(), expected_buffer_size);



    EXPECT_EQ(buffer.writeHeader(32, 2), 2);

    EXPECT_EQ(buffer->writeHeader(32, 2), 2);

    expected_buffer_size += 2;

    EXPECT_EQ(buffer.size(), expected_buffer_size);

    EXPECT_EQ(buffer->size(), expected_buffer_size);



    // verify data are correctly written to the buffer.

    expectPointer(buffer.ep(), 0);

    EXPECT_EQ(buffer.readRawVarint(), UINT32_C(13));

    EXPECT_EQ(buffer.readRawVarint(), UINT32_C(-1));

    EXPECT_EQ(buffer.readRawVarint(), UINT64_C(200));

    EXPECT_EQ(buffer.readRawVarint(), UINT64_C(-1));

    EXPECT_EQ(buffer.readRawFixed32(), UINT32_C(-1));

    EXPECT_EQ(buffer.readRawFixed64(), UINT64_C(-1));

    EXPECT_EQ(buffer.readRawVarint(), UINT64_C((32 << 3) + 2));

    expectPointer(buffer.ep(), expected_buffer_size);

    expectPointer(buffer->ep(), 0);

    EXPECT_EQ(buffer->readRawVarint(), UINT32_C(13));

    EXPECT_EQ(buffer->readRawVarint(), UINT32_C(-1));

    EXPECT_EQ(buffer->readRawVarint(), UINT64_C(200));

    EXPECT_EQ(buffer->readRawVarint(), UINT64_C(-1));

    EXPECT_EQ(buffer->readRawFixed32(), UINT32_C(-1));

    EXPECT_EQ(buffer->readRawFixed64(), UINT64_C(-1));

    EXPECT_EQ(buffer->readRawVarint(), UINT64_C((32 << 3) + 2));

    expectPointer(buffer->ep(), expected_buffer_size);

}



TEST(EncodedBufferTest, Edit) {

    EncodedBuffer buffer(TEST_CHUNK_SIZE);

    buffer.writeRawFixed64(0xdeadbeefdeadbeef);

    EXPECT_EQ(buffer.readRawFixed64(), UINT64_C(0xdeadbeefdeadbeef));

    sp<EncodedBuffer> buffer = new EncodedBuffer(TEST_CHUNK_SIZE);

    buffer->writeRawFixed64(0xdeadbeefdeadbeef);

    EXPECT_EQ(buffer->readRawFixed64(), UINT64_C(0xdeadbeefdeadbeef));



    buffer.editRawFixed32(4, 0x12345678);

    buffer->editRawFixed32(4, 0x12345678);

    // fixed 64 is little endian order.

    buffer.ep()->rewind(); // rewind ep for readRawFixed64 from 0

    EXPECT_EQ(buffer.readRawFixed64(), UINT64_C(0x12345678deadbeef));



    buffer.wp()->rewind();

    expectPointer(buffer.wp(), 0);

    buffer.copy(4, 3);

    buffer.ep()->rewind(); // rewind ep for readRawFixed64 from 0

    EXPECT_EQ(buffer.readRawFixed64(), UINT64_C(0x12345678de345678));

    buffer->ep()->rewind(); // rewind ep for readRawFixed64 from 0

    EXPECT_EQ(buffer->readRawFixed64(), UINT64_C(0x12345678deadbeef));



    buffer->wp()->rewind();

    expectPointer(buffer->wp(), 0);

    buffer->copy(4, 3);

    buffer->ep()->rewind(); // rewind ep for readRawFixed64 from 0

    EXPECT_EQ(buffer->readRawFixed64(), UINT64_C(0x12345678de345678));

}



TEST(EncodedBufferTest, ReadSimple) {

    EncodedBuffer buffer(TEST_CHUNK_SIZE);

    sp<EncodedBuffer> buffer = new EncodedBuffer(TEST_CHUNK_SIZE);

    for (size_t i = 0; i < TEST_CHUNK_3X_SIZE; i++) {

        buffer.writeRawByte(i);

        buffer->writeRawByte(i);

    }

    sp<ProtoReader> reader1 = buffer.read();

    sp<ProtoReader> reader1 = buffer->read();

    EXPECT_EQ(reader1->size(), TEST_CHUNK_3X_SIZE);

    EXPECT_EQ(reader1->bytesRead(), 0);
@@ -132,7 +132,7 @@ TEST(EncodedBufferTest, ReadSimple) { 
    }

    EXPECT_EQ(reader1->bytesRead(), TEST_CHUNK_3X_SIZE);



    sp<ProtoReader> reader2 = buffer.read();

    sp<ProtoReader> reader2 = buffer->read();

    uint8_t val = 0;

    while (reader2->hasNext()) {

        EXPECT_EQ(reader2->next(), val);
@@ -143,10 +143,10 @@ TEST(EncodedBufferTest, ReadSimple) { 
}



TEST(EncodedBufferTest, ReadVarint) {

    EncodedBuffer buffer;

    sp<EncodedBuffer> buffer = new EncodedBuffer();

    uint64_t val = UINT64_C(1522865904593);

    size_t len = buffer.writeRawVarint64(val);

    sp<ProtoReader> reader = buffer.read();

    size_t len = buffer->writeRawVarint64(val);

    sp<ProtoReader> reader = buffer->read();

    EXPECT_EQ(reader->size(), len);

    EXPECT_EQ(reader->readRawVarint(), val);

}