Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
TreeHugger Robot
2019-05-16 18:54:50 +00:00
committed by Android (Google) Code Review
parent b899f8abdd 05270525ee
commit e229a5b70b
1 changed files with 60 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
libs/protoutil/tests/EncodedBuffer_test.cpp
View File

@@ -29,101 +29,101 @@ static void expectPointer(EncodedBuffer::Pointer* p, size_t pos) {
} }
TEST(EncodedBufferTest, WriteSimple) { TEST(EncodedBufferTest, WriteSimple) {
EncodedBuffer buffer(TEST_CHUNK_SIZE); sp<EncodedBuffer> buffer = new EncodedBuffer(TEST_CHUNK_SIZE);
EXPECT_EQ(buffer.size(), 0UL); EXPECT_EQ(buffer->size(), 0UL);
expectPointer(buffer.wp(), 0); expectPointer(buffer->wp(), 0);
EXPECT_EQ(buffer.currentToWrite(), TEST_CHUNK_SIZE); EXPECT_EQ(buffer->currentToWrite(), TEST_CHUNK_SIZE);
for (size_t i = 0; i < TEST_CHUNK_HALF_SIZE; i++) { 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); EXPECT_EQ(buffer->size(), TEST_CHUNK_HALF_SIZE);
expectPointer(buffer.wp(), TEST_CHUNK_HALF_SIZE); expectPointer(buffer->wp(), TEST_CHUNK_HALF_SIZE);
EXPECT_EQ(buffer.currentToWrite(), TEST_CHUNK_HALF_SIZE); EXPECT_EQ(buffer->currentToWrite(), TEST_CHUNK_HALF_SIZE);
for (size_t i = 0; i < TEST_CHUNK_SIZE; i++) { 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); EXPECT_EQ(buffer->size(), TEST_CHUNK_SIZE + TEST_CHUNK_HALF_SIZE);
expectPointer(buffer.wp(), 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->currentToWrite(), TEST_CHUNK_HALF_SIZE);
// verifies the buffer's data // verifies the buffer's data
expectPointer(buffer.ep(), 0); expectPointer(buffer->ep(), 0);
for (size_t i = 0; i < TEST_CHUNK_HALF_SIZE; i++) { 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++) { 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 // clears the buffer
buffer.clear(); buffer->clear();
EXPECT_EQ(buffer.size(), 0UL); EXPECT_EQ(buffer->size(), 0UL);
expectPointer(buffer.wp(), 0); expectPointer(buffer->wp(), 0);
} }
TEST(EncodedBufferTest, WriteVarint) { TEST(EncodedBufferTest, WriteVarint) {
EncodedBuffer buffer(TEST_CHUNK_SIZE); sp<EncodedBuffer> buffer = new EncodedBuffer(TEST_CHUNK_SIZE);
size_t expected_buffer_size = 0; size_t expected_buffer_size = 0;
EXPECT_EQ(buffer.writeRawVarint32(13), 1); EXPECT_EQ(buffer->writeRawVarint32(13), 1);
expected_buffer_size += 1; expected_buffer_size += 1;
EXPECT_EQ(buffer.size(), expected_buffer_size); EXPECT_EQ(buffer->size(), expected_buffer_size);
EXPECT_EQ(buffer.writeRawVarint32(UINT32_C(-1)), 5); EXPECT_EQ(buffer->writeRawVarint32(UINT32_C(-1)), 5);
expected_buffer_size += 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; expected_buffer_size += 2;
EXPECT_EQ(buffer.size(), expected_buffer_size); EXPECT_EQ(buffer->size(), expected_buffer_size);
EXPECT_EQ(buffer.writeRawVarint64(UINT64_C(-1)), 10); EXPECT_EQ(buffer->writeRawVarint64(UINT64_C(-1)), 10);
expected_buffer_size += 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; expected_buffer_size += 4;
EXPECT_EQ(buffer.size(), expected_buffer_size); EXPECT_EQ(buffer->size(), expected_buffer_size);
buffer.writeRawFixed64(UINT64_C(-1)); buffer->writeRawFixed64(UINT64_C(-1));
expected_buffer_size += 8; 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; 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. // verify data are correctly written to the buffer.
expectPointer(buffer.ep(), 0); expectPointer(buffer->ep(), 0);
EXPECT_EQ(buffer.readRawVarint(), UINT32_C(13)); EXPECT_EQ(buffer->readRawVarint(), UINT32_C(13));
EXPECT_EQ(buffer.readRawVarint(), UINT32_C(-1)); EXPECT_EQ(buffer->readRawVarint(), UINT32_C(-1));
EXPECT_EQ(buffer.readRawVarint(), UINT64_C(200)); EXPECT_EQ(buffer->readRawVarint(), UINT64_C(200));
EXPECT_EQ(buffer.readRawVarint(), UINT64_C(-1)); EXPECT_EQ(buffer->readRawVarint(), UINT64_C(-1));
EXPECT_EQ(buffer.readRawFixed32(), UINT32_C(-1)); EXPECT_EQ(buffer->readRawFixed32(), UINT32_C(-1));
EXPECT_EQ(buffer.readRawFixed64(), UINT64_C(-1)); EXPECT_EQ(buffer->readRawFixed64(), UINT64_C(-1));
EXPECT_EQ(buffer.readRawVarint(), UINT64_C((32 << 3) + 2)); EXPECT_EQ(buffer->readRawVarint(), UINT64_C((32 << 3) + 2));
expectPointer(buffer.ep(), expected_buffer_size); expectPointer(buffer->ep(), expected_buffer_size);
} }
TEST(EncodedBufferTest, Edit) { TEST(EncodedBufferTest, Edit) {
EncodedBuffer buffer(TEST_CHUNK_SIZE); sp<EncodedBuffer> buffer = new EncodedBuffer(TEST_CHUNK_SIZE);
buffer.writeRawFixed64(0xdeadbeefdeadbeef); buffer->writeRawFixed64(0xdeadbeefdeadbeef);
EXPECT_EQ(buffer.readRawFixed64(), UINT64_C(0xdeadbeefdeadbeef)); EXPECT_EQ(buffer->readRawFixed64(), UINT64_C(0xdeadbeefdeadbeef));
buffer.editRawFixed32(4, 0x12345678); buffer->editRawFixed32(4, 0x12345678);
// fixed 64 is little endian order. // fixed 64 is little endian order.
buffer.ep()->rewind(); // rewind ep for readRawFixed64 from 0 buffer->ep()->rewind(); // rewind ep for readRawFixed64 from 0
EXPECT_EQ(buffer.readRawFixed64(), UINT64_C(0x12345678deadbeef)); EXPECT_EQ(buffer->readRawFixed64(), UINT64_C(0x12345678deadbeef));
buffer.wp()->rewind(); buffer->wp()->rewind();
expectPointer(buffer.wp(), 0); expectPointer(buffer->wp(), 0);
buffer.copy(4, 3); buffer->copy(4, 3);
buffer.ep()->rewind(); // rewind ep for readRawFixed64 from 0 buffer->ep()->rewind(); // rewind ep for readRawFixed64 from 0
EXPECT_EQ(buffer.readRawFixed64(), UINT64_C(0x12345678de345678)); EXPECT_EQ(buffer->readRawFixed64(), UINT64_C(0x12345678de345678));
} }
TEST(EncodedBufferTest, ReadSimple) { 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++) { 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->size(), TEST_CHUNK_3X_SIZE);
EXPECT_EQ(reader1->bytesRead(), 0); EXPECT_EQ(reader1->bytesRead(), 0);
@@ -132,7 +132,7 @@ TEST(EncodedBufferTest, ReadSimple) {
} }
EXPECT_EQ(reader1->bytesRead(), TEST_CHUNK_3X_SIZE); EXPECT_EQ(reader1->bytesRead(), TEST_CHUNK_3X_SIZE);
sp<ProtoReader> reader2 = buffer.read(); sp<ProtoReader> reader2 = buffer->read();
uint8_t val = 0; uint8_t val = 0;
while (reader2->hasNext()) { while (reader2->hasNext()) {
EXPECT_EQ(reader2->next(), val); EXPECT_EQ(reader2->next(), val);
@@ -143,10 +143,10 @@ TEST(EncodedBufferTest, ReadSimple) {
} }
TEST(EncodedBufferTest, ReadVarint) { TEST(EncodedBufferTest, ReadVarint) {
EncodedBuffer buffer; sp<EncodedBuffer> buffer = new EncodedBuffer();
uint64_t val = UINT64_C(1522865904593); uint64_t val = UINT64_C(1522865904593);
size_t len = buffer.writeRawVarint64(val); size_t len = buffer->writeRawVarint64(val);
sp<ProtoReader> reader = buffer.read(); sp<ProtoReader> reader = buffer->read();
EXPECT_EQ(reader->size(), len); EXPECT_EQ(reader->size(), len);
EXPECT_EQ(reader->readRawVarint(), val); EXPECT_EQ(reader->readRawVarint(), val);
} }