From eb93f4ffa847ee827f656ba97291eab66e01fc8a Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Fri, 17 Apr 2026 23:56:31 -0700 Subject: [PATCH] Automated Code Change PiperOrigin-RevId: 901651266 --- tsl/platform/base64.cc | 12 +++--- tsl/platform/null_file_system.h | 24 +++++------ tsl/platform/retrying_file_system_test.cc | 51 +++++++++++++---------- tsl/platform/retrying_utils_test.cc | 16 +++---- 4 files changed, 55 insertions(+), 48 deletions(-) diff --git a/tsl/platform/base64.cc b/tsl/platform/base64.cc index 7a71a3c63..f344f69d5 100644 --- a/tsl/platform/base64.cc +++ b/tsl/platform/base64.cc @@ -70,7 +70,7 @@ absl::Status DecodeThreeChars(const char* codes, char* result) { // Convert() return value has upper 25 bits set if input is invalid. // Therefore `packed` has high bits set iff at least one of code is invalid. if (TF_PREDICT_FALSE((packed & 0xFF000000) != 0)) { - return errors::InvalidArgument("Invalid character found in base64."); + return absl::InvalidArgumentError("Invalid character found in base64."); } result[0] = static_cast(packed >> 16); result[1] = static_cast(packed >> 8); @@ -82,7 +82,7 @@ absl::Status DecodeThreeChars(const char* codes, char* result) { template absl::Status Base64Decode(absl::string_view data, T* decoded) { if (decoded == nullptr) { - return errors::Internal("'decoded' cannot be nullptr."); + return absl::InternalError("'decoded' cannot be nullptr."); } if (data.empty()) { @@ -98,7 +98,7 @@ absl::Status Base64Decode(absl::string_view data, T* decoded) { std::unique_ptr buffer(new char[max_decoded_size]); char* current = buffer.get(); if (current == nullptr) { - return errors::ResourceExhausted( + return absl::ResourceExhaustedError( "Failed to allocate buffer for decoded string."); } @@ -125,7 +125,7 @@ absl::Status Base64Decode(absl::string_view data, T* decoded) { const int remain = static_cast(end - b64); if (TF_PREDICT_FALSE(remain == 1)) { // We may check this condition early by checking data.size() % 4 == 1. - return errors::InvalidArgument( + return absl::InvalidArgumentError( "Base64 string length cannot be 1 modulo 4."); } @@ -152,7 +152,7 @@ absl::Status Base64Encode(absl::string_view source, bool with_padding, T* encoded) { const char* const base64_chars = kBase64UrlSafeChars; if (encoded == nullptr) { - return errors::Internal("'encoded' cannot be nullptr."); + return absl::InternalError("'encoded' cannot be nullptr."); } // max_encoded_size may overestimate by up to 4 bytes. @@ -160,7 +160,7 @@ absl::Status Base64Encode(absl::string_view source, bool with_padding, std::unique_ptr buffer(new char[max_encoded_size]); char* current = buffer.get(); if (current == nullptr) { - return errors::ResourceExhausted( + return absl::ResourceExhaustedError( "Failed to allocate buffer for encoded string."); } diff --git a/tsl/platform/null_file_system.h b/tsl/platform/null_file_system.h index 8b9d69fcc..6345551bc 100644 --- a/tsl/platform/null_file_system.h +++ b/tsl/platform/null_file_system.h @@ -41,34 +41,34 @@ class NullFileSystem : public FileSystem { absl::Status NewRandomAccessFile( const std::string& fname, std::unique_ptr* result) override { - return errors::Unimplemented("NewRandomAccessFile unimplemented"); + return absl::UnimplementedError("NewRandomAccessFile unimplemented"); } absl::Status NewWritableFile(const std::string& fname, std::unique_ptr* result) override { - return errors::Unimplemented("NewWritableFile unimplemented"); + return absl::UnimplementedError("NewWritableFile unimplemented"); } absl::Status NewAppendableFile( const std::string& fname, std::unique_ptr* result) override { - return errors::Unimplemented("NewAppendableFile unimplemented"); + return absl::UnimplementedError("NewAppendableFile unimplemented"); } absl::Status NewReadOnlyMemoryRegionFromFile( const std::string& fname, std::unique_ptr* result) override { - return errors::Unimplemented( + return absl::UnimplementedError( "NewReadOnlyMemoryRegionFromFile unimplemented"); } absl::Status FileExists(absl::string_view fname) override { - return errors::Unimplemented("FileExists unimplemented"); + return absl::UnimplementedError("FileExists unimplemented"); } absl::Status GetChildren(const std::string& dir, std::vector* result) override { - return errors::Unimplemented("GetChildren unimplemented"); + return absl::UnimplementedError("GetChildren unimplemented"); } absl::Status GetMatchingPaths(const std::string& pattern, @@ -77,29 +77,29 @@ class NullFileSystem : public FileSystem { } absl::Status DeleteFile(const std::string& fname) override { - return errors::Unimplemented("DeleteFile unimplemented"); + return absl::UnimplementedError("DeleteFile unimplemented"); } absl::Status CreateDir(const std::string& dirname) override { - return errors::Unimplemented("CreateDir unimplemented"); + return absl::UnimplementedError("CreateDir unimplemented"); } absl::Status DeleteDir(const std::string& dirname) override { - return errors::Unimplemented("DeleteDir unimplemented"); + return absl::UnimplementedError("DeleteDir unimplemented"); } absl::Status GetFileSize(const std::string& fname, uint64_t* file_size) override { - return errors::Unimplemented("GetFileSize unimplemented"); + return absl::UnimplementedError("GetFileSize unimplemented"); } absl::Status RenameFile(const std::string& src, const std::string& target) override { - return errors::Unimplemented("RenameFile unimplemented"); + return absl::UnimplementedError("RenameFile unimplemented"); } absl::Status Stat(const std::string& fname, FileStatistics* stat) override { - return errors::Unimplemented("Stat unimplemented"); + return absl::UnimplementedError("Stat unimplemented"); } }; #endif diff --git a/tsl/platform/retrying_file_system_test.cc b/tsl/platform/retrying_file_system_test.cc index 494c45c7b..c23216b12 100644 --- a/tsl/platform/retrying_file_system_test.cc +++ b/tsl/platform/retrying_file_system_test.cc @@ -42,7 +42,7 @@ ExpectedCalls CreateRetriableErrors(const std::string& method, int n) { expected_calls.reserve(n); for (int i = 0; i < n; i++) { expected_calls.emplace_back(std::make_tuple( - method, errors::Unavailable(absl::StrCat("Retriable error #", i)))); + method, absl::UnavailableError(absl::StrCat("Retriable error #", i)))); } return expected_calls; } @@ -234,8 +234,8 @@ TEST(RetryingFileSystemTest, NewRandomAccessFile_ImmediateSuccess) { TEST(RetryingFileSystemTest, NewRandomAccessFile_SuccessWith3rdTry) { // Configure the mock base random access file. ExpectedCalls expected_file_calls( - {std::make_tuple("Read", errors::Unavailable("Something is wrong")), - std::make_tuple("Read", errors::Unavailable("Wrong again")), + {std::make_tuple("Read", absl::UnavailableError("Something is wrong")), + std::make_tuple("Read", absl::UnavailableError("Wrong again")), std::make_tuple("Read", absl::OkStatus())}); std::unique_ptr base_file( new MockRandomAccessFile(expected_file_calls)); @@ -292,7 +292,7 @@ TEST(RetryingFileSystemTest, NewRandomAccessFile_NoRetriesForSomeErrors) { // Configure the mock base random access file. ExpectedCalls expected_file_calls({ std::make_tuple("Read", - errors::FailedPrecondition("Failed precondition")), + absl::FailedPreconditionError("Failed precondition")), }); std::unique_ptr base_file( new MockRandomAccessFile(expected_file_calls)); @@ -351,8 +351,9 @@ TEST(RetryingFileSystemTest, NewWritableFile_ImmediateSuccess) { TEST(RetryingFileSystemTest, NewWritableFile_SuccessWith3rdTry) { // Configure the mock base random access file. ExpectedCalls expected_file_calls( - {std::make_tuple("Sync", errors::Unavailable("Something is wrong")), - std::make_tuple("Sync", errors::Unavailable("Something is wrong again")), + {std::make_tuple("Sync", absl::UnavailableError("Something is wrong")), + std::make_tuple("Sync", + absl::UnavailableError("Something is wrong again")), std::make_tuple("Sync", absl::OkStatus()), std::make_tuple("Close", absl::OkStatus())}); std::unique_ptr base_file( @@ -378,9 +379,9 @@ TEST(RetryingFileSystemTest, NewWritableFile_SuccessWith3rdTry) { TEST(RetryingFileSystemTest, NewWritableFile_SuccessWith3rdTry_ViaDestructor) { // Configure the mock base random access file. ExpectedCalls expected_file_calls( - {std::make_tuple("Close", errors::Unavailable("Something is wrong")), + {std::make_tuple("Close", absl::UnavailableError("Something is wrong")), std::make_tuple("Close", - errors::Unavailable("Something is wrong again")), + absl::UnavailableError("Something is wrong again")), std::make_tuple("Close", absl::OkStatus())}); std::unique_ptr base_file( new MockWritableFile(expected_file_calls)); @@ -404,8 +405,9 @@ TEST(RetryingFileSystemTest, NewWritableFile_SuccessWith3rdTry_ViaDestructor) { TEST(RetryingFileSystemTest, NewAppendableFile_SuccessWith3rdTry) { // Configure the mock base random access file. ExpectedCalls expected_file_calls( - {std::make_tuple("Sync", errors::Unavailable("Something is wrong")), - std::make_tuple("Sync", errors::Unavailable("Something is wrong again")), + {std::make_tuple("Sync", absl::UnavailableError("Something is wrong")), + std::make_tuple("Sync", + absl::UnavailableError("Something is wrong again")), std::make_tuple("Sync", absl::OkStatus()), std::make_tuple("Close", absl::OkStatus())}); std::unique_ptr base_file( @@ -458,7 +460,7 @@ TEST(RetryingFileSystemTest, NewReadOnlyMemoryRegionFromFile_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( {std::make_tuple("NewReadOnlyMemoryRegionFromFile", - errors::Unavailable("Something is wrong")), + absl::UnavailableError("Something is wrong")), std::make_tuple("NewReadOnlyMemoryRegionFromFile", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -487,7 +489,7 @@ TEST(RetryingFileSystemTest, NewReadOnlyMemoryRegionFromFile_AllRetriesFailed) { TEST(RetryingFileSystemTest, GetChildren_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( {std::make_tuple("GetChildren", - errors::Unavailable("Something is wrong")), + absl::UnavailableError("Something is wrong")), std::make_tuple("GetChildren", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -514,7 +516,7 @@ TEST(RetryingFileSystemTest, GetChildren_AllRetriesFailed) { TEST(RetryingFileSystemTest, GetMatchingPaths_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( {std::make_tuple("GetMatchingPaths", - errors::Unavailable("Something is wrong")), + absl::UnavailableError("Something is wrong")), std::make_tuple("GetMatchingPaths", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -541,7 +543,8 @@ TEST(RetryingFileSystemTest, GetMatchingPaths_AllRetriesFailed) { TEST(RetryingFileSystemTest, DeleteFile_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( - {std::make_tuple("DeleteFile", errors::Unavailable("Something is wrong")), + {std::make_tuple("DeleteFile", + absl::UnavailableError("Something is wrong")), std::make_tuple("DeleteFile", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -565,7 +568,8 @@ TEST(RetryingFileSystemTest, DeleteFile_AllRetriesFailed) { TEST(RetryingFileSystemTest, CreateDir_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( - {std::make_tuple("CreateDir", errors::Unavailable("Something is wrong")), + {std::make_tuple("CreateDir", + absl::UnavailableError("Something is wrong")), std::make_tuple("CreateDir", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -589,7 +593,8 @@ TEST(RetryingFileSystemTest, CreateDir_AllRetriesFailed) { TEST(RetryingFileSystemTest, DeleteDir_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( - {std::make_tuple("DeleteDir", errors::Unavailable("Something is wrong")), + {std::make_tuple("DeleteDir", + absl::UnavailableError("Something is wrong")), std::make_tuple("DeleteDir", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -614,7 +619,7 @@ TEST(RetryingFileSystemTest, DeleteDir_AllRetriesFailed) { TEST(RetryingFileSystemTest, GetFileSize_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( {std::make_tuple("GetFileSize", - errors::Unavailable("Something is wrong")), + absl::UnavailableError("Something is wrong")), std::make_tuple("GetFileSize", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -640,7 +645,8 @@ TEST(RetryingFileSystemTest, GetFileSize_AllRetriesFailed) { TEST(RetryingFileSystemTest, RenameFile_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( - {std::make_tuple("RenameFile", errors::Unavailable("Something is wrong")), + {std::make_tuple("RenameFile", + absl::UnavailableError("Something is wrong")), std::make_tuple("RenameFile", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -664,7 +670,7 @@ TEST(RetryingFileSystemTest, RenameFile_AllRetriesFailed) { TEST(RetryingFileSystemTest, Stat_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( - {std::make_tuple("Stat", errors::Unavailable("Something is wrong")), + {std::make_tuple("Stat", absl::UnavailableError("Something is wrong")), std::make_tuple("Stat", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -702,7 +708,8 @@ TEST(RetryingFileSystemTest, FileExists_AllRetriesFailed) { TEST(RetryingFileSystemTest, FileExists_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( - {std::make_tuple("FileExists", errors::Unavailable("Something is wrong")), + {std::make_tuple("FileExists", + absl::UnavailableError("Something is wrong")), std::make_tuple("FileExists", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -715,7 +722,7 @@ TEST(RetryingFileSystemTest, FileExists_SuccessWith2ndTry) { TEST(RetryingFileSystemTest, IsDirectory_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( {std::make_tuple("IsDirectory", - errors::Unavailable("Something is wrong")), + absl::UnavailableError("Something is wrong")), std::make_tuple("IsDirectory", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); @@ -740,7 +747,7 @@ TEST(RetryingFileSystemTest, IsDirectory_AllRetriesFailed) { TEST(RetryingFileSystemTest, DeleteRecursively_SuccessWith2ndTry) { ExpectedCalls expected_fs_calls( {std::make_tuple("DeleteRecursively", - errors::Unavailable("Something is wrong")), + absl::UnavailableError("Something is wrong")), std::make_tuple("DeleteRecursively", absl::OkStatus())}); std::unique_ptr base_fs( new MockFileSystem(expected_fs_calls)); diff --git a/tsl/platform/retrying_utils_test.cc b/tsl/platform/retrying_utils_test.cc index 9e2f47b35..908b1b5c9 100644 --- a/tsl/platform/retrying_utils_test.cc +++ b/tsl/platform/retrying_utils_test.cc @@ -37,7 +37,7 @@ TEST(RetryingUtilsTest, CallWithRetries_RetryDelays) { requested_delays.emplace_back(delay / 1000000.0); }; std::function f = []() { - return errors::Unavailable("Failed."); + return absl::UnavailableError("Failed."); }; const auto& status = RetryingUtils::CallWithRetries( @@ -65,7 +65,7 @@ TEST(RetryingUtilsTest, CallWithRetries_RetryDelays) { TEST(RetryingUtilsTest, CallWithRetries_NotFoundIsNotRetried) { std::vector results( - {errors::Unavailable("Failed."), errors::NotFound("Not found.")}); + {absl::UnavailableError("Failed."), absl::NotFoundError("Not found.")}); std::function f = [&results]() { auto result = results[0]; results.erase(results.begin()); @@ -90,8 +90,8 @@ TEST(RetryingUtilsTest, CallWithRetries_ImmediateSuccess) { } TEST(RetryingUtilsTest, CallWithRetries_EventualSuccess) { - std::vector results({errors::Unavailable("Failed."), - errors::Unavailable("Failed again."), + std::vector results({absl::UnavailableError("Failed."), + absl::UnavailableError("Failed again."), absl::OkStatus()}); std::function f = [&results]() { auto result = results[0]; @@ -115,7 +115,7 @@ TEST(RetryingUtilsTest, DeleteWithRetries_ImmediateSuccess) { TEST(RetryingUtilsTest, DeleteWithRetries_EventualSuccess) { std::vector delete_results( - {errors::Unavailable(""), absl::OkStatus()}); + {absl::UnavailableError(""), absl::OkStatus()}); const auto delete_func = [&delete_results]() { auto result = delete_results[0]; delete_results.erase(delete_results.begin()); @@ -127,7 +127,7 @@ TEST(RetryingUtilsTest, DeleteWithRetries_EventualSuccess) { TEST(RetryingUtilsTest, DeleteWithRetries_PermissionDeniedNotRetried) { std::vector delete_results( - {errors::Unavailable(""), errors::PermissionDenied("")}); + {absl::UnavailableError(""), absl::PermissionDeniedError("")}); const auto delete_func = [&delete_results]() { auto result = delete_results[0]; delete_results.erase(delete_results.begin()); @@ -139,7 +139,7 @@ TEST(RetryingUtilsTest, DeleteWithRetries_PermissionDeniedNotRetried) { TEST(RetryingUtilsTest, DeleteWithRetries_SuccessThroughFileNotFound) { std::vector delete_results( - {errors::Unavailable(""), errors::NotFound("")}); + {absl::UnavailableError(""), absl::NotFoundError("")}); const auto delete_func = [&delete_results]() { auto result = delete_results[0]; delete_results.erase(delete_results.begin()); @@ -150,7 +150,7 @@ TEST(RetryingUtilsTest, DeleteWithRetries_SuccessThroughFileNotFound) { } TEST(RetryingUtilsTest, DeleteWithRetries_FirstNotFoundReturnedAsIs) { - std::vector delete_results({errors::NotFound("")}); + std::vector delete_results({absl::NotFoundError("")}); const auto delete_func = [&delete_results]() { auto result = delete_results[0]; delete_results.erase(delete_results.begin());