blob: c689afbe220610551a7244c3da5936b7dc5660b6 [file] [log] [blame]
// Copyright 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Tests for automatically-sized arrays from auto_array_size.emb.
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <stdint.h>
#include <iterator>
#include <random>
#include <vector>
#include "public/emboss_text_util.h"
#include "testdata/auto_array_size.emb.h"
namespace emboss {
namespace test {
namespace {
alignas(8) static const ::std::uint8_t kAutoSize[22] = {
0x03, // 0:1 array_size == 3
0x10, 0x20, 0x30, 0x40, // 1:5 four_byte_array
0x11, 0x12, 0x21, 0x22, // 5:9 four_struct_array[0, 1]
0x31, 0x32, 0x41, 0x42, // 9:13 four_struct_array[2, 3]
0x50, 0x60, 0x70, // 13:16 dynamic_byte_array
0x51, 0x52, 0x61, 0x62, 0x71, 0x72, // 16:22 dynamic_struct_array
};
TEST(AutoSizeView, IteratorIncrement) {
auto src_buf = ::std::vector</**/ ::std::uint8_t>(
kAutoSize, kAutoSize + sizeof kAutoSize);
auto src = MakeAutoSizeView(&src_buf).four_struct_array();
auto dst_buf = ::std::vector</**/ ::std::uint8_t>(
kAutoSize, kAutoSize + sizeof kAutoSize);
auto dst = MakeAutoSizeView(&dst_buf).four_struct_array();
EXPECT_TRUE(src.Equals(dst));
::std::fill(dst.BackingStorage().begin(), dst.BackingStorage().end(), 0);
EXPECT_FALSE(src.Equals(dst));
for (auto src_it = src.begin(), dst_it = dst.begin();
src_it != src.end() && dst_it != dst.end(); ++src_it, ++dst_it) {
dst_it->CopyFrom(*src_it);
}
EXPECT_TRUE(src.Equals(dst));
::std::fill(dst.BackingStorage().begin(), dst.BackingStorage().end(), 0);
EXPECT_FALSE(src.Equals(dst));
for (auto src_it = src.begin(), dst_it = dst.begin();
src_it != src.end() && dst_it != dst.end(); src_it++, dst_it++) {
dst_it->CopyFrom(*src_it);
}
EXPECT_TRUE(src.Equals(dst));
::std::fill(dst.BackingStorage().begin(), dst.BackingStorage().end(), 0);
EXPECT_FALSE(src.Equals(dst));
for (auto src_it = src.rbegin(), dst_it = dst.rbegin();
src_it != src.rend() && dst_it != dst.rend(); ++src_it, ++dst_it) {
dst_it->CopyFrom(*src_it);
}
EXPECT_TRUE(src.Equals(dst));
::std::fill(dst.BackingStorage().begin(), dst.BackingStorage().end(), 0);
EXPECT_FALSE(src.Equals(dst));
for (auto src_it = src.rbegin(), dst_it = dst.rbegin();
src_it != src.rend() && dst_it != dst.rend(); src_it++, dst_it++) {
dst_it->CopyFrom(*src_it);
}
EXPECT_TRUE(src.Equals(dst));
EXPECT_EQ(src.begin(), src.begin()++);
EXPECT_EQ(src.rbegin(), src.rbegin()++);
EXPECT_EQ(src.end(), (src.end())--);
EXPECT_EQ(src.rend(), src.rend()--);
}
TEST(AutoSizeView, PreviousNext) {
auto view = MakeAutoSizeView(kAutoSize, sizeof kAutoSize).four_struct_array();
EXPECT_TRUE(::std::next(view.begin(), 0)->Equals(view[0]));
EXPECT_TRUE(::std::next(view.begin(), 1)->Equals(view[1]));
EXPECT_TRUE(::std::next(view.begin(), 2)->Equals(view[2]));
EXPECT_TRUE(::std::next(view.begin(), 3)->Equals(view[3]));
EXPECT_TRUE(::std::next(view.rbegin(), 0)->Equals(view[3]));
EXPECT_TRUE(::std::next(view.rbegin(), 1)->Equals(view[2]));
EXPECT_TRUE(::std::next(view.rbegin(), 2)->Equals(view[1]));
EXPECT_TRUE(::std::next(view.rbegin(), 3)->Equals(view[0]));
EXPECT_TRUE(::std::prev(view.end(), 1)->Equals(view[3]));
EXPECT_TRUE(::std::prev(view.end(), 2)->Equals(view[2]));
EXPECT_TRUE(::std::prev(view.end(), 3)->Equals(view[1]));
EXPECT_TRUE(::std::prev(view.end(), 4)->Equals(view[0]));
EXPECT_TRUE(::std::prev(view.rend(), 1)->Equals(view[0]));
EXPECT_TRUE(::std::prev(view.rend(), 2)->Equals(view[1]));
EXPECT_TRUE(::std::prev(view.rend(), 3)->Equals(view[2]));
EXPECT_TRUE(::std::prev(view.rend(), 4)->Equals(view[3]));
}
TEST(AutoSizeView, ForEach) {
auto view = MakeAutoSizeView(kAutoSize, sizeof kAutoSize).four_struct_array();
int i = 0;
::std::for_each(view.begin(), view.end(), [&](ElementView element) {
ASSERT_TRUE(element.Equals(view[i++]));
});
i = view.ElementCount() - 1;
::std::for_each(view.rbegin(), view.rend(), [&](ElementView element) {
ASSERT_TRUE(element.Equals(view[i--]));
});
}
TEST(AutoSizeView, Find) {
auto view = MakeAutoSizeView(kAutoSize, sizeof kAutoSize).four_struct_array();
EXPECT_TRUE(
::std::find_if(view.begin(), view.end(), [view](ElementView element) {
return element.Equals(view[0]);
})->Equals(view[0]));
EXPECT_TRUE(
::std::find_if(view.begin(), view.end(), [view](ElementView element) {
return element.Equals(view[1]);
})->Equals(view[1]));
EXPECT_TRUE(
::std::find_if(view.begin(), view.end(), [view](ElementView element) {
return element.Equals(view[2]);
})->Equals(view[2]));
EXPECT_TRUE(
::std::find_if(view.begin(), view.end(), [view](ElementView element) {
return element.Equals(view[3]);
})->Equals(view[3]));
EXPECT_TRUE(
::std::find_if(view.rbegin(), view.rend(), [view](ElementView element) {
return element.Equals(view[0]);
})->Equals(view[0]));
EXPECT_TRUE(
::std::find_if(view.rbegin(), view.rend(), [view](ElementView element) {
return element.Equals(view[1]);
})->Equals(view[1]));
EXPECT_TRUE(
::std::find_if(view.rbegin(), view.rend(), [view](ElementView element) {
return element.Equals(view[2]);
})->Equals(view[2]));
EXPECT_TRUE(
::std::find_if(view.rbegin(), view.rend(), [view](ElementView element) {
return element.Equals(view[3]);
})->Equals(view[3]));
}
TEST(AutoSizeView, Comparison) {
auto view = MakeAutoSizeView(kAutoSize, sizeof kAutoSize).four_struct_array();
EXPECT_EQ(view.begin() + view.ElementCount(), view.end());
EXPECT_EQ(view.end() - view.ElementCount(), view.begin());
EXPECT_EQ(view.rbegin() + view.ElementCount(), view.rend());
EXPECT_EQ(view.rend() - view.ElementCount(), view.rbegin());
EXPECT_LT(view.begin(), view.end());
EXPECT_LT(view.rbegin(), view.rend());
EXPECT_LE(view.begin() - 1, view.end());
EXPECT_LE(view.rbegin() - 1, view.rend());
EXPECT_LE(view.begin() - 1, view.end());
EXPECT_LE(view.rbegin() - 1, view.rend());
EXPECT_GT(view.end(), view.begin());
EXPECT_GT(view.rend(), view.rbegin());
EXPECT_GE(view.end() + 1, view.begin());
EXPECT_GE(view.end() + 1, view.begin());
EXPECT_GE(view.rend() + 1, view.rbegin());
EXPECT_GE(view.rend() + 1, view.rbegin());
}
TEST(AutoSizeView, RangeBasedFor) {
auto view = MakeAutoSizeView(kAutoSize, sizeof kAutoSize).four_struct_array();
int i = 0;
for (auto element : view) {
ASSERT_TRUE(element.Equals(view[i++]));
}
}
TEST(AutoSizeView, CanReadAutoArrays) {
auto view = MakeAlignedAutoSizeView<const ::std::uint8_t, 8>(
kAutoSize, sizeof kAutoSize);
EXPECT_EQ(22U, view.SizeInBytes());
EXPECT_EQ(3U, view.array_size().Read());
EXPECT_EQ(0x10U, view.four_byte_array()[0].Read());
EXPECT_EQ(0x20U, view.four_byte_array()[1].Read());
EXPECT_EQ(0x30U, view.four_byte_array()[2].Read());
EXPECT_EQ(0x40U, view.four_byte_array()[3].Read());
EXPECT_EQ(4U, view.four_byte_array().SizeInBytes());
EXPECT_DEATH(view.four_byte_array()[4].Read(), "");
EXPECT_EQ(0x11U, view.four_struct_array()[0].a().Read());
EXPECT_EQ(0x12U, view.four_struct_array()[0].b().Read());
EXPECT_EQ(0x21U, view.four_struct_array()[1].a().Read());
EXPECT_EQ(0x22U, view.four_struct_array()[1].b().Read());
EXPECT_EQ(0x31U, view.four_struct_array()[2].a().Read());
EXPECT_EQ(0x32U, view.four_struct_array()[2].b().Read());
EXPECT_EQ(0x41U, view.four_struct_array()[3].a().Read());
EXPECT_EQ(0x42U, view.four_struct_array()[3].b().Read());
EXPECT_EQ(8U, view.four_struct_array().SizeInBytes());
EXPECT_DEATH(view.four_struct_array()[4].a().Read(), "");
EXPECT_EQ(0x50U, view.dynamic_byte_array()[0].Read());
EXPECT_EQ(0x60U, view.dynamic_byte_array()[1].Read());
EXPECT_EQ(0x70U, view.dynamic_byte_array()[2].Read());
EXPECT_EQ(3U, view.dynamic_byte_array().SizeInBytes());
EXPECT_FALSE(view.dynamic_byte_array()[3].IsComplete());
EXPECT_EQ(0x51U, view.dynamic_struct_array()[0].a().Read());
EXPECT_EQ(0x52U, view.dynamic_struct_array()[0].b().Read());
EXPECT_EQ(0x61U, view.dynamic_struct_array()[1].a().Read());
EXPECT_EQ(0x62U, view.dynamic_struct_array()[1].b().Read());
EXPECT_EQ(0x71U, view.dynamic_struct_array()[2].a().Read());
EXPECT_EQ(0x72U, view.dynamic_struct_array()[2].b().Read());
EXPECT_EQ(6U, view.dynamic_struct_array().SizeInBytes());
EXPECT_FALSE(view.dynamic_struct_array()[3].IsComplete());
}
TEST(AutoSizeWriter, CanWriteAutoArrays) {
::std::vector<char> buffer(sizeof kAutoSize, 0);
auto writer = MakeAutoSizeView(&buffer);
writer.array_size().Write(0);
EXPECT_EQ(13U, writer.SizeInBytes());
EXPECT_DEATH(writer.dynamic_byte_array()[0].Read(), "");
writer.array_size().Write(3);
EXPECT_EQ(22U, writer.SizeInBytes());
writer.four_byte_array()[0].Write(0x10);
writer.four_byte_array()[1].Write(0x20);
writer.four_byte_array()[2].Write(0x30);
writer.four_byte_array()[3].Write(0x40);
EXPECT_DEATH(writer.four_byte_array()[4].Write(0), "");
writer.four_struct_array()[0].a().Write(0x11);
writer.four_struct_array()[0].b().Write(0x12);
writer.four_struct_array()[1].a().Write(0x21);
writer.four_struct_array()[1].b().Write(0x22);
writer.four_struct_array()[2].a().Write(0x31);
writer.four_struct_array()[2].b().Write(0x32);
writer.four_struct_array()[3].a().Write(0x41);
writer.four_struct_array()[3].b().Write(0x42);
EXPECT_FALSE(writer.four_struct_array()[4].IsComplete());
writer.dynamic_byte_array()[0].Write(0x50);
writer.dynamic_byte_array()[1].Write(0x60);
writer.dynamic_byte_array()[2].Write(0x70);
EXPECT_FALSE(writer.dynamic_byte_array()[3].IsComplete());
writer.dynamic_struct_array()[0].a().Write(0x51);
writer.dynamic_struct_array()[0].b().Write(0x52);
writer.dynamic_struct_array()[1].a().Write(0x61);
writer.dynamic_struct_array()[1].b().Write(0x62);
writer.dynamic_struct_array()[2].a().Write(0x71);
writer.dynamic_struct_array()[2].b().Write(0x72);
EXPECT_FALSE(writer.dynamic_struct_array()[3].IsComplete());
EXPECT_EQ(::std::vector<char>(kAutoSize, kAutoSize + sizeof kAutoSize),
buffer);
}
TEST(AutoSizeView, CanUseDataMethod) {
auto view = MakeAlignedAutoSizeView<const ::std::uint8_t, 8>(
kAutoSize, sizeof kAutoSize);
for (unsigned i = 0; i < view.SizeInBytes(); ++i) {
EXPECT_EQ(*(view.BackingStorage().data() + i), kAutoSize[i])
<< " at element " << i;
}
}
TEST(AutoSizeView, CanCopyFrom) {
auto source = MakeAlignedAutoSizeView<const ::std::uint8_t, 8>(
kAutoSize, sizeof kAutoSize);
::std::array</**/ ::std::uint8_t, sizeof kAutoSize> buf = {0};
auto dest =
MakeAlignedAutoSizeView</**/ ::std::uint8_t, 8>(buf.data(), buf.size());
// Copy one element.
EXPECT_NE(source.four_struct_array()[0].a().Read(),
dest.four_struct_array()[0].a().Read());
EXPECT_NE(source.four_struct_array()[0].b().Read(),
dest.four_struct_array()[0].b().Read());
dest.four_struct_array()[0].CopyFrom(source.four_struct_array()[0]);
EXPECT_EQ(source.four_struct_array()[0].a().Read(),
dest.four_struct_array()[0].a().Read());
EXPECT_EQ(source.four_struct_array()[0].b().Read(),
dest.four_struct_array()[0].b().Read());
// Copy entire view.
dest.CopyFrom(source);
for (unsigned i = 0; i < source.four_struct_array().ElementCount(); ++i) {
EXPECT_EQ(source.four_struct_array()[i].a().Read(),
dest.four_struct_array()[i].a().Read());
EXPECT_EQ(source.four_struct_array()[i].b().Read(),
dest.four_struct_array()[i].b().Read());
}
}
TEST(AutoSizeView, CanCopyFromDifferentSizes) {
constexpr int padding = 10;
::std::array</**/ ::std::uint8_t, sizeof kAutoSize + padding> source_buffer;
memset(source_buffer.data(), 0, source_buffer.size());
memcpy(source_buffer.data(), kAutoSize, sizeof kAutoSize);
auto source = MakeAutoSizeView(&source_buffer);
::std::array</**/ ::std::uint8_t, sizeof kAutoSize + padding> buf;
memset(buf.data(), 0xff, buf.size());
auto dest = MakeAutoSizeView(buf.data(), sizeof kAutoSize);
dest.CopyFrom(source);
for (unsigned i = 0; i < sizeof kAutoSize; ++i) {
EXPECT_EQ(buf[i], source_buffer[i]) << i;
}
for (unsigned i = sizeof kAutoSize; i < sizeof kAutoSize + padding; ++i) {
EXPECT_EQ(buf[i], 0xff) << i;
}
}
TEST(AutoSizeView, CanCopyFromOverlapping) {
constexpr int kElementSizeBytes = ElementView::SizeInBytes();
::std::vector</**/ ::std::uint8_t> buf = {1, 2, 3};
auto source = MakeElementView(buf.data(), kElementSizeBytes);
auto dest = MakeElementView(buf.data() + 1, kElementSizeBytes);
EXPECT_EQ(source.a().Read(), buf[0]);
EXPECT_EQ(source.b().Read(), dest.a().Read());
EXPECT_EQ(dest.b().Read(), buf[2]);
dest.CopyFrom(source); // Forward overlap.
EXPECT_EQ(buf, ::std::vector</**/ ::std::uint8_t>({1, 1, 2}));
source.CopyFrom(dest); // Reverse overlap.
EXPECT_EQ(buf, ::std::vector</**/ ::std::uint8_t>({1, 2, 2}));
}
TEST(AutoSizeView, Equals) {
::std::vector</**/ ::std::uint8_t> buf_x = {1, 2};
::std::vector</**/ ::std::uint8_t> buf_y = {1, 2, 3};
auto x = MakeElementView(&buf_x);
auto x_const = MakeElementView(
static_cast<const ::std::vector</**/ ::std::uint8_t>*>(&buf_x));
auto y = MakeElementView(&buf_y);
EXPECT_TRUE(x.Equals(x));
EXPECT_TRUE(x.UncheckedEquals(x));
EXPECT_TRUE(y.Equals(y));
EXPECT_TRUE(y.UncheckedEquals(y));
EXPECT_TRUE(x.Equals(y));
EXPECT_TRUE(x.UncheckedEquals(y));
EXPECT_TRUE(y.Equals(x));
EXPECT_TRUE(y.UncheckedEquals(x));
EXPECT_TRUE(y.Equals(x_const));
EXPECT_TRUE(y.UncheckedEquals(x_const));
EXPECT_TRUE(x_const.Equals(y));
EXPECT_TRUE(x_const.UncheckedEquals(y));
++buf_y[1];
EXPECT_FALSE(x.Equals(y));
EXPECT_FALSE(x.UncheckedEquals(y));
EXPECT_FALSE(y.Equals(x));
EXPECT_FALSE(y.UncheckedEquals(x));
}
} // namespace
} // namespace test
} // namespace emboss