blob: 0b9ba6c5f360e6c674f46e1630bfc947e8ce1952 [file] [log] [blame] [edit]
// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "vm/datastream.h"
#include "platform/assert.h"
#include "vm/unit_test.h"
namespace dart {
// As a baseline, testing encodings of all numbers with bit size <= 16, as
// that's both a reasonable amount of numbers to iterate over and that way we
// test all 1-byte, all 2-byte, and some 3-byte encodings.
static constexpr intptr_t kUnsignedEnd = kMaxUint16;
static constexpr intptr_t kSignedStart = kMinInt16;
static constexpr intptr_t kSignedEnd = kMaxInt16;
// Testing some numbers with first, second, and/or third MSBs set.
#define DEFINE_LARGE_CONSTANTS(T) \
using Unsigned = typename std::make_unsigned<T>::type; \
constexpr T all_ones = static_cast<T>(-1); /* 111... */ \
constexpr T min = \
static_cast<T>(static_cast<Unsigned>(1) \
<< (kBitsPerByte * sizeof(T) - 1)); /* 100... */ \
constexpr T max = \
static_cast<T>(static_cast<Unsigned>(min) - 1); /* 011... */ \
constexpr T half_min = min / 2; /* 110... */ \
constexpr T half_max = max / 2; /* 001... */
TEST_CASE(BaseWriteStream_Write) {
MallocWriteStream writer(1 * KB);
for (intptr_t i = kSignedStart; i < kSignedEnd; i++) {
writer.Write(i);
}
DEFINE_LARGE_CONSTANTS(intptr_t);
writer.Write(all_ones);
writer.Write(min);
writer.Write(max);
writer.Write(half_min);
writer.Write(half_max);
ReadStream reader(writer.buffer(), writer.bytes_written());
for (intptr_t i = kSignedStart; i < kSignedEnd; i++) {
const intptr_t r = reader.Read<intptr_t>();
EXPECT_EQ(i, r);
}
const intptr_t read_all_ones = reader.Read<intptr_t>();
EXPECT_EQ(all_ones, read_all_ones);
const intptr_t read_min = reader.Read<intptr_t>();
EXPECT_EQ(min, read_min);
const intptr_t read_max = reader.Read<intptr_t>();
EXPECT_EQ(max, read_max);
const intptr_t read_half_min = reader.Read<intptr_t>();
EXPECT_EQ(half_min, read_half_min);
const intptr_t read_half_max = reader.Read<intptr_t>();
EXPECT_EQ(half_max, read_half_max);
}
TEST_CASE(BaseWriteStream_WriteUnsigned) {
MallocWriteStream writer(1 * KB);
for (uintptr_t i = 0; i < kUnsignedEnd; i++) {
writer.WriteUnsigned(i);
}
DEFINE_LARGE_CONSTANTS(uintptr_t);
writer.WriteUnsigned(all_ones);
writer.WriteUnsigned(min);
writer.WriteUnsigned(max);
writer.WriteUnsigned(half_min);
writer.WriteUnsigned(half_max);
ReadStream reader(writer.buffer(), writer.bytes_written());
for (uintptr_t i = 0; i < kUnsignedEnd; i++) {
const uintptr_t r = reader.ReadUnsigned<uintptr_t>();
EXPECT_EQ(i, r);
}
const uintptr_t read_all_ones = reader.ReadUnsigned<uintptr_t>();
EXPECT_EQ(all_ones, read_all_ones);
const uintptr_t read_min = reader.ReadUnsigned<uintptr_t>();
EXPECT_EQ(min, read_min);
const uintptr_t read_max = reader.ReadUnsigned<uintptr_t>();
EXPECT_EQ(max, read_max);
const uintptr_t read_half_min = reader.ReadUnsigned<uintptr_t>();
EXPECT_EQ(half_min, read_half_min);
const uintptr_t read_half_max = reader.ReadUnsigned<uintptr_t>();
EXPECT_EQ(half_max, read_half_max);
}
template <typename T>
void TestRaw() {
MallocWriteStream writer(1 * KB);
for (T i = kSignedStart; i < kSignedEnd; i++) {
writer.Write(i);
}
DEFINE_LARGE_CONSTANTS(T);
writer.Write(all_ones);
writer.Write(min);
writer.Write(max);
writer.Write(half_min);
writer.Write(half_max);
ReadStream reader(writer.buffer(), writer.bytes_written());
using Raw = ReadStream::Raw<sizeof(T), T>;
for (T i = kSignedStart; i < kSignedEnd; i++) {
const T r = Raw::Read(&reader);
EXPECT_EQ(i, r);
}
const T read_all_ones = Raw::Read(&reader);
EXPECT_EQ(all_ones, read_all_ones);
const T read_min = Raw::Read(&reader);
EXPECT_EQ(min, read_min);
const T read_max = Raw::Read(&reader);
EXPECT_EQ(max, read_max);
const T read_half_min = Raw::Read(&reader);
EXPECT_EQ(half_min, read_half_min);
const T read_half_max = Raw::Read(&reader);
EXPECT_EQ(half_max, read_half_max);
}
TEST_CASE(ReadStream_Read16) {
TestRaw<int16_t>();
}
TEST_CASE(ReadStream_Read32) {
TestRaw<int32_t>();
}
TEST_CASE(ReadStream_Read64) {
TestRaw<int64_t>();
}
TEST_CASE(BaseWriteStream_WriteLEB128) {
MallocWriteStream writer(1 * KB);
for (uintptr_t i = 0; i < kUnsignedEnd; i++) {
writer.WriteLEB128(i);
}
DEFINE_LARGE_CONSTANTS(uintptr_t);
writer.WriteLEB128(all_ones);
writer.WriteLEB128(min);
writer.WriteLEB128(max);
writer.WriteLEB128(half_min);
writer.WriteLEB128(half_max);
ReadStream reader(writer.buffer(), writer.bytes_written());
for (uintptr_t i = 0; i < kUnsignedEnd; i++) {
const uintptr_t r = reader.ReadLEB128();
EXPECT_EQ(i, r);
}
const uintptr_t read_all_ones = reader.ReadLEB128();
EXPECT_EQ(all_ones, read_all_ones);
const uintptr_t read_min = reader.ReadLEB128();
EXPECT_EQ(min, read_min);
const uintptr_t read_max = reader.ReadLEB128();
EXPECT_EQ(max, read_max);
const uintptr_t read_half_min = reader.ReadLEB128();
EXPECT_EQ(half_min, read_half_min);
const uintptr_t read_half_max = reader.ReadLEB128();
EXPECT_EQ(half_max, read_half_max);
}
TEST_CASE(BaseWriteStream_WriteSLEB128) {
MallocWriteStream writer(1 * KB);
for (intptr_t i = kSignedStart; i < kSignedEnd; i++) {
writer.WriteSLEB128(i);
}
DEFINE_LARGE_CONSTANTS(intptr_t);
writer.WriteSLEB128(all_ones);
writer.WriteSLEB128(min);
writer.WriteSLEB128(max);
writer.WriteSLEB128(half_min);
writer.WriteSLEB128(half_max);
ReadStream reader(writer.buffer(), writer.bytes_written());
for (intptr_t i = kSignedStart; i < kSignedEnd; i++) {
const intptr_t r = reader.ReadSLEB128();
EXPECT_EQ(i, r);
}
const intptr_t read_all_ones = reader.ReadSLEB128();
EXPECT_EQ(all_ones, read_all_ones);
const intptr_t read_min = reader.ReadSLEB128();
EXPECT_EQ(min, read_min);
const intptr_t read_max = reader.ReadSLEB128();
EXPECT_EQ(max, read_max);
const intptr_t read_half_min = reader.ReadSLEB128();
EXPECT_EQ(half_min, read_half_min);
const intptr_t read_half_max = reader.ReadSLEB128();
EXPECT_EQ(half_max, read_half_max);
}
} // namespace dart