// 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 "array-tests.h"

#include <limits>

#include "bootfs-tests.h"
#include "tests.h"

namespace {

using FblUint64ArrayTestTraits = FblArrayTestTraits<uint64_t>;

TEST(ZbitlImageFblByteArrayTests, ExtendBogusZbi) {
  ASSERT_NO_FATAL_FAILURE(TestExtendBogusZbiImage<FblByteArrayTestTraits>());
}

TEST(ZbitlViewFblByteArrayTests, DefaultConstructed) {
  ASSERT_NO_FATAL_FAILURE(TestDefaultConstructedView<FblByteArrayTestTraits>());
}

TEST(ZbitlViewFblByteArrayTests, CreateFromBogusZbi) {
  ASSERT_NO_FATAL_FAILURE(TestViewFromBogusZbi<FblByteArrayTestTraits>());
}

TEST_ITERATION(ZbitlViewFblByteArrayTests, FblByteArrayTestTraits)

TEST_MUTATION(ZbitlViewFblByteArrayTests, FblByteArrayTestTraits)

TEST_COPY_CREATION(ZbitlViewFblByteArrayTests, FblByteArrayTestTraits)

TEST(ZbitlImageFblByteArrayTests, Appending) {
  ASSERT_NO_FATAL_FAILURE(TestAppending<FblByteArrayTestTraits>());
}

TEST(ZbitlViewFblUint64ArrayTests, DefaultConstructed) {
  ASSERT_NO_FATAL_FAILURE(TestDefaultConstructedView<FblUint64ArrayTestTraits>());
}

// TODO(joshuaseaton): Use ZBIs with payload size divisible by eight so we can
// further test FblUint64ArrayTestTraits.

TEST(ZbitlViewFblByteArrayTests, BoundsChecking) {
  using TestTraits = FblByteArrayTestTraits;

  files::ScopedTempDir dir;
  fbl::unique_fd fd;
  size_t size = 0;
  ASSERT_NO_FATAL_FAILURE(OpenTestDataZbi(TestDataZbiType::kOneItem, dir.path(), &fd, &size));

  typename TestTraits::Context context;
  ASSERT_NO_FATAL_FAILURE(TestTraits::Create(std::move(fd), size, &context));
  zbitl::View view(context.TakeStorage());

  ASSERT_EQ(kOneItemZbiSize, view.size_bytes());

  // Byte-range, direct copy: offset + length exceeds ZBI size
  {
    std::byte buff[kOneItemZbiSize];
    std::span to{buff, kOneItemZbiSize};
    auto result = view.Copy(to, kOneItemZbiSize, 1u);
    ASSERT_TRUE(result.is_error());
    EXPECT_EQ("offset + length exceeds ZBI size", std::move(result).error_value().zbi_error);
  }

  // Byte-range, direct copy: to_offset + length overflows
  {
    std::byte buff[kOneItemZbiSize];
    std::span to{buff, kOneItemZbiSize};
    auto result = view.Copy(to, 0u, 1u, std::numeric_limits<uint32_t>::max());
    ASSERT_TRUE(result.is_error());
    EXPECT_EQ("to_offset + length overflows", std::move(result).error_value().zbi_error);
  }

  // Byte-range copy-creation: offset + length exceeds ZBI size.
  {
    auto result = view.Copy(kOneItemZbiSize, 1u);
    ASSERT_TRUE(result.is_error());
    EXPECT_EQ("offset + length exceeds ZBI size", std::move(result).error_value().zbi_error);
  }

  // Byte-range, copy-creation: to_offset + length overflows.
  {
    auto result = view.Copy(0u, 1u, std::numeric_limits<uint32_t>::max());
    ASSERT_TRUE(result.is_error());
    EXPECT_EQ("to_offset + length overflows", std::move(result).error_value().zbi_error);
  }
}

TEST(StorageFromRawHeader, Creation) {
  // Create a simple in-memory ZBI with a single item payload.
  zbitl::Image<fbl::Array<std::byte>> image;
  ASSERT_TRUE(image.clear().is_ok());
  ASSERT_TRUE(image.Append(zbi_header_t{.type = ZBI_TYPE_DISCARD}, {}).is_ok());
  std::byte* raw_pointer = image.storage().data();
  const zbi_header_t* header = reinterpret_cast<zbi_header_t*>(raw_pointer);

  {
    auto view = zbitl::StorageFromRawHeader(header);  // default type is a ByteView
    EXPECT_EQ(view.data(), raw_pointer);
    EXPECT_EQ(view.size(), image.size_bytes());
  }
  {
    auto view = zbitl::StorageFromRawHeader<std::span<const std::byte>>(header);
    EXPECT_EQ(view.data(), raw_pointer);
    EXPECT_EQ(view.size(), image.size_bytes());
  }
}

TEST(StorageFromRawHeader, BadHeader) {
  // Create a zbi_header_t with invalid magic.
  constexpr zbi_header_t header = {
      .length = 12345,
  };

  // Ensure that the length field was ignored, and that the returned span only
  // covers the zbi_header_t itself.
  zbitl::ByteView view = zbitl::StorageFromRawHeader(&header);
  EXPECT_EQ(view.size(), sizeof(zbi_header_t));
  EXPECT_EQ(view.data(), reinterpret_cast<const std::byte*>(&header));
}

TEST(ZbitlBootfsFblByteArrayTests, Iteration) {
  ASSERT_NO_FATAL_FAILURE(TestBootfsIteration<FblByteArrayTestTraits>());
}

TEST(ZbitlBootfsFblByteArrayTests, Subdirectory) {
  ASSERT_NO_FATAL_FAILURE(TestBootfsSubdirectory<FblByteArrayTestTraits>());
}

}  // namespace