Add tests for POSIX file flush, truncate, and delete. (#3139)

b/302715109

Change-Id: I0547db9a11a812d49d48b821c0f9690a110ede2f

starboard/elf_loader/exported_symbols.cc

@@ -52,12 +52,12 @@
 #include "starboard/mutex.h"
 #include "starboard/player.h"
 #if SB_API_VERSION >= 16
-#include "starboard/shared/modular/starboard_layer_posix_file_abi_wrappers.h"
 #include "starboard/shared/modular/starboard_layer_posix_mmap_abi_wrappers.h"
 #include "starboard/shared/modular/starboard_layer_posix_pthread_abi_wrappers.h"
 #include "starboard/shared/modular/starboard_layer_posix_socket_abi_wrappers.h"
 #include "starboard/shared/modular/starboard_layer_posix_stat_abi_wrappers.h"
 #include "starboard/shared/modular/starboard_layer_posix_time_abi_wrappers.h"
+#include "starboard/shared/modular/starboard_layer_posix_unistd_abi_wrappers.h"
 #endif  // SB_API_VERSION >= 16
 #include "starboard/socket.h"
 #include "starboard/socket_waiter.h"
@@ -466,6 +466,8 @@ ExportedSymbols::ExportedSymbols() {
   REGISTER_SYMBOL(freeaddrinfo);
   REGISTER_SYMBOL(freeifaddrs);
   REGISTER_SYMBOL(fstat);
+  REGISTER_SYMBOL(fsync);
+  REGISTER_SYMBOL(ftruncate);
   REGISTER_SYMBOL(getaddrinfo);
   REGISTER_SYMBOL(getifaddrs);
   REGISTER_SYMBOL(getsockname);
@@ -483,17 +485,19 @@ ExportedSymbols::ExportedSymbols() {
   REGISTER_SYMBOL(recv);
   REGISTER_SYMBOL(send);
   REGISTER_SYMBOL(recvfrom);
+  REGISTER_SYMBOL(rmdir);
   REGISTER_SYMBOL(sched_yield);
   REGISTER_SYMBOL(sendto);
   REGISTER_SYMBOL(setsockopt);
   REGISTER_SYMBOL(socket);
   REGISTER_SYMBOL(snprintf);
   REGISTER_SYMBOL(sprintf);
   REGISTER_SYMBOL(stat);
+  REGISTER_SYMBOL(unlink);
+  REGISTER_SYMBOL(usleep);
   REGISTER_SYMBOL(vfwprintf);
   REGISTER_SYMBOL(vsnprintf);
   REGISTER_SYMBOL(vsscanf);
-  REGISTER_SYMBOL(usleep);
 
   // Custom mapped POSIX APIs to compatibility wrappers.
   // These will rely on Starboard-side implementations that properly translate

starboard/nplb/BUILD.gn

@@ -144,6 +144,9 @@ target(gtest_target_type, "nplb") {
     "posix_compliance/posix_directory_can_open_test.cc",
     "posix_compliance/posix_directory_create_test.cc",
     "posix_compliance/posix_file_close_test.cc",
+    "posix_compliance/posix_file_delete_test.cc",
+    "posix_compliance/posix_file_fsync_test.cc",
+    "posix_compliance/posix_file_ftruncate_test.cc",
     "posix_compliance/posix_file_get_info_test.cc",
     "posix_compliance/posix_file_get_path_info_test.cc",
     "posix_compliance/posix_file_open_test.cc",

starboard/nplb/posix_compliance/posix_file_delete_test.cc

@@ -0,0 +1,67 @@
+// Copyright 2024 The Cobalt 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 <unistd.h>
+
+#include <sys/stat.h>
+
+#include <string>
+
+#include "starboard/directory.h"
+#include "starboard/file.h"
+#include "starboard/nplb/file_helpers.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard {
+namespace nplb {
+namespace {
+
+bool FileExists(const char* path) {
+  struct stat info;
+  return stat(path, &info) == 0;
+}
+
+bool DirectoryExists(const char* path) {
+  struct stat info;
+  return stat(path, &info) == 0 && S_ISDIR(info.st_mode);
+}
+
+TEST(PosixFileDeleteTest, SunnyDayDeleteExistingFile) {
+  ScopedRandomFile file;
+
+  EXPECT_TRUE(FileExists(file.filename().c_str()));
+  EXPECT_TRUE(unlink(file.filename().c_str()) == 0);
+}
+
+TEST(PosixFileDeleteTest, SunnyDayDeleteExistingDirectory) {
+  ScopedRandomFile file(ScopedRandomFile::kDontCreate);
+
+  const std::string& path = file.filename();
+
+  EXPECT_FALSE(FileExists(path.c_str()));
+  EXPECT_TRUE(mkdir(path.c_str(), 0700) == 0 || DirectoryExists(path.c_str()));
+  EXPECT_TRUE(DirectoryExists(path.c_str()));
+  EXPECT_TRUE(rmdir(path.c_str()) == 0);
+}
+
+TEST(PosixFileDeleteTest, RainyDayNonExistentDirErrors) {
+  ScopedRandomFile file(ScopedRandomFile::kDontCreate);
+
+  EXPECT_FALSE(FileExists(file.filename().c_str()));
+  EXPECT_TRUE(rmdir(file.filename().c_str()));
+}
+
+}  // namespace
+}  // namespace nplb
+}  // namespace starboard

starboard/nplb/posix_compliance/posix_file_fsync_test.cc

@@ -0,0 +1,32 @@
+// Copyright 2024 The Cobalt 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.
+
+// flush() is otherwise tested in PosixFileWriteTest.
+
+#include <unistd.h>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard {
+namespace nplb {
+namespace {
+
+TEST(PosixFileFsyncTest, InvalidFileErrors) {
+  int result = fsync(-1);
+  EXPECT_FALSE(result == 0);
+}
+
+}  // namespace
+}  // namespace nplb
+}  // namespace starboard

starboard/nplb/posix_compliance/posix_file_ftruncate_test.cc

@@ -0,0 +1,117 @@
+// Copyright 2024 The Cobalt Authors. All Rights Reserved.
+// PosixFileWriteTest
+// 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 <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <string>
+
+#include "starboard/common/file.h"
+#include "starboard/nplb/file_helpers.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard {
+namespace nplb {
+namespace {
+
+TEST(PosixFileFtruncateTest, InvalidFileErrors) {
+  int result = ftruncate(-1, 0);
+  EXPECT_FALSE(result == 0);
+
+  result = ftruncate(-1, -1);
+  EXPECT_FALSE(result == 0);
+
+  result = ftruncate(-1, 100);
+  EXPECT_FALSE(result == 0);
+}
+
+TEST(PosixFileFtruncateTest, TruncateToZero) {
+  const int kStartSize = 123;
+  const int kEndSize = 0;
+  ScopedRandomFile random_file(kStartSize);
+  const std::string& filename = random_file.filename();
+
+  int file = open(filename.c_str(), O_RDWR);
+  ASSERT_TRUE(file >= 0);
+
+  {
+    struct stat info = {0};
+    int result = fstat(file, &info);
+    EXPECT_EQ(kStartSize, info.st_size);
+  }
+
+  int result = ftruncate(file, kEndSize);
+  EXPECT_TRUE(result == 0);
+
+  {
+    struct stat info = {0};
+    result = fstat(file, &info);
+    EXPECT_EQ(kEndSize, info.st_size);
+  }
+
+  result = close(file);
+  EXPECT_TRUE(result == 0);
+}
+
+TEST(PosixFileFtruncateTest, TruncateUpInSize) {
+  // "Truncate," I don't think that word means what you think it means.
+  const int kStartSize = 123;
+  const int kEndSize = kStartSize * 2;
+  ScopedRandomFile random_file(kStartSize);
+  const std::string& filename = random_file.filename();
+
+  int file = open(filename.c_str(), O_RDWR);
+  ASSERT_TRUE(file >= 0);
+
+  {
+    struct stat info = {0};
+    int result = fstat(file, &info);
+    EXPECT_TRUE(result == 0);
+    EXPECT_EQ(kStartSize, info.st_size);
+  }
+
+  int position = static_cast<int>(lseek(file, 0, SEEK_CUR));
+  EXPECT_EQ(0, position);
+
+  int result = ftruncate(file, kEndSize);
+  EXPECT_TRUE(result == 0);
+
+  position = static_cast<int>(lseek(file, 0, SEEK_CUR));
+  EXPECT_EQ(0, position);
+
+  {
+    struct stat info = {0};
+    result = fstat(file, &info);
+    EXPECT_TRUE(result == 0);
+    EXPECT_EQ(kEndSize, info.st_size);
+  }
+
+  char buffer[kEndSize] = {0};
+  int bytes = static_cast<int>(ReadAll(file, buffer, kEndSize));
+  EXPECT_EQ(kEndSize, bytes);
+
+  ScopedRandomFile::ExpectPattern(0, buffer, kStartSize, __LINE__);
+
+  for (int i = kStartSize; i < kEndSize; ++i) {
+    EXPECT_EQ(0, buffer[i]);
+  }
+
+  result = close(file);
+  EXPECT_TRUE(result == 0);
+}
+
+}  // namespace
+}  // namespace nplb
+}  // namespace starboard

starboard/nplb/posix_compliance/posix_file_read_test.cc

@@ -39,7 +39,7 @@ class PosixRead {
 
 class PosixReadAll {
  public:
-  static ssize_t Read(int file, void* data, int size) {
+  static ssize_t Read(int file, void* data, size_t size) {
     return ReadAll(file, data, size);
   }
 };

starboard/shared/modular/BUILD.gn

@@ -19,8 +19,6 @@ if ((sb_is_modular || sb_is_evergreen_compatible) &&
      build_with_separate_cobalt_toolchain)) {
   source_set("starboard_layer_posix_abi_wrappers") {
     sources = [
-      "starboard_layer_posix_file_abi_wrappers.cc",
-      "starboard_layer_posix_file_abi_wrappers.h",
       "starboard_layer_posix_mmap_abi_wrappers.cc",
       "starboard_layer_posix_mmap_abi_wrappers.h",
       "starboard_layer_posix_pthread_abi_wrappers.cc",
@@ -31,6 +29,8 @@ if ((sb_is_modular || sb_is_evergreen_compatible) &&
       "starboard_layer_posix_stat_abi_wrappers.h",
       "starboard_layer_posix_time_abi_wrappers.cc",
       "starboard_layer_posix_time_abi_wrappers.h",
+      "starboard_layer_posix_unistd_abi_wrappers.cc",
+      "starboard_layer_posix_unistd_abi_wrappers.h",
     ]
 
     configs += [ "//starboard/build/config:starboard_implementation" ]
@@ -43,12 +43,12 @@ if (sb_is_modular && !sb_is_evergreen &&
     current_toolchain == cobalt_toolchain) {
   source_set("cobalt_layer_posix_abi_wrappers") {
     sources = [
-      "cobalt_layer_posix_file_abi_wrappers.cc",
       "cobalt_layer_posix_mmap_abi_wrappers.cc",
       "cobalt_layer_posix_pthread_abi_wrappers.cc",
       "cobalt_layer_posix_socket_abi_wrappers.cc",
       "cobalt_layer_posix_stat_abi_wrappers.cc",
       "cobalt_layer_posix_time_abi_wrappers.cc",
+      "cobalt_layer_posix_unistd_abi_wrappers.cc",
     ]
   }
 }

starboard/shared/modular/cobalt_layer_posix_file_abi_wrappers.cc → starboard/shared/modular/cobalt_layer_posix_unistd_abi_wrappers.cc

@@ -18,6 +18,12 @@
 
 extern "C" {
 
+int __abi_wrap_ftruncate(int fildes, off_t length);
+
+int ftruncate(int fildes, off_t length) {
+  return __abi_wrap_ftruncate(fildes, length);
+}
+
 off_t __abi_wrap_lseek(int fildes, off_t offset, int whence);
 
 off_t lseek(int fildes, off_t offset, int whence) {

starboard/shared/modular/starboard_layer_posix_file_abi_wrappers.cc → starboard/shared/modular/starboard_layer_posix_unistd_abi_wrappers.cc

@@ -14,11 +14,15 @@
 
 #if SB_API_VERSION >= 16
 
-#include "starboard/shared/modular/starboard_layer_posix_file_abi_wrappers.h"
+#include "starboard/shared/modular/starboard_layer_posix_unistd_abi_wrappers.h"
 
 #include <sys/types.h>
 #include <unistd.h>
 
+int __abi_wrap_ftruncate(int fildes, musl_off_t length) {
+  return ftruncate(fildes, static_cast<off_t>(length));
+}
+
 musl_off_t __abi_wrap_lseek(int fildes, musl_off_t offset, int whence) {
   return static_cast<off_t>(lseek(fildes, static_cast<off_t>(offset), whence));
 }

starboard/shared/modular/starboard_layer_posix_file_abi_wrappers.h → starboard/shared/modular/starboard_layer_posix_unistd_abi_wrappers.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef STARBOARD_SHARED_MODULAR_STARBOARD_LAYER_POSIX_FILE_ABI_WRAPPERS_H_
-#define STARBOARD_SHARED_MODULAR_STARBOARD_LAYER_POSIX_FILE_ABI_WRAPPERS_H_
+#ifndef STARBOARD_SHARED_MODULAR_STARBOARD_LAYER_POSIX_UNISTD_ABI_WRAPPERS_H_
+#define STARBOARD_SHARED_MODULAR_STARBOARD_LAYER_POSIX_UNISTD_ABI_WRAPPERS_H_
 
 #include <stdint.h>
 #include <sys/types.h>
@@ -50,6 +50,8 @@ typedef int32_t ssize_t;
 extern "C" {
 #endif
 
+SB_EXPORT int __abi_wrap_ftruncate(int fildes, musl_off_t length);
+
 SB_EXPORT musl_off_t __abi_wrap_lseek(int fildes,
                                       musl_off_t offset,
                                       int whence);
@@ -60,4 +62,4 @@ SB_EXPORT ssize_t __abi_wrap_read(int fildes, void* buf, size_t nbyte);
 }  // extern "C"
 #endif
 
-#endif  // STARBOARD_SHARED_MODULAR_STARBOARD_LAYER_POSIX_FILE_ABI_WRAPPERS_H_
+#endif  // STARBOARD_SHARED_MODULAR_STARBOARD_LAYER_POSIX_UNISTD_ABI_WRAPPERS_H_

starboard/shared/win32/posix_emu/include/unistd.h

@@ -26,6 +26,10 @@ extern "C" {
 // This function will handle both files and sockets.
 int close(int fd);
 
+int fsync(int fd);
+
+int ftruncate(int fd, off_t length);
+
 off_t sb_lseek(int fd, off_t offset, int origin);
 #define lseek sb_lseek