src/storage/lib/disk_inspector/disk_struct_test.cc

// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "disk_inspector/disk_struct.h"

#include <disk_inspector/type_utils.h>
#include <gtest/gtest.h>

namespace disk_inspector {
namespace {

constexpr uint64_t element_count = 3;

std::string child_struct_name = "child_struct";
struct ChildTestStruct {
  uint8_t child_uint8;
  uint64_t child_uint64;
};

std::string struct_name = "struct";
struct TestStruct {
  uint8_t uint8;
  uint16_t uint16;
  uint32_t uint32;
  uint64_t uint64;
  ChildTestStruct child_test_struct;
  uint8_t uint8_array[element_count];
  uint16_t uint16_array[element_count];
  uint32_t uint32_array[element_count];
  uint64_t uint64_array[element_count];
  ChildTestStruct child_test_struct_array[element_count];
};

std::unique_ptr<DiskStruct> BuildChildTestStruct() {
  std::unique_ptr<DiskStruct> object =
      DiskStruct::Create(child_struct_name, sizeof(ChildTestStruct));
  ADD_FIELD(object, ChildTestStruct, child_uint8);
  ADD_FIELD(object, ChildTestStruct, child_uint64);
  return object;
}

std::unique_ptr<DiskStruct> BuildTestStruct() {
  std::unique_ptr<DiskStruct> object = DiskStruct::Create(struct_name, sizeof(TestStruct));
  ADD_FIELD(object, TestStruct, uint8);
  ADD_FIELD(object, TestStruct, uint16);
  ADD_FIELD(object, TestStruct, uint32);
  ADD_FIELD(object, TestStruct, uint64);
  ADD_STRUCT_FIELD(object, TestStruct, child_test_struct, BuildChildTestStruct());
  ADD_ARRAY_FIELD(object, TestStruct, uint8_array, element_count);
  ADD_ARRAY_FIELD(object, TestStruct, uint16_array, element_count);
  ADD_ARRAY_FIELD(object, TestStruct, uint32_array, element_count);
  ADD_ARRAY_FIELD(object, TestStruct, uint64_array, element_count);
  ADD_STRUCT_ARRAY_FIELD(object, TestStruct, child_test_struct_array, element_count,
                         BuildChildTestStruct());
  return object;
}

TEST(DiskStructTest, GetSize) {
  uint64_t test_size = 42;
  std::unique_ptr<DiskStruct> disk_struct = DiskStruct::Create("disk_struct", test_size);
  EXPECT_EQ(disk_struct->GetSize(), test_size);
}

TEST(DiskStructTest, WriteUint8Field) {
  TestStruct test_struct;
  uint8_t result = 42;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"uint8"}, {0}, std::to_string(result)));
  EXPECT_EQ(test_struct.uint8, result);
}

TEST(DiskStructTest, WriteUint16Field) {
  TestStruct test_struct;
  uint16_t result = 42;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"uint16"}, {0}, std::to_string(result)));
  EXPECT_EQ(test_struct.uint16, result);
}

TEST(DiskStructTest, WriteUint32Field) {
  TestStruct test_struct;
  uint32_t result = 42;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"uint32"}, {0}, std::to_string(result)));
  EXPECT_EQ(test_struct.uint32, result);
}

TEST(DiskStructTest, WriteUint64Field) {
  TestStruct test_struct;
  uint64_t result = 42;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"uint64"}, {0}, std::to_string(result)));
  EXPECT_EQ(test_struct.uint64, result);
}

TEST(DiskStructTest, WriteFieldOfStructField) {
  TestStruct test_struct;
  uint8_t result = 42;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"child_test_struct", "child_uint8"},
                                           {0, 0}, std::to_string(result)));
  EXPECT_EQ(test_struct.child_test_struct.child_uint8, result);
}

TEST(DiskStructTest, WriteUint8ArrayFieldElement) {
  TestStruct test_struct;
  uint8_t result = 42;
  uint64_t index = element_count - 1;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"uint8_array"}, {index},
                                           std::to_string(result)));
  EXPECT_EQ(test_struct.uint8_array[index], result);
}

TEST(DiskStructTest, WriteUint16ArrayFieldElement) {
  TestStruct test_struct;
  uint16_t result = 42;
  uint64_t index = element_count - 1;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"uint16_array"}, {index},
                                           std::to_string(result)));
  EXPECT_EQ(test_struct.uint16_array[index], result);
}

TEST(DiskStructTest, WriteUint32ArrayFieldElement) {
  TestStruct test_struct;
  uint32_t result = 42;
  uint64_t index = element_count - 1;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"uint32_array"}, {index},
                                           std::to_string(result)));
  EXPECT_EQ(test_struct.uint32_array[index], result);
}

TEST(DiskStructTest, WriteUint64ArrayFieldElement) {
  TestStruct test_struct;
  uint64_t result = 42;
  uint64_t index = element_count - 1;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"uint64_array"}, {index},
                                           std::to_string(result)));
  EXPECT_EQ(test_struct.uint64_array[index], result);
}

TEST(DiskStructTest, WriteFieldOfStructArrayFieldElement) {
  TestStruct test_struct;
  uint8_t result = 42;
  uint64_t index = element_count - 1;
  std::unique_ptr<DiskStruct> disk_struct = BuildTestStruct();
  ASSERT_EQ(ZX_OK, disk_struct->WriteField(&test_struct, {"child_test_struct_array", "child_uint8"},
                                           {index, 0}, std::to_string(result)));
  EXPECT_EQ(test_struct.child_test_struct_array[index].child_uint8, result);
}

}  // namespace
}  // namespace disk_inspector