zircon/system/ulib/fbl/test/string_buffer_tests.cc

// Copyright 2017 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 <fbl/string_buffer.h>
#include <zxtest/zxtest.h>

#define EXPECT_DATA_AND_LENGTH(expected, actual)  \
  do {                                            \
    EXPECT_STR_EQ(expected, actual.data());       \
    EXPECT_EQ(strlen(expected), actual.length()); \
  } while (false)

namespace {

// Note: |runnable| can't be a reference since that'd make the behavior of
// |va_start()| undefined.
template <typename Runnable>
void VAListHelper(Runnable runnable, ...) {
  va_list ap;
  va_start(ap, runnable);
  runnable(ap);
  va_end(ap);
}

TEST(StringBufferTest, Capacity) {
  {
    fbl::StringBuffer<0u> buf;
    EXPECT_EQ(0u, buf.capacity());
  }

  {
    fbl::StringBuffer<100u> buf;
    EXPECT_EQ(100u, buf.capacity());
  }
}

TEST(StringBufferTest, EmptyString) {
  {
    fbl::StringBuffer<0u> empty;

    EXPECT_STR_EQ("", empty.data());
    EXPECT_STR_EQ("", empty.c_str());

    EXPECT_EQ(0u, empty.length());
    EXPECT_EQ(0u, empty.size());
    EXPECT_TRUE(empty.empty());
    EXPECT_EQ(0u, empty.capacity());

    EXPECT_STR_EQ("", empty.begin());
    EXPECT_EQ(0u, empty.end() - empty.begin());
    EXPECT_STR_EQ("", empty.cbegin());
    EXPECT_EQ(0u, empty.cend() - empty.cbegin());

    EXPECT_EQ(0, empty[0u]);
  }

  {
    fbl::StringBuffer<16u> empty;

    EXPECT_STR_EQ("", empty.data());
    EXPECT_STR_EQ("", empty.c_str());

    EXPECT_EQ(0u, empty.length());
    EXPECT_EQ(0u, empty.size());
    EXPECT_TRUE(empty.empty());
    EXPECT_EQ(16u, empty.capacity());

    EXPECT_STR_EQ("", empty.begin());
    EXPECT_EQ(0u, empty.end() - empty.begin());
    EXPECT_STR_EQ("", empty.cbegin());
    EXPECT_EQ(0u, empty.cend() - empty.cbegin());

    EXPECT_EQ(0, empty[0u]);
  }
}

TEST(StringBufferTest, Append) {
  {
    fbl::StringBuffer<16u> str;
    str.Append('a')
        .Append('b')
        .Append("cd")
        .Append("efghi", 3u)
        .Append(fbl::StringPiece("hijkl", 3u))
        .Append(fbl::String("klmnopqrstuvwxyz"))
        .Append('z')  // these will be truncated away
        .Append("zz")
        .Append("zzzzzz", 3u)
        .Append(fbl::StringPiece("zzzzz", 3u))
        .Append(fbl::String("zzzzz"));

    EXPECT_STR_EQ("abcdefghijklmnop", str.data());
    EXPECT_STR_EQ("abcdefghijklmnop", str.c_str());

    EXPECT_EQ(16u, str.length());
    EXPECT_EQ(16u, str.size());
    EXPECT_FALSE(str.empty());
    EXPECT_EQ(16u, str.capacity());

    EXPECT_STR_EQ("abcdefghijklmnop", str.begin());
    EXPECT_EQ(16u, str.end() - str.begin());
    EXPECT_STR_EQ("abcdefghijklmnop", str.cbegin());
    EXPECT_EQ(16u, str.cend() - str.cbegin());

    EXPECT_EQ('b', str[1u]);
  }

  {
    fbl::StringBuffer<3u> str;
    str.Append('a');
    EXPECT_DATA_AND_LENGTH("a", str);
    str.Append('b');
    EXPECT_DATA_AND_LENGTH("ab", str);
    str.Append('c');
    EXPECT_DATA_AND_LENGTH("abc", str);
    str.Append('d');
    EXPECT_DATA_AND_LENGTH("abc", str);
  }

  {
    fbl::StringBuffer<3u> str;
    str.Append("ab");
    EXPECT_DATA_AND_LENGTH("ab", str);
    str.Append("");
    EXPECT_DATA_AND_LENGTH("ab", str);
    str.Append("cdefg");
    EXPECT_DATA_AND_LENGTH("abc", str);
  }

  {
    fbl::StringBuffer<3u> str;
    str.Append("abcdef", 2u);
    EXPECT_DATA_AND_LENGTH("ab", str);
    str.Append("zzzz", 0u);
    EXPECT_DATA_AND_LENGTH("ab", str);
    str.Append("cdefghijk", 5u);
    EXPECT_DATA_AND_LENGTH("abc", str);
  }

  {
    fbl::StringBuffer<3u> str;
    str.Append(fbl::StringPiece("abcdef", 2u));
    EXPECT_DATA_AND_LENGTH("ab", str);
    str.Append(fbl::StringPiece("zzzz", 0u));
    EXPECT_DATA_AND_LENGTH("ab", str);
    str.Append(fbl::StringPiece("cdefghijk", 5u));
    EXPECT_DATA_AND_LENGTH("abc", str);
  }

  {
    fbl::StringBuffer<3u> str;
    str.Append(fbl::String("ab"));
    EXPECT_DATA_AND_LENGTH("ab", str);
    str.Append(fbl::String());
    EXPECT_DATA_AND_LENGTH("ab", str);
    str.Append(fbl::String("cdefg"));
    EXPECT_DATA_AND_LENGTH("abc", str);
  }
}

TEST(StringBufferTest, AppendPrintf) {
  {
    fbl::StringBuffer<12u> str;
    str.AppendPrintf("abc");
    EXPECT_DATA_AND_LENGTH("abc", str);
    str.AppendPrintf("%d,%s", 20, "de").Append('f');
    EXPECT_DATA_AND_LENGTH("abc20,def", str);
    str.AppendPrintf("%d", 123456789);
    EXPECT_DATA_AND_LENGTH("abc20,def123", str);
  }

  {
    fbl::StringBuffer<12u> str;
    VAListHelper([&str](va_list ap) { str.AppendVPrintf("abc", ap); });
    EXPECT_DATA_AND_LENGTH("abc", str);
    VAListHelper([&str](va_list ap) { str.AppendVPrintf("%d,%s", ap).Append('f'); }, 20, "de");
    EXPECT_DATA_AND_LENGTH("abc20,def", str);
    VAListHelper([&str](va_list ap) { str.AppendVPrintf("%d", ap); }, 123456789);
    EXPECT_DATA_AND_LENGTH("abc20,def123", str);
  }
}

TEST(StringBufferTest, Modify) {
  fbl::StringBuffer<16u> str;
  str.Append("abcdef");

  EXPECT_EQ('c', str[2u]);
  str[2u] = 'x';
  EXPECT_EQ('x', str[2u]);
  EXPECT_DATA_AND_LENGTH("abxdef", str);

  memcpy(str.data(), "yyyy", 4u);
  EXPECT_DATA_AND_LENGTH("yyyyef", str);
}

TEST(StringBufferTest, Resize) {
  fbl::StringBuffer<16u> str;

  str.Resize(4u, 'x');
  EXPECT_STR_EQ("xxxx", str.data());
  EXPECT_EQ(4u, str.length());

  str.Resize(8u, 'y');
  EXPECT_STR_EQ("xxxxyyyy", str.data());
  EXPECT_EQ(8u, str.length());

  str.Resize(16u);
  EXPECT_STR_EQ("xxxxyyyy", str.data());
  EXPECT_EQ(0, memcmp("xxxxyyyy\0\0\0\0\0\0\0\0\0", str.data(), str.length() + 1));
  EXPECT_EQ(16u, str.length());

  str.Resize(0u);
  EXPECT_STR_EQ("", str.data());
  EXPECT_EQ(0u, str.length());
}

TEST(StringBufferTest, Clear) {
  fbl::StringBuffer<16u> str;
  str.Append("abcdef");

  str.Clear();
  EXPECT_STR_EQ("", str.data());
  EXPECT_EQ(0u, str.length());
}

TEST(StringBufferTest, ToString) {
  fbl::StringBuffer<16u> buf;
  buf.Append("abcdef");

  fbl::String str = buf.ToString();
  EXPECT_TRUE(str == "abcdef");
}

TEST(StringBufferTest, ToStringPiece) {
  fbl::StringBuffer<16u> buf;
  buf.Append("abcdef");

  fbl::StringPiece piece = buf.ToStringPiece();
  EXPECT_EQ(buf.data(), piece.data());
  EXPECT_EQ(buf.length(), piece.length());
}

}  // namespace