blob: 9813b4ba5d6ba80390ec971361782652d186eb2f [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 the generated View class for Container and Box from
// nested_structure.emb.
//
// These tests check that nested structures work.
#include <stdint.h>
#include <vector>
#include "gtest/gtest.h"
#include "testdata/nested_structure.emb.h"
namespace emboss {
namespace test {
namespace {
alignas(8) static const ::std::uint8_t kContainer[20] = {
0x28, 0x00, 0x00, 0x00, // 0:4 weight == 40
0x78, 0x56, 0x34, 0x12, // 4:8 important_box.id == 0x12345678
0x03, 0x02, 0x01, 0x00, // 8:12 important_box.count == 0x010203
0x21, 0x43, 0x65, 0x87, // 12:16 other_box.id == 0x87654321
0xcc, 0xbb, 0xaa, 0x00, // 16:20 other_box.count == 0xaabbcc
};
// ContainerView::SizeInBytes() returns the expected value.
TEST(ContainerView, StaticSizeIsCorrect) {
EXPECT_EQ(20U, ContainerView::SizeInBytes());
}
// ContainerView::SizeInBytes() returns the expected value.
TEST(ContainerView, SizeFieldIsCorrect) {
auto view = MakeAlignedContainerView<const ::std::uint8_t, 8>(
kContainer, sizeof kContainer);
EXPECT_EQ(40U, view.weight().Read());
}
// ContainerView::important_box() returns a BoxView, and not a different
// template instantiation.
TEST(ContainerView, FieldTypesAreExpected) {
auto container = MakeAlignedContainerView<const ::std::uint8_t, 8>(
kContainer, sizeof kContainer);
auto box = container.important_box();
EXPECT_EQ(0x12345678U, box.id().Read());
}
// Box::SizeInBytes() returns the expected value, when retrieved from a
// Container.
TEST(ContainerView, BoxSizeFieldIsCorrect) {
auto view = MakeAlignedContainerView<const ::std::uint8_t, 8>(
kContainer, sizeof kContainer);
EXPECT_EQ(8U, view.important_box().SizeInBytes());
}
// Box::id() and Box::count() return correct values when retrieved from
// Container.
TEST(ContainerView, BoxFieldValuesAreCorrect) {
auto view = MakeAlignedContainerView<const ::std::uint8_t, 8>(
kContainer, sizeof kContainer);
EXPECT_EQ(0x12345678U, view.important_box().id().Read());
EXPECT_EQ(0x010203U, view.important_box().count().Read());
EXPECT_EQ(0x87654321U, view.other_box().id().Read());
EXPECT_EQ(0xaabbccU, view.other_box().count().Read());
}
TEST(ContainerView, CanWriteValues) {
alignas(8)::std::uint8_t buffer[sizeof kContainer];
auto writer =
MakeAlignedContainerView</**/ ::std::uint8_t, 8>(buffer, sizeof buffer);
writer.weight().Write(40);
writer.important_box().id().Write(0x12345678);
writer.important_box().count().Write(0x010203);
writer.other_box().id().Write(0x87654321);
writer.other_box().count().Write(0xaabbcc);
EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kContainer,
kContainer + sizeof kContainer),
::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}
TEST(ContainerView, CanReadTextFormat) {
alignas(8)::std::uint8_t buffer[sizeof kContainer];
auto writer =
MakeAlignedContainerView</**/ ::std::uint8_t, 8>(buffer, sizeof buffer);
EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
{
weight: 40
important_box: {
id: 0x12345678
count: 0x010203
}
other_box: {
id: 0x87654321
count: 0xaabbcc
}
}
)"));
EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kContainer,
kContainer + sizeof kContainer),
::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}
alignas(8) static const ::std::uint8_t kTruck[44] = {
0x88, 0x66, 0x44, 0x22, // 0:4 id == 0x22446688
0x64, 0x00, 0x00, 0x00, // 4:8 cargo[0].weight == 100
0xff, 0x00, 0x00, 0x00, // 8:12 cargo[0].important_box.id == 255
0x0a, 0x00, 0x00, 0x00, // 12:16 cargo[0].important_box.count == 10
0x00, 0x94, 0x35, 0x77, // 16:20 cargo[0].other_box.id == 2000000000
0xf4, 0x01, 0x00, 0x00, // 20:24 cargo[0].other_box.count == 500
0x65, 0x00, 0x00, 0x00, // 24:28 cargo[1].weight == 101
0xfe, 0x00, 0x00, 0x00, // 28:32 cargo[1].important_box.id == 254
0x09, 0x00, 0x00, 0x00, // 32:36 cargo[1].important_box.count == 9
0x01, 0x94, 0x35, 0x77, // 36:40 cargo[1].other_box.id == 2000000001
0xf3, 0x01, 0x00, 0x00, // 40:44 cargo[1].other_box.count == 499
};
TEST(TruckView, ValuesAreCorrect) {
auto view =
MakeAlignedTruckView<const ::std::uint8_t, 8>(kTruck, sizeof kTruck);
EXPECT_EQ(0x22446688U, view.id().Read());
EXPECT_EQ(100U, view.cargo()[0].weight().Read());
EXPECT_EQ(255U, view.cargo()[0].important_box().id().Read());
EXPECT_EQ(10U, view.cargo()[0].important_box().count().Read());
EXPECT_EQ(2000000000U, view.cargo()[0].other_box().id().Read());
EXPECT_EQ(500U, view.cargo()[0].other_box().count().Read());
EXPECT_EQ(101U, view.cargo()[1].weight().Read());
EXPECT_EQ(254U, view.cargo()[1].important_box().id().Read());
EXPECT_EQ(9U, view.cargo()[1].important_box().count().Read());
EXPECT_EQ(2000000001U, view.cargo()[1].other_box().id().Read());
EXPECT_EQ(499U, view.cargo()[1].other_box().count().Read());
}
TEST(TruckView, WriteValues) {
::std::uint8_t buffer[sizeof kTruck];
auto writer = TruckWriter(buffer, sizeof buffer);
writer.id().Write(0x22446688);
writer.cargo()[0].weight().Write(100);
writer.cargo()[0].important_box().id().Write(255);
writer.cargo()[0].important_box().count().Write(10);
writer.cargo()[0].other_box().id().Write(2000000000);
writer.cargo()[0].other_box().count().Write(500);
writer.cargo()[1].weight().Write(101);
writer.cargo()[1].important_box().id().Write(254);
writer.cargo()[1].important_box().count().Write(9);
writer.cargo()[1].other_box().id().Write(2000000001);
writer.cargo()[1].other_box().count().Write(499);
EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kTruck, kTruck + sizeof kTruck),
::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}
TEST(TruckView, CanReadTextFormat) {
::std::uint8_t buffer[sizeof kTruck];
auto writer = TruckWriter(buffer, sizeof buffer);
EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
{
id: 0x22446688
cargo: {
{
weight: 100
important_box: {
id: 255
count: 10
}
other_box: {
id: 2_000_000_000
count: 500
}
},
{
weight: 101
important_box: {
id: 254
count: 9
}
other_box: {
id: 2_000_000_001
count: 499
}
},
}
}
)"));
EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kTruck, kTruck + sizeof kTruck),
::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}
} // namespace
} // namespace test
} // namespace emboss