blob: c2229620efd4fe857ef1e64fdddc96452606c2a5 [file] [log] [blame]
// Copyright 2021 The Pigweed Authors
//
// 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.
#include "pw_string/util.h"
#include "gtest/gtest.h"
namespace pw::string {
namespace {
using namespace std::literals::string_view_literals;
TEST(ClampedLength, Nullptr_Returns0) {
EXPECT_EQ(0u, internal::ClampedLength(nullptr, 100));
}
TEST(ClampedLength, EmptyString_Returns0) {
EXPECT_EQ(0u, internal::ClampedLength("", 0));
EXPECT_EQ(0u, internal::ClampedLength("", 100));
}
TEST(ClampedLength, MaxLongerThanString_ReturnsStrlen) {
EXPECT_EQ(5u, internal::ClampedLength("12345", 100));
}
TEST(ClampedLength, StringMaxLongerThanMax_ReturnsMax) {
EXPECT_EQ(0u, internal::ClampedLength("12345", 0));
EXPECT_EQ(4u, internal::ClampedLength("12345", 4));
}
TEST(ClampedLength, LengthEqualsMax) {
EXPECT_EQ(5u, internal::ClampedLength("12345", 5));
}
TEST(ClampedCString, NullPtr_ReturnsEmpty) {
EXPECT_TRUE(ClampedCString(nullptr, 100).empty());
}
TEST(ClampedCString, EmptyString_Returns0) {
EXPECT_TRUE(ClampedCString("", 0).empty());
EXPECT_TRUE(ClampedCString("", 100).empty());
}
TEST(ClampedCString, MaxLongerThanString_ReturnsStr) {
static constexpr char kInput[] = "12345";
const std::string_view result = ClampedCString(kInput, 100);
EXPECT_EQ(result.size(), strlen(kInput));
EXPECT_EQ(result.data(), &kInput[0]);
}
TEST(ClampedCString, StringMaxLongerThanMax_ClampsView) {
static constexpr char kInput[] = "12345";
EXPECT_TRUE(ClampedCString(kInput, 0).empty());
const std::string_view result = ClampedCString(kInput, 4);
EXPECT_EQ(result.size(), 4u);
EXPECT_EQ(result.data(), &kInput[0]);
}
TEST(ClampedCString, FullStringView) {
static constexpr char kInput[] = "12345";
const std::string_view result = ClampedCString(kInput);
EXPECT_EQ(result.size(), strlen(kInput));
EXPECT_EQ(result.data(), &kInput[0]);
}
TEST(NullTerminatedLength, EmptyString_RequiresNullTerminator) {
EXPECT_TRUE(NullTerminatedLength("", 0).status().IsOutOfRange());
ASSERT_TRUE(NullTerminatedLength("", 100).status().ok());
EXPECT_EQ(0u, NullTerminatedLength("", 100).value());
}
TEST(NullTerminatedLength, MaxLongerThanString_ReturnsStrlen) {
ASSERT_TRUE(NullTerminatedLength("12345", 100).status().ok());
EXPECT_EQ(5u, NullTerminatedLength("12345", 100).value());
}
TEST(NullTerminatedLength, StringMaxLongerThanMax_Fails) {
EXPECT_TRUE(NullTerminatedLength("12345", 0).status().IsOutOfRange());
EXPECT_TRUE(NullTerminatedLength("12345", 4).status().IsOutOfRange());
}
TEST(NullTerminatedLength, LengthEqualsMax) {
static constexpr char kInput[] = "12345";
ASSERT_TRUE(NullTerminatedLength(kInput).ok());
EXPECT_EQ(5u, NullTerminatedLength(kInput).value());
}
class TestWithBuffer : public ::testing::Test {
protected:
static constexpr char kStartingString[] = "!@#$%^&*()!@#$%^&*()";
TestWithBuffer() { std::memcpy(buffer_, kStartingString, sizeof(buffer_)); }
char buffer_[sizeof(kStartingString)];
};
class CopyTest : public TestWithBuffer {};
TEST_F(CopyTest, EmptyStringView_WritesNullTerminator) {
EXPECT_EQ(0u, Copy("", buffer_).size());
EXPECT_EQ('\0', buffer_[0]);
}
TEST_F(CopyTest, EmptyBuffer_WritesNothing) {
auto result = Copy("Hello", std::span(buffer_, 0));
EXPECT_EQ(0u, result.size());
EXPECT_FALSE(result.ok());
EXPECT_STREQ(kStartingString, buffer_);
}
TEST_F(CopyTest, TooSmall_Truncates) {
auto result = Copy("Hi!", std::span(buffer_, 3));
EXPECT_EQ(2u, result.size());
EXPECT_FALSE(result.ok());
EXPECT_STREQ("Hi", buffer_);
}
TEST_F(CopyTest, ExactFit) {
auto result = Copy("Hi!", std::span(buffer_, 4));
EXPECT_EQ(3u, result.size());
EXPECT_TRUE(result.ok());
EXPECT_STREQ("Hi!", buffer_);
}
TEST_F(CopyTest, NullTerminatorsInString) {
ASSERT_EQ(4u, Copy("\0!\0\0"sv, std::span(buffer_, 5)).size());
EXPECT_EQ("\0!\0\0"sv, std::string_view(buffer_, 4));
}
class PrintableCopyTest : public TestWithBuffer {};
TEST_F(PrintableCopyTest, EmptyBuffer_WritesNothing) {
auto result = PrintableCopy("Hello", std::span(buffer_, 0));
EXPECT_EQ(0u, result.size());
EXPECT_FALSE(result.ok());
EXPECT_STREQ(kStartingString, buffer_);
}
TEST_F(PrintableCopyTest, TooSmall_Truncates) {
auto result = PrintableCopy("Hi!", std::span(buffer_, 3));
EXPECT_EQ(2u, result.size());
EXPECT_FALSE(result.ok());
EXPECT_STREQ("Hi", buffer_);
}
TEST_F(PrintableCopyTest, ExactFit) {
auto result = PrintableCopy("Hi!", std::span(buffer_, 4));
EXPECT_EQ(3u, result.size());
EXPECT_TRUE(result.ok());
EXPECT_STREQ("Hi!", buffer_);
}
TEST_F(PrintableCopyTest, StartingString) {
memset(buffer_, '\0', sizeof(buffer_));
auto result = PrintableCopy(kStartingString, std::span(buffer_));
EXPECT_EQ(sizeof(kStartingString) - 1, result.size());
EXPECT_TRUE(result.ok());
EXPECT_STREQ(kStartingString, buffer_);
}
TEST_F(PrintableCopyTest, NullTerminatorsInString) {
ASSERT_EQ(4u, PrintableCopy("\0!\0\0"sv, std::span(buffer_, 5)).size());
EXPECT_STREQ(".!..", buffer_);
}
TEST_F(PrintableCopyTest, ControlCharsInString) {
ASSERT_EQ(14u,
PrintableCopy("\n!\t\n\x10\x7F\xFF\vabcd\b\r"sv, std::span(buffer_))
.size());
EXPECT_STREQ(".!......abcd..", buffer_);
}
} // namespace
} // namespace pw::string