Fix suggestions from clang.

PiperOrigin-RevId: 255679603

29 files changed, 128 insertions, 96 deletions

diff --git a/test/syscalls/linux/chmod.cc b/test/syscalls/linux/chmod.cc
index 79e98597f..7e918b9b2 100644
--- a/test/syscalls/linux/chmod.cc
+++ b/test/syscalls/linux/chmod.cc
@@ -140,7 +140,8 @@ TEST(ChmodTest, FchmodatFile) {
       SyscallSucceeds());
 
   ASSERT_THAT(
-      fchmodat(parent_fd, std::string(Basename(temp_file.path())).c_str(), 0444, 0),
+      fchmodat(parent_fd, std::string(Basename(temp_file.path())).c_str(), 0444,
+               0),
       SyscallSucceeds());
   EXPECT_THAT(close(parent_fd), SyscallSucceeds());
 
@@ -165,8 +166,9 @@ TEST(ChmodTest, FchmodatDir) {
               SyscallSucceeds());
   EXPECT_THAT(close(fd), SyscallSucceeds());
 
-  ASSERT_THAT(fchmodat(parent_fd, std::string(Basename(dir.path())).c_str(), 0, 0),
-              SyscallSucceeds());
+  ASSERT_THAT(
+      fchmodat(parent_fd, std::string(Basename(dir.path())).c_str(), 0, 0),
+      SyscallSucceeds());
   EXPECT_THAT(close(parent_fd), SyscallSucceeds());
 
   EXPECT_THAT(open(dir.path().c_str(), O_RDONLY | O_DIRECTORY),
diff --git a/test/syscalls/linux/chown.cc b/test/syscalls/linux/chown.cc
index eb1762ddf..2e82f0b3a 100644
--- a/test/syscalls/linux/chown.cc
+++ b/test/syscalls/linux/chown.cc
@@ -186,10 +186,10 @@ INSTANTIATE_TEST_SUITE_P(
           return errorFromReturn("fchownat-fd", rc);
         },
         [](const std::string& path, uid_t owner, gid_t group) -> PosixError {
-          ASSIGN_OR_RETURN_ERRNO(
-              auto dirfd, Open(std::string(Dirname(path)), O_DIRECTORY | O_RDONLY));
-          int rc = fchownat(dirfd.get(), std::string(Basename(path)).c_str(), owner,
-                            group, 0);
+          ASSIGN_OR_RETURN_ERRNO(auto dirfd, Open(std::string(Dirname(path)),
+                                                  O_DIRECTORY | O_RDONLY));
+          int rc = fchownat(dirfd.get(), std::string(Basename(path)).c_str(),
+                            owner, group, 0);
           MaybeSave();
           return errorFromReturn("fchownat-dirfd", rc);
         }));
diff --git a/test/syscalls/linux/chroot.cc b/test/syscalls/linux/chroot.cc
index a4354ff62..498c45f16 100644
--- a/test/syscalls/linux/chroot.cc
+++ b/test/syscalls/linux/chroot.cc
@@ -273,7 +273,8 @@ TEST(ChrootTest, ProcMemSelfMapsNoEscapeProcOpen) {
   ASSERT_GT(bytes_read, 0);
 
   // Finally we want to make sure the maps don't contain the chroot path
-  ASSERT_EQ(std::string(buf, bytes_read).find(temp_dir.path()), std::string::npos);
+  ASSERT_EQ(std::string(buf, bytes_read).find(temp_dir.path()),
+            std::string::npos);
 }
 
 // Test that mounts outside the chroot will not appear in /proc/self/mounts or
diff --git a/test/syscalls/linux/exec.cc b/test/syscalls/linux/exec.cc
index 06c322a99..4c7c95321 100644
--- a/test/syscalls/linux/exec.cc
+++ b/test/syscalls/linux/exec.cc
@@ -255,7 +255,8 @@ TEST(ExecDeathTest, InterpreterScriptArgNUL) {
 
   TempPath script = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
       GetAbsoluteTestTmpdir(),
-      absl::StrCat("#!", link.path(), " foo", std::string(1, '\0'), "bar"), 0755));
+      absl::StrCat("#!", link.path(), " foo", std::string(1, '\0'), "bar"),
+      0755));
 
   CheckOutput(script.path(), {script.path()}, {}, ArgEnvExitStatus(2, 0),
               absl::StrCat(link.path(), "\nfoo\n", script.path(), "\n"));
diff --git a/test/syscalls/linux/exec_proc_exe_workload.cc b/test/syscalls/linux/exec_proc_exe_workload.cc
index b3fbd5042..b790fe5be 100644
--- a/test/syscalls/linux/exec_proc_exe_workload.cc
+++ b/test/syscalls/linux/exec_proc_exe_workload.cc
@@ -21,7 +21,8 @@
 #include "test/util/posix_error.h"
 
 int main(int argc, char** argv, char** envp) {
-  std::string exe = gvisor::testing::ProcessExePath(getpid()).ValueOrDie();
+  std::string exe =
+      gvisor::testing::ProcessExePath(getpid()).ValueOrDie();
   if (exe[0] != '/') {
     std::cerr << "relative path: " << exe << std::endl;
     exit(1);
diff --git a/test/syscalls/linux/file_base.h b/test/syscalls/linux/file_base.h
index b5b972c07..36efabcae 100644
--- a/test/syscalls/linux/file_base.h
+++ b/test/syscalls/linux/file_base.h
@@ -160,7 +160,7 @@ class SocketTest : public ::testing::Test {
 
 // MatchesStringLength checks that a tuple argument of (struct iovec *, int)
 // corresponding to an iovec array and its length, contains data that matches
-// the std::string length strlen.
+// the string length strlen.
 MATCHER_P(MatchesStringLength, strlen, "") {
   struct iovec* iovs = arg.first;
   int niov = arg.second;
@@ -177,7 +177,7 @@ MATCHER_P(MatchesStringLength, strlen, "") {
 
 // MatchesStringValue checks that a tuple argument of (struct iovec *, int)
 // corresponding to an iovec array and its length, contains data that matches
-// the std::string value str.
+// the string value str.
 MATCHER_P(MatchesStringValue, str, "") {
   struct iovec* iovs = arg.first;
   int len = strlen(str);
diff --git a/test/syscalls/linux/inotify.cc b/test/syscalls/linux/inotify.cc
index 6a3539e22..7384c27dc 100644
--- a/test/syscalls/linux/inotify.cc
+++ b/test/syscalls/linux/inotify.cc
@@ -122,8 +122,8 @@ std::string DumpEvents(const std::vector<Event>& events, int indent_level) {
                      (events.size() > 1) ? "s" : "");
   int i = 0;
   for (const Event& ev : events) {
-    ss << StreamFormat("%sevents[%d]: %s\n", std::string(indent_level, '\t'), i++,
-                       DumpEvent(ev));
+    ss << StreamFormat("%sevents[%d]: %s\n", std::string(indent_level, '\t'),
+                       i++, DumpEvent(ev));
   }
   return ss.str();
 }
@@ -295,10 +295,10 @@ PosixErrorOr<std::vector<Event>> DrainEvents(int fd) {
       if (event.len > 0) {
         TEST_CHECK(static_cast<int>(sizeof(struct inotify_event) + event.len) <=
                    readlen);
-        ev.name =
-            std::string(cursor + offsetof(struct inotify_event, name));  // NOLINT
+        ev.name = std::string(cursor +
+                              offsetof(struct inotify_event, name));  // NOLINT
         // Name field should always be smaller than event.len, otherwise we have
-        // a buffer overflow. The two sizes aren't equal because the std::string
+        // a buffer overflow. The two sizes aren't equal because the string
         // constructor will stop at the first null byte, while event.name may be
         // padded up to event.len using multiple null bytes.
         TEST_CHECK(ev.name.size() <= event.len);
@@ -319,7 +319,8 @@ PosixErrorOr<FileDescriptor> InotifyInit1(int flags) {
   return FileDescriptor(fd);
 }
 
-PosixErrorOr<int> InotifyAddWatch(int fd, const std::string& path, uint32_t mask) {
+PosixErrorOr<int> InotifyAddWatch(int fd, const std::string& path,
+                                  uint32_t mask) {
   int wd;
   EXPECT_THAT(wd = inotify_add_watch(fd, path.c_str(), mask),
               SyscallSucceeds());
@@ -980,8 +981,8 @@ TEST(Inotify, WatchOnRelativePath) {
   EXPECT_THAT(chdir(root.path().c_str()), SyscallSucceeds());
 
   // Add a watch on file1 with a relative path.
-  const int wd = ASSERT_NO_ERRNO_AND_VALUE(
-      InotifyAddWatch(fd.get(), std::string(Basename(file1.path())), IN_ALL_EVENTS));
+  const int wd = ASSERT_NO_ERRNO_AND_VALUE(InotifyAddWatch(
+      fd.get(), std::string(Basename(file1.path())), IN_ALL_EVENTS));
 
   // Perform a read on file1, this should generate an IN_ACCESS event.
   char c;
diff --git a/test/syscalls/linux/madvise.cc b/test/syscalls/linux/madvise.cc
index 352fcc6c4..08ff4052c 100644
--- a/test/syscalls/linux/madvise.cc
+++ b/test/syscalls/linux/madvise.cc
@@ -162,7 +162,8 @@ TEST(MadviseDontforkTest, DontforkShared) {
   // Mmap two shared file-backed pages and MADV_DONTFORK the second page.
   TempPath f = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateFileWith(
       /* parent = */ GetAbsoluteTestTmpdir(),
-      /* content = */ std::string(kPageSize * 2, 2), TempPath::kDefaultFileMode));
+      /* content = */ std::string(kPageSize * 2, 2),
+      TempPath::kDefaultFileMode));
   FileDescriptor fd = ASSERT_NO_ERRNO_AND_VALUE(Open(f.path(), O_RDWR));
 
   Mapping m = ASSERT_NO_ERRNO_AND_VALUE(Mmap(
diff --git a/test/syscalls/linux/memfd.cc b/test/syscalls/linux/memfd.cc
index 3494bcd13..e57b49a4a 100644
--- a/test/syscalls/linux/memfd.cc
+++ b/test/syscalls/linux/memfd.cc
@@ -60,7 +60,8 @@ int memfd_create(const std::string& name, unsigned int flags) {
   return syscall(__NR_memfd_create, name.c_str(), flags);
 }
 
-PosixErrorOr<FileDescriptor> MemfdCreate(const std::string& name, uint32_t flags) {
+PosixErrorOr<FileDescriptor> MemfdCreate(const std::string& name,
+                                         uint32_t flags) {
   int fd = memfd_create(name, flags);
   if (fd < 0) {
     return PosixError(
diff --git a/test/syscalls/linux/mknod.cc b/test/syscalls/linux/mknod.cc
index febf2eb14..4c45766c7 100644
--- a/test/syscalls/linux/mknod.cc
+++ b/test/syscalls/linux/mknod.cc
@@ -90,7 +90,7 @@ TEST(MknodTest, Fifo) {
   ASSERT_THAT(stat(fifo.c_str(), &st), SyscallSucceeds());
   EXPECT_TRUE(S_ISFIFO(st.st_mode));
 
-  std::string msg = "some string";
+  std::string msg = "some std::string";
   std::vector<char> buf(512);
 
   // Read-end of the pipe.
@@ -116,7 +116,7 @@ TEST(MknodTest, FifoOtrunc) {
   ASSERT_THAT(stat(fifo.c_str(), &st), SyscallSucceeds());
   EXPECT_TRUE(S_ISFIFO(st.st_mode));
 
-  std::string msg = "some string";
+  std::string msg = "some std::string";
   std::vector<char> buf(512);
   // Read-end of the pipe.
   ScopedThread t([&fifo, &buf, &msg]() {
@@ -144,7 +144,7 @@ TEST(MknodTest, FifoTruncNoOp) {
   ASSERT_THAT(stat(fifo.c_str(), &st), SyscallSucceeds());
   EXPECT_TRUE(S_ISFIFO(st.st_mode));
 
-  std::string msg = "some string";
+  std::string msg = "some std::string";
   std::vector<char> buf(512);
   // Read-end of the pipe.
   ScopedThread t([&fifo, &buf, &msg]() {
diff --git a/test/syscalls/linux/mmap.cc b/test/syscalls/linux/mmap.cc
index 5b5b4c2e8..a112316e9 100644
--- a/test/syscalls/linux/mmap.cc
+++ b/test/syscalls/linux/mmap.cc
@@ -113,7 +113,7 @@ class MMapTest : public ::testing::Test {
   size_t length_ = 0;
 };
 
-// Matches if arg contains the same contents as std::string str.
+// Matches if arg contains the same contents as string str.
 MATCHER_P(EqualsMemory, str, "") {
   if (0 == memcmp(arg, str.c_str(), str.size())) {
     return true;
@@ -1086,8 +1086,8 @@ TEST_F(MMapFileTest, WriteShared) {
   ASSERT_THAT(Read(buf.data(), buf.size()),
               SyscallSucceedsWithValue(buf.size()));
   // Cast to void* to avoid EXPECT_THAT assuming buf.data() is a
-  // NUL-terminated C std::string. EXPECT_THAT will try to print a char* as a C
-  // std::string, possibly overruning the buffer.
+  // NUL-terminated C string. EXPECT_THAT will try to print a char* as a C
+  // string, possibly overruning the buffer.
   EXPECT_THAT(reinterpret_cast<void*>(buf.data()),
               EqualsMemory(std::string(kFileContents)));
 }
@@ -1122,6 +1122,7 @@ TEST_F(MMapFileTest, WriteSharedBeyondEnd) {
   ASSERT_THAT(Read(buf.data(), buf.size()),
               SyscallSucceedsWithValue(first.size()));
   // Cast to void* to avoid EXPECT_THAT assuming buf.data() is a
+  // NUL-terminated C string. EXPECT_THAT will try to print a char* as a C
   // NUL-terminated C std::string. EXPECT_THAT will try to print a char* as a C
   // std::string, possibly overruning the buffer.
   EXPECT_THAT(reinterpret_cast<void*>(buf.data()), EqualsMemory(first));
@@ -1159,8 +1160,8 @@ TEST_F(MMapFileTest, WriteSharedTruncateUp) {
   ASSERT_THAT(Read(buf.data(), buf.size()),
               SyscallSucceedsWithValue(buf.size()));
   // Cast to void* to avoid EXPECT_THAT assuming buf.data() is a
-  // NUL-terminated C std::string. EXPECT_THAT will try to print a char* as a C
-  // std::string, possibly overruning the buffer.
+  // NUL-terminated C string. EXPECT_THAT will try to print a char* as a C
+  // string, possibly overruning the buffer.
   EXPECT_THAT(reinterpret_cast<void*>(buf.data()), EqualsMemory(first));
   EXPECT_THAT(reinterpret_cast<void*>(buf.data() + kPageSize / 2),
               EqualsMemory(second));
@@ -1234,8 +1235,8 @@ TEST_F(MMapFileTest, WriteSharedTruncateDownThenUp) {
   ASSERT_THAT(Read(buf.data(), buf.size()),
               SyscallSucceedsWithValue(buf.size()));
   // Cast to void* to avoid EXPECT_THAT assuming buf.data() is a
-  // NUL-terminated C std::string. EXPECT_THAT will try to print a char* as a C
-  // std::string, possibly overruning the buffer.
+  // NUL-terminated C string. EXPECT_THAT will try to print a char* as a C
+  // string, possibly overruning the buffer.
   EXPECT_THAT(reinterpret_cast<void*>(buf.data()), EqualsMemory(zeroed));
 }
 
@@ -1363,8 +1364,8 @@ TEST_F(MMapFileTest, WritePrivate) {
   ASSERT_THAT(Read(buf.data(), buf.size()),
               SyscallSucceedsWithValue(buf.size()));
   // Cast to void* to avoid EXPECT_THAT assuming buf.data() is a
-  // NUL-terminated C std::string. EXPECT_THAT will try to print a char* as a C
-  // std::string, possibly overruning the buffer.
+  // NUL-terminated C string. EXPECT_THAT will try to print a char* as a C
+  // string, possibly overruning the buffer.
   EXPECT_THAT(reinterpret_cast<void*>(buf.data()),
               EqualsMemory(std::string(len, '\0')));
 }
diff --git a/test/syscalls/linux/proc.cc b/test/syscalls/linux/proc.cc
index 924b98e3a..490bf4424 100644
--- a/test/syscalls/linux/proc.cc
+++ b/test/syscalls/linux/proc.cc
@@ -206,8 +206,8 @@ PosixError WithSubprocess(SubprocessCallback const& running,
 }
 
 // Access the file returned by name when a subprocess is running.
-PosixError AccessWhileRunning(std::function<std::string(int pid)> name, int flags,
-                              std::function<void(int fd)> access) {
+PosixError AccessWhileRunning(std::function<std::string(int pid)> name,
+                              int flags, std::function<void(int fd)> access) {
   FileDescriptor fd;
   return WithSubprocess(
       [&](int pid) -> PosixError {
@@ -221,8 +221,8 @@ PosixError AccessWhileRunning(std::function<std::string(int pid)> name, int flag
 }
 
 // Access the file returned by name when the a subprocess is zombied.
-PosixError AccessWhileZombied(std::function<std::string(int pid)> name, int flags,
-                              std::function<void(int fd)> access) {
+PosixError AccessWhileZombied(std::function<std::string(int pid)> name,
+                              int flags, std::function<void(int fd)> access) {
   FileDescriptor fd;
   return WithSubprocess(
       [&](int pid) -> PosixError {
@@ -239,8 +239,8 @@ PosixError AccessWhileZombied(std::function<std::string(int pid)> name, int flag
 }
 
 // Access the file returned by name when the a subprocess is exited.
-PosixError AccessWhileExited(std::function<std::string(int pid)> name, int flags,
-                             std::function<void(int fd)> access) {
+PosixError AccessWhileExited(std::function<std::string(int pid)> name,
+                             int flags, std::function<void(int fd)> access) {
   FileDescriptor fd;
   return WithSubprocess(
       [&](int pid) -> PosixError {
@@ -704,7 +704,8 @@ TEST(ProcSelfExe, Absolute) {
 
 // Sanity check for /proc/cpuinfo fields that must be present.
 TEST(ProcCpuinfo, RequiredFieldsArePresent) {
-  std::string proc_cpuinfo = ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/cpuinfo"));
+  std::string proc_cpuinfo =
+      ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/cpuinfo"));
   ASSERT_FALSE(proc_cpuinfo.empty());
   std::vector<std::string> cpuinfo_fields = absl::StrSplit(proc_cpuinfo, '\n');
 
@@ -743,7 +744,8 @@ TEST(ProcCpuinfo, DeniesWrite) {
 
 // Sanity checks that uptime is present.
 TEST(ProcUptime, IsPresent) {
-  std::string proc_uptime = ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/uptime"));
+  std::string proc_uptime =
+      ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/uptime"));
   ASSERT_FALSE(proc_uptime.empty());
   std::vector<std::string> uptime_parts = absl::StrSplit(proc_uptime, ' ');
 
@@ -775,7 +777,8 @@ TEST(ProcUptime, IsPresent) {
 }
 
 TEST(ProcMeminfo, ContainsBasicFields) {
-  std::string proc_meminfo = ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/meminfo"));
+  std::string proc_meminfo =
+      ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/meminfo"));
   EXPECT_THAT(proc_meminfo, AllOf(ContainsRegex(R"(MemTotal:\s+[0-9]+ kB)"),
                                   ContainsRegex(R"(MemFree:\s+[0-9]+ kB)")));
 }
@@ -853,12 +856,14 @@ TEST(ProcStat, Fields) {
 }
 
 TEST(ProcLoadavg, EndsWithNewline) {
-  std::string proc_loadvg = ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/loadavg"));
+  std::string proc_loadvg =
+      ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/loadavg"));
   EXPECT_EQ(proc_loadvg.back(), '\n');
 }
 
 TEST(ProcLoadavg, Fields) {
-  std::string proc_loadvg = ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/loadavg"));
+  std::string proc_loadvg =
+      ASSERT_NO_ERRNO_AND_VALUE(GetContents("/proc/loadavg"));
   std::vector<std::string> lines = absl::StrSplit(proc_loadvg, '\n');
 
   // Single line.
@@ -1238,10 +1243,12 @@ TEST(ProcPidStatTest, VmStats) {
   EXPECT_NE('0', data_str[0]);
 }
 
-// Parse an array of NUL-terminated char* arrays, returning a vector of strings.
+// Parse an array of NUL-terminated char* arrays, returning a vector of
+// strings.
 std::vector<std::string> ParseNulTerminatedStrings(std::string contents) {
   EXPECT_EQ('\0', contents.back());
-  // The split will leave an empty std::string if the NUL-byte remains, so pop it.
+  // The split will leave an empty string if the NUL-byte remains, so pop
+  // it.
   contents.pop_back();
 
   return absl::StrSplit(contents, '\0');
@@ -1491,7 +1498,8 @@ TEST(ProcPidFile, SubprocessExited) {
 }
 
 PosixError DirContainsImpl(absl::string_view path,
-                           const std::vector<std::string>& targets, bool strict) {
+                           const std::vector<std::string>& targets,
+                           bool strict) {
   ASSIGN_OR_RETURN_ERRNO(auto listing, ListDir(path, false));
   bool success = true;
 
@@ -1530,8 +1538,8 @@ PosixError DirContainsExactly(absl::string_view path,
   return DirContainsImpl(path, targets, true);
 }
 
-PosixError EventuallyDirContainsExactly(absl::string_view path,
-                                        const std::vector<std::string>& targets) {
+PosixError EventuallyDirContainsExactly(
+    absl::string_view path, const std::vector<std::string>& targets) {
   constexpr int kRetryCount = 100;
   const absl::Duration kRetryDelay = absl::Milliseconds(100);
 
@@ -1553,11 +1561,13 @@ TEST(ProcTask, Basic) {
       DirContains("/proc/self/task", {".", "..", absl::StrCat(getpid())}));
 }
 
-std::vector<std::string> TaskFiles(const std::vector<std::string>& initial_contents,
-                              const std::vector<pid_t>& pids) {
+std::vector<std::string> TaskFiles(
+    const std::vector<std::string>& initial_contents,
+    const std::vector<pid_t>& pids) {
   return VecCat<std::string>(
       initial_contents,
-      ApplyVec<std::string>([](const pid_t p) { return absl::StrCat(p); }, pids));
+      ApplyVec<std::string>([](const pid_t p) { return absl::StrCat(p); },
+                            pids));
 }
 
 std::vector<std::string> TaskFiles(const std::vector<pid_t>& pids) {
@@ -1894,7 +1904,8 @@ void CheckDuplicatesRecursively(std::string path) {
       continue;
     }
 
-    ASSERT_EQ(children.find(std::string(dp->d_name)), children.end()) << dp->d_name;
+    ASSERT_EQ(children.find(std::string(dp->d_name)), children.end())
+        << dp->d_name;
     children.insert(std::string(dp->d_name));
 
     ASSERT_NE(dp->d_type, DT_UNKNOWN);
diff --git a/test/syscalls/linux/proc_net_unix.cc b/test/syscalls/linux/proc_net_unix.cc
index 74acbe92c..9b9be66ff 100644
--- a/test/syscalls/linux/proc_net_unix.cc
+++ b/test/syscalls/linux/proc_net_unix.cc
@@ -67,7 +67,7 @@ std::string ExtractPath(const struct sockaddr* addr) {
     // Abstract socket paths are null padded to the end of the struct
     // sockaddr. However, these null bytes may or may not show up in
     // /proc/net/unix depending on the kernel version. Truncate after the first
-    // null byte (by treating path as a c-std::string).
+    // null byte (by treating path as a c-string).
     return StrCat("@", &path[1]);
   }
   return std::string(path);
@@ -80,7 +80,7 @@ PosixErrorOr<std::vector<UnixEntry>> ProcNetUnixEntries() {
 
   bool skipped_header = false;
   std::vector<UnixEntry> entries;
-  std::vector<std::string> lines = absl::StrSplit(content, absl::ByAnyChar("\n"));
+  std::vector<std::string> lines = absl::StrSplit(content, '\n');
   std::cerr << "<contents of /proc/net/unix>" << std::endl;
   for (std::string line : lines) {
     // Emit the proc entry to the test output to provide context for the test
@@ -123,7 +123,8 @@ PosixErrorOr<std::vector<UnixEntry>> ProcNetUnixEntries() {
     UnixEntry entry;
 
     // Process the first 6 fields, up to but not including "Inode".
-    std::vector<std::string> fields = absl::StrSplit(line, absl::MaxSplits(' ', 6));
+    std::vector<std::string> fields =
+        absl::StrSplit(line, absl::MaxSplits(' ', 6));
 
     if (fields.size() < 7) {
       return PosixError(EINVAL, StrFormat("Invalid entry: '%s'\n", line));
diff --git a/test/syscalls/linux/pty.cc b/test/syscalls/linux/pty.cc
index f926ac0f9..d1ab4703f 100644
--- a/test/syscalls/linux/pty.cc
+++ b/test/syscalls/linux/pty.cc
@@ -105,7 +105,7 @@ struct Field {
   uint64_t value;
 };
 
-// ParseFields returns a std::string representation of value, using the names in
+// ParseFields returns a string representation of value, using the names in
 // fields.
 std::string ParseFields(const Field* fields, size_t len, uint64_t value) {
   bool first = true;
diff --git a/test/syscalls/linux/readv_common.h b/test/syscalls/linux/readv_common.h
index b16179fca..2fa40c35f 100644
--- a/test/syscalls/linux/readv_common.h
+++ b/test/syscalls/linux/readv_common.h
@@ -20,7 +20,7 @@
 namespace gvisor {
 namespace testing {
 
-// A NUL-terminated std::string containing the data used by tests using the following
+// A NUL-terminated string containing the data used by tests using the following
 // test helpers.
 extern const char kReadvTestData[];
 
diff --git a/test/syscalls/linux/sendfile.cc b/test/syscalls/linux/sendfile.cc
index 2fbb3f4ef..e5d72e28a 100644
--- a/test/syscalls/linux/sendfile.cc
+++ b/test/syscalls/linux/sendfile.cc
@@ -135,7 +135,7 @@ TEST(SendFileTest, SendTriviallyWithBothFilesReadWrite) {
 
 TEST(SendFileTest, SendAndUpdateFileOffset) {
   // Create temp files.
-  // Test input std::string length must be > 2 AND even.
+  // Test input string length must be > 2 AND even.
   constexpr char kData[] = "The slings and arrows of outrageous fortune,";
   constexpr int kDataSize = sizeof(kData) - 1;
   constexpr int kHalfDataSize = kDataSize / 2;
@@ -180,7 +180,7 @@ TEST(SendFileTest, SendAndUpdateFileOffset) {
 
 TEST(SendFileTest, SendAndUpdateFileOffsetFromNonzeroStartingPoint) {
   // Create temp files.
-  // Test input std::string length must be > 2 AND divisible by 4.
+  // Test input string length must be > 2 AND divisible by 4.
   constexpr char kData[] = "The slings and arrows of outrageous fortune,";
   constexpr int kDataSize = sizeof(kData) - 1;
   constexpr int kHalfDataSize = kDataSize / 2;
@@ -233,7 +233,7 @@ TEST(SendFileTest, SendAndUpdateFileOffsetFromNonzeroStartingPoint) {
 
 TEST(SendFileTest, SendAndUpdateGivenOffset) {
   // Create temp files.
-  // Test input std::string length must be >= 4 AND divisible by 4.
+  // Test input string length must be >= 4 AND divisible by 4.
   constexpr char kData[] = "Or to take Arms against a Sea of troubles,";
   constexpr int kDataSize = sizeof(kData) + 1;
   constexpr int kHalfDataSize = kDataSize / 2;
diff --git a/test/syscalls/linux/socket_netlink_route.cc b/test/syscalls/linux/socket_netlink_route.cc
index 53dd1ca78..b5c38f27e 100644
--- a/test/syscalls/linux/socket_netlink_route.cc
+++ b/test/syscalls/linux/socket_netlink_route.cc
@@ -151,8 +151,8 @@ TEST(NetlinkRouteTest, GetPeerName) {
 //    the value is considered ok.
 // 2: A description of what the sockopt value is expected to be. Should complete
 //    the sentence "<value> was unexpected, expected <description>"
-using SockOptTest =
-    ::testing::TestWithParam<std::tuple<int, std::function<bool(int)>, std::string>>;
+using SockOptTest = ::testing::TestWithParam<
+    std::tuple<int, std::function<bool(int)>, std::string>>;
 
 TEST_P(SockOptTest, GetSockOpt) {
   int sockopt = std::get<0>(GetParam());
diff --git a/test/syscalls/linux/unix_domain_socket_test_util.cc b/test/syscalls/linux/unix_domain_socket_test_util.cc
index ff28850b2..7fb9eed8d 100644
--- a/test/syscalls/linux/unix_domain_socket_test_util.cc
+++ b/test/syscalls/linux/unix_domain_socket_test_util.cc
@@ -53,7 +53,7 @@ SocketPairKind UnixDomainSocketPair(int type) {
 
 SocketPairKind FilesystemBoundUnixDomainSocketPair(int type) {
   std::string description = absl::StrCat(DescribeUnixDomainSocketType(type),
-                                    " created with filesystem binding");
+                                         " created with filesystem binding");
   if ((type & SOCK_DGRAM) == SOCK_DGRAM) {
     return SocketPairKind{
         description, AF_UNIX, type, 0,
@@ -65,8 +65,9 @@ SocketPairKind FilesystemBoundUnixDomainSocketPair(int type) {
 }
 
 SocketPairKind AbstractBoundUnixDomainSocketPair(int type) {
-  std::string description = absl::StrCat(DescribeUnixDomainSocketType(type),
-                                    " created with abstract namespace binding");
+  std::string description =
+      absl::StrCat(DescribeUnixDomainSocketType(type),
+                   " created with abstract namespace binding");
   if ((type & SOCK_DGRAM) == SOCK_DGRAM) {
     return SocketPairKind{
         description, AF_UNIX, type, 0,
@@ -78,7 +79,7 @@ SocketPairKind AbstractBoundUnixDomainSocketPair(int type) {
 
 SocketPairKind SocketpairGoferUnixDomainSocketPair(int type) {
   std::string description = absl::StrCat(DescribeUnixDomainSocketType(type),
-                                    " created with the socketpair gofer");
+                                         " created with the socketpair gofer");
   return SocketPairKind{description, AF_UNIX, type, 0,
                         SocketpairGoferSocketPairCreator(AF_UNIX, type, 0)};
 }
diff --git a/test/syscalls/linux/unix_domain_socket_test_util.h b/test/syscalls/linux/unix_domain_socket_test_util.h
index 25729e421..5eca0b7f0 100644
--- a/test/syscalls/linux/unix_domain_socket_test_util.h
+++ b/test/syscalls/linux/unix_domain_socket_test_util.h
@@ -21,7 +21,7 @@
 namespace gvisor {
 namespace testing {
 
-// DescribeUnixDomainSocketType returns a human-readable std::string explaining the
+// DescribeUnixDomainSocketType returns a human-readable string explaining the
 // given Unix domain socket type.
 std::string DescribeUnixDomainSocketType(int type);
 
diff --git a/test/util/fs_util.cc b/test/util/fs_util.cc
index bc90bd78e..ae49725a0 100644
--- a/test/util/fs_util.cc
+++ b/test/util/fs_util.cc
@@ -290,7 +290,7 @@ PosixError WalkTree(
 }
 
 PosixErrorOr<std::vector<std::string>> ListDir(absl::string_view abspath,
-                                          bool skipdots) {
+                                               bool skipdots) {
   std::vector<std::string> files;
 
   DIR* dir = opendir(std::string(abspath).c_str());
@@ -381,7 +381,7 @@ PosixError RecursivelyCreateDir(absl::string_view path) {
 // Makes a path absolute with respect to an optional base. If no base is
 // provided it will use the current working directory.
 PosixErrorOr<std::string> MakeAbsolute(absl::string_view filename,
-                                  absl::string_view base) {
+                                       absl::string_view base) {
   if (filename.empty()) {
     return PosixError(EINVAL, "filename cannot be empty.");
   }
@@ -494,7 +494,7 @@ std::string CleanPath(const absl::string_view unclean_path) {
 }
 
 PosixErrorOr<std::string> GetRelativePath(absl::string_view source,
-                                     absl::string_view dest) {
+                                          absl::string_view dest) {
   if (!absl::StartsWith(source, "/") || !absl::StartsWith(dest, "/")) {
     // At least one of the inputs is not an absolute path.
     return PosixError(
diff --git a/test/util/fs_util.h b/test/util/fs_util.h
index eb7cdaa24..3969f8309 100644
--- a/test/util/fs_util.h
+++ b/test/util/fs_util.h
@@ -61,7 +61,7 @@ PosixError SetContents(absl::string_view path, absl::string_view contents);
 PosixError CreateWithContents(absl::string_view path,
                               absl::string_view contents, int mode = 0666);
 
-// Attempts to read the entire contents of the file into the provided std::string
+// Attempts to read the entire contents of the file into the provided string
 // buffer or returns an error.
 PosixError GetContents(absl::string_view path, std::string* output);
 
@@ -69,7 +69,7 @@ PosixError GetContents(absl::string_view path, std::string* output);
 PosixErrorOr<std::string> GetContents(absl::string_view path);
 
 // Attempts to read the entire contents of the provided fd into the provided
-// std::string or returns an error.
+// string or returns an error.
 PosixError GetContentsFD(int fd, std::string* output);
 
 // Attempts to read the entire contents of the provided fd or returns an error.
@@ -94,7 +94,7 @@ PosixError WalkTree(
 // method does not walk the tree recursively it only returns the elements
 // in that directory.
 PosixErrorOr<std::vector<std::string>> ListDir(absl::string_view abspath,
-                                          bool skipdots);
+                                               bool skipdots);
 
 // Attempt to recursively delete a directory or file. Returns an error and
 // the number of undeleted directories and files. If either
@@ -108,20 +108,20 @@ PosixError RecursivelyCreateDir(absl::string_view path);
 // Makes a path absolute with respect to an optional base. If no base is
 // provided it will use the current working directory.
 PosixErrorOr<std::string> MakeAbsolute(absl::string_view filename,
-                                  absl::string_view base);
+                                       absl::string_view base);
 
 // Generates a relative path from the source directory to the destination
 // (dest) file or directory.  This uses ../ when necessary for destinations
 // which are not nested within the source.  Both source and dest are required
-// to be absolute paths, and an empty std::string will be returned if they are not.
+// to be absolute paths, and an empty string will be returned if they are not.
 PosixErrorOr<std::string> GetRelativePath(absl::string_view source,
-                                     absl::string_view dest);
+                                          absl::string_view dest);
 
 // Returns the part of the path before the final "/", EXCEPT:
 // * If there is a single leading "/" in the path, the result will be the
 //   leading "/".
 // * If there is no "/" in the path, the result is the empty prefix of the
-//   input std::string.
+//   input string.
 absl::string_view Dirname(absl::string_view path);
 
 // Return the parts of the path, split on the final "/".  If there is no
@@ -135,7 +135,7 @@ std::pair<absl::string_view, absl::string_view> SplitPath(
 // "/" in the path, the result is the same as the input.
 // Note that this function's behavior differs from the Unix basename
 // command if path ends with "/". For such paths, this function returns the
-// empty std::string.
+// empty string.
 absl::string_view Basename(absl::string_view path);
 
 // Collapse duplicate "/"s, resolve ".." and "." path elements, remove
@@ -144,7 +144,7 @@ absl::string_view Basename(absl::string_view path);
 // NOTE: This respects relative vs. absolute paths, but does not
 // invoke any system calls (getcwd(2)) in order to resolve relative
 // paths wrt actual working directory.  That is, this is purely a
-// std::string manipulation, completely independent of process state.
+// string manipulation, completely independent of process state.
 std::string CleanPath(absl::string_view path);
 
 // Returns the full path to the executable of the given pid or a PosixError.
@@ -174,7 +174,7 @@ inline std::string JoinPath(absl::string_view path) {
 std::string JoinPath(absl::string_view path1, absl::string_view path2);
 template <typename... T>
 inline std::string JoinPath(absl::string_view path1, absl::string_view path2,
-                       absl::string_view path3, const T&... args) {
+                            absl::string_view path3, const T&... args) {
   return internal::JoinPathImpl({path1, path2, path3, args...});
 }
 }  // namespace testing
diff --git a/test/util/fs_util_test.cc b/test/util/fs_util_test.cc
index 4e12076a1..2a200320a 100644
--- a/test/util/fs_util_test.cc
+++ b/test/util/fs_util_test.cc
@@ -29,7 +29,8 @@ namespace {
 
 TEST(FsUtilTest, RecursivelyCreateDirManualDelete) {
   const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
-  const std::string base_path = JoinPath(root.path(), "/a/b/c/d/e/f/g/h/i/j/k/l/m");
+  const std::string base_path =
+      JoinPath(root.path(), "/a/b/c/d/e/f/g/h/i/j/k/l/m");
 
   ASSERT_THAT(Exists(base_path), IsPosixErrorOkAndHolds(false));
   ASSERT_NO_ERRNO(RecursivelyCreateDir(base_path));
@@ -48,7 +49,8 @@ TEST(FsUtilTest, RecursivelyCreateDirManualDelete) {
 
 TEST(FsUtilTest, RecursivelyCreateAndDeleteDir) {
   const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
-  const std::string base_path = JoinPath(root.path(), "/a/b/c/d/e/f/g/h/i/j/k/l/m");
+  const std::string base_path =
+      JoinPath(root.path(), "/a/b/c/d/e/f/g/h/i/j/k/l/m");
 
   ASSERT_THAT(Exists(base_path), IsPosixErrorOkAndHolds(false));
   ASSERT_NO_ERRNO(RecursivelyCreateDir(base_path));
@@ -60,7 +62,8 @@ TEST(FsUtilTest, RecursivelyCreateAndDeleteDir) {
 
 TEST(FsUtilTest, RecursivelyCreateAndDeletePartial) {
   const TempPath root = ASSERT_NO_ERRNO_AND_VALUE(TempPath::CreateDir());
-  const std::string base_path = JoinPath(root.path(), "/a/b/c/d/e/f/g/h/i/j/k/l/m");
+  const std::string base_path =
+      JoinPath(root.path(), "/a/b/c/d/e/f/g/h/i/j/k/l/m");
 
   ASSERT_THAT(Exists(base_path), IsPosixErrorOkAndHolds(false));
   ASSERT_NO_ERRNO(RecursivelyCreateDir(base_path));
diff --git a/test/util/logging.cc b/test/util/logging.cc
index cc71d77b0..5d5e76c46 100644
--- a/test/util/logging.cc
+++ b/test/util/logging.cc
@@ -50,7 +50,7 @@ int WriteNumber(int fd, uint32_t val) {
   constexpr int kBufferSize = 11;
   char buf[kBufferSize];
 
-  // Convert the number to std::string.
+  // Convert the number to string.
   char* s = buf + sizeof(buf) - 1;
   size_t size = 0;
 
diff --git a/test/util/mount_util.h b/test/util/mount_util.h
index 7782e6bf2..38ec6c8a1 100644
--- a/test/util/mount_util.h
+++ b/test/util/mount_util.h
@@ -30,9 +30,11 @@ namespace testing {
 
 // Mount mounts the filesystem, and unmounts when the returned reference is
 // destroyed.
-inline PosixErrorOr<Cleanup> Mount(const std::string &source, const std::string &target,
+inline PosixErrorOr<Cleanup> Mount(const std::string &source,
+                                   const std::string &target,
                                    const std::string &fstype, uint64_t mountflags,
-                                   const std::string &data, uint64_t umountflags) {
+                                   const std::string &data,
+                                   uint64_t umountflags) {
   if (mount(source.c_str(), target.c_str(), fstype.c_str(), mountflags,
             data.c_str()) == -1) {
     return PosixError(errno, "mount failed");
diff --git a/test/util/posix_error.h b/test/util/posix_error.h
index b604f4f8f..ad666bce0 100644
--- a/test/util/posix_error.h
+++ b/test/util/posix_error.h
@@ -51,7 +51,7 @@ class ABSL_MUST_USE_RESULT PosixError {
 
   std::string error_message() const { return msg_; }
 
-  // ToString produces a full std::string representation of this posix error
+  // ToString produces a full string representation of this posix error
   // including the printable representation of the errno and the error message.
   std::string ToString() const;
 
diff --git a/test/util/proc_util.cc b/test/util/proc_util.cc
index 9d4db37c3..75b24da37 100644
--- a/test/util/proc_util.cc
+++ b/test/util/proc_util.cc
@@ -76,7 +76,8 @@ PosixErrorOr<ProcMapsEntry> ParseProcMapsLine(absl::string_view line) {
   if (parts.size() == 6) {
     // A filename is present. However, absl::StrSplit retained the whitespace
     // between the inode number and the filename.
-    map_entry.filename = std::string(absl::StripLeadingAsciiWhitespace(parts[5]));
+    map_entry.filename =
+        std::string(absl::StripLeadingAsciiWhitespace(parts[5]));
   }
 
   return map_entry;
diff --git a/test/util/temp_path.cc b/test/util/temp_path.cc
index de7c04a6f..35aacb172 100644
--- a/test/util/temp_path.cc
+++ b/test/util/temp_path.cc
@@ -70,13 +70,16 @@ std::string NewTempAbsPathInDir(absl::string_view const dir) {
   return JoinPath(dir, NextTempBasename());
 }
 
-std::string NewTempAbsPath() { return NewTempAbsPathInDir(GetAbsoluteTestTmpdir()); }
+std::string NewTempAbsPath() {
+  return NewTempAbsPathInDir(GetAbsoluteTestTmpdir());
+}
 
 std::string NewTempRelPath() { return NextTempBasename(); }
 
 std::string GetAbsoluteTestTmpdir() {
   char* env_tmpdir = getenv("TEST_TMPDIR");
-  std::string tmp_dir = env_tmpdir != nullptr ? std::string(env_tmpdir) : "/tmp";
+  std::string tmp_dir =
+      env_tmpdir != nullptr ? std::string(env_tmpdir) : "/tmp";
 
   return MakeAbsolute(tmp_dir, "").ValueOrDie();
 }
diff --git a/test/util/temp_path.h b/test/util/temp_path.h
index 89302e0fd..92d669503 100644
--- a/test/util/temp_path.h
+++ b/test/util/temp_path.h
@@ -30,7 +30,7 @@ namespace testing {
 // Distinct calls to NewTempAbsPathInDir from the same process, even from
 // multiple threads, are guaranteed to return different paths. Distinct calls to
 // NewTempAbsPathInDir from different processes are not synchronized.
-std::string NewTempAbsPathInDir(absl::string_view base);
+std::string NewTempAbsPathInDir(absl::string_view const dir);
 
 // Like NewTempAbsPathInDir, but the returned path is in the test's temporary
 // directory, as provided by the testing framework.
@@ -105,7 +105,7 @@ class TempPath {
 
   // Changes the path this TempPath represents. If the TempPath already
   // represented a path, deletes and returns that path. Otherwise returns the
-  // empty std::string.
+  // empty string.
   std::string reset(std::string newpath);
   std::string reset() { return reset(""); }
 
diff --git a/test/util/test_util.cc b/test/util/test_util.cc
index bf0029951..e42bba04a 100644
--- a/test/util/test_util.cc
+++ b/test/util/test_util.cc
@@ -73,7 +73,7 @@ Platform GvisorPlatform() {
 CPUVendor GetCPUVendor() {
   uint32_t eax, ebx, ecx, edx;
   std::string vendor_str;
-  // Get vendor std::string (issue CPUID with eax = 0)
+  // Get vendor string (issue CPUID with eax = 0)
   GETCPUID(eax, ebx, ecx, edx, 0, 0);
   vendor_str.append(reinterpret_cast<char*>(&ebx), 4);
   vendor_str.append(reinterpret_cast<char*>(&edx), 4);
@@ -93,7 +93,8 @@ bool operator==(const KernelVersion& first, const KernelVersion& second) {
 
 PosixErrorOr<KernelVersion> ParseKernelVersion(absl::string_view vers_str) {
   KernelVersion version = {};
-  std::vector<std::string> values = absl::StrSplit(vers_str, absl::ByAnyChar(".-"));
+  std::vector<std::string> values =
+      absl::StrSplit(vers_str, absl::ByAnyChar(".-"));
   if (values.size() == 2) {
     ASSIGN_OR_RETURN_ERRNO(version.major, Atoi<int>(values[0]));
     ASSIGN_OR_RETURN_ERRNO(version.minor, Atoi<int>(values[1]));