Change file op |ssize_t|s to FileOperationResult

util/file/string_file_test.cc

 // 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,
@@ skipping 179 matching lines @@
   EXPECT_TRUE(string_file.string().empty());
   EXPECT_EQ(0, string_file.Seek(0, SEEK_CUR));
 }
 
 TEST(StringFile, WriteInvalid) {
   StringFile string_file;
 
   EXPECT_EQ(0, string_file.Seek(0, SEEK_CUR));
 
   EXPECT_FALSE(string_file.Write(
-      "", implicit_cast<size_t>(std::numeric_limits<ssize_t>::max()) + 1));
+      "",
+      implicit_cast<size_t>(std::numeric_limits<FileOperationResult>::max()) +
+          1));
   EXPECT_TRUE(string_file.string().empty());
   EXPECT_EQ(0, string_file.Seek(0, SEEK_CUR));
 
   EXPECT_TRUE(string_file.Write("a", 1));
   EXPECT_FALSE(string_file.Write(
-      "", implicit_cast<size_t>(std::numeric_limits<ssize_t>::max())));
+      "",
+      implicit_cast<size_t>(std::numeric_limits<FileOperationResult>::max())));
   EXPECT_EQ(1u, string_file.string().size());
   EXPECT_EQ("a", string_file.string());
   EXPECT_EQ(1, string_file.Seek(0, SEEK_CUR));
 }
 
 TEST(StringFile, WriteIoVec) {
   StringFile string_file;
 
   std::vector<WritableIoVec> iovecs;
   WritableIoVec iov;
@@ skipping 66 matching lines @@
   StringFile string_file;
 
   std::vector<WritableIoVec> iovecs;
   EXPECT_FALSE(string_file.WriteIoVec(&iovecs));
   EXPECT_TRUE(string_file.string().empty());
   EXPECT_EQ(0, string_file.Seek(0, SEEK_CUR));
 
   WritableIoVec iov;
   EXPECT_EQ(1, string_file.Seek(1, SEEK_CUR));
   iov.iov_base = "a";
-  iov.iov_len = std::numeric_limits<ssize_t>::max();
+  iov.iov_len = std::numeric_limits<FileOperationResult>::max();
   iovecs.push_back(iov);
   EXPECT_FALSE(string_file.WriteIoVec(&iovecs));
   EXPECT_TRUE(string_file.string().empty());
   EXPECT_EQ(1, string_file.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;
+  iov.iov_len = std::numeric_limits<FileOperationResult>::max() - 1;
   iovecs.push_back(iov);
   EXPECT_FALSE(string_file.WriteIoVec(&iovecs));
   EXPECT_TRUE(string_file.string().empty());
   EXPECT_EQ(1, string_file.Seek(0, SEEK_CUR));
 }
 
 TEST(StringFile, Seek) {
   StringFile string_file;
 
   EXPECT_TRUE(string_file.Write("abcd", 4));
@@ skipping 128 matching lines @@
 }
 
 TEST(StringFile, SeekInvalid) {
   StringFile string_file;
 
   EXPECT_EQ(0, string_file.Seek(0, SEEK_CUR));
   EXPECT_EQ(1, string_file.Seek(1, SEEK_SET));
   EXPECT_EQ(1, string_file.Seek(0, SEEK_CUR));
   EXPECT_LT(string_file.Seek(-1, SEEK_SET), 0);
   EXPECT_EQ(1, string_file.Seek(0, SEEK_CUR));
-  EXPECT_LT(string_file.Seek(std::numeric_limits<ssize_t>::min(), SEEK_SET), 0);
+  EXPECT_LT(string_file.Seek(std::numeric_limits<FileOperationResult>::min(),
+                             SEEK_SET),
+            0);
   EXPECT_EQ(1, string_file.Seek(0, SEEK_CUR));
   EXPECT_LT(string_file.Seek(std::numeric_limits<FileOffset>::min(), SEEK_SET),
             0);
   EXPECT_EQ(1, string_file.Seek(0, SEEK_CUR));
   EXPECT_TRUE(string_file.string().empty());
 
   static_assert(SEEK_SET != 3 && SEEK_CUR != 3 && SEEK_END != 3,
                 "3 must be invalid for whence");
   EXPECT_LT(string_file.Seek(0, 3), 0);
 
@@ skipping 17 matching lines @@
 TEST(StringFile, SeekSet) {
   StringFile string_file;
   EXPECT_TRUE(string_file.SeekSet(1));
   EXPECT_EQ(1, string_file.Seek(0, SEEK_CUR));
   EXPECT_TRUE(string_file.SeekSet(0));
   EXPECT_EQ(0, string_file.Seek(0, SEEK_CUR));
   EXPECT_TRUE(string_file.SeekSet(10));
   EXPECT_EQ(10, string_file.Seek(0, SEEK_CUR));
   EXPECT_FALSE(string_file.SeekSet(-1));
   EXPECT_EQ(10, string_file.Seek(0, SEEK_CUR));
-  EXPECT_FALSE(string_file.SeekSet(std::numeric_limits<ssize_t>::min()));
+  EXPECT_FALSE(
+      string_file.SeekSet(std::numeric_limits<FileOperationResult>::min()));
   EXPECT_EQ(10, string_file.Seek(0, SEEK_CUR));
   EXPECT_FALSE(string_file.SeekSet(std::numeric_limits<FileOffset>::min()));
   EXPECT_EQ(10, string_file.Seek(0, SEEK_CUR));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad