zircon/kernel/tests/string_file_tests.cc - fuchsia - Git at Google

 // Copyright 2021 The Fuchsia Authors
 //
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT

 #include <lib/unittest/unittest.h>
 #include <string-file.h>

 #include "ktl/array.h"
 #include "ktl/string_view.h"

 namespace {

 constexpr char kVal = static_cast<char>(-1);

 bool WriteOnEmptyBufferIsOk() {
   BEGIN_TEST;
   constexpr ktl::string_view kInput = "12345";

   StringFile sfile(ktl::span<char>{});
   EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));

   END_TEST;
 }

 bool WriteEmptyStringViewIsOk() {
   BEGIN_TEST;
   ktl::array<char, 1> buffer = {};

   StringFile sfile(buffer);

   EXPECT_EQ(sfile.Write({}), 0);

   auto writen_view = std::move(sfile).take();
   ASSERT_FALSE(writen_view.empty());
   ASSERT_EQ(buffer.front(), '\0');

   END_TEST;
 }

 bool WriteStringViewThatFitsInBuffer() {
   BEGIN_TEST;
   constexpr ktl::string_view kInput = "12345";
   ktl::array<char, kInput.length() + 1> buffer = {};

   StringFile sfile(buffer);

   EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));

   auto writen_view = std::move(sfile).take();

   EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), kInput.size()) == 0);
   ASSERT_TRUE(writen_view.data() == buffer.data());

   END_TEST;
 }

 bool WriteTruncateStringViewThatDoesntFitsInBuffer() {
   BEGIN_TEST;
   constexpr ktl::string_view kInput = "12345";
   // We would reserve last char for '\0'
   ktl::array<char, kInput.length()> buffer = {};

   StringFile sfile(buffer);

   EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));

   auto writen_view = std::move(sfile).take();

   ASSERT_EQ(writen_view.size(), kInput.size());
   EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), writen_view.size() - 1) == 0);
   ASSERT_EQ(buffer.back(), '\0');
   ASSERT_TRUE(writen_view.data() == buffer.data());

   END_TEST;
 }

 bool WriteManyTimes() {
   BEGIN_TEST;
   constexpr ktl::string_view kInput = "12345";
   // We would reserve last char for '\0'
   ktl::array<char, kInput.length()> buffer = {kVal, kVal, kVal, kVal, kVal};

   StringFile sfile(buffer);

   EXPECT_EQ(sfile.Write(kInput.substr(0, 2)), 2);
   EXPECT_TRUE(memcmp(buffer.data(), kInput.data(), 2) == 0);

   EXPECT_EQ(sfile.Write(kInput.substr(2, 1)), 1);
   EXPECT_TRUE(memcmp(buffer.data() + 2, kInput.data() + 2, 1) == 0);

   EXPECT_EQ(sfile.Write(kInput.substr(3, 2)), 2);
   EXPECT_TRUE(memcmp(buffer.data() + 3, kInput.data() + 3, 1) == 0);

   ASSERT_EQ(buffer.back(), kVal);

   auto writen_view = std::move(sfile).take();

   ASSERT_EQ(writen_view.size(), kInput.size());
   EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), writen_view.size() - 1) == 0);
   ASSERT_EQ(buffer.back(), '\0');
   ASSERT_TRUE(writen_view.data() == buffer.data());

   END_TEST;
 }

 bool TakeAddsNullCharacter() {
   BEGIN_TEST;
   constexpr ktl::string_view kInput = "12345";
   // We would reserve last char for '\0'
   ktl::array<char, kInput.length()> buffer = {kVal, kVal, kVal, kVal, kVal};

   StringFile sfile(buffer);

   EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));
   // Write should not have set the last character set yet.
   ASSERT_EQ(buffer.back(), kVal);

   auto writen_view = std::move(sfile).take();
   ASSERT_EQ(buffer.back(), '\0');

   ASSERT_EQ(writen_view.size(), kInput.size());
   EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), writen_view.size() - 1) == 0);
   ASSERT_TRUE(writen_view.data() == buffer.data());

   END_TEST;
 }

 bool TakeOnEmptyBufferIsEmpty() {
   BEGIN_TEST;

   StringFile sfile(ktl::span<char>{});
   auto writen_view = std::move(sfile).take();
   ASSERT_TRUE(writen_view.empty());

   END_TEST;
 }

 bool AvailableUsedSpace() {
   BEGIN_TEST;

   auto Validate = [](const StringFile& file, const char* buffer, size_t capacity,
                      size_t written) -> bool {
     BEGIN_TEST;

     const size_t effective_capacity = (capacity > 0) ? capacity - 1 : 0;
     const size_t expected_used = ktl::min(written, effective_capacity);
     const size_t expected_avail = effective_capacity - expected_used;
     const char* const expected_used_base = (expected_used > 0) ? buffer : nullptr;
     const char* const expected_avail_base = (expected_avail > 0) ? buffer + expected_used : nullptr;

     ASSERT_EQ(expected_used, file.used_region().size());
     ASSERT_EQ(expected_avail, file.available_region().size());

     ktl::span<char> used_region = file.used_region();
     ASSERT_EQ(expected_used_base, used_region.data());
     ASSERT_EQ(expected_used, used_region.size());

     ktl::span<char> available_region = file.available_region();
     ASSERT_EQ(expected_avail_base, available_region.data());
     ASSERT_EQ(expected_avail, available_region.size());

     END_TEST;
   };

   // Empty files should always report no space remaining, and no space used.
   StringFile empty_file(ktl::span<char>{});
   ASSERT_TRUE(Validate(empty_file, nullptr, 0, 0));

   // Writing to the file with no buffer should not change anything.
   empty_file.Write(ktl::string_view("x"));
   ASSERT_TRUE(Validate(empty_file, nullptr, 0, 1));

   // Repeat the tests, but now with a file backed by a non-empty buffer.
   char buffer[4];
   StringFile sfile(ktl::span<char>{buffer, sizeof(buffer)});
   for (size_t i = 0; i < sizeof(buffer); ++i) {
     ASSERT_TRUE(Validate(sfile, buffer, sizeof(buffer), i));
     sfile.Write(ktl::string_view("x"));
     ASSERT_TRUE(Validate(sfile, buffer, sizeof(buffer), i + 1));
   }

   END_TEST;
 }

 bool Skip() {
   BEGIN_TEST;

   char buffer[10]{0};

   // Skip a part of the start of the file, but overwrite the end.
   {
     memset(buffer, 'x', ktl::size(buffer));
     StringFile sfile{ktl::span<char>(buffer, ktl::size(buffer))};

     sfile.Skip(3);
     sfile.Write("123456789abcde");

     constexpr const char* expected_str = "xxx123456";
     ktl::span<char> actual_str = std::move(sfile).take();
     ASSERT_EQ(ktl::size(buffer), actual_str.size());
     ASSERT_EQ(ktl::size(buffer), strlen(expected_str) + 1);
     ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected_str),
                     reinterpret_cast<const uint8_t*>(actual_str.data()), ktl::size(buffer));
   }

   // Skip some of the middle of a file.
   {
     memset(buffer, 'x', ktl::size(buffer));
     StringFile sfile{ktl::span<char>(buffer, ktl::size(buffer))};

     sfile.Write("123");
     sfile.Skip(3);
     sfile.Write("456789abcde");

     constexpr const char* expected_str = "123xxx456";
     ktl::span<char> actual_str = std::move(sfile).take();
     ASSERT_EQ(ktl::size(buffer), actual_str.size());
     ASSERT_EQ(ktl::size(buffer), strlen(expected_str) + 1);
     ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected_str),
                     reinterpret_cast<const uint8_t*>(actual_str.data()), ktl::size(buffer));
   }

   // Attempt to skip past the end of a file.
   {
     memset(buffer, 'x', ktl::size(buffer));
     StringFile sfile{ktl::span<char>(buffer, ktl::size(buffer))};

     sfile.Write("123456");
     sfile.Skip(30);
     sfile.Write("789abcde");

     constexpr const char* expected_str = "123456xxx";
     ktl::span<char> actual_str = std::move(sfile).take();
     ASSERT_EQ(ktl::size(buffer), actual_str.size());
     ASSERT_EQ(ktl::size(buffer), strlen(expected_str) + 1);
     ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected_str),
                     reinterpret_cast<const uint8_t*>(actual_str.data()), ktl::size(buffer));
   }

   END_TEST;
 }

 bool StringViewConversion() {
   BEGIN_TEST;

   auto Validate = [](const StringFile& file, const ktl::string_view expected) -> bool {
     BEGIN_TEST;

     ktl::string_view sv;

     // Test the |as_string_view| method.
     sv = file.as_string_view();
     ASSERT_EQ(expected.size(), sv.size());
     if (!expected.size()) {
       ASSERT_NULL(sv.data());
     } else {
       ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected.data()),
                       reinterpret_cast<const uint8_t*>(sv.data()), expected.size());
     }

     // Same test, but used the explicit conversion operator instead.
     sv = static_cast<ktl::string_view>(file);
     ASSERT_EQ(expected.size(), sv.size());
     if (!expected.size()) {
       ASSERT_NULL(sv.data());
     } else {
       ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected.data()),
                       reinterpret_cast<const uint8_t*>(sv.data()), expected.size());
     }

     END_TEST;
   };

   {
     // A file with no buffer should always yield an empty string view.
     StringFile empty_file(ktl::span<char>({}));
     ASSERT_TRUE(Validate(empty_file, {}));

     // Attempting to write to the file should not change this.
     empty_file.Write("12345");
     ASSERT_TRUE(Validate(empty_file, {}));
   }

   {
     constexpr ktl::string_view kPattern{"1234"};
     char buffer[10]{0};
     StringFile sfile({buffer, sizeof(buffer)});

     ASSERT_TRUE(Validate(sfile, {}));
     sfile.Write(kPattern);
     ASSERT_TRUE(Validate(sfile, {"1234"}));
     sfile.Write(kPattern);
     ASSERT_TRUE(Validate(sfile, {"12341234"}));
     sfile.Write(kPattern);
     ASSERT_TRUE(Validate(sfile, {"123412341"}));
     sfile.Write(kPattern);
     ASSERT_TRUE(Validate(sfile, {"123412341"}));
   }

   END_TEST;
 }

 }  // namespace

 UNITTEST_START_TESTCASE(string_file_tests)
 UNITTEST("StringFile::Write - With Empty Buffer", WriteOnEmptyBufferIsOk)
 UNITTEST("StringFile::Write - With Empty Input", WriteEmptyStringViewIsOk)
 UNITTEST("StringFile::Write - Input fits in buffer", WriteStringViewThatFitsInBuffer)
 UNITTEST("StringFile::Write - Input does not fit in buffer",
          WriteTruncateStringViewThatDoesntFitsInBuffer)
 UNITTEST("StringFile::Write - Multiple Calls are correct", WriteManyTimes)
 UNITTEST("StringFile::take - Adds Null Character", TakeAddsNullCharacter)
 UNITTEST("StringFile::take - Empty Buffer", TakeOnEmptyBufferIsEmpty)
 UNITTEST("StringFile avail/used space", AvailableUsedSpace)
 UNITTEST("StringFile::Skip", Skip)
 UNITTEST("StringFile string_view conversion", StringViewConversion)
 UNITTEST_END_TESTCASE(string_file_tests, "string_file", "StringFile tests")
	// Copyright 2021 The Fuchsia Authors
	//
	// Use of this source code is governed by a MIT-style
	// license that can be found in the LICENSE file or at
	// https://opensource.org/licenses/MIT

	#include <lib/unittest/unittest.h>
	#include <string-file.h>

	#include "ktl/array.h"
	#include "ktl/string_view.h"

	namespace {

	constexpr char kVal = static_cast<char>(-1);

	bool WriteOnEmptyBufferIsOk() {
	BEGIN_TEST;
	constexpr ktl::string_view kInput = "12345";

	StringFile sfile(ktl::span<char>{});
	EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));

	END_TEST;
	}

	bool WriteEmptyStringViewIsOk() {
	BEGIN_TEST;
	ktl::array<char, 1> buffer = {};

	StringFile sfile(buffer);

	EXPECT_EQ(sfile.Write({}), 0);

	auto writen_view = std::move(sfile).take();
	ASSERT_FALSE(writen_view.empty());
	ASSERT_EQ(buffer.front(), '\0');

	END_TEST;
	}

	bool WriteStringViewThatFitsInBuffer() {
	BEGIN_TEST;
	constexpr ktl::string_view kInput = "12345";
	ktl::array<char, kInput.length() + 1> buffer = {};

	StringFile sfile(buffer);

	EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));

	auto writen_view = std::move(sfile).take();

	EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), kInput.size()) == 0);
	ASSERT_TRUE(writen_view.data() == buffer.data());

	END_TEST;
	}

	bool WriteTruncateStringViewThatDoesntFitsInBuffer() {
	BEGIN_TEST;
	constexpr ktl::string_view kInput = "12345";
	// We would reserve last char for '\0'
	ktl::array<char, kInput.length()> buffer = {};

	StringFile sfile(buffer);

	EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));

	auto writen_view = std::move(sfile).take();

	ASSERT_EQ(writen_view.size(), kInput.size());
	EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), writen_view.size() - 1) == 0);
	ASSERT_EQ(buffer.back(), '\0');
	ASSERT_TRUE(writen_view.data() == buffer.data());

	END_TEST;
	}

	bool WriteManyTimes() {
	BEGIN_TEST;
	constexpr ktl::string_view kInput = "12345";
	// We would reserve last char for '\0'
	ktl::array<char, kInput.length()> buffer = {kVal, kVal, kVal, kVal, kVal};

	StringFile sfile(buffer);

	EXPECT_EQ(sfile.Write(kInput.substr(0, 2)), 2);
	EXPECT_TRUE(memcmp(buffer.data(), kInput.data(), 2) == 0);

	EXPECT_EQ(sfile.Write(kInput.substr(2, 1)), 1);
	EXPECT_TRUE(memcmp(buffer.data() + 2, kInput.data() + 2, 1) == 0);

	EXPECT_EQ(sfile.Write(kInput.substr(3, 2)), 2);
	EXPECT_TRUE(memcmp(buffer.data() + 3, kInput.data() + 3, 1) == 0);

	ASSERT_EQ(buffer.back(), kVal);

	auto writen_view = std::move(sfile).take();

	ASSERT_EQ(writen_view.size(), kInput.size());
	EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), writen_view.size() - 1) == 0);
	ASSERT_EQ(buffer.back(), '\0');
	ASSERT_TRUE(writen_view.data() == buffer.data());

	END_TEST;
	}

	bool TakeAddsNullCharacter() {
	BEGIN_TEST;
	constexpr ktl::string_view kInput = "12345";
	// We would reserve last char for '\0'
	ktl::array<char, kInput.length()> buffer = {kVal, kVal, kVal, kVal, kVal};

	StringFile sfile(buffer);

	EXPECT_EQ(sfile.Write(kInput), static_cast<int>(kInput.size()));
	// Write should not have set the last character set yet.
	ASSERT_EQ(buffer.back(), kVal);

	auto writen_view = std::move(sfile).take();
	ASSERT_EQ(buffer.back(), '\0');

	ASSERT_EQ(writen_view.size(), kInput.size());
	EXPECT_TRUE(memcmp(writen_view.data(), kInput.data(), writen_view.size() - 1) == 0);
	ASSERT_TRUE(writen_view.data() == buffer.data());

	END_TEST;
	}

	bool TakeOnEmptyBufferIsEmpty() {
	BEGIN_TEST;

	StringFile sfile(ktl::span<char>{});
	auto writen_view = std::move(sfile).take();
	ASSERT_TRUE(writen_view.empty());

	END_TEST;
	}

	bool AvailableUsedSpace() {
	BEGIN_TEST;

	auto Validate = [](const StringFile& file, const char* buffer, size_t capacity,
	size_t written) -> bool {
	BEGIN_TEST;

	const size_t effective_capacity = (capacity > 0) ? capacity - 1 : 0;
	const size_t expected_used = ktl::min(written, effective_capacity);
	const size_t expected_avail = effective_capacity - expected_used;
	const char* const expected_used_base = (expected_used > 0) ? buffer : nullptr;
	const char* const expected_avail_base = (expected_avail > 0) ? buffer + expected_used : nullptr;

	ASSERT_EQ(expected_used, file.used_region().size());
	ASSERT_EQ(expected_avail, file.available_region().size());

	ktl::span<char> used_region = file.used_region();
	ASSERT_EQ(expected_used_base, used_region.data());
	ASSERT_EQ(expected_used, used_region.size());

	ktl::span<char> available_region = file.available_region();
	ASSERT_EQ(expected_avail_base, available_region.data());
	ASSERT_EQ(expected_avail, available_region.size());

	END_TEST;
	};

	// Empty files should always report no space remaining, and no space used.
	StringFile empty_file(ktl::span<char>{});
	ASSERT_TRUE(Validate(empty_file, nullptr, 0, 0));

	// Writing to the file with no buffer should not change anything.
	empty_file.Write(ktl::string_view("x"));
	ASSERT_TRUE(Validate(empty_file, nullptr, 0, 1));

	// Repeat the tests, but now with a file backed by a non-empty buffer.
	char buffer[4];
	StringFile sfile(ktl::span<char>{buffer, sizeof(buffer)});
	for (size_t i = 0; i < sizeof(buffer); ++i) {
	ASSERT_TRUE(Validate(sfile, buffer, sizeof(buffer), i));
	sfile.Write(ktl::string_view("x"));
	ASSERT_TRUE(Validate(sfile, buffer, sizeof(buffer), i + 1));
	}

	END_TEST;
	}

	bool Skip() {
	BEGIN_TEST;

	char buffer[10]{0};

	// Skip a part of the start of the file, but overwrite the end.
	{
	memset(buffer, 'x', ktl::size(buffer));
	StringFile sfile{ktl::span<char>(buffer, ktl::size(buffer))};

	sfile.Skip(3);
	sfile.Write("123456789abcde");

	constexpr const char* expected_str = "xxx123456";
	ktl::span<char> actual_str = std::move(sfile).take();
	ASSERT_EQ(ktl::size(buffer), actual_str.size());
	ASSERT_EQ(ktl::size(buffer), strlen(expected_str) + 1);
	ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected_str),
	reinterpret_cast<const uint8_t*>(actual_str.data()), ktl::size(buffer));
	}

	// Skip some of the middle of a file.
	{
	memset(buffer, 'x', ktl::size(buffer));
	StringFile sfile{ktl::span<char>(buffer, ktl::size(buffer))};

	sfile.Write("123");
	sfile.Skip(3);
	sfile.Write("456789abcde");

	constexpr const char* expected_str = "123xxx456";
	ktl::span<char> actual_str = std::move(sfile).take();
	ASSERT_EQ(ktl::size(buffer), actual_str.size());
	ASSERT_EQ(ktl::size(buffer), strlen(expected_str) + 1);
	ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected_str),
	reinterpret_cast<const uint8_t*>(actual_str.data()), ktl::size(buffer));
	}

	// Attempt to skip past the end of a file.
	{
	memset(buffer, 'x', ktl::size(buffer));
	StringFile sfile{ktl::span<char>(buffer, ktl::size(buffer))};

	sfile.Write("123456");
	sfile.Skip(30);
	sfile.Write("789abcde");

	constexpr const char* expected_str = "123456xxx";
	ktl::span<char> actual_str = std::move(sfile).take();
	ASSERT_EQ(ktl::size(buffer), actual_str.size());
	ASSERT_EQ(ktl::size(buffer), strlen(expected_str) + 1);
	ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected_str),
	reinterpret_cast<const uint8_t*>(actual_str.data()), ktl::size(buffer));
	}

	END_TEST;
	}

	bool StringViewConversion() {
	BEGIN_TEST;

	auto Validate = [](const StringFile& file, const ktl::string_view expected) -> bool {
	BEGIN_TEST;

	ktl::string_view sv;

	// Test the \|as_string_view\| method.
	sv = file.as_string_view();
	ASSERT_EQ(expected.size(), sv.size());
	if (!expected.size()) {
	ASSERT_NULL(sv.data());
	} else {
	ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected.data()),
	reinterpret_cast<const uint8_t*>(sv.data()), expected.size());
	}

	// Same test, but used the explicit conversion operator instead.
	sv = static_cast<ktl::string_view>(file);
	ASSERT_EQ(expected.size(), sv.size());
	if (!expected.size()) {
	ASSERT_NULL(sv.data());
	} else {
	ASSERT_BYTES_EQ(reinterpret_cast<const uint8_t*>(expected.data()),
	reinterpret_cast<const uint8_t*>(sv.data()), expected.size());
	}

	END_TEST;
	};

	{
	// A file with no buffer should always yield an empty string view.
	StringFile empty_file(ktl::span<char>({}));
	ASSERT_TRUE(Validate(empty_file, {}));

	// Attempting to write to the file should not change this.
	empty_file.Write("12345");
	ASSERT_TRUE(Validate(empty_file, {}));
	}

	{
	constexpr ktl::string_view kPattern{"1234"};
	char buffer[10]{0};
	StringFile sfile({buffer, sizeof(buffer)});

	ASSERT_TRUE(Validate(sfile, {}));
	sfile.Write(kPattern);
	ASSERT_TRUE(Validate(sfile, {"1234"}));
	sfile.Write(kPattern);
	ASSERT_TRUE(Validate(sfile, {"12341234"}));
	sfile.Write(kPattern);
	ASSERT_TRUE(Validate(sfile, {"123412341"}));
	sfile.Write(kPattern);
	ASSERT_TRUE(Validate(sfile, {"123412341"}));
	}

	END_TEST;
	}

	} // namespace

	UNITTEST_START_TESTCASE(string_file_tests)
	UNITTEST("StringFile::Write - With Empty Buffer", WriteOnEmptyBufferIsOk)
	UNITTEST("StringFile::Write - With Empty Input", WriteEmptyStringViewIsOk)
	UNITTEST("StringFile::Write - Input fits in buffer", WriteStringViewThatFitsInBuffer)
	UNITTEST("StringFile::Write - Input does not fit in buffer",
	WriteTruncateStringViewThatDoesntFitsInBuffer)
	UNITTEST("StringFile::Write - Multiple Calls are correct", WriteManyTimes)
	UNITTEST("StringFile::take - Adds Null Character", TakeAddsNullCharacter)
	UNITTEST("StringFile::take - Empty Buffer", TakeOnEmptyBufferIsEmpty)
	UNITTEST("StringFile avail/used space", AvailableUsedSpace)
	UNITTEST("StringFile::Skip", Skip)
	UNITTEST("StringFile string_view conversion", StringViewConversion)
	UNITTEST_END_TESTCASE(string_file_tests, "string_file", "StringFile tests")