Introduce MinidumpWritable, its dependencies, and their tests

util/file/string_file_writer_test.cc

Index: util/file/string_file_writer_test.cc
diff --git a/util/file/string_file_writer_test.cc b/util/file/string_file_writer_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f0ec72f75e958da164887f85767abcaef9f82d7d
--- /dev/null
+++ b/util/file/string_file_writer_test.cc
@@ -0,0 +1,378 @@
+// Copyright 2014 The Crashpad Authors. All rights reserved.
+//
+// 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
+//
+//     http://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 "util/file/string_file_writer.h"
+
+#include <algorithm>
+#include <limits>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+using namespace crashpad;
+
+TEST(StringFileWriter, EmptyFile) {
+  StringFileWriter writer;
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+  EXPECT_TRUE(writer.Write("", 0));
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+}
+
+TEST(StringFileWriter, OneByteFile) {
+  StringFileWriter writer;
+
+  EXPECT_TRUE(writer.Write("a", 1));
+  EXPECT_EQ(1u, writer.string().size());
+  EXPECT_EQ("a", writer.string());
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(0, writer.Seek(0, SEEK_SET));
+  EXPECT_TRUE(writer.Write("b", 1));
+  EXPECT_EQ(1u, writer.string().size());
+  EXPECT_EQ("b", writer.string());
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(0, writer.Seek(0, SEEK_SET));
+  EXPECT_TRUE(writer.Write("\0", 1));
+  EXPECT_EQ(1u, writer.string().size());
+  EXPECT_EQ('\0', writer.string()[0]);
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+}
+
+TEST(StringFileWriter, Reset) {
+  StringFileWriter writer;
+
+  EXPECT_TRUE(writer.Write("abc", 3));
+  EXPECT_EQ(3u, writer.string().size());
+  EXPECT_EQ("abc", writer.string());
+  EXPECT_EQ(3, writer.Seek(0, SEEK_CUR));
+
+  writer.Reset();
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_TRUE(writer.Write("de", 2));
+  EXPECT_EQ(2u, writer.string().size());
+  EXPECT_EQ("de", writer.string());
+  EXPECT_EQ(2, writer.Seek(0, SEEK_CUR));
+
+  writer.Reset();
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_TRUE(writer.Write("fghi", 4));
+  EXPECT_EQ(4u, writer.string().size());
+  EXPECT_EQ("fghi", writer.string());
+  EXPECT_EQ(4, writer.Seek(0, SEEK_CUR));
+
+  writer.Reset();
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+
+  // Test resetting after a sparse write.
+  EXPECT_EQ(1, writer.Seek(1, SEEK_SET));
+  EXPECT_TRUE(writer.Write("j", 1));
+  EXPECT_EQ(2u, writer.string().size());
+  EXPECT_EQ(std::string("\0j", 2), writer.string());
+  EXPECT_EQ(2, writer.Seek(0, SEEK_CUR));
+
+  writer.Reset();
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+}
+
+TEST(StringFileWriter, WriteInvalid) {
+  StringFileWriter writer;
+
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_FALSE(writer.Write(
+      "", static_cast<size_t>(std::numeric_limits<ssize_t>::max()) + 1));
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_TRUE(writer.Write("a", 1));
+  EXPECT_FALSE(writer.Write(
+      "", static_cast<size_t>(std::numeric_limits<ssize_t>::max())));
+  EXPECT_EQ(1u, writer.string().size());
+  EXPECT_EQ("a", writer.string());
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+}
+
+TEST(StringFileWriter, WriteIoVec) {
+  StringFileWriter writer;
+
+  std::vector<WritableIoVec> iovecs;
+  WritableIoVec iov;
+  iov.iov_base = "";
+  iov.iov_len = 0;
+  iovecs.push_back(iov);
+  EXPECT_TRUE(writer.WriteIoVec(&iovecs));
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+
+  iovecs.clear();
+  iov.iov_base = "a";
+  iov.iov_len = 1;
+  iovecs.push_back(iov);
+  EXPECT_TRUE(writer.WriteIoVec(&iovecs));
+  EXPECT_EQ(1u, writer.string().size());
+  EXPECT_EQ("a", writer.string());
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+
+  iovecs.clear();
+  iovecs.push_back(iov);
+  EXPECT_TRUE(writer.WriteIoVec(&iovecs));
+  EXPECT_EQ(2u, writer.string().size());
+  EXPECT_EQ("aa", writer.string());
+  EXPECT_EQ(2, writer.Seek(0, SEEK_CUR));
+
+  iovecs.clear();
+  iovecs.push_back(iov);
+  iov.iov_base = "bc";
+  iov.iov_len = 2;
+  iovecs.push_back(iov);
+  EXPECT_TRUE(writer.WriteIoVec(&iovecs));
+  EXPECT_EQ(5u, writer.string().size());
+  EXPECT_EQ("aaabc", writer.string());
+  EXPECT_EQ(5, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_TRUE(writer.Write("def", 3));
+  EXPECT_EQ(8u, writer.string().size());
+  EXPECT_EQ("aaabcdef", writer.string());
+  EXPECT_EQ(8, writer.Seek(0, SEEK_CUR));
+
+  iovecs.clear();
+  iov.iov_base = "ghij";
+  iov.iov_len = 4;
+  iovecs.push_back(iov);
+  iov.iov_base = "klmno";
+  iov.iov_len = 5;
+  iovecs.push_back(iov);
+  EXPECT_TRUE(writer.WriteIoVec(&iovecs));
+  EXPECT_EQ(17u, writer.string().size());
+  EXPECT_EQ("aaabcdefghijklmno", writer.string());
+  EXPECT_EQ(17, writer.Seek(0, SEEK_CUR));
+
+  writer.Reset();
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+
+  iovecs.clear();
+  iov.iov_base = "abcd";
+  iov.iov_len = 4;
+  iovecs.resize(16, iov);
+  EXPECT_TRUE(writer.WriteIoVec(&iovecs));
+  EXPECT_EQ(64u, writer.string().size());
+  EXPECT_EQ("abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd",
+            writer.string());
+  EXPECT_EQ(64, writer.Seek(0, SEEK_CUR));
+}
+
+TEST(StringFileWriter, WriteIoVecInvalid) {
+  StringFileWriter writer;
+
+  std::vector<WritableIoVec> iovecs;
+  EXPECT_FALSE(writer.WriteIoVec(&iovecs));
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+
+  WritableIoVec iov;
+  EXPECT_EQ(1, writer.Seek(1, SEEK_CUR));
+  iov.iov_base = "a";
+  iov.iov_len = std::numeric_limits<ssize_t>::max();
+  iovecs.push_back(iov);
+  EXPECT_FALSE(writer.WriteIoVec(&iovecs));
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+
+  iovecs.clear();
+  iov.iov_base = "a";
+  iov.iov_len = 1;
+  iovecs.push_back(iov);
+  iov.iov_len = std::numeric_limits<ssize_t>::max() - 1;
+  iovecs.push_back(iov);
+  EXPECT_FALSE(writer.WriteIoVec(&iovecs));
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+}
+
+TEST(StringFileWriter, Seek) {
+  StringFileWriter writer;
+
+  EXPECT_TRUE(writer.Write("abcd", 4));
+  EXPECT_EQ(4u, writer.string().size());
+  EXPECT_EQ("abcd", writer.string());
+  EXPECT_EQ(4, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(0, writer.Seek(0, SEEK_SET));
+  EXPECT_TRUE(writer.Write("efgh", 4));
+  EXPECT_EQ(4u, writer.string().size());
+  EXPECT_EQ("efgh", writer.string());
+  EXPECT_EQ(4, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(0, writer.Seek(0, SEEK_SET));
+  EXPECT_TRUE(writer.Write("ijk", 3));
+  EXPECT_EQ(4u, writer.string().size());
+  EXPECT_EQ("ijkh", writer.string());
+  EXPECT_EQ(3, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(0, writer.Seek(0, SEEK_SET));
+  EXPECT_TRUE(writer.Write("lmnop", 5));
+  EXPECT_EQ(5u, writer.string().size());
+  EXPECT_EQ("lmnop", writer.string());
+  EXPECT_EQ(5, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(1, writer.Seek(1, SEEK_SET));
+  EXPECT_TRUE(writer.Write("q", 1));
+  EXPECT_EQ(5u, writer.string().size());
+  EXPECT_EQ("lqnop", writer.string());
+  EXPECT_EQ(2, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(1, writer.Seek(-1, SEEK_CUR));
+  EXPECT_TRUE(writer.Write("r", 1));
+  EXPECT_EQ(5u, writer.string().size());
+  EXPECT_EQ("lrnop", writer.string());
+  EXPECT_EQ(2, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_TRUE(writer.Write("s", 1));
+  EXPECT_EQ(5u, writer.string().size());
+  EXPECT_EQ("lrsop", writer.string());
+  EXPECT_EQ(3, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(2, writer.Seek(-1, SEEK_CUR));
+  EXPECT_TRUE(writer.Write("t", 1));
+  EXPECT_EQ(5u, writer.string().size());
+  EXPECT_EQ("lrtop", writer.string());
+  EXPECT_EQ(3, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(4, writer.Seek(-1, SEEK_END));
+  EXPECT_TRUE(writer.Write("u", 1));
+  EXPECT_EQ(5u, writer.string().size());
+  EXPECT_EQ("lrtou", writer.string());
+  EXPECT_EQ(5, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(0, writer.Seek(-5, SEEK_END));
+  EXPECT_TRUE(writer.Write("v", 1));
+  EXPECT_EQ(5u, writer.string().size());
+  EXPECT_EQ("vrtou", writer.string());
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(5, writer.Seek(0, SEEK_END));
+  EXPECT_TRUE(writer.Write("w", 1));
+  EXPECT_EQ(6u, writer.string().size());
+  EXPECT_EQ("vrtouw", writer.string());
+  EXPECT_EQ(6, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(8, writer.Seek(2, SEEK_END));
+  EXPECT_EQ(6u, writer.string().size());
+  EXPECT_EQ("vrtouw", writer.string());
+
+  EXPECT_EQ(6, writer.Seek(0, SEEK_END));
+  EXPECT_TRUE(writer.Write("x", 1));
+  EXPECT_EQ(7u, writer.string().size());
+  EXPECT_EQ("vrtouwx", writer.string());
+  EXPECT_EQ(7, writer.Seek(0, SEEK_CUR));
+}
+
+TEST(StringFileWriter, SeekSparse) {
+  StringFileWriter writer;
+
+  EXPECT_EQ(3, writer.Seek(3, SEEK_SET));
+  EXPECT_TRUE(writer.string().empty());
+  EXPECT_EQ(3, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_TRUE(writer.Write("abc", 3));
+  EXPECT_EQ(6u, writer.string().size());
+  EXPECT_EQ(std::string("\0\0\0abc", 6), writer.string());
+  EXPECT_EQ(6, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(9, writer.Seek(3, SEEK_END));
+  EXPECT_EQ(6u, writer.string().size());
+  EXPECT_EQ(9, writer.Seek(0, SEEK_CUR));
+  EXPECT_TRUE(writer.Write("def", 3));
+  EXPECT_EQ(12u, writer.string().size());
+  EXPECT_EQ(std::string("\0\0\0abc\0\0\0def", 12), writer.string());
+  EXPECT_EQ(12, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(7, writer.Seek(-5, SEEK_END));
+  EXPECT_EQ(12u, writer.string().size());
+  EXPECT_EQ(7, writer.Seek(0, SEEK_CUR));
+  EXPECT_TRUE(writer.Write("g", 1));
+  EXPECT_EQ(12u, writer.string().size());
+  EXPECT_EQ(std::string("\0\0\0abc\0g\0def", 12), writer.string());
+  EXPECT_EQ(8, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(15, writer.Seek(7, SEEK_CUR));
+  EXPECT_EQ(12u, writer.string().size());
+  EXPECT_EQ(15, writer.Seek(0, SEEK_CUR));
+  EXPECT_TRUE(writer.Write("hij", 3));
+  EXPECT_EQ(18u, writer.string().size());
+  EXPECT_EQ(std::string("\0\0\0abc\0g\0def\0\0\0hij", 18), writer.string());
+  EXPECT_EQ(18, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_EQ(1, writer.Seek(-17, SEEK_CUR));
+  EXPECT_EQ(18u, writer.string().size());
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+  EXPECT_TRUE(writer.Write("k", 1));
+  EXPECT_EQ(18u, writer.string().size());
+  EXPECT_EQ(std::string("\0k\0abc\0g\0def\0\0\0hij", 18), writer.string());
+  EXPECT_EQ(2, writer.Seek(0, SEEK_CUR));
+
+  EXPECT_TRUE(writer.Write("l", 1));
+  EXPECT_TRUE(writer.Write("mnop", 4));
+  EXPECT_EQ(18u, writer.string().size());
+  EXPECT_EQ(std::string("\0klmnopg\0def\0\0\0hij", 18), writer.string());
+  EXPECT_EQ(7, writer.Seek(0, SEEK_CUR));
+}
+
+TEST(StringFileWriter, SeekInvalid) {
+  StringFileWriter writer;
+
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+  EXPECT_EQ(1, writer.Seek(1, SEEK_SET));
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+  EXPECT_LT(writer.Seek(-1, SEEK_SET), 0);
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+  EXPECT_LT(writer.Seek(std::numeric_limits<ssize_t>::min(), SEEK_SET), 0);
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+  EXPECT_LT(writer.Seek(std::numeric_limits<off_t>::min(), SEEK_SET), 0);
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+  EXPECT_TRUE(writer.string().empty());
+
+  COMPILE_ASSERT(SEEK_SET != 3 && SEEK_CUR != 3 && SEEK_END != 3,
+                 three_must_be_invalid_for_whence);
+  EXPECT_LT(writer.Seek(0, 3), 0);
+
+  writer.Reset();
+  EXPECT_EQ(0, writer.Seek(0, SEEK_CUR));
+  EXPECT_TRUE(writer.string().empty());
+
+  const off_t kMaxOffset =
+      std::min(static_cast<uint64_t>(std::numeric_limits<off_t>::max()),
+               static_cast<uint64_t>(std::numeric_limits<size_t>::max()));
+
+  EXPECT_EQ(kMaxOffset, writer.Seek(kMaxOffset, SEEK_SET));
+  EXPECT_EQ(kMaxOffset, writer.Seek(0, SEEK_CUR));
+  EXPECT_LT(writer.Seek(1, SEEK_CUR), 0);
+
+  EXPECT_EQ(1, writer.Seek(1, SEEK_SET));
+  EXPECT_EQ(1, writer.Seek(0, SEEK_CUR));
+  EXPECT_LT(writer.Seek(kMaxOffset, SEEK_CUR), 0);
+}
+
+}  // namespace