Replacing EXPECT/ASSERT/CHECK macros with IREE_* versions.
diff --git a/iree/base/api.c b/iree/base/api.c index ae7af99..a867d0c 100644 --- a/iree/base/api.c +++ b/iree/base/api.c
@@ -231,7 +231,7 @@ } } -// TODO(#265): move payload methods/types to header when API is stabilized. +// TODO(#55): move payload methods/types to header when API is stabilized. // Defines the type of an iree_status_payload_t. typedef enum { @@ -343,7 +343,7 @@ static void iree_status_attach_stack_trace(iree_status_storage_t* storage, int skip_frames) { #if (IREE_STATUS_FEATURES & IREE_STATUS_FEATURE_STACK_TRACE) != 0 - // TODO(#265): backtrace or other magic. + // TODO(#55): backtrace or other magic. #endif // has IREE_STATUS_FEATURE_STACK_TRACE }
diff --git a/iree/base/api.h b/iree/base/api.h index 98f048f..b478fb8 100644 --- a/iree/base/api.h +++ b/iree/base/api.h
@@ -604,7 +604,7 @@ IREE_STATUS_IMPL_IGNORE_ERROR_( \ IREE_STATUS_IMPL_CONCAT_(__status_, __COUNTER__), (expr)) -// TODO(#265): better logging of status checks. +// TODO(#2843): better logging of status checks. #define IREE_CHECK_OK(expr) \ CHECK_EQ(IREE_STATUS_OK, iree_status_consume_code(expr)) #define IREE_ASSERT_ARGUMENT(name) assert(name)
diff --git a/iree/base/dynamic_library_test.cc b/iree/base/dynamic_library_test.cc index efbbe25..4e91ba2 100644 --- a/iree/base/dynamic_library_test.cc +++ b/iree/base/dynamic_library_test.cc
@@ -19,9 +19,9 @@ #include "iree/base/dynamic_library_test_library_embed.h" #include "iree/base/file_io.h" #include "iree/base/status.h" -#include "iree/testing/status_matchers.h" #include "iree/base/target_platform.h" #include "iree/testing/gtest.h" +#include "iree/testing/status_matchers.h" namespace iree { namespace { @@ -38,7 +38,8 @@ // to a platform/test-environment specific temp file for loading. std::string base_name = "dynamic_library_test_library"; - ASSERT_OK_AND_ASSIGN(library_temp_path_, file_io::GetTempFile(base_name)); + IREE_ASSERT_OK_AND_ASSIGN(library_temp_path_, + file_io::GetTempFile(base_name)); // System APIs for loading dynamic libraries typically require an extension. #if defined(IREE_PLATFORM_WINDOWS) library_temp_path_ += ".dll"; @@ -49,7 +50,7 @@ const auto* file_toc = dynamic_library_test_library_create(); absl::string_view file_data(reinterpret_cast<const char*>(file_toc->data), file_toc->size); - ASSERT_OK(file_io::SetFileContents(library_temp_path_, file_data)); + IREE_ASSERT_OK(file_io::SetFileContents(library_temp_path_, file_data)); LOG(INFO) << "Embedded test library written to temp path: " << library_temp_path_; @@ -61,11 +62,8 @@ std::string DynamicLibraryTest::library_temp_path_; TEST_F(DynamicLibraryTest, LoadLibrarySuccess) { - auto library_or = DynamicLibrary::Load(library_temp_path_.c_str()); - ASSERT_OK(library_or); - - auto library = std::move(library_or.value()); - + IREE_ASSERT_OK_AND_ASSIGN(auto library, + DynamicLibrary::Load(library_temp_path_.c_str())); EXPECT_EQ(library_temp_path_, library->file_name()); } @@ -75,15 +73,15 @@ } TEST_F(DynamicLibraryTest, LoadLibraryTwice) { - ASSERT_OK_AND_ASSIGN(auto library1, - DynamicLibrary::Load(library_temp_path_.c_str())); - ASSERT_OK_AND_ASSIGN(auto library2, - DynamicLibrary::Load(library_temp_path_.c_str())); + IREE_ASSERT_OK_AND_ASSIGN(auto library1, + DynamicLibrary::Load(library_temp_path_.c_str())); + IREE_ASSERT_OK_AND_ASSIGN(auto library2, + DynamicLibrary::Load(library_temp_path_.c_str())); } TEST_F(DynamicLibraryTest, GetSymbolSuccess) { - ASSERT_OK_AND_ASSIGN(auto library, - DynamicLibrary::Load(library_temp_path_.c_str())); + IREE_ASSERT_OK_AND_ASSIGN(auto library, + DynamicLibrary::Load(library_temp_path_.c_str())); auto times_two_fn = library->GetSymbol<int (*)(int)>("times_two"); ASSERT_NE(nullptr, times_two_fn); @@ -91,8 +89,8 @@ } TEST_F(DynamicLibraryTest, GetSymbolFailure) { - ASSERT_OK_AND_ASSIGN(auto library, - DynamicLibrary::Load(library_temp_path_.c_str())); + IREE_ASSERT_OK_AND_ASSIGN(auto library, + DynamicLibrary::Load(library_temp_path_.c_str())); auto unknown_fn = library->GetSymbol<int (*)(int)>("unknown"); EXPECT_EQ(nullptr, unknown_fn);
diff --git a/iree/base/file_io_test.cc b/iree/base/file_io_test.cc index 5a72242..098ee41 100644 --- a/iree/base/file_io_test.cc +++ b/iree/base/file_io_test.cc
@@ -44,8 +44,8 @@ ASSERT_THAT(FileExists(path), StatusIs(StatusCode::kNotFound)); auto to_write = GetUniqueContents(unique_name); - ASSERT_OK(SetFileContents(path, to_write)); - ASSERT_OK_AND_ASSIGN(std::string read, GetFileContents(path)); + IREE_ASSERT_OK(SetFileContents(path, to_write)); + IREE_ASSERT_OK_AND_ASSIGN(std::string read, GetFileContents(path)); EXPECT_EQ(to_write, read); } @@ -55,9 +55,9 @@ ASSERT_THAT(FileExists(path), StatusIs(StatusCode::kNotFound)); auto to_write = GetUniqueContents(unique_name); - ASSERT_OK(SetFileContents(path, to_write)); - ASSERT_OK(FileExists(path)); - ASSERT_OK(DeleteFile(path)); + IREE_ASSERT_OK(SetFileContents(path, to_write)); + IREE_ASSERT_OK(FileExists(path)); + IREE_ASSERT_OK(DeleteFile(path)); EXPECT_THAT(FileExists(path), StatusIs(StatusCode::kNotFound)); } @@ -68,12 +68,12 @@ ASSERT_THAT(FileExists(to_path), StatusIs(StatusCode::kNotFound)); auto to_write = GetUniqueContents("MoveFile"); - ASSERT_OK(SetFileContents(from_path, to_write)); - ASSERT_OK(FileExists(from_path)); - EXPECT_OK(MoveFile(from_path, to_path)); + IREE_ASSERT_OK(SetFileContents(from_path, to_write)); + IREE_ASSERT_OK(FileExists(from_path)); + IREE_EXPECT_OK(MoveFile(from_path, to_path)); EXPECT_THAT(FileExists(from_path), StatusIs(StatusCode::kNotFound)); - EXPECT_OK(FileExists(to_path)); - ASSERT_OK_AND_ASSIGN(std::string read, GetFileContents(to_path)); + IREE_EXPECT_OK(FileExists(to_path)); + IREE_ASSERT_OK_AND_ASSIGN(std::string read, GetFileContents(to_path)); EXPECT_EQ(to_write, read); } @@ -83,7 +83,7 @@ } TEST(FileIo, GetTempFile) { - ASSERT_OK_AND_ASSIGN(std::string path1, GetTempFile("foo")); + IREE_ASSERT_OK_AND_ASSIGN(std::string path1, GetTempFile("foo")); EXPECT_TRUE(path1.find("foo") != std::string::npos); // Should be able to set file contents at the given path. @@ -91,10 +91,10 @@ // a file must be created at the path before calling GetTempFile again, or // else the same path may be returned. auto to_write = GetUniqueContents("GetTempFile"); - ASSERT_OK(SetFileContents(path1, to_write)); + IREE_ASSERT_OK(SetFileContents(path1, to_write)); // Create another temp file with the same base name, check for a unique path. - ASSERT_OK_AND_ASSIGN(std::string path2, GetTempFile("foo")); + IREE_ASSERT_OK_AND_ASSIGN(std::string path2, GetTempFile("foo")); EXPECT_TRUE(path2.find("foo") != std::string::npos); EXPECT_NE(path1, path2); }
diff --git a/iree/base/internal/status.cc b/iree/base/internal/status.cc index e1afb9d..6d52f47 100644 --- a/iree/base/internal/status.cc +++ b/iree/base/internal/status.cc
@@ -23,17 +23,18 @@ return os; } -std::string Status::ToString() const { - if (ok()) { +// static +IREE_MUST_USE_RESULT std::string Status::ToString(const iree_status_t& status) { + if (iree_status_is_ok(status)) { return "OK"; } iree_host_size_t buffer_length = 0; - if (IREE_UNLIKELY(!iree_status_format(value_, /*buffer_capacity=*/0, + if (IREE_UNLIKELY(!iree_status_format(status, /*buffer_capacity=*/0, /*buffer=*/NULL, &buffer_length))) { return "<!>"; } std::string result(buffer_length, '\0'); - if (IREE_UNLIKELY(!iree_status_format(value_, result.size() + 1, + if (IREE_UNLIKELY(!iree_status_format(status, result.size() + 1, const_cast<char*>(result.data()), &buffer_length))) { return "<!>";
diff --git a/iree/base/internal/status.h b/iree/base/internal/status.h index 42e279b..b202b5e 100644 --- a/iree/base/internal/status.h +++ b/iree/base/internal/status.h
@@ -98,6 +98,9 @@ // about the error. class Status final { public: + // Return a combination of the error code name and message. + static IREE_MUST_USE_RESULT std::string ToString(const iree_status_t& status); + // Creates an OK status with no message. Status() = default; @@ -174,7 +177,9 @@ } // Return a combination of the error code name and message. - IREE_MUST_USE_RESULT std::string ToString() const; + IREE_MUST_USE_RESULT std::string ToString() const { + return Status::ToString(value_); + } // Ignores any errors, potentially suppressing complaints from any tools. void IgnoreError() { value_ = iree_status_ignore(value_); } @@ -299,10 +304,13 @@ return status.code() == StatusCode::kUnknown; } -// TODO(#265): rename to IREE_CHECK_OK and make compatible with C API macros. -#define CHECK_OK(val) CHECK_EQ(::iree::StatusCode::kOk, (val)) -#define QCHECK_OK(val) QCHECK_EQ(::iree::StatusCode::kOk, (val)) -#define DCHECK_OK(val) DCHECK_EQ(::iree::StatusCode::kOk, (val)) +// TODO(#2843): better logging of status checks. +#undef IREE_CHECK_OK +#undef IREE_QCHECK_OK +#undef IREE_DCHECK_OK +#define IREE_CHECK_OK(val) CHECK(::iree::IsOk(val)) << (val) +#define IREE_QCHECK_OK(val) QCHECK_EQ(::iree::StatusCode::kOk, (val)) +#define IREE_DCHECK_OK(val) DCHECK_EQ(::iree::StatusCode::kOk, (val)) } // namespace iree
diff --git a/iree/base/status_test.cc b/iree/base/status_test.cc index ac85f2f..3ae5c7f 100644 --- a/iree/base/status_test.cc +++ b/iree/base/status_test.cc
@@ -73,7 +73,7 @@ EXPECT_THAT(status.ToString(), HasSubstr("message")); EXPECT_THAT(status.ToString(), HasSubstr("annotation")); - EXPECT_OK(returnIfError(OkStatus())); + IREE_EXPECT_OK(returnIfError(OkStatus())); } TEST(StatusMacro, ReturnIfErrorFormat) { @@ -89,7 +89,7 @@ EXPECT_THAT(status.ToString(), HasSubstr("annotation 1 2 3")); EXPECT_THAT(status.ToString(), HasSubstr("extra annotation")); - EXPECT_OK(returnIfError(OkStatus())); + IREE_EXPECT_OK(returnIfError(OkStatus())); } TEST(StatusMacro, AssignOrReturn) { @@ -105,7 +105,7 @@ EXPECT_THAT(status.ToString(), HasSubstr("message")); EXPECT_THAT(status.ToString(), HasSubstr("annotation")); - EXPECT_OK(assignOrReturn("foo")); + IREE_EXPECT_OK(assignOrReturn("foo")); } } // namespace
diff --git a/iree/base/wait_handle.cc b/iree/base/wait_handle.cc index 7a0886b..ddaec34 100644 --- a/iree/base/wait_handle.cc +++ b/iree/base/wait_handle.cc
@@ -467,7 +467,7 @@ void ManualResetEvent::Dispose() { if (fd_ != kInvalidFd) { // Always signal, as we need to ensure waiters are woken. - CHECK_OK(Set()); + IREE_CHECK_OK(Set()); Syscall(::close, fd_).value(); fd_ = kInvalidFd; }
diff --git a/iree/base/wait_handle_test.cc b/iree/base/wait_handle_test.cc index cd5c46f..66befcf 100644 --- a/iree/base/wait_handle_test.cc +++ b/iree/base/wait_handle_test.cc
@@ -36,7 +36,7 @@ // Tests the AlwaysSignaling helper. TEST(WaitHandleTest, AlwaysSignaling) { - ASSERT_OK(WaitHandle::AlwaysSignaling().Wait()); + IREE_ASSERT_OK(WaitHandle::AlwaysSignaling().Wait()); EXPECT_FALSE(WaitHandle::AlwaysSignaling().DebugString().empty()); } @@ -54,11 +54,11 @@ // Try waiting; should return immediately. WaitHandle wh0; - ASSERT_OK(wh0.Wait()); + IREE_ASSERT_OK(wh0.Wait()); // Waits on multiple permanent handles should be ok. WaitHandle wh1; - ASSERT_OK(WaitHandle::WaitAll({&wh0, &wh1})); + IREE_ASSERT_OK(WaitHandle::WaitAll({&wh0, &wh1})); } // Tests moving permanent WaitHandles around. @@ -88,17 +88,17 @@ // Since these just call WaitAll we leave the involved testing to those. TEST(WaitHandleTest, SingleWait) { WaitHandle wh; - ASSERT_OK(wh.Wait()); - ASSERT_OK(wh.Wait(Now() + absl::Seconds(1))); - ASSERT_OK(wh.Wait(absl::Seconds(1))); + IREE_ASSERT_OK(wh.Wait()); + IREE_ASSERT_OK(wh.Wait(Now() + absl::Seconds(1))); + IREE_ASSERT_OK(wh.Wait(absl::Seconds(1))); ASSERT_STATUSOR_TRUE(wh.TryWait()); } // Tests using WaitAll with no valid handles. This should no-op. TEST(WaitHandleTest, WaitAllNop) { - ASSERT_OK(WaitHandle::WaitAll({})); - ASSERT_OK(WaitHandle::WaitAll({nullptr})); - ASSERT_OK(WaitHandle::WaitAll({nullptr, nullptr})); + IREE_ASSERT_OK(WaitHandle::WaitAll({})); + IREE_ASSERT_OK(WaitHandle::WaitAll({nullptr})); + IREE_ASSERT_OK(WaitHandle::WaitAll({nullptr, nullptr})); } // Tests polling with WaitAll with multiple wait handles. @@ -113,17 +113,17 @@ IsDeadlineExceeded(WaitHandle::WaitAll({&wh0, &wh1}, InfinitePast()))); // Notify fence1. - ASSERT_OK(fence1.Set()); + IREE_ASSERT_OK(fence1.Set()); // Poll; should return immediately with timeout as fence1 is not signaled. ASSERT_TRUE( IsDeadlineExceeded(WaitHandle::WaitAll({&wh0, &wh1}, InfinitePast()))); // Notify fence0. - ASSERT_OK(fence0.Set()); + IREE_ASSERT_OK(fence0.Set()); // Poll again; should return immediately with success. - ASSERT_OK(WaitHandle::WaitAll({&wh0, &wh1}, InfinitePast())); + IREE_ASSERT_OK(WaitHandle::WaitAll({&wh0, &wh1}, InfinitePast())); } // Tests waiting when the first file handle is invalid. This is to verify a @@ -137,10 +137,10 @@ IsDeadlineExceeded(WaitHandle::WaitAll({nullptr, &wh}, InfinitePast()))); // Notify fence. - ASSERT_OK(fence.Set()); + IREE_ASSERT_OK(fence.Set()); // Poll again; should return immediately with success. - ASSERT_OK(WaitHandle::WaitAll({nullptr, &wh}, InfinitePast())); + IREE_ASSERT_OK(WaitHandle::WaitAll({nullptr, &wh}, InfinitePast())); } // Tests exceeding the timeout deadline with WaitAll. @@ -160,10 +160,10 @@ IsDeadlineExceeded(WaitHandle::WaitAll({&wh}, Milliseconds(-250)))); // Notify and ensure no more timeouts. - ASSERT_OK(fence.Set()); - ASSERT_OK(WaitHandle::WaitAll({&wh}, InfinitePast())); + IREE_ASSERT_OK(fence.Set()); + IREE_ASSERT_OK(WaitHandle::WaitAll({&wh}, InfinitePast())); ASSERT_STATUSOR_TRUE(WaitHandle::TryWaitAll({&wh})); - ASSERT_OK(WaitHandle::WaitAll({&wh}, Milliseconds(250))); + IREE_ASSERT_OK(WaitHandle::WaitAll({&wh}, Milliseconds(250))); // Via time in the past, should exceed deadline even if signaled. ASSERT_TRUE( @@ -176,18 +176,18 @@ ManualResetEvent fence0; std::thread t0{[&]() { ::usleep(absl::ToInt64Microseconds(Milliseconds(250))); - ASSERT_OK(fence0.Set()); + IREE_ASSERT_OK(fence0.Set()); }}; ManualResetEvent fence1; std::thread t1{[&]() { ::usleep(absl::ToInt64Microseconds(Milliseconds(250))); - ASSERT_OK(fence1.Set()); + IREE_ASSERT_OK(fence1.Set()); }}; // Wait on both threads to complete. WaitHandle wh0 = fence0.OnSet(); WaitHandle wh1 = fence1.OnSet(); - ASSERT_OK(WaitHandle::WaitAll({&wh0, &wh1})); + IREE_ASSERT_OK(WaitHandle::WaitAll({&wh0, &wh1})); t0.join(); t1.join(); @@ -200,8 +200,8 @@ WaitHandle wh1 = fence.OnSet(); ASSERT_TRUE( IsDeadlineExceeded(WaitHandle::WaitAll({&wh0, &wh1}, InfinitePast()))); - ASSERT_OK(fence.Set()); - ASSERT_OK(WaitHandle::WaitAll({&wh0, &wh1})); + IREE_ASSERT_OK(fence.Set()); + IREE_ASSERT_OK(WaitHandle::WaitAll({&wh0, &wh1})); } // Tests using WaitAll with literally the same wait handles. @@ -210,8 +210,8 @@ WaitHandle wh = fence.OnSet(); ASSERT_TRUE( IsDeadlineExceeded(WaitHandle::WaitAll({&wh, &wh}, InfinitePast()))); - ASSERT_OK(fence.Set()); - ASSERT_OK(WaitHandle::WaitAll({&wh, &wh})); + IREE_ASSERT_OK(fence.Set()); + IREE_ASSERT_OK(WaitHandle::WaitAll({&wh, &wh})); } // Tests WaitAll when a wait handle fails. @@ -226,9 +226,9 @@ // Tests using WaitAny with no valid handles. This should no-op. TEST(WaitHandleTest, WaitAnyNop) { ASSERT_TRUE(IsInvalidArgument(WaitHandle::WaitAny({}).status())); - ASSERT_OK_AND_ASSIGN(int index, WaitHandle::WaitAny({nullptr})); + IREE_ASSERT_OK_AND_ASSIGN(int index, WaitHandle::WaitAny({nullptr})); ASSERT_EQ(0, index); - ASSERT_OK_AND_ASSIGN(index, WaitHandle::WaitAny({nullptr, nullptr})); + IREE_ASSERT_OK_AND_ASSIGN(index, WaitHandle::WaitAny({nullptr, nullptr})); ASSERT_EQ(0, index); } @@ -244,19 +244,19 @@ WaitHandle::WaitAny({&wh0, &wh1}, InfinitePast()).status())); // Notify fence1. - ASSERT_OK(fence1.Set()); + IREE_ASSERT_OK(fence1.Set()); // Poll; should return immediately with fence1 signaled. - ASSERT_OK_AND_ASSIGN(int index, - WaitHandle::WaitAny({&wh0, &wh1}, InfinitePast())); + IREE_ASSERT_OK_AND_ASSIGN(int index, + WaitHandle::WaitAny({&wh0, &wh1}, InfinitePast())); EXPECT_EQ(1, index); // Notify fence0. - ASSERT_OK(fence0.Set()); + IREE_ASSERT_OK(fence0.Set()); // Poll again; should return immediately; which one is signaled is undefined. - ASSERT_OK_AND_ASSIGN(index, - WaitHandle::WaitAny({&wh0, &wh1}, InfinitePast())); + IREE_ASSERT_OK_AND_ASSIGN(index, + WaitHandle::WaitAny({&wh0, &wh1}, InfinitePast())); ASSERT_TRUE(index == 0 || index == 1); } @@ -271,38 +271,39 @@ // Via polling (should never block): ASSERT_TRUE(IsDeadlineExceeded( WaitHandle::WaitAny({&wh0, &wh1}, InfinitePast()).status())); - ASSERT_OK_AND_ASSIGN(int index, WaitHandle::TryWaitAny({&wh0, &wh1})); + IREE_ASSERT_OK_AND_ASSIGN(int index, WaitHandle::TryWaitAny({&wh0, &wh1})); ASSERT_EQ(-1, index); // Via time in the near future (should block): ASSERT_TRUE(IsDeadlineExceeded( WaitHandle::WaitAny({&wh0, &wh1}, Milliseconds(250)).status())); // Notify one of the fences. Should return immediately. - ASSERT_OK(fence1.Set()); - ASSERT_OK_AND_ASSIGN(index, - WaitHandle::WaitAny({&wh0, &wh1}, InfinitePast())); + IREE_ASSERT_OK(fence1.Set()); + IREE_ASSERT_OK_AND_ASSIGN(index, + WaitHandle::WaitAny({&wh0, &wh1}, InfinitePast())); ASSERT_EQ(1, index); - ASSERT_OK_AND_ASSIGN(index, WaitHandle::TryWaitAny({&wh0, &wh1})); + IREE_ASSERT_OK_AND_ASSIGN(index, WaitHandle::TryWaitAny({&wh0, &wh1})); ASSERT_EQ(1, index); - ASSERT_OK_AND_ASSIGN(index, - WaitHandle::WaitAny({&wh0, &wh1}, Milliseconds(250))); + IREE_ASSERT_OK_AND_ASSIGN( + index, WaitHandle::WaitAny({&wh0, &wh1}, Milliseconds(250))); ASSERT_EQ(1, index); // The unnotified fence should still timeout. ASSERT_TRUE( IsDeadlineExceeded(WaitHandle::WaitAny({&wh0}, InfinitePast()).status())); - ASSERT_OK_AND_ASSIGN(index, WaitHandle::TryWaitAny({&wh0})); + IREE_ASSERT_OK_AND_ASSIGN(index, WaitHandle::TryWaitAny({&wh0})); ASSERT_EQ(-1, index); ASSERT_TRUE(IsDeadlineExceeded( WaitHandle::WaitAny({&wh0}, Milliseconds(250)).status())); // Notify last fence and ensure complete. - ASSERT_OK(fence0.Set()); - ASSERT_OK_AND_ASSIGN(index, WaitHandle::WaitAny({&wh0}, InfinitePast())); + IREE_ASSERT_OK(fence0.Set()); + IREE_ASSERT_OK_AND_ASSIGN(index, WaitHandle::WaitAny({&wh0}, InfinitePast())); ASSERT_EQ(0, index); - ASSERT_OK_AND_ASSIGN(index, WaitHandle::TryWaitAny({&wh0})); + IREE_ASSERT_OK_AND_ASSIGN(index, WaitHandle::TryWaitAny({&wh0})); ASSERT_EQ(0, index); - ASSERT_OK_AND_ASSIGN(index, WaitHandle::WaitAny({&wh0}, Milliseconds(250))); + IREE_ASSERT_OK_AND_ASSIGN(index, + WaitHandle::WaitAny({&wh0}, Milliseconds(250))); ASSERT_EQ(0, index); } @@ -313,23 +314,23 @@ ManualResetEvent fence0; std::thread t0{[&]() { ::usleep(absl::ToInt64Microseconds(Milliseconds(250))); - ASSERT_OK(fence0.Set()); + IREE_ASSERT_OK(fence0.Set()); }}; ManualResetEvent fence1; std::thread t1{[&]() { - ASSERT_OK(fence0.OnSet().Wait()); + IREE_ASSERT_OK(fence0.OnSet().Wait()); ::usleep(absl::ToInt64Microseconds(Milliseconds(250))); - ASSERT_OK(fence1.Set()); + IREE_ASSERT_OK(fence1.Set()); }}; // Wait on both threads. We expect 0 to complete first. WaitHandle wh0 = fence0.OnSet(); WaitHandle wh1 = fence1.OnSet(); - ASSERT_OK_AND_ASSIGN(int index, WaitHandle::WaitAny({&wh0, &wh1})); + IREE_ASSERT_OK_AND_ASSIGN(int index, WaitHandle::WaitAny({&wh0, &wh1})); ASSERT_EQ(0, index); // Now wait for thread 1. - ASSERT_OK_AND_ASSIGN(index, WaitHandle::WaitAny({&wh1})); + IREE_ASSERT_OK_AND_ASSIGN(index, WaitHandle::WaitAny({&wh1})); ASSERT_EQ(0, index); t0.join(); @@ -343,8 +344,8 @@ WaitHandle wh1 = fence.OnSet(); ASSERT_TRUE(IsDeadlineExceeded( WaitHandle::WaitAny({&wh0, &wh1}, InfinitePast()).status())); - ASSERT_OK(fence.Set()); - ASSERT_OK_AND_ASSIGN(int index, WaitHandle::WaitAny({&wh0, &wh1})); + IREE_ASSERT_OK(fence.Set()); + IREE_ASSERT_OK_AND_ASSIGN(int index, WaitHandle::WaitAny({&wh0, &wh1})); ASSERT_TRUE(index == 0 || index == 1); } @@ -354,8 +355,8 @@ WaitHandle wh = fence.OnSet(); ASSERT_TRUE(IsDeadlineExceeded( WaitHandle::WaitAny({&wh, &wh}, InfinitePast()).status())); - ASSERT_OK(fence.Set()); - ASSERT_OK_AND_ASSIGN(int index, WaitHandle::WaitAny({&wh, &wh})); + IREE_ASSERT_OK(fence.Set()); + IREE_ASSERT_OK_AND_ASSIGN(int index, WaitHandle::WaitAny({&wh, &wh})); ASSERT_TRUE(index == 0 || index == 1); } @@ -405,7 +406,7 @@ ASSERT_STATUSOR_FALSE(wh.TryWait()); // Signal the MRE. - ASSERT_OK(mre.Set()); + IREE_ASSERT_OK(mre.Set()); // Try waiting again; we should get the AcquireFdForWait and then also get // the TryResolveWakeOnFd. @@ -488,15 +489,15 @@ ASSERT_STATUSOR_FALSE(wh0.TryWait()); ASSERT_STATUSOR_FALSE(wh1.TryWait()); // Set should be sticky. - ASSERT_OK(ev.Set()); + IREE_ASSERT_OK(ev.Set()); ASSERT_STATUSOR_TRUE(wh0.TryWait()); ASSERT_STATUSOR_TRUE(wh1.TryWait()); // Reset should clear. - ASSERT_OK(ev.Reset()); + IREE_ASSERT_OK(ev.Reset()); ASSERT_STATUSOR_FALSE(wh0.TryWait()); ASSERT_STATUSOR_FALSE(wh1.TryWait()); // Setting again should enable the previous WaitHandles to be signaled. - ASSERT_OK(ev.Set()); + IREE_ASSERT_OK(ev.Set()); ASSERT_STATUSOR_TRUE(wh0.TryWait()); ASSERT_STATUSOR_TRUE(wh1.TryWait()); } @@ -508,27 +509,27 @@ ManualResetEvent ev1{std::move(ev0)}; ManualResetEvent ev2 = std::move(ev1); ev1 = std::move(ev2); - ASSERT_OK(ev1.Set()); + IREE_ASSERT_OK(ev1.Set()); ASSERT_STATUSOR_TRUE(wh.TryWait()); } // Tests redundantly setting and resetting ManualResetEvents. TEST(ManualResetEventTest, RedundantUse) { ManualResetEvent ev; - ASSERT_OK(ev.Reset()); - ASSERT_OK(ev.Reset()); + IREE_ASSERT_OK(ev.Reset()); + IREE_ASSERT_OK(ev.Reset()); ASSERT_FALSE(ev.OnSet().TryWait().value()); - ASSERT_OK(ev.Set()); - ASSERT_OK(ev.Set()); + IREE_ASSERT_OK(ev.Set()); + IREE_ASSERT_OK(ev.Set()); ASSERT_TRUE(ev.OnSet().TryWait().value()); - ASSERT_OK(ev.Reset()); + IREE_ASSERT_OK(ev.Reset()); ASSERT_FALSE(ev.OnSet().TryWait().value()); } // Tests waiting on an initially-set ManualResetEvent; TEST(ManualResetEventTest, SetThenWait) { ManualResetEvent ev; - ASSERT_OK(ev.Set()); + IREE_ASSERT_OK(ev.Set()); ASSERT_TRUE(ev.OnSet().TryWait().value()); }
diff --git a/iree/hal/api_string_util_test.cc b/iree/hal/api_string_util_test.cc index bdd5642..cb2fe07 100644 --- a/iree/hal/api_string_util_test.cc +++ b/iree/hal/api_string_util_test.cc
@@ -673,23 +673,24 @@ TEST(ElementStringUtilTest, ParseOpaqueElement) { std::vector<uint8_t> buffer1(1); - EXPECT_OK(ParseElement("FF", IREE_HAL_ELEMENT_TYPE_OPAQUE_8, - absl::MakeSpan(buffer1))); + IREE_EXPECT_OK(ParseElement("FF", IREE_HAL_ELEMENT_TYPE_OPAQUE_8, + absl::MakeSpan(buffer1))); EXPECT_THAT(buffer1, Eq(std::vector<uint8_t>{0xFF})); std::vector<uint16_t> buffer2(1); - EXPECT_OK(ParseElement("FFCD", IREE_HAL_ELEMENT_TYPE_OPAQUE_16, - absl::MakeSpan(buffer2))); + IREE_EXPECT_OK(ParseElement("FFCD", IREE_HAL_ELEMENT_TYPE_OPAQUE_16, + absl::MakeSpan(buffer2))); EXPECT_THAT(buffer2, Eq(std::vector<uint16_t>{0xCDFFu})); std::vector<uint32_t> buffer4(1); - EXPECT_OK(ParseElement("FFCDAABB", IREE_HAL_ELEMENT_TYPE_OPAQUE_32, - absl::MakeSpan(buffer4))); + IREE_EXPECT_OK(ParseElement("FFCDAABB", IREE_HAL_ELEMENT_TYPE_OPAQUE_32, + absl::MakeSpan(buffer4))); EXPECT_THAT(buffer4, Eq(std::vector<uint32_t>{0xBBAACDFFu})); std::vector<uint64_t> buffer8(1); - EXPECT_OK(ParseElement("FFCDAABBCCDDEEFF", IREE_HAL_ELEMENT_TYPE_OPAQUE_64, - absl::MakeSpan(buffer8))); + IREE_EXPECT_OK(ParseElement("FFCDAABBCCDDEEFF", + IREE_HAL_ELEMENT_TYPE_OPAQUE_64, + absl::MakeSpan(buffer8))); EXPECT_THAT(buffer8, Eq(std::vector<uint64_t>{0xFFEEDDCCBBAACDFFull})); } @@ -754,36 +755,36 @@ TEST(BufferElementsStringUtilTest, ParseBufferElements) { // Empty: std::vector<int8_t> buffer0(0); - EXPECT_OK(ParseBufferElements<int8_t>("", absl::MakeSpan(buffer0))); + IREE_EXPECT_OK(ParseBufferElements<int8_t>("", absl::MakeSpan(buffer0))); EXPECT_THAT(buffer0, Eq(std::vector<int8_t>{})); std::vector<int8_t> buffer8(8, 123); - EXPECT_OK(ParseBufferElements<int8_t>("", absl::MakeSpan(buffer8))); + IREE_EXPECT_OK(ParseBufferElements<int8_t>("", absl::MakeSpan(buffer8))); EXPECT_THAT(buffer8, Eq(std::vector<int8_t>{0, 0, 0, 0, 0, 0, 0, 0})); // Scalar: std::vector<int8_t> buffer1(1); - EXPECT_OK(ParseBufferElements<int8_t>("1", absl::MakeSpan(buffer1))); + IREE_EXPECT_OK(ParseBufferElements<int8_t>("1", absl::MakeSpan(buffer1))); EXPECT_THAT(buffer1, Eq(std::vector<int8_t>{1})); // Splat: - EXPECT_OK(ParseBufferElements<int8_t>("3", absl::MakeSpan(buffer8))); + IREE_EXPECT_OK(ParseBufferElements<int8_t>("3", absl::MakeSpan(buffer8))); EXPECT_THAT(buffer8, Eq(std::vector<int8_t>{3, 3, 3, 3, 3, 3, 3, 3})); // 1:1: - EXPECT_OK(ParseBufferElements<int8_t>("2", absl::MakeSpan(buffer1))); + IREE_EXPECT_OK(ParseBufferElements<int8_t>("2", absl::MakeSpan(buffer1))); EXPECT_THAT(buffer1, Eq(std::vector<int8_t>{2})); std::vector<int16_t> buffer8i16(8); - EXPECT_OK(ParseBufferElements<int16_t>("0 1 2 3 4 5 6 7", - absl::MakeSpan(buffer8i16))); + IREE_EXPECT_OK(ParseBufferElements<int16_t>("0 1 2 3 4 5 6 7", + absl::MakeSpan(buffer8i16))); EXPECT_THAT(buffer8i16, Eq(std::vector<int16_t>{0, 1, 2, 3, 4, 5, 6, 7})); std::vector<int32_t> buffer8i32(8); - EXPECT_OK(ParseBufferElements<int32_t>("[0 1 2 3] [4 5 6 7]", - absl::MakeSpan(buffer8i32))); + IREE_EXPECT_OK(ParseBufferElements<int32_t>("[0 1 2 3] [4 5 6 7]", + absl::MakeSpan(buffer8i32))); EXPECT_THAT(buffer8i32, Eq(std::vector<int32_t>{0, 1, 2, 3, 4, 5, 6, 7})); } TEST(BufferElementsStringUtilTest, ParseBufferElementsOpaque) { std::vector<uint16_t> buffer3i16(3); - EXPECT_OK(ParseBufferElements("0011 2233 4455", - IREE_HAL_ELEMENT_TYPE_OPAQUE_16, - absl::MakeSpan(buffer3i16))); + IREE_EXPECT_OK(ParseBufferElements("0011 2233 4455", + IREE_HAL_ELEMENT_TYPE_OPAQUE_16, + absl::MakeSpan(buffer3i16))); EXPECT_THAT(buffer3i16, Eq(std::vector<uint16_t>{0x1100, 0x3322, 0x5544})); } @@ -895,44 +896,44 @@ } TEST(BufferViewStringUtilTest, Parse) { - ASSERT_OK_AND_ASSIGN(auto allocator, Allocator::CreateHostLocal()); + IREE_ASSERT_OK_AND_ASSIGN(auto allocator, Allocator::CreateHostLocal()); // Zero fill. - ASSERT_OK_AND_ASSIGN(auto bv0, BufferView::Parse("i8", allocator)); + IREE_ASSERT_OK_AND_ASSIGN(auto bv0, BufferView::Parse("i8", allocator)); EXPECT_THAT(bv0.buffer().CloneData<int8_t>(), IsOkAndHolds(Eq(std::vector<int8_t>{0}))); // Zero fill (empty value). - ASSERT_OK_AND_ASSIGN(auto bv1, BufferView::Parse("2x2xi8=", allocator)); + IREE_ASSERT_OK_AND_ASSIGN(auto bv1, BufferView::Parse("2x2xi8=", allocator)); EXPECT_THAT(bv1.buffer().CloneData<int8_t>(), IsOkAndHolds(Eq(std::vector<int8_t>{0, 0, 0, 0}))); // Splat. - ASSERT_OK_AND_ASSIGN(auto bv2, BufferView::Parse("2x2xi8=3", allocator)); + IREE_ASSERT_OK_AND_ASSIGN(auto bv2, BufferView::Parse("2x2xi8=3", allocator)); EXPECT_THAT(bv2.buffer().CloneData<int8_t>(), IsOkAndHolds(Eq(std::vector<int8_t>{3, 3, 3, 3}))); // Flat list. - ASSERT_OK_AND_ASSIGN(auto bv3, - BufferView::Parse("2x2xi8=1 2 3 4", allocator)); + IREE_ASSERT_OK_AND_ASSIGN(auto bv3, + BufferView::Parse("2x2xi8=1 2 3 4", allocator)); EXPECT_THAT(bv3.buffer().CloneData<int8_t>(), IsOkAndHolds(Eq(std::vector<int8_t>{1, 2, 3, 4}))); // Whitespace and separators shouldn't matter. - ASSERT_OK_AND_ASSIGN(auto bv4, - BufferView::Parse(" 2x2xi8 = 1,\n2 3\t,4", allocator)); + IREE_ASSERT_OK_AND_ASSIGN( + auto bv4, BufferView::Parse(" 2x2xi8 = 1,\n2 3\t,4", allocator)); EXPECT_THAT(bv4.buffer().CloneData<int8_t>(), IsOkAndHolds(Eq(std::vector<int8_t>{1, 2, 3, 4}))); // Brackets are optional. - ASSERT_OK_AND_ASSIGN(auto bv5, - BufferView::Parse("4xi16=[[0][1][2]][3]", allocator)); + IREE_ASSERT_OK_AND_ASSIGN( + auto bv5, BufferView::Parse("4xi16=[[0][1][2]][3]", allocator)); EXPECT_THAT(bv5.buffer().CloneData<int16_t>(), IsOkAndHolds(Eq(std::vector<int16_t>{0, 1, 2, 3}))); } TEST(BufferViewStringUtilTest, ParseInvalid) { - ASSERT_OK_AND_ASSIGN(auto allocator, Allocator::CreateHostLocal()); + IREE_ASSERT_OK_AND_ASSIGN(auto allocator, Allocator::CreateHostLocal()); // Incomplete. EXPECT_THAT(BufferView::Parse("", allocator), @@ -986,10 +987,10 @@ } TEST(BufferViewStringUtilTest, RoundTrip) { - ASSERT_OK_AND_ASSIGN(auto allocator, Allocator::CreateHostLocal()); + IREE_ASSERT_OK_AND_ASSIGN(auto allocator, Allocator::CreateHostLocal()); auto expect_round_trip = [&](std::string source_value) { - ASSERT_OK_AND_ASSIGN(auto buffer_view, - BufferView::Parse(source_value, allocator)); + IREE_ASSERT_OK_AND_ASSIGN(auto buffer_view, + BufferView::Parse(source_value, allocator)); EXPECT_THAT(buffer_view.ToString(), IsOkAndHolds(source_value)); };
diff --git a/iree/hal/buffer_mapping_test.cc b/iree/hal/buffer_mapping_test.cc index 748d4d2..513f3ea 100644 --- a/iree/hal/buffer_mapping_test.cc +++ b/iree/hal/buffer_mapping_test.cc
@@ -92,8 +92,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mapping, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); + IREE_ASSERT_OK_AND_ASSIGN(auto mapping, + buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); EXPECT_CALL(*buffer, UnmapMemoryImpl(0, 128, kValidPtr)) .WillOnce(Return(OkStatus())); mapping.reset(); @@ -106,8 +106,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 4, 12, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mapping, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead, 4, 12)); + IREE_ASSERT_OK_AND_ASSIGN( + auto mapping, buffer->MapMemory<uint8_t>(MemoryAccess::kRead, 4, 12)); EXPECT_CALL(*buffer, UnmapMemoryImpl(4, 12, kValidPtr)) .WillOnce(Return(OkStatus())); mapping.reset(); @@ -139,8 +139,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_a, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_a, + buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); // Should be able to move the handle around without having any calls. auto mm_b = std::move(mm_a); @@ -161,12 +161,12 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_r, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_r, + buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); // Non-mutable access is fine. EXPECT_EQ(kValidPtr, mm_r.data()); - ASSERT_OK_AND_ASSIGN(auto span, mm_r.Subspan()); + IREE_ASSERT_OK_AND_ASSIGN(auto span, mm_r.Subspan()); (void)span; // Read-only mappings should not be able to get mutable access. @@ -195,15 +195,15 @@ MemoryAccess::kRead | MemoryAccess::kWrite, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN( + IREE_ASSERT_OK_AND_ASSIGN( auto mm_rw, buffer->MapMemory<uint8_t>(MemoryAccess::kRead | MemoryAccess::kWrite)); // Everything valid. EXPECT_EQ(kValidPtr, mm_rw.data()); - ASSERT_OK_AND_ASSIGN(auto span, mm_rw.Subspan()); + IREE_ASSERT_OK_AND_ASSIGN(auto span, mm_rw.Subspan()); EXPECT_EQ(kValidPtr, mm_rw.mutable_data()); - ASSERT_OK_AND_ASSIGN(span, mm_rw.MutableSubspan()); + IREE_ASSERT_OK_AND_ASSIGN(span, mm_rw.MutableSubspan()); EXPECT_CALL(*buffer, UnmapMemoryImpl(0, 128, kValidPtr)) .WillOnce(Return(OkStatus())); @@ -223,12 +223,12 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kWrite, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_w, - buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_w, + buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); // Mutable access is valid. EXPECT_EQ(kValidPtr, mm_w.mutable_data()); - ASSERT_OK_AND_ASSIGN(auto span, mm_w.MutableSubspan()); + IREE_ASSERT_OK_AND_ASSIGN(auto span, mm_w.MutableSubspan()); (void)span; // Write-only mappings should not be able to get non-mutable access. @@ -260,8 +260,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kDiscardWrite, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_dw, - buffer->MapMemory<uint8_t>(MemoryAccess::kDiscardWrite)); + IREE_ASSERT_OK_AND_ASSIGN( + auto mm_dw, buffer->MapMemory<uint8_t>(MemoryAccess::kDiscardWrite)); EXPECT_CALL(*buffer, UnmapMemoryImpl(0, 128, kValidPtr)) .WillOnce(Return(OkStatus())); mm_dw.reset(); @@ -270,8 +270,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kWrite, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_w, - buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_w, + buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); EXPECT_CALL(*buffer, UnmapMemoryImpl(0, 128, kValidPtr)) .WillOnce(Return(OkStatus())); mm_w.reset(); @@ -288,28 +288,28 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_r, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_r, + buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); // Request some valid ranges and ensure the byte offsets are correct. - ASSERT_OK_AND_ASSIGN(auto ss, mm_r.Subspan()); + IREE_ASSERT_OK_AND_ASSIGN(auto ss, mm_r.Subspan()); EXPECT_EQ(kValidPtr, ss.data()); EXPECT_EQ(128, ss.size()); - ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(100, 2)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(100, 2)); EXPECT_EQ(static_cast<const uint8_t*>(kValidPtr) + 100, ss.data()); EXPECT_EQ(2, ss.size()); - ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(100, kWholeBuffer)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(100, kWholeBuffer)); EXPECT_EQ(static_cast<const uint8_t*>(kValidPtr) + 100, ss.data()); EXPECT_EQ(28, ss.size()); // Zero length ranges are fine. - ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(0, 0)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(0, 0)); EXPECT_EQ(kValidPtr, ss.data()); EXPECT_TRUE(ss.empty()); - ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(128, 0)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(128, 0)); EXPECT_EQ(static_cast<const uint8_t*>(kValidPtr) + 128, ss.data()); EXPECT_TRUE(ss.empty()); - ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(128, kWholeBuffer)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_r.Subspan(128, kWholeBuffer)); EXPECT_EQ(static_cast<const uint8_t*>(kValidPtr) + 128, ss.data()); EXPECT_TRUE(ss.empty()); @@ -325,8 +325,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_r, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_r, + buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); // Try some invalid ranges that would overrun the span. EXPECT_TRUE(IsOutOfRange(mm_r.Subspan(1234, 0).status())); @@ -346,28 +346,28 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kWrite, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_w, - buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_w, + buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); // Request some valid ranges and ensure the byte offsets are correct. - ASSERT_OK_AND_ASSIGN(auto ss, mm_w.MutableSubspan()); + IREE_ASSERT_OK_AND_ASSIGN(auto ss, mm_w.MutableSubspan()); EXPECT_EQ(kValidPtr, ss.data()); EXPECT_EQ(128, ss.size()); - ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(100, 2)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(100, 2)); EXPECT_EQ(static_cast<const uint8_t*>(kValidPtr) + 100, ss.data()); EXPECT_EQ(2, ss.size()); - ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(100, kWholeBuffer)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(100, kWholeBuffer)); EXPECT_EQ(static_cast<const uint8_t*>(kValidPtr) + 100, ss.data()); EXPECT_EQ(28, ss.size()); // Zero length ranges are fine. - ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(0, 0)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(0, 0)); EXPECT_EQ(kValidPtr, ss.data()); EXPECT_TRUE(ss.empty()); - ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(128, 0)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(128, 0)); EXPECT_EQ(static_cast<const uint8_t*>(kValidPtr) + 128, ss.data()); EXPECT_TRUE(ss.empty()); - ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(128, kWholeBuffer)); + IREE_ASSERT_OK_AND_ASSIGN(ss, mm_w.MutableSubspan(128, kWholeBuffer)); EXPECT_EQ(static_cast<const uint8_t*>(kValidPtr) + 128, ss.data()); EXPECT_TRUE(ss.empty()); @@ -383,8 +383,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kWrite, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_w, - buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_w, + buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); // Try some invalid ranges that would overrun the span. EXPECT_TRUE(IsOutOfRange(mm_w.MutableSubspan(1234, 0).status())); @@ -404,8 +404,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_r, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_r, + buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); // Just verify we are getting the expected pointer back. EXPECT_EQ(kValidPtr, &mm_r[0]); @@ -422,19 +422,19 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_r, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_r, + buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); // Invalidate a few ways. EXPECT_CALL(*buffer, InvalidateMappedMemoryImpl(0, 128)) .WillOnce(Return(OkStatus())); - EXPECT_OK(mm_r.Invalidate()); + IREE_EXPECT_OK(mm_r.Invalidate()); EXPECT_CALL(*buffer, InvalidateMappedMemoryImpl(100, 2)) .WillOnce(Return(OkStatus())); - EXPECT_OK(mm_r.Invalidate(100, 2)); + IREE_EXPECT_OK(mm_r.Invalidate(100, 2)); EXPECT_CALL(*buffer, InvalidateMappedMemoryImpl(100, 28)) .WillOnce(Return(OkStatus())); - EXPECT_OK(mm_r.Invalidate(100, kWholeBuffer)); + IREE_EXPECT_OK(mm_r.Invalidate(100, kWholeBuffer)); EXPECT_CALL(*buffer, UnmapMemoryImpl(0, 128, kValidPtr)) .WillOnce(Return(OkStatus())); @@ -448,8 +448,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_r, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_r, + buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); // Try to invalidate invalid ranges. EXPECT_TRUE(IsOutOfRange(mm_r.Invalidate(1234, 0))); @@ -470,7 +470,7 @@ EXPECT_CALL(*coherent_buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kRead, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN( + IREE_ASSERT_OK_AND_ASSIGN( auto mm_r, coherent_buffer->MapMemory<uint8_t>(MemoryAccess::kRead)); EXPECT_TRUE(IsPermissionDenied(mm_r.Invalidate())); EXPECT_CALL(*coherent_buffer, UnmapMemoryImpl(0, 128, kValidPtr)) @@ -485,19 +485,19 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kWrite, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_w, - buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_w, + buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); // Flush a few ways. EXPECT_CALL(*buffer, FlushMappedMemoryImpl(0, 128)) .WillOnce(Return(OkStatus())); - EXPECT_OK(mm_w.Flush()); + IREE_EXPECT_OK(mm_w.Flush()); EXPECT_CALL(*buffer, FlushMappedMemoryImpl(100, 2)) .WillOnce(Return(OkStatus())); - EXPECT_OK(mm_w.Flush(100, 2)); + IREE_EXPECT_OK(mm_w.Flush(100, 2)); EXPECT_CALL(*buffer, FlushMappedMemoryImpl(100, 28)) .WillOnce(Return(OkStatus())); - EXPECT_OK(mm_w.Flush(100, kWholeBuffer)); + IREE_EXPECT_OK(mm_w.Flush(100, kWholeBuffer)); EXPECT_CALL(*buffer, UnmapMemoryImpl(0, 128, kValidPtr)) .WillOnce(Return(OkStatus())); @@ -511,8 +511,8 @@ EXPECT_CALL(*buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kWrite, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN(auto mm_w, - buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); + IREE_ASSERT_OK_AND_ASSIGN(auto mm_w, + buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); // Try to flush invalid ranges. EXPECT_TRUE(IsOutOfRange(mm_w.Flush(1234, 0))); @@ -533,7 +533,7 @@ EXPECT_CALL(*uncached_buffer, MapMemoryImpl(MockBuffer::MappingMode::kScoped, MemoryAccess::kWrite, 0, 128, _)) .WillOnce(DoAll(SetArgPointee<4>(kValidPtr), Return(OkStatus()))); - ASSERT_OK_AND_ASSIGN( + IREE_ASSERT_OK_AND_ASSIGN( auto mm_w, uncached_buffer->MapMemory<uint8_t>(MemoryAccess::kWrite)); EXPECT_TRUE(IsPermissionDenied(mm_w.Flush())); EXPECT_CALL(*uncached_buffer, UnmapMemoryImpl(0, 128, kValidPtr))
diff --git a/iree/hal/buffer_test.cc b/iree/hal/buffer_test.cc index cc54bef..9f575da 100644 --- a/iree/hal/buffer_test.cc +++ b/iree/hal/buffer_test.cc
@@ -49,7 +49,7 @@ // Data should be zeroed by default. std::vector<uint8_t> zero_data(buffer->allocation_size()); std::vector<uint8_t> actual_data(buffer->allocation_size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(zero_data)); } @@ -72,12 +72,12 @@ // Data should have been copied. std::vector<uint8_t> actual_data(src_data.size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(src_data)); // Modify the source data and ensure it is not reflected in the buffer. src_data[0] = 0x88; - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Not(Eq(src_data))); } @@ -102,8 +102,8 @@ // Data should have been copied. std::vector<int32_t> actual_data(src_data.size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), - actual_data.size() * sizeof(int32_t))); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), + actual_data.size() * sizeof(int32_t))); EXPECT_THAT(actual_data, Eq(src_data)); } @@ -118,12 +118,12 @@ // src_data and buffer should match after the wrapping. std::vector<uint8_t> actual_data(src_data.size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(src_data)); // Modify the source data directly. src_data[0] = 123; - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(src_data)); // Attempts to modify the buffer should fail. @@ -143,17 +143,17 @@ // src_data and buffer should match after the wrapping. std::vector<uint8_t> actual_data(src_data.size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(src_data)); // Modify the source data directly. src_data[0] = 123; - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(src_data)); // Modify the source data via the Buffer and ensure reflected in src_data. std::vector<uint8_t> new_data = {3, 2, 1, 0}; - EXPECT_OK(buffer->WriteData(0, new_data.data(), new_data.size())); + IREE_EXPECT_OK(buffer->WriteData(0, new_data.data(), new_data.size())); EXPECT_THAT(src_data, Eq(new_data)); } @@ -186,10 +186,10 @@ parent_buffer.get(), 1, 0)); // Subspans should offset within their allocation. - ASSERT_OK_AND_ASSIGN(auto subspan_buffer_0, - Buffer::Subspan(parent_buffer, 1, 2)); - ASSERT_OK_AND_ASSIGN(auto subspan_buffer_1, - Buffer::Subspan(parent_buffer, 2, 2)); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer_0, + Buffer::Subspan(parent_buffer, 1, 2)); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer_1, + Buffer::Subspan(parent_buffer, 2, 2)); EXPECT_FALSE(Buffer::DoesOverlap(subspan_buffer_0.get(), 0, 1, subspan_buffer_1.get(), 0, 1)); EXPECT_TRUE(Buffer::DoesOverlap(subspan_buffer_0.get(), 1, 1, @@ -215,43 +215,44 @@ ASSERT_TRUE(parent_buffer); // Create a subspan of the buffer. - ASSERT_OK_AND_ASSIGN(auto subspan_buffer, - Buffer::Subspan(parent_buffer, 1, 2)); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer, + Buffer::Subspan(parent_buffer, 1, 2)); ASSERT_TRUE(subspan_buffer); EXPECT_EQ(1, subspan_buffer->byte_offset()); EXPECT_EQ(2, subspan_buffer->byte_length()); // Modifications to either buffer should appear in the other. - EXPECT_OK(subspan_buffer->Fill8(1, kWholeBuffer, 0xFFu)); + IREE_EXPECT_OK(subspan_buffer->Fill8(1, kWholeBuffer, 0xFFu)); std::vector<uint8_t> actual_data(src_data.size()); - EXPECT_OK(parent_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK( + parent_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 1, 0xFF, 3)); // Subspans should be able to create subspans. // NOTE: offset is from the original buffer. - ASSERT_OK_AND_ASSIGN(auto subsubspan_buffer, - Buffer::Subspan(subspan_buffer, 1, 1)); + IREE_ASSERT_OK_AND_ASSIGN(auto subsubspan_buffer, + Buffer::Subspan(subspan_buffer, 1, 1)); ASSERT_TRUE(subsubspan_buffer); EXPECT_EQ(2, subsubspan_buffer->byte_offset()); EXPECT_EQ(1, subsubspan_buffer->byte_length()); // Zero length subspans are fine. - ASSERT_OK_AND_ASSIGN(auto zero_subspan_buffer, - Buffer::Subspan(parent_buffer, 0, 0)); + IREE_ASSERT_OK_AND_ASSIGN(auto zero_subspan_buffer, + Buffer::Subspan(parent_buffer, 0, 0)); ASSERT_TRUE(zero_subspan_buffer); EXPECT_EQ(0, zero_subspan_buffer->byte_offset()); EXPECT_EQ(0, zero_subspan_buffer->byte_length()); // Subspan with kWholeBuffer should get the remaining size (or zero). - ASSERT_OK_AND_ASSIGN(auto whole_subspan_buffer, - Buffer::Subspan(parent_buffer, 1, kWholeBuffer)); + IREE_ASSERT_OK_AND_ASSIGN(auto whole_subspan_buffer, + Buffer::Subspan(parent_buffer, 1, kWholeBuffer)); ASSERT_TRUE(whole_subspan_buffer); EXPECT_EQ(1, whole_subspan_buffer->byte_offset()); EXPECT_EQ(3, whole_subspan_buffer->byte_length()); // Zero length subspans are fine. - ASSERT_OK(Buffer::Subspan(subspan_buffer, 2, 0)); - ASSERT_OK(Buffer::Subspan(subspan_buffer, 2, kWholeBuffer)); + IREE_ASSERT_OK(Buffer::Subspan(subspan_buffer, 2, 0)); + IREE_ASSERT_OK(Buffer::Subspan(subspan_buffer, 2, kWholeBuffer)); } TEST(BufferTest, SubspanIdentity) { @@ -276,8 +277,8 @@ ASSERT_TRUE(parent_buffer); // Create a subspan of the buffer. - ASSERT_OK_AND_ASSIGN(auto subspan_buffer, - Buffer::Subspan(parent_buffer, 1, 2)); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer, + Buffer::Subspan(parent_buffer, 1, 2)); ASSERT_TRUE(subspan_buffer); EXPECT_EQ(1, subspan_buffer->byte_offset()); EXPECT_EQ(2, subspan_buffer->byte_length()); @@ -298,34 +299,34 @@ // Data should be zeroed by default. std::vector<uint8_t> actual_data(buffer->allocation_size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 0, 0, 0, 0)); // Fill with a sentinel. - EXPECT_OK(buffer->Fill8(0, buffer->allocation_size(), 0x33u)); + IREE_EXPECT_OK(buffer->Fill8(0, buffer->allocation_size(), 0x33u)); // Verify data. - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x33, 0x33, 0x33, 0x33, 0x33)); // Zero fills are fine. - EXPECT_OK(buffer->Fill8(0, 0, 0x44u)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->Fill8(0, 0, 0x44u)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x33, 0x33, 0x33, 0x33, 0x33)); // Fill the remaining parts of the buffer by using kWholeBuffer. - EXPECT_OK(buffer->Fill8(2, kWholeBuffer, 0x55u)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->Fill8(2, kWholeBuffer, 0x55u)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x33, 0x33, 0x55, 0x55, 0x55)); // Fill a small region of the buffer. - EXPECT_OK(buffer->Fill8(1, 1, 0x66u)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->Fill8(1, 1, 0x66u)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x33, 0x66, 0x55, 0x55, 0x55)); // Whole buffer helper. - EXPECT_OK(buffer->Fill8(0x99u)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->Fill8(0x99u)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x99, 0x99, 0x99, 0x99, 0x99)); } @@ -334,7 +335,7 @@ ASSERT_TRUE(buffer); // Fill with a sentinel. - EXPECT_OK(buffer->Fill8(0, buffer->allocation_size(), 0x33u)); + IREE_EXPECT_OK(buffer->Fill8(0, buffer->allocation_size(), 0x33u)); // Try to fill with invalid ranges. EXPECT_TRUE(IsOutOfRange(buffer->Fill8(1, 444, 0x44u))); @@ -344,7 +345,7 @@ // Ensure nothing happened with the bad ranges. std::vector<uint8_t> actual_data(buffer->allocation_size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x33, 0x33, 0x33, 0x33, 0x33)); } @@ -369,9 +370,9 @@ // Test on subspan. std::vector<uint8_t> actual_data(buffer->allocation_size()); - ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 1, 3)); - EXPECT_OK(subspan_buffer->Fill8(2, kWholeBuffer, 0xDDu)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 1, 3)); + IREE_EXPECT_OK(subspan_buffer->Fill8(2, kWholeBuffer, 0xDDu)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 0, 0, 0xDD, 0)); } @@ -381,34 +382,34 @@ // Data should be zeroed by default. std::vector<uint8_t> actual_data(buffer->allocation_size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 0, 0, 0, 0, 0, 0, 0, 0)); // Fill with a sentinel. - EXPECT_OK(buffer->Fill16(0, 4, 0x1122u)); + IREE_EXPECT_OK(buffer->Fill16(0, 4, 0x1122u)); // Verify data. - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x22, 0x11, 0x22, 0x11, 0, 0, 0, 0, 0)); // Zero fills are fine. - EXPECT_OK(buffer->Fill16(0, 0, 0x5566u)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->Fill16(0, 0, 0x5566u)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x22, 0x11, 0x22, 0x11, 0, 0, 0, 0, 0)); // Fill the remaining parts of the buffer by using kWholeBuffer. auto aligned_buffer = HeapBuffer::Allocate(BufferUsage::kMapping, 8); - EXPECT_OK(aligned_buffer->Fill16(4, kWholeBuffer, 0x5566u)); + IREE_EXPECT_OK(aligned_buffer->Fill16(4, kWholeBuffer, 0x5566u)); std::vector<uint8_t> aligned_actual_data(aligned_buffer->allocation_size()); - EXPECT_OK(aligned_buffer->ReadData(0, aligned_actual_data.data(), - aligned_actual_data.size())); + IREE_EXPECT_OK(aligned_buffer->ReadData(0, aligned_actual_data.data(), + aligned_actual_data.size())); EXPECT_THAT(aligned_actual_data, ElementsAre(0, 0, 0, 0, 0x66, 0x55, 0x66, 0x55)); // Whole buffer helper. - EXPECT_OK(aligned_buffer->Fill16(0x5566u)); - EXPECT_OK(aligned_buffer->ReadData(0, aligned_actual_data.data(), - aligned_actual_data.size())); + IREE_EXPECT_OK(aligned_buffer->Fill16(0x5566u)); + IREE_EXPECT_OK(aligned_buffer->ReadData(0, aligned_actual_data.data(), + aligned_actual_data.size())); EXPECT_THAT(aligned_actual_data, ElementsAre(0x66, 0x55, 0x66, 0x55, 0x66, 0x55, 0x66, 0x55)); } @@ -453,13 +454,13 @@ ASSERT_TRUE(buffer); // Fill with a sentinel. - EXPECT_OK(buffer->Fill16(0, 4, 0x1122u)); + IREE_EXPECT_OK(buffer->Fill16(0, 4, 0x1122u)); // Test on subspan. std::vector<uint8_t> actual_data(buffer->allocation_size()); - ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 2, 4)); - EXPECT_OK(subspan_buffer->Fill16(2, kWholeBuffer, 0xAABBu)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 2, 4)); + IREE_EXPECT_OK(subspan_buffer->Fill16(2, kWholeBuffer, 0xAABBu)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x22, 0x11, 0x22, 0x11, 0xBB, 0xAA, 0, 0, 0)); } @@ -470,36 +471,36 @@ // Data should be zeroed by default. std::vector<uint8_t> actual_data(buffer->allocation_size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 0, 0, 0, 0, 0, 0, 0, 0)); // Fill with a sentinel. - EXPECT_OK(buffer->Fill32(0, 8, 0x11223344u)); + IREE_EXPECT_OK(buffer->Fill32(0, 8, 0x11223344u)); // Verify data. - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x44, 0x33, 0x22, 0x11, 0x44, 0x33, 0x22, 0x11, 0)); // Zero fills are fine. - EXPECT_OK(buffer->Fill32(0, 0, 0x55667788u)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->Fill32(0, 0, 0x55667788u)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x44, 0x33, 0x22, 0x11, 0x44, 0x33, 0x22, 0x11, 0)); // Fill the remaining parts of the buffer by using kWholeBuffer. auto aligned_buffer = HeapBuffer::Allocate(BufferUsage::kMapping, 8); - EXPECT_OK(aligned_buffer->Fill32(4, kWholeBuffer, 0x55667788u)); + IREE_EXPECT_OK(aligned_buffer->Fill32(4, kWholeBuffer, 0x55667788u)); std::vector<uint8_t> aligned_actual_data(aligned_buffer->allocation_size()); - EXPECT_OK(aligned_buffer->ReadData(0, aligned_actual_data.data(), - aligned_actual_data.size())); + IREE_EXPECT_OK(aligned_buffer->ReadData(0, aligned_actual_data.data(), + aligned_actual_data.size())); EXPECT_THAT(aligned_actual_data, ElementsAre(0, 0, 0, 0, 0x88, 0x77, 0x66, 0x55)); // Whole buffer helper. - EXPECT_OK(aligned_buffer->Fill32(0x55667788u)); - EXPECT_OK(aligned_buffer->ReadData(0, aligned_actual_data.data(), - aligned_actual_data.size())); + IREE_EXPECT_OK(aligned_buffer->Fill32(0x55667788u)); + IREE_EXPECT_OK(aligned_buffer->ReadData(0, aligned_actual_data.data(), + aligned_actual_data.size())); EXPECT_THAT(aligned_actual_data, ElementsAre(0x88, 0x77, 0x66, 0x55, 0x88, 0x77, 0x66, 0x55)); } @@ -544,13 +545,13 @@ ASSERT_TRUE(buffer); // Fill with a sentinel. - EXPECT_OK(buffer->Fill32(0, 8, 0x11223344u)); + IREE_EXPECT_OK(buffer->Fill32(0, 8, 0x11223344u)); // Test on subspan. std::vector<uint8_t> actual_data(buffer->allocation_size()); - ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 4, 4)); - EXPECT_OK(subspan_buffer->Fill32(0, kWholeBuffer, 0xAABBCCDDu)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 4, 4)); + IREE_EXPECT_OK(subspan_buffer->Fill32(0, kWholeBuffer, 0xAABBCCDDu)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0x44, 0x33, 0x22, 0x11, 0xDD, 0xCC, 0xBB, 0xAA, 0)); } @@ -564,16 +565,16 @@ // Read the data back. std::vector<uint8_t> actual_data(src_data.size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(src_data)); // Reading zero bytes is valid. std::vector<uint8_t> zero_data(0); - EXPECT_OK(buffer->ReadData(1, zero_data.data(), 0)); + IREE_EXPECT_OK(buffer->ReadData(1, zero_data.data(), 0)); // Read a portion of the data. std::vector<uint8_t> partial_data(2); - EXPECT_OK(buffer->ReadData(1, partial_data.data(), 2)); + IREE_EXPECT_OK(buffer->ReadData(1, partial_data.data(), 2)); EXPECT_THAT(partial_data, ElementsAre(1, 2)); } @@ -610,8 +611,8 @@ // Test on subspan. std::vector<uint8_t> subspan_data(1); - ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 1, 2)); - EXPECT_OK(subspan_buffer->ReadData(1, subspan_data.data(), 1)); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 1, 2)); + IREE_EXPECT_OK(subspan_buffer->ReadData(1, subspan_data.data(), 1)); EXPECT_THAT(subspan_data, ElementsAre(2)); } @@ -624,25 +625,26 @@ // Read the data back - should still match. std::vector<uint8_t> actual_data(src_data.size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(src_data)); // Write over the entire buffer. std::vector<uint8_t> new_data = {10, 20, 30, 40}; - EXPECT_OK(buffer->WriteData(0, new_data.data(), new_data.size())); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->WriteData(0, new_data.data(), new_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(new_data)); // Writing zero bytes is valid. std::vector<uint8_t> zero_data; - EXPECT_OK(buffer->WriteData(0, zero_data.data(), 0)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->WriteData(0, zero_data.data(), 0)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(new_data)); // Write over a portion of the buffer. std::vector<uint8_t> partial_data = {99}; - EXPECT_OK(buffer->WriteData(1, partial_data.data(), partial_data.size())); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK( + buffer->WriteData(1, partial_data.data(), partial_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(10, 99, 30, 40)); } @@ -688,10 +690,10 @@ // Test on subspan. std::vector<uint8_t> subspan_data = {0xAA}; - ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 1, 2)); - EXPECT_OK(subspan_buffer->WriteData(1, subspan_data.data(), 1)); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer, Buffer::Subspan(buffer, 1, 2)); + IREE_EXPECT_OK(subspan_buffer->WriteData(1, subspan_data.data(), 1)); std::vector<uint8_t> actual_data(src_data.size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 1, 0xAA, 3)); } @@ -708,30 +710,36 @@ ASSERT_TRUE(dst_buffer); // Copy of length 0 should not change the dest buffer. - EXPECT_OK(dst_buffer->CopyData(0, src_buffer.get(), 0, 0)); + IREE_EXPECT_OK(dst_buffer->CopyData(0, src_buffer.get(), 0, 0)); std::vector<uint8_t> actual_data(dst_data.size()); - EXPECT_OK(dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK( + dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, Eq(dst_data)); // Copy a subrange of the buffer. - EXPECT_OK(dst_buffer->CopyData(1, src_buffer.get(), 2, 2)); - EXPECT_OK(dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(dst_buffer->CopyData(1, src_buffer.get(), 2, 2)); + IREE_EXPECT_OK( + dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 2, 3, 3, 4)); // Copy the entire buffer using kWholeBuffer. This will adjust sizes // to ensure that the min buffer is taken. We test both src and dst buffer // offset/length calculations (note that some may end up as 0 copies). - EXPECT_OK(dst_buffer->CopyData(3, src_buffer.get(), 0, kWholeBuffer)); - EXPECT_OK(dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(dst_buffer->CopyData(3, src_buffer.get(), 0, kWholeBuffer)); + IREE_EXPECT_OK( + dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 2, 3, 0, 1)); - EXPECT_OK(dst_buffer->CopyData(0, src_buffer.get(), 2, kWholeBuffer)); - EXPECT_OK(dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(dst_buffer->CopyData(0, src_buffer.get(), 2, kWholeBuffer)); + IREE_EXPECT_OK( + dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(2, 3, 3, 0, 1)); - EXPECT_OK(dst_buffer->CopyData(0, src_buffer.get(), 3, kWholeBuffer)); - EXPECT_OK(dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(dst_buffer->CopyData(0, src_buffer.get(), 3, kWholeBuffer)); + IREE_EXPECT_OK( + dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(3, 3, 3, 0, 1)); - EXPECT_OK(dst_buffer->CopyData(4, src_buffer.get(), 0, kWholeBuffer)); - EXPECT_OK(dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(dst_buffer->CopyData(4, src_buffer.get(), 0, kWholeBuffer)); + IREE_EXPECT_OK( + dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(3, 3, 3, 0, 0)); } @@ -771,8 +779,9 @@ // Test overlap. Non-overlapping regions should be fine, otherwise fail. std::vector<uint8_t> actual_data(dst_data.size()); - EXPECT_OK(dst_buffer->CopyData(0, dst_buffer.get(), 4, 1)); - EXPECT_OK(dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(dst_buffer->CopyData(0, dst_buffer.get(), 4, 1)); + IREE_EXPECT_OK( + dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(4, 1, 2, 3, 4)); EXPECT_TRUE( IsInvalidArgument(dst_buffer->CopyData(2, dst_buffer.get(), 0, 3))); @@ -816,12 +825,14 @@ // Test on subspan. std::vector<uint8_t> actual_data(dst_data.size()); - ASSERT_OK_AND_ASSIGN(auto subspan_src_buffer, - Buffer::Subspan(src_buffer, 1, 3)); - ASSERT_OK_AND_ASSIGN(auto subspan_dst_buffer, - Buffer::Subspan(dst_buffer, 2, 3)); - EXPECT_OK(subspan_dst_buffer->CopyData(1, subspan_src_buffer.get(), 1, 2)); - EXPECT_OK(dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_src_buffer, + Buffer::Subspan(src_buffer, 1, 3)); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_dst_buffer, + Buffer::Subspan(dst_buffer, 2, 3)); + IREE_EXPECT_OK( + subspan_dst_buffer->CopyData(1, subspan_src_buffer.get(), 1, 2)); + IREE_EXPECT_OK( + dst_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 1, 2, 2, 3)); } @@ -837,29 +848,29 @@ ASSERT_TRUE(buffer); // 0-length mappings are valid. - ASSERT_OK_AND_ASSIGN(auto mapping, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead, 0, 0)); + IREE_ASSERT_OK_AND_ASSIGN( + auto mapping, buffer->MapMemory<uint8_t>(MemoryAccess::kRead, 0, 0)); EXPECT_TRUE(mapping.empty()); EXPECT_EQ(0, mapping.size()); EXPECT_EQ(0, mapping.byte_length()); EXPECT_NE(nullptr, mapping.data()); - ASSERT_OK_AND_ASSIGN(auto span, mapping.Subspan()); + IREE_ASSERT_OK_AND_ASSIGN(auto span, mapping.Subspan()); EXPECT_TRUE(span.empty()); mapping.reset(); // Map the whole buffer for reading. - ASSERT_OK_AND_ASSIGN(mapping, buffer->MapMemory<uint8_t>(MemoryAccess::kRead, - 0, kWholeBuffer)); + IREE_ASSERT_OK_AND_ASSIGN(mapping, buffer->MapMemory<uint8_t>( + MemoryAccess::kRead, 0, kWholeBuffer)); EXPECT_EQ(src_data.size(), mapping.size()); - ASSERT_OK_AND_ASSIGN(span, mapping.Subspan()); + IREE_ASSERT_OK_AND_ASSIGN(span, mapping.Subspan()); EXPECT_THAT(span, ElementsAre(0, 1, 2, 3, 4, 5, 6)); mapping.reset(); // Map a portion of the buffer for reading. - ASSERT_OK_AND_ASSIGN(mapping, - buffer->MapMemory<uint8_t>(MemoryAccess::kRead, 1, 2)); + IREE_ASSERT_OK_AND_ASSIGN( + mapping, buffer->MapMemory<uint8_t>(MemoryAccess::kRead, 1, 2)); EXPECT_EQ(2, mapping.size()); - ASSERT_OK_AND_ASSIGN(span, mapping.Subspan()); + IREE_ASSERT_OK_AND_ASSIGN(span, mapping.Subspan()); EXPECT_THAT(span, ElementsAre(1, 2)); mapping.reset(); } @@ -874,11 +885,11 @@ // Map the buffer as non-byte values. // Note that we'll round down to the number of valid elements at the // alignment. - ASSERT_OK_AND_ASSIGN(auto mapping16, - buffer->MapMemory<uint16_t>(MemoryAccess::kRead)); + IREE_ASSERT_OK_AND_ASSIGN(auto mapping16, + buffer->MapMemory<uint16_t>(MemoryAccess::kRead)); EXPECT_EQ(3, mapping16.size()); EXPECT_LE(6, mapping16.byte_length()); - ASSERT_OK_AND_ASSIGN(auto span16, mapping16.Subspan()); + IREE_ASSERT_OK_AND_ASSIGN(auto span16, mapping16.Subspan()); EXPECT_THAT(span16, ElementsAre(0x0100, 0x0302, 0x0504)); mapping16.reset(); } @@ -930,14 +941,14 @@ ASSERT_TRUE(buffer); // Map and modify the data. We should see it when we read back. - ASSERT_OK_AND_ASSIGN(auto mapping, - buffer->MapMemory<uint8_t>(MemoryAccess::kWrite, 1, 2)); + IREE_ASSERT_OK_AND_ASSIGN( + auto mapping, buffer->MapMemory<uint8_t>(MemoryAccess::kWrite, 1, 2)); auto mutable_data = mapping.mutable_data(); mutable_data[0] = 0xAA; mutable_data[1] = 0xBB; mapping.reset(); std::vector<uint8_t> actual_data(src_data.size()); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 0xAA, 0xBB, 3, 4, 5, 6)); } @@ -952,9 +963,10 @@ // so we just trust that it's been discarded. It's a hint, anyway. We can be // sure that the data we didn't want to discard is the same though. std::vector<uint8_t> actual_data(src_data.size()); - ASSERT_OK_AND_ASSIGN(auto mapping, buffer->MapMemory<uint8_t>( - MemoryAccess::kDiscardWrite, 1, 2)); - EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_ASSERT_OK_AND_ASSIGN( + auto mapping, + buffer->MapMemory<uint8_t>(MemoryAccess::kDiscardWrite, 1, 2)); + IREE_EXPECT_OK(buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, _, _, 3, 4, 5, 6)); mapping.reset(); } @@ -965,17 +977,19 @@ BufferUsage::kTransfer | BufferUsage::kMapping, MemoryAccess::kAll, src_data.data(), src_data.size()); ASSERT_TRUE(parent_buffer); - ASSERT_OK_AND_ASSIGN(auto subspan_buffer, - Buffer::Subspan(parent_buffer, 1, 3)); - ASSERT_OK_AND_ASSIGN(auto mapping, subspan_buffer->MapMemory<uint8_t>( - MemoryAccess::kDiscardWrite, 1, 2)); + IREE_ASSERT_OK_AND_ASSIGN(auto subspan_buffer, + Buffer::Subspan(parent_buffer, 1, 3)); + IREE_ASSERT_OK_AND_ASSIGN( + auto mapping, + subspan_buffer->MapMemory<uint8_t>(MemoryAccess::kDiscardWrite, 1, 2)); auto* mutable_data = mapping.mutable_data(); mutable_data[0] = 0xCC; mutable_data[1] = 0xDD; mapping.reset(); std::vector<uint8_t> actual_data(src_data.size()); - EXPECT_OK(parent_buffer->ReadData(0, actual_data.data(), actual_data.size())); + IREE_EXPECT_OK( + parent_buffer->ReadData(0, actual_data.data(), actual_data.size())); EXPECT_THAT(actual_data, ElementsAre(0, 1, 0xCC, 0xDD, 4, 5, 6)); // Just here to make coverage happy; they are currently no-ops on the host. @@ -985,12 +999,12 @@ auto external_buffer = HeapBuffer::WrapMutable( MemoryType::kHostVisible | MemoryType::kHostCached, MemoryAccess::kAll, BufferUsage::kAll, absl::MakeSpan(external_data)); - ASSERT_OK_AND_ASSIGN(auto external_subspan_buffer, - Buffer::Subspan(external_buffer, 0, 1)); - ASSERT_OK_AND_ASSIGN( + IREE_ASSERT_OK_AND_ASSIGN(auto external_subspan_buffer, + Buffer::Subspan(external_buffer, 0, 1)); + IREE_ASSERT_OK_AND_ASSIGN( mapping, external_subspan_buffer->MapMemory<uint8_t>(MemoryAccess::kAll)); - EXPECT_OK(mapping.Invalidate()); - EXPECT_OK(mapping.Flush()); + IREE_EXPECT_OK(mapping.Invalidate()); + IREE_EXPECT_OK(mapping.Flush()); } } // namespace
diff --git a/iree/hal/cts/allocator_test.cc b/iree/hal/cts/allocator_test.cc index d2decb5..2b4f4b9 100644 --- a/iree/hal/cts/allocator_test.cc +++ b/iree/hal/cts/allocator_test.cc
@@ -53,7 +53,7 @@ BufferUsage usage = BufferUsage::kMapping; size_t allocation_size = 1024; - ASSERT_OK_AND_ASSIGN( + IREE_ASSERT_OK_AND_ASSIGN( auto buffer, allocator_->Allocate(memory_type, usage, allocation_size)); EXPECT_EQ(allocator_, buffer->allocator());
diff --git a/iree/hal/cts/command_buffer_test.cc b/iree/hal/cts/command_buffer_test.cc index 8937cb1..458fdc7 100644 --- a/iree/hal/cts/command_buffer_test.cc +++ b/iree/hal/cts/command_buffer_test.cc
@@ -24,9 +24,10 @@ class CommandBufferTest : public CtsTestBase {}; TEST_P(CommandBufferTest, CreateCommandBuffer) { - ASSERT_OK_AND_ASSIGN(auto command_buffer, device_->CreateCommandBuffer( - CommandBufferMode::kOneShot, - CommandCategory::kDispatch)); + IREE_ASSERT_OK_AND_ASSIGN( + auto command_buffer, + device_->CreateCommandBuffer(CommandBufferMode::kOneShot, + CommandCategory::kDispatch)); EXPECT_TRUE((command_buffer->mode() & CommandBufferMode::kOneShot) == CommandBufferMode::kOneShot);
diff --git a/iree/hal/cts/command_queue_test.cc b/iree/hal/cts/command_queue_test.cc index afb99a4..ced3226 100644 --- a/iree/hal/cts/command_queue_test.cc +++ b/iree/hal/cts/command_queue_test.cc
@@ -50,10 +50,10 @@ // Tests that waiting for idle is a no-op when nothing is queued. TEST_P(CommandQueueTest, WaitIdleWhileIdle) { for (auto* dispatch_queue : device_->dispatch_queues()) { - EXPECT_OK(dispatch_queue->WaitIdle()); + IREE_EXPECT_OK(dispatch_queue->WaitIdle()); } for (auto* transfer_queue : device_->transfer_queues()) { - EXPECT_OK(transfer_queue->WaitIdle()); + IREE_EXPECT_OK(transfer_queue->WaitIdle()); } } @@ -63,14 +63,15 @@ TEST_P(CommandQueueTest, BlockingSubmit) { auto command_queue = device_->dispatch_queues()[0]; - ASSERT_OK_AND_ASSIGN(auto command_buffer, device_->CreateCommandBuffer( - CommandBufferMode::kOneShot, - CommandCategory::kDispatch)); - ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(0ull)); + IREE_ASSERT_OK_AND_ASSIGN( + auto command_buffer, + device_->CreateCommandBuffer(CommandBufferMode::kOneShot, + CommandCategory::kDispatch)); + IREE_ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(0ull)); - ASSERT_OK(command_queue->Submit( + IREE_ASSERT_OK(command_queue->Submit( {{}, {command_buffer.get()}, {{semaphore.get(), 1ull}}})); - ASSERT_OK(semaphore->Wait(1ull, InfiniteFuture())); + IREE_ASSERT_OK(semaphore->Wait(1ull, InfiniteFuture())); } // Tests waiting while work is pending/in-flight. @@ -78,38 +79,46 @@ TEST_P(CommandQueueTest, WaitTimeout) { auto command_queue = device_->dispatch_queues()[0]; - ASSERT_OK_AND_ASSIGN(auto command_buffer, device_->CreateCommandBuffer( - CommandBufferMode::kOneShot, - CommandCategory::kDispatch)); - ASSERT_OK_AND_ASSIGN(auto wait_semaphore, device_->CreateSemaphore(0ull)); - ASSERT_OK_AND_ASSIGN(auto signal_semaphore, device_->CreateSemaphore(0ull)); + IREE_ASSERT_OK_AND_ASSIGN( + auto command_buffer, + device_->CreateCommandBuffer(CommandBufferMode::kOneShot, + CommandCategory::kDispatch)); + IREE_ASSERT_OK_AND_ASSIGN(auto wait_semaphore, + device_->CreateSemaphore(0ull)); + IREE_ASSERT_OK_AND_ASSIGN(auto signal_semaphore, + device_->CreateSemaphore(0ull)); - ASSERT_OK(command_queue->Submit({{{wait_semaphore.get(), 1ull}}, - {command_buffer.get()}, - {{signal_semaphore.get(), 1ull}}})); + IREE_ASSERT_OK(command_queue->Submit({{{wait_semaphore.get(), 1ull}}, + {command_buffer.get()}, + {{signal_semaphore.get(), 1ull}}})); // Work shouldn't start until the wait semaphore reaches its payload value. EXPECT_THAT(signal_semaphore->Query(), IsOkAndHolds(Eq(0ull))); EXPECT_TRUE(IsDeadlineExceeded(command_queue->WaitIdle(Milliseconds(100)))); // Signal the wait semaphore, work should begin and complete. - ASSERT_OK(wait_semaphore->Signal(1ull)); - ASSERT_OK(signal_semaphore->Wait(1ull, InfiniteFuture())); + IREE_ASSERT_OK(wait_semaphore->Signal(1ull)); + IREE_ASSERT_OK(signal_semaphore->Wait(1ull, InfiniteFuture())); } // Tests using multiple wait and signal semaphores. TEST_P(CommandQueueTest, WaitMultiple) { auto command_queue = device_->dispatch_queues()[0]; - ASSERT_OK_AND_ASSIGN(auto command_buffer, device_->CreateCommandBuffer( - CommandBufferMode::kOneShot, - CommandCategory::kDispatch)); - ASSERT_OK_AND_ASSIGN(auto wait_semaphore_1, device_->CreateSemaphore(0ull)); - ASSERT_OK_AND_ASSIGN(auto wait_semaphore_2, device_->CreateSemaphore(0ull)); - ASSERT_OK_AND_ASSIGN(auto signal_semaphore_1, device_->CreateSemaphore(0ull)); - ASSERT_OK_AND_ASSIGN(auto signal_semaphore_2, device_->CreateSemaphore(0ull)); + IREE_ASSERT_OK_AND_ASSIGN( + auto command_buffer, + device_->CreateCommandBuffer(CommandBufferMode::kOneShot, + CommandCategory::kDispatch)); + IREE_ASSERT_OK_AND_ASSIGN(auto wait_semaphore_1, + device_->CreateSemaphore(0ull)); + IREE_ASSERT_OK_AND_ASSIGN(auto wait_semaphore_2, + device_->CreateSemaphore(0ull)); + IREE_ASSERT_OK_AND_ASSIGN(auto signal_semaphore_1, + device_->CreateSemaphore(0ull)); + IREE_ASSERT_OK_AND_ASSIGN(auto signal_semaphore_2, + device_->CreateSemaphore(0ull)); - ASSERT_OK(command_queue->Submit( + IREE_ASSERT_OK(command_queue->Submit( {{{wait_semaphore_1.get(), 1ull}, {wait_semaphore_2.get(), 1ull}}, {command_buffer.get()}, {{signal_semaphore_1.get(), 1ull}, {signal_semaphore_2.get(), 1ull}}})); @@ -121,12 +130,12 @@ EXPECT_TRUE(IsDeadlineExceeded(command_queue->WaitIdle(Milliseconds(100)))); // Signal the wait semaphores, work should only begin after each is set. - ASSERT_OK(wait_semaphore_1->Signal(1ull)); + IREE_ASSERT_OK(wait_semaphore_1->Signal(1ull)); EXPECT_THAT(signal_semaphore_1->Query(), IsOkAndHolds(Eq(0ull))); EXPECT_THAT(signal_semaphore_2->Query(), IsOkAndHolds(Eq(0ull))); - ASSERT_OK(wait_semaphore_2->Signal(1ull)); + IREE_ASSERT_OK(wait_semaphore_2->Signal(1ull)); - ASSERT_OK(command_queue->WaitIdle()); + IREE_ASSERT_OK(command_queue->WaitIdle()); } INSTANTIATE_TEST_SUITE_P(AllDrivers, CommandQueueTest,
diff --git a/iree/hal/cts/cts_test_base.h b/iree/hal/cts/cts_test_base.h index 2e156ab..006dc06 100644 --- a/iree/hal/cts/cts_test_base.h +++ b/iree/hal/cts/cts_test_base.h
@@ -62,9 +62,9 @@ GTEST_SKIP(); return; } - ASSERT_OK_AND_ASSIGN(driver_, std::move(driver_or)); + IREE_ASSERT_OK_AND_ASSIGN(driver_, std::move(driver_or)); LOG(INFO) << "Creating default device..."; - ASSERT_OK_AND_ASSIGN(device_, driver_->CreateDefaultDevice()); + IREE_ASSERT_OK_AND_ASSIGN(device_, driver_->CreateDefaultDevice()); LOG(INFO) << "Created device '" << device_->info().name() << "'"; }
diff --git a/iree/hal/cts/semaphore_test.cc b/iree/hal/cts/semaphore_test.cc index 5b212aa..185acb7 100644 --- a/iree/hal/cts/semaphore_test.cc +++ b/iree/hal/cts/semaphore_test.cc
@@ -26,18 +26,18 @@ // Tests that a semaphore that is unused properly cleans itself up. TEST_P(SemaphoreTest, NoOp) { - ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(123u)); - ASSERT_OK_AND_ASSIGN(uint64_t value, semaphore->Query()); + IREE_ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(123u)); + IREE_ASSERT_OK_AND_ASSIGN(uint64_t value, semaphore->Query()); EXPECT_EQ(123u, value); } // Tests that a semaphore will accept new values as it is signaled. TEST_P(SemaphoreTest, NormalSignaling) { - ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(2u)); + IREE_ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(2u)); EXPECT_EQ(2u, semaphore->Query().value()); - EXPECT_OK(semaphore->Signal(3u)); + IREE_EXPECT_OK(semaphore->Signal(3u)); EXPECT_EQ(3u, semaphore->Query().value()); - EXPECT_OK(semaphore->Signal(40u)); + IREE_EXPECT_OK(semaphore->Signal(40u)); EXPECT_EQ(40u, semaphore->Query().value()); } @@ -47,9 +47,9 @@ // Tests that a semaphore that has failed will remain in a failed state. TEST_P(SemaphoreTest, Failure) { - ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(2u)); + IREE_ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(2u)); // Signal to 3. - EXPECT_OK(semaphore->Signal(3u)); + IREE_EXPECT_OK(semaphore->Signal(3u)); EXPECT_EQ(3u, semaphore->Query().value()); // Fail now. @@ -62,22 +62,22 @@ // Tests waiting on no semaphores. TEST_P(SemaphoreTest, EmptyWait) { - EXPECT_OK(device_->WaitAllSemaphores({}, InfiniteFuture())); + IREE_EXPECT_OK(device_->WaitAllSemaphores({}, InfiniteFuture())); } // Tests waiting on a semaphore that has already been signaled. TEST_P(SemaphoreTest, WaitAlreadySignaled) { - ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(2u)); + IREE_ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(2u)); // Test both previous and current values. - EXPECT_OK( + IREE_EXPECT_OK( device_->WaitAllSemaphores({{semaphore.get(), 1u}}, InfiniteFuture())); - EXPECT_OK( + IREE_EXPECT_OK( device_->WaitAllSemaphores({{semaphore.get(), 2u}}, InfiniteFuture())); } // Tests waiting on a semaphore that has not been signaled. TEST_P(SemaphoreTest, WaitUnsignaled) { - ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(2u)); + IREE_ASSERT_OK_AND_ASSIGN(auto semaphore, device_->CreateSemaphore(2u)); // NOTE: we don't actually block here because otherwise we'd lock up. // Result status is undefined - some backends may return DeadlineExceededError // while others may return success. @@ -91,17 +91,20 @@ // Tests threading behavior by ping-ponging between the test main thread and // a little thread. TEST_P(SemaphoreTest, PingPong) { - ASSERT_OK_AND_ASSIGN(auto a2b, device_->CreateSemaphore(0u)); - ASSERT_OK_AND_ASSIGN(auto b2a, device_->CreateSemaphore(0u)); + IREE_ASSERT_OK_AND_ASSIGN(auto a2b, device_->CreateSemaphore(0u)); + IREE_ASSERT_OK_AND_ASSIGN(auto b2a, device_->CreateSemaphore(0u)); std::thread thread([&]() { // Should advance right past this because the value is already set. - ASSERT_OK(device_->WaitAllSemaphores({{a2b.get(), 0u}}, InfiniteFuture())); - ASSERT_OK(b2a->Signal(1u)); + IREE_ASSERT_OK( + device_->WaitAllSemaphores({{a2b.get(), 0u}}, InfiniteFuture())); + IREE_ASSERT_OK(b2a->Signal(1u)); // Jump ahead. - ASSERT_OK(device_->WaitAllSemaphores({{a2b.get(), 4u}}, InfiniteFuture())); + IREE_ASSERT_OK( + device_->WaitAllSemaphores({{a2b.get(), 4u}}, InfiniteFuture())); }); - ASSERT_OK(device_->WaitAllSemaphores({{b2a.get(), 1u}}, InfiniteFuture())); - ASSERT_OK(a2b->Signal(4u)); + IREE_ASSERT_OK( + device_->WaitAllSemaphores({{b2a.get(), 1u}}, InfiniteFuture())); + IREE_ASSERT_OK(a2b->Signal(4u)); thread.join(); }
diff --git a/iree/hal/deferred_buffer_test.cc b/iree/hal/deferred_buffer_test.cc index 8045001..f3f8016 100644 --- a/iree/hal/deferred_buffer_test.cc +++ b/iree/hal/deferred_buffer_test.cc
@@ -68,11 +68,12 @@ EXPECT_CALL(allocator, CanUseBufferLike(_, _, _, _)) .WillRepeatedly(Return(true)); - EXPECT_OK(deferred_buffer->BindAllocation(add_ref(real_buffer), 10, 100)); + IREE_EXPECT_OK( + deferred_buffer->BindAllocation(add_ref(real_buffer), 10, 100)); EXPECT_EQ(256, deferred_buffer->allocation_size()); EXPECT_EQ(10, deferred_buffer->byte_offset()); EXPECT_EQ(100, deferred_buffer->byte_length()); - EXPECT_OK( + IREE_EXPECT_OK( deferred_buffer->BindAllocation(add_ref(real_buffer), 10, kWholeBuffer)); EXPECT_EQ(256, deferred_buffer->allocation_size()); EXPECT_EQ(10, deferred_buffer->byte_offset()); @@ -99,14 +100,15 @@ // Grow. EXPECT_EQ(100, deferred_buffer->byte_length()); - EXPECT_OK(deferred_buffer->GrowByteLength(150)); + IREE_EXPECT_OK(deferred_buffer->GrowByteLength(150)); EXPECT_EQ(150, deferred_buffer->byte_length()); // Shrinking should fail. EXPECT_TRUE(IsInvalidArgument(deferred_buffer->GrowByteLength(5))); // Growing should fail if bound. - EXPECT_OK(deferred_buffer->BindAllocation(std::move(real_buffer), 0, 150)); + IREE_EXPECT_OK( + deferred_buffer->BindAllocation(std::move(real_buffer), 0, 150)); EXPECT_TRUE(IsFailedPrecondition(deferred_buffer->GrowByteLength(100))); } @@ -126,13 +128,13 @@ EXPECT_EQ(deferred_buffer.get(), deferred_buffer->allocated_buffer()); EXPECT_EQ(0, deferred_buffer->allocation_size()); - EXPECT_OK(deferred_buffer->BindAllocation(add_ref(real_buffer), 0, 100)); + IREE_EXPECT_OK(deferred_buffer->BindAllocation(add_ref(real_buffer), 0, 100)); EXPECT_EQ(real_buffer.get(), deferred_buffer->allocated_buffer()); EXPECT_EQ(256, deferred_buffer->allocation_size()); deferred_buffer->ResetAllocation(); EXPECT_EQ(deferred_buffer.get(), deferred_buffer->allocated_buffer()); EXPECT_EQ(0, deferred_buffer->allocation_size()); - EXPECT_OK(deferred_buffer->BindAllocation(add_ref(real_buffer), 0, 100)); + IREE_EXPECT_OK(deferred_buffer->BindAllocation(add_ref(real_buffer), 0, 100)); EXPECT_EQ(real_buffer.get(), deferred_buffer->allocated_buffer()); EXPECT_EQ(256, deferred_buffer->allocation_size()); } @@ -147,12 +149,13 @@ HeapBuffer::Allocate(MemoryType::kHostLocal, BufferUsage::kAll, 256); EXPECT_CALL(allocator, CanUseBufferLike(_, _, _, _)) .WillRepeatedly(Return(true)); - EXPECT_OK(deferred_buffer->BindAllocation(std::move(real_buffer), 0, 100)); + IREE_EXPECT_OK( + deferred_buffer->BindAllocation(std::move(real_buffer), 0, 100)); EXPECT_FALSE(deferred_buffer->DebugString().empty()); EXPECT_FALSE(deferred_buffer->DebugStringShort().empty()); - EXPECT_OK(deferred_buffer->Fill8(0, 10, 0xFF)); + IREE_EXPECT_OK(deferred_buffer->Fill8(0, 10, 0xFF)); } // Tests that unbound buffers fail to perform any buffer actions.
diff --git a/iree/hal/dylib/dylib_driver_module.cc b/iree/hal/dylib/dylib_driver_module.cc index 2ef0089..d71d3fa 100644 --- a/iree/hal/dylib/dylib_driver_module.cc +++ b/iree/hal/dylib/dylib_driver_module.cc
@@ -32,7 +32,7 @@ } // namespace iree IREE_REGISTER_MODULE_INITIALIZER(iree_hal_dylib_driver, { - QCHECK_OK(::iree::hal::DriverRegistry::shared_registry()->Register( + IREE_QCHECK_OK(::iree::hal::DriverRegistry::shared_registry()->Register( "dylib", ::iree::hal::dylib::CreateDyLibDriver)); }); IREE_REGISTER_MODULE_INITIALIZER_SEQUENCE(iree_hal, iree_hal_dylib_driver);
diff --git a/iree/hal/host/condvar_semaphore_test.cc b/iree/hal/host/condvar_semaphore_test.cc index 5e11067..e2e4c57 100644 --- a/iree/hal/host/condvar_semaphore_test.cc +++ b/iree/hal/host/condvar_semaphore_test.cc
@@ -28,7 +28,7 @@ // Tests that a semaphore that is unused properly cleans itself up. TEST(CondVarSemaphoreTest, NoOp) { CondVarSemaphore semaphore(123u); - ASSERT_OK_AND_ASSIGN(uint64_t value, semaphore.Query()); + IREE_ASSERT_OK_AND_ASSIGN(uint64_t value, semaphore.Query()); EXPECT_EQ(123u, value); } @@ -36,9 +36,9 @@ TEST(CondVarSemaphoreTest, NormalSignaling) { CondVarSemaphore semaphore(2u); EXPECT_EQ(2u, semaphore.Query().value()); - EXPECT_OK(semaphore.Signal(3u)); + IREE_EXPECT_OK(semaphore.Signal(3u)); EXPECT_EQ(3u, semaphore.Query().value()); - EXPECT_OK(semaphore.Signal(40u)); + IREE_EXPECT_OK(semaphore.Signal(40u)); EXPECT_EQ(40u, semaphore.Query().value()); } @@ -56,7 +56,7 @@ TEST(CondVarSemaphoreTest, StickyFailure) { CondVarSemaphore semaphore(2u); // Signal to 3. - EXPECT_OK(semaphore.Signal(3u)); + IREE_EXPECT_OK(semaphore.Signal(3u)); EXPECT_EQ(3u, semaphore.Query().value()); // Fail now. @@ -70,17 +70,17 @@ // Tests waiting on no semaphores. TEST(CondVarSemaphoreTest, EmptyWait) { - EXPECT_OK(CondVarSemaphore::WaitForSemaphores({}, /*wait_all=*/true, - InfiniteFuture())); + IREE_EXPECT_OK(CondVarSemaphore::WaitForSemaphores({}, /*wait_all=*/true, + InfiniteFuture())); } // Tests waiting on a semaphore that has already been signaled. TEST(CondVarSemaphoreTest, WaitAlreadySignaled) { CondVarSemaphore semaphore(2u); // Test both previous and current values. - EXPECT_OK(CondVarSemaphore::WaitForSemaphores( + IREE_EXPECT_OK(CondVarSemaphore::WaitForSemaphores( {{&semaphore, 1u}}, /*wait_all=*/true, InfiniteFuture())); - EXPECT_OK(CondVarSemaphore::WaitForSemaphores( + IREE_EXPECT_OK(CondVarSemaphore::WaitForSemaphores( {{&semaphore, 2u}}, /*wait_all=*/true, InfiniteFuture())); } @@ -108,16 +108,16 @@ CondVarSemaphore b2a(0u); std::thread thread([&]() { // Should advance right past this because the value is already set. - ASSERT_OK(CondVarSemaphore::WaitForSemaphores( + IREE_ASSERT_OK(CondVarSemaphore::WaitForSemaphores( {{&a2b, 0u}}, /*wait_all=*/true, InfiniteFuture())); - ASSERT_OK(b2a.Signal(1u)); + IREE_ASSERT_OK(b2a.Signal(1u)); // Jump ahead. - ASSERT_OK(CondVarSemaphore::WaitForSemaphores( + IREE_ASSERT_OK(CondVarSemaphore::WaitForSemaphores( {{&a2b, 4u}}, /*wait_all=*/true, InfiniteFuture())); }); - ASSERT_OK(CondVarSemaphore::WaitForSemaphores({{&b2a, 1u}}, /*wait_all=*/true, - InfiniteFuture())); - ASSERT_OK(a2b.Signal(4u)); + IREE_ASSERT_OK(CondVarSemaphore::WaitForSemaphores( + {{&b2a, 1u}}, /*wait_all=*/true, InfiniteFuture())); + IREE_ASSERT_OK(a2b.Signal(4u)); thread.join(); } @@ -127,12 +127,12 @@ CondVarSemaphore b2a(0u); bool got_failure = false; std::thread thread([&]() { - ASSERT_OK(b2a.Signal(1u)); + IREE_ASSERT_OK(b2a.Signal(1u)); got_failure = IsUnknown(CondVarSemaphore::WaitForSemaphores( {{&a2b, 1u}}, /*wait_all=*/true, InfiniteFuture())); }); - ASSERT_OK(CondVarSemaphore::WaitForSemaphores({{&b2a, 1u}}, /*wait_all=*/true, - InfiniteFuture())); + IREE_ASSERT_OK(CondVarSemaphore::WaitForSemaphores( + {{&b2a, 1u}}, /*wait_all=*/true, InfiniteFuture())); a2b.Fail(UnknownErrorBuilder(IREE_LOC)); thread.join(); ASSERT_TRUE(got_failure);
diff --git a/iree/hal/host/serial/async_command_queue_test.cc b/iree/hal/host/serial/async_command_queue_test.cc index 6f4d639..c6fdaed 100644 --- a/iree/hal/host/serial/async_command_queue_test.cc +++ b/iree/hal/host/serial/async_command_queue_test.cc
@@ -80,9 +80,9 @@ return OkStatus(); }); CondVarSemaphore semaphore(0ull); - ASSERT_OK( + IREE_ASSERT_OK( command_queue->Submit({{}, {cmd_buffer.get()}, {{&semaphore, 1ull}}})); - ASSERT_OK(semaphore.Wait(1ull, InfiniteFuture())); + IREE_ASSERT_OK(semaphore.Wait(1ull, InfiniteFuture())); } // Tests that failure is propagated along the fence from the target queue. @@ -97,14 +97,14 @@ return DataLossErrorBuilder(IREE_LOC); }); CondVarSemaphore semaphore(0ull); - ASSERT_OK( + IREE_ASSERT_OK( command_queue->Submit({{}, {cmd_buffer.get()}, {{&semaphore, 1ull}}})); EXPECT_TRUE(IsDataLoss(semaphore.Wait(1ull, InfiniteFuture()))); } // Tests that waiting for idle is a no-op when nothing is queued. TEST_F(AsyncCommandQueueTest, WaitIdleWhileIdle) { - ASSERT_OK(command_queue->WaitIdle()); + IREE_ASSERT_OK(command_queue->WaitIdle()); } // Tests that waiting for idle will block when work is pending/in-flight. @@ -120,14 +120,14 @@ return OkStatus(); }); CondVarSemaphore semaphore(0ull); - ASSERT_OK( + IREE_ASSERT_OK( command_queue->Submit({{}, {cmd_buffer.get()}, {{&semaphore, 1ull}}})); // This should block for a sec or two. - ASSERT_OK(command_queue->WaitIdle()); + IREE_ASSERT_OK(command_queue->WaitIdle()); // Should have already expired. - ASSERT_OK_AND_ASSIGN(uint64_t value, semaphore.Query()); + IREE_ASSERT_OK_AND_ASSIGN(uint64_t value, semaphore.Query()); ASSERT_EQ(1ull, value); } @@ -148,19 +148,19 @@ CommandCategory::kTransfer); CondVarSemaphore semaphore_0(0u); - ASSERT_OK(command_queue->Submit( + IREE_ASSERT_OK(command_queue->Submit( {{}, {cmd_buffer_0.get()}, {{&semaphore_0, 1ull}}})); CondVarSemaphore semaphore_1(0u); - ASSERT_OK( + IREE_ASSERT_OK( command_queue->Submit({{}, {cmd_buffer_1.get()}, {{&semaphore_1, 1u}}})); // This should block for a sec or two. - ASSERT_OK(command_queue->WaitIdle()); + IREE_ASSERT_OK(command_queue->WaitIdle()); // Both should have already expired. - ASSERT_OK_AND_ASSIGN(uint64_t value_0, semaphore_0.Query()); + IREE_ASSERT_OK_AND_ASSIGN(uint64_t value_0, semaphore_0.Query()); ASSERT_EQ(1ull, value_0); - ASSERT_OK_AND_ASSIGN(uint64_t value_1, semaphore_1.Query()); + IREE_ASSERT_OK_AND_ASSIGN(uint64_t value_1, semaphore_1.Query()); ASSERT_EQ(1ull, value_1); } @@ -177,7 +177,7 @@ auto cmd_buffer_0 = make_ref<MockCommandBuffer>(CommandBufferMode::kOneShot, CommandCategory::kTransfer); CondVarSemaphore semaphore_0(0ull); - ASSERT_OK( + IREE_ASSERT_OK( command_queue->Submit({{}, {cmd_buffer_0.get()}, {{&semaphore_0, 1u}}})); EXPECT_TRUE(IsDataLoss(semaphore_0.Wait(1ull, InfiniteFuture()))); @@ -210,10 +210,10 @@ CommandCategory::kTransfer); CondVarSemaphore semaphore_0(0ull); - ASSERT_OK(command_queue->Submit( + IREE_ASSERT_OK(command_queue->Submit( {{}, {cmd_buffer_0.get()}, {{&semaphore_0, 1ull}}})); CondVarSemaphore semaphore_1(0ull); - ASSERT_OK(command_queue->Submit( + IREE_ASSERT_OK(command_queue->Submit( {{{&semaphore_0, 1ull}}, {cmd_buffer_1.get()}, {{&semaphore_1, 1ull}}})); EXPECT_TRUE(IsDataLoss(command_queue->WaitIdle()));
diff --git a/iree/hal/llvmjit/llvmjit_driver_module.cc b/iree/hal/llvmjit/llvmjit_driver_module.cc index a1be4dd..db1837f 100644 --- a/iree/hal/llvmjit/llvmjit_driver_module.cc +++ b/iree/hal/llvmjit/llvmjit_driver_module.cc
@@ -35,7 +35,7 @@ } // namespace iree IREE_REGISTER_MODULE_INITIALIZER(iree_hal_llvm_driver, { - QCHECK_OK(::iree::hal::DriverRegistry::shared_registry()->Register( + IREE_QCHECK_OK(::iree::hal::DriverRegistry::shared_registry()->Register( "llvm", ::iree::hal::llvmjit::CreateLLVMJITDriver)); }); IREE_REGISTER_MODULE_INITIALIZER_SEQUENCE(iree_hal, iree_hal_llvm_driver);
diff --git a/iree/hal/vmla/op_kernels_test.cc b/iree/hal/vmla/op_kernels_test.cc index a65a0bc..711a7d2 100644 --- a/iree/hal/vmla/op_kernels_test.cc +++ b/iree/hal/vmla/op_kernels_test.cc
@@ -16,8 +16,8 @@ #include "absl/container/inlined_vector.h" #include "iree/base/memory.h" -#include "iree/testing/status_matchers.h" #include "iree/testing/gtest.h" +#include "iree/testing/status_matchers.h" namespace iree { namespace hal { @@ -55,9 +55,9 @@ std::vector<int32_t> lengths = {2, 2}; auto expected_dst = src_buffer; - EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); EXPECT_EQ(dst_buffer, expected_dst); } @@ -71,9 +71,9 @@ std::vector<int32_t> lengths = {1, 4}; std::vector<uint8_t> expected_dst = {1, 2, 3, 4}; - EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); EXPECT_EQ(dst_buffer, expected_dst); } @@ -87,9 +87,9 @@ std::vector<int32_t> lengths = {1, 2}; std::vector<uint8_t> expected_dst = {6, 7}; - EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); EXPECT_EQ(dst_buffer, expected_dst); } @@ -103,9 +103,9 @@ std::vector<int32_t> lengths = {2, 4}; std::vector<uint8_t> expected_dst = {5, 6, 7, 8, 9, 10, 11, 12}; - EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); EXPECT_EQ(dst_buffer, expected_dst); } @@ -119,9 +119,9 @@ std::vector<int32_t> lengths = {2, 2}; std::vector<uint8_t> expected_dst = {6, 7, 10, 11}; - EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); EXPECT_EQ(dst_buffer, expected_dst); } @@ -137,9 +137,9 @@ std::vector<int32_t> lengths = {2, 2}; std::vector<int32_t> expected_dst = {6, 7, 10, 11}; - EXPECT_OK(Copy::Execute<4>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<4>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); absl::Span<int32_t> dst_buffer_int32_t = ReinterpretSpan<int32_t>(absl::MakeSpan(dst_buffer)); @@ -162,9 +162,9 @@ 42, 42, 42}; // clang-format on - EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); EXPECT_EQ(dst_buffer, expected_dst); } @@ -179,9 +179,9 @@ std::vector<uint8_t> expected_dst = {41, 42, 44, 45, 50, 51, 53, 54, 68, 69, 71, 72, 77, 78, 80, 81}; - EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); EXPECT_EQ(dst_buffer, expected_dst); } @@ -195,9 +195,9 @@ std::vector<int32_t> lengths = {}; std::vector<uint8_t> expected_dst = {42}; - EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<1>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); EXPECT_EQ(dst_buffer, expected_dst); } @@ -212,9 +212,9 @@ std::vector<int32_t> lengths = {}; std::vector<int32_t> expected_dst = {INT32_MAX}; - EXPECT_OK(Copy::Execute<4>(src_buffer, src_shape, src_indices, - absl::MakeSpan(dst_buffer), dst_shape, dst_indices, - lengths)); + IREE_EXPECT_OK(Copy::Execute<4>(src_buffer, src_shape, src_indices, + absl::MakeSpan(dst_buffer), dst_shape, + dst_indices, lengths)); absl::Span<int32_t> dst_buffer_int32_t = ReinterpretSpan<int32_t>(absl::MakeSpan(dst_buffer)); @@ -233,7 +233,7 @@ std::vector<uint16_t> dst_buffer(GetShapeElementCount(dst_shape), UINT16_MAX); auto expected_dst = src_buffer; - EXPECT_OK(Pad::Execute<uint16_t>( + IREE_EXPECT_OK(Pad::Execute<uint16_t>( src_buffer, pad_value_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, edge_padding_low, edge_padding_high, interior_padding)); EXPECT_EQ(dst_buffer, expected_dst); @@ -254,7 +254,7 @@ 0, 0, 0, 0, 0, 0}; // clang-format on - EXPECT_OK(Pad::Execute<uint16_t>( + IREE_EXPECT_OK(Pad::Execute<uint16_t>( src_buffer, pad_value_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, edge_padding_low, edge_padding_high, interior_padding)); EXPECT_EQ(dst_buffer, expected_dst); @@ -275,7 +275,7 @@ 0, 0, 0, 0, 0, 0}; // clang-format on - EXPECT_OK(Pad::Execute<uint16_t>( + IREE_EXPECT_OK(Pad::Execute<uint16_t>( src_buffer, pad_value_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, edge_padding_low, edge_padding_high, interior_padding)); EXPECT_EQ(dst_buffer, expected_dst); @@ -296,7 +296,7 @@ 0, 0, 0, 4, 5, 6}; // clang-format on - EXPECT_OK(Pad::Execute<uint16_t>( + IREE_EXPECT_OK(Pad::Execute<uint16_t>( src_buffer, pad_value_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, edge_padding_low, edge_padding_high, interior_padding)); EXPECT_EQ(dst_buffer, expected_dst); @@ -317,7 +317,7 @@ 4, 0, 5, 0, 6}; // clang-format on - EXPECT_OK(Pad::Execute<uint16_t>( + IREE_EXPECT_OK(Pad::Execute<uint16_t>( src_buffer, pad_value_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, edge_padding_low, edge_padding_high, interior_padding)); EXPECT_EQ(dst_buffer, expected_dst); @@ -340,7 +340,7 @@ 0, 0, 0, 0, 0, 0, 0, 0}; // clang-format on - EXPECT_OK(Pad::Execute<uint16_t>( + IREE_EXPECT_OK(Pad::Execute<uint16_t>( src_buffer, pad_value_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, edge_padding_low, edge_padding_high, interior_padding)); EXPECT_EQ(dst_buffer, expected_dst); @@ -371,7 +371,7 @@ ASSERT_EQ(dst_buffer.size(), expected_dst.size()); - EXPECT_OK(Pad::Execute<uint16_t>( + IREE_EXPECT_OK(Pad::Execute<uint16_t>( src_buffer, pad_value_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, edge_padding_low, edge_padding_high, interior_padding)); EXPECT_EQ(dst_buffer, expected_dst); @@ -386,9 +386,9 @@ std::vector<float> dst_buffer(GetShapeElementCount(dst_shape), 0.0f); std::vector<float> expected_dst = {5.0f}; - EXPECT_OK(ReduceSum::Execute<float>(src_buffer, init_buffer, - absl::MakeSpan(dst_buffer), dimension, - src_shape, dst_shape)); + IREE_EXPECT_OK(ReduceSum::Execute<float>(src_buffer, init_buffer, + absl::MakeSpan(dst_buffer), + dimension, src_shape, dst_shape)); for (int i = 0; i < dst_buffer.size(); ++i) { EXPECT_NEAR(expected_dst[i], dst_buffer[i], kEpsilon); @@ -405,9 +405,9 @@ std::vector<float> dst_buffer(GetShapeElementCount(dst_shape), 0.0f); std::vector<float> expected_dst = {1.0f, 2.0f, 3.0f}; - EXPECT_OK(ReduceMin::Execute<float>(src_buffer, init_buffer, - absl::MakeSpan(dst_buffer), dimension, - src_shape, dst_shape)); + IREE_EXPECT_OK(ReduceMin::Execute<float>(src_buffer, init_buffer, + absl::MakeSpan(dst_buffer), + dimension, src_shape, dst_shape)); for (int i = 0; i < dst_buffer.size(); ++i) { EXPECT_NEAR(expected_dst[i], dst_buffer[i], kEpsilon); @@ -425,7 +425,7 @@ std::vector<int> dst_buffer(GetShapeElementCount(dst_shape), 0.0f); std::vector<int> expected_dst = {9, 12, 21, 24}; - EXPECT_OK(PoolingMax::Execute<int>( + IREE_EXPECT_OK(PoolingMax::Execute<int>( src_buffer, init_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, window_sizes, strides, pad_low)); EXPECT_EQ(dst_buffer, expected_dst); @@ -446,7 +446,7 @@ std::vector<int> dst_buffer(GetShapeElementCount(dst_shape), 0.0f); std::vector<int> expected_dst = {1, 1, 2, 1, 1, 2}; - EXPECT_OK(PoolingMin::Execute<int>( + IREE_EXPECT_OK(PoolingMin::Execute<int>( src_buffer, init_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, window_sizes, strides, pad_low)); EXPECT_EQ(dst_buffer, expected_dst); @@ -464,7 +464,7 @@ std::vector<float> dst_buffer(GetShapeElementCount(dst_shape), 0.0f); std::vector<float> expected_dst = {24, 30, 48, 54}; - EXPECT_OK(PoolingSum::Execute<float>( + IREE_EXPECT_OK(PoolingSum::Execute<float>( src_buffer, init_buffer, absl::MakeSpan(dst_buffer), src_shape, dst_shape, window_sizes, strides, pad_low)); for (int i = 0; i < dst_buffer.size(); ++i) { @@ -492,10 +492,10 @@ } std::vector<float> dst_buffer(GetShapeElementCount(dst_shape), 0.0f); - EXPECT_OK(Conv2D::Execute<float>(input_buffer, input_shape, filter_buffer, - filter_shape, absl::MakeSpan(dst_buffer), - dst_shape, strides, pad_h, pad_w, dilation, - 1)); + IREE_EXPECT_OK(Conv2D::Execute<float>(input_buffer, input_shape, + filter_buffer, filter_shape, + absl::MakeSpan(dst_buffer), dst_shape, + strides, pad_h, pad_w, dilation, 1)); for (int i = 0; i < dst_buffer.size(); ++i) { EXPECT_NEAR(expected_dst[i], dst_buffer[i], kEpsilon); @@ -524,10 +524,10 @@ } std::vector<float> dst_buffer(GetShapeElementCount(dst_shape), 0.0f); - EXPECT_OK(Conv2D::Execute<float>(input_buffer, input_shape, filter_buffer, - filter_shape, absl::MakeSpan(dst_buffer), - dst_shape, strides, pad_h, pad_w, dilation, - 2)); + IREE_EXPECT_OK(Conv2D::Execute<float>(input_buffer, input_shape, + filter_buffer, filter_shape, + absl::MakeSpan(dst_buffer), dst_shape, + strides, pad_h, pad_w, dilation, 2)); for (int i = 0; i < dst_buffer.size(); ++i) { EXPECT_NEAR(expected_dst[i], dst_buffer[i], kEpsilon);
diff --git a/iree/hal/vmla/vmla_driver_module.cc b/iree/hal/vmla/vmla_driver_module.cc index 4afcf96..b051db6 100644 --- a/iree/hal/vmla/vmla_driver_module.cc +++ b/iree/hal/vmla/vmla_driver_module.cc
@@ -32,7 +32,7 @@ } // namespace iree IREE_REGISTER_MODULE_INITIALIZER(iree_hal_vmla_driver, { - QCHECK_OK(::iree::hal::DriverRegistry::shared_registry()->Register( + IREE_QCHECK_OK(::iree::hal::DriverRegistry::shared_registry()->Register( "vmla", ::iree::hal::vmla::CreateVMLADriver)); }); IREE_REGISTER_MODULE_INITIALIZER_SEQUENCE(iree_hal, iree_hal_vmla_driver);
diff --git a/iree/hal/vulkan/dynamic_symbols_test.cc b/iree/hal/vulkan/dynamic_symbols_test.cc index 5210f3a..be0114c 100644 --- a/iree/hal/vulkan/dynamic_symbols_test.cc +++ b/iree/hal/vulkan/dynamic_symbols_test.cc
@@ -49,7 +49,7 @@ TEST(DynamicSymbolsTest, CreateFromSystemLoader) { auto status_or_syms = DynamicSymbols::CreateFromSystemLoader(); - ASSERT_OK(status_or_syms); + IREE_ASSERT_OK(status_or_syms); ref_ptr<DynamicSymbols> syms = std::move(status_or_syms.value()); // Create and destroy a VkInstance using the symbols. This is mainly testing @@ -60,7 +60,7 @@ VK_CHECK_OK( syms->vkCreateInstance(&create_info, /*pAllocator=*/nullptr, &instance)); - ASSERT_OK(syms->LoadFromInstance(instance)); + IREE_ASSERT_OK(syms->LoadFromInstance(instance)); syms->vkDestroyInstance(instance, /*pAllocator=*/nullptr); }
diff --git a/iree/hal/vulkan/emulated_timeline_semaphore.cc b/iree/hal/vulkan/emulated_timeline_semaphore.cc index 2e1d00a..83f1613 100644 --- a/iree/hal/vulkan/emulated_timeline_semaphore.cc +++ b/iree/hal/vulkan/emulated_timeline_semaphore.cc
@@ -51,7 +51,7 @@ EmulatedTimelineSemaphore::~EmulatedTimelineSemaphore() { IREE_TRACE_SCOPE0("EmulatedTimelineSemaphore::dtor"); - CHECK_OK(TryToAdvanceTimeline(UINT64_MAX).status()); + IREE_CHECK_OK(TryToAdvanceTimeline(UINT64_MAX).status()); absl::MutexLock lock(&mutex_); CHECK(outstanding_semaphores_.empty()) << "Destroying an emulated timeline semaphore without first waiting on "
diff --git a/iree/hal/vulkan/status_util.h b/iree/hal/vulkan/status_util.h index 7d8a5c0..2a866b5 100644 --- a/iree/hal/vulkan/status_util.h +++ b/iree/hal/vulkan/status_util.h
@@ -29,16 +29,15 @@ // Usage: // VK_RETURN_IF_ERROR(vkDoThing(...)); #define VK_RETURN_IF_ERROR(expr) \ - IREE_RETURN_IF_ERROR( \ - ::iree::hal::vulkan::VkResultToStatus(__FILE__, __LINE__, expr)) + IREE_RETURN_IF_ERROR(::iree::hal::vulkan::VkResultToStatus(expr, IREE_LOC)) -// CHECK_OK but implicitly converts the VkResults return value to a +// IREE_CHECK_OK but implicitly converts the VkResults return value to a // Status and checks that it is OkStatus. // // Usage: // VK_CHECK_OK(vkDoThing(...)); #define VK_CHECK_OK(expr) \ - CHECK_OK(::iree::hal::vulkan::VkResultToStatus(__FILE__, __LINE__, expr)) + IREE_CHECK_OK(::iree::hal::vulkan::VkResultToStatus(expr, IREE_LOC)) // Converts a VkResult to a Status object. //
diff --git a/iree/hal/vulkan/vulkan_driver_module.cc b/iree/hal/vulkan/vulkan_driver_module.cc index dcb8d84..21c127f 100644 --- a/iree/hal/vulkan/vulkan_driver_module.cc +++ b/iree/hal/vulkan/vulkan_driver_module.cc
@@ -107,7 +107,7 @@ } // namespace iree IREE_REGISTER_MODULE_INITIALIZER(iree_hal_vulkan_driver, { - QCHECK_OK(::iree::hal::DriverRegistry::shared_registry()->Register( + IREE_QCHECK_OK(::iree::hal::DriverRegistry::shared_registry()->Register( "vulkan", ::iree::hal::vulkan::CreateVulkanDriver)); }); IREE_REGISTER_MODULE_INITIALIZER_SEQUENCE(iree_hal, iree_hal_vulkan_driver);
diff --git a/iree/modules/check/check_test.cc b/iree/modules/check/check_test.cc index 820a9c1..4c30063 100644 --- a/iree/modules/check/check_test.cc +++ b/iree/modules/check/check_test.cc
@@ -214,28 +214,28 @@ iree_vm_module_t* CheckTest::hal_module_ = nullptr; TEST_F(CheckTest, ExpectTrueSuccess) { - ASSERT_OK(Invoke("expect_true", {iree_vm_value_make_i32(1)})); + IREE_ASSERT_OK(Invoke("expect_true", {iree_vm_value_make_i32(1)})); } TEST_F(CheckTest, ExpectTrueFailure) { EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_true", {iree_vm_value_make_i32(0)})), + IREE_ASSERT_OK(Invoke("expect_true", {iree_vm_value_make_i32(0)})), "Expected 0 to be nonzero"); } TEST_F(CheckTest, ExpectFalseSuccess) { - ASSERT_OK(Invoke("expect_false", {iree_vm_value_make_i32(0)})); + IREE_ASSERT_OK(Invoke("expect_false", {iree_vm_value_make_i32(0)})); } TEST_F(CheckTest, ExpectFalseFailure) { EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_false", {iree_vm_value_make_i32(1)})), + IREE_ASSERT_OK(Invoke("expect_false", {iree_vm_value_make_i32(1)})), "Expected 1 to be zero"); } TEST_F(CheckTest, ExpectFalseNotOneFailure) { EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_false", {iree_vm_value_make_i32(42)})), + IREE_ASSERT_OK(Invoke("expect_false", {iree_vm_value_make_i32(42)})), "Expected 42 to be zero"); } @@ -245,7 +245,7 @@ int32_t shape[] = {1}; ASSERT_NO_FATAL_FAILURE( CreateInt32BufferView(contents, shape, &input_buffer_view)); - ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})); + IREE_ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})); } TEST_F(CheckTest, ExpectAllTrue3DTrueSuccess) { @@ -254,7 +254,7 @@ int32_t shape[] = {2, 2, 2}; ASSERT_NO_FATAL_FAILURE( CreateInt32BufferView(contents, shape, &input_buffer_view)); - ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})); + IREE_ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})); } TEST_F(CheckTest, ExpectAllTrueFailure) { @@ -264,7 +264,7 @@ ASSERT_NO_FATAL_FAILURE( CreateInt32BufferView(contents, shape, &input_buffer_view)); EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})), "0"); + IREE_ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})), "0"); } TEST_F(CheckTest, ExpectAllTrueSingleElementFailure) { @@ -274,7 +274,7 @@ ASSERT_NO_FATAL_FAILURE( CreateInt32BufferView(contents, shape, &input_buffer_view)); EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})), + IREE_ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})), "1, 2, 3, 0, 4"); } @@ -285,7 +285,7 @@ ASSERT_NO_FATAL_FAILURE( CreateInt32BufferView(contents, shape, &input_buffer_view)); EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})), + IREE_ASSERT_OK(Invoke("expect_all_true", {input_buffer_view})), "1, 2, 3, 4, 5, 6, 0, 8"); } @@ -295,7 +295,7 @@ int32_t shape[] = {1}; ASSERT_NO_FATAL_FAILURE( CreateInt32BufferView(contents, shape, &input_buffer_view)); - ASSERT_OK(Invoke("expect_eq", {input_buffer_view, input_buffer_view})); + IREE_ASSERT_OK(Invoke("expect_eq", {input_buffer_view, input_buffer_view})); } TEST_F(CheckTest, ExpectEqIdenticalBufferSuccess) { @@ -305,7 +305,7 @@ int32_t shape[] = {1}; ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(contents, shape, &rhs)); - ASSERT_OK(Invoke("expect_eq", {lhs, rhs})); + IREE_ASSERT_OK(Invoke("expect_eq", {lhs, rhs})); } TEST_F(CheckTest, ExpectEqIdentical3DBufferSuccess) { @@ -315,7 +315,7 @@ int32_t shape[] = {2, 2, 2}; ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(contents, shape, &rhs)); - ASSERT_OK(Invoke("expect_eq", {lhs, rhs})); + IREE_ASSERT_OK(Invoke("expect_eq", {lhs, rhs})); } TEST_F(CheckTest, ExpectEqDifferentShapeFailure) { @@ -326,7 +326,7 @@ int32_t rhs_shape[] = {4}; ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(contents, lhs_shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(contents, rhs_shape, &rhs)); - EXPECT_NONFATAL_FAILURE(ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), + EXPECT_NONFATAL_FAILURE(IREE_ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), "Shapes do not match"); } @@ -338,7 +338,7 @@ int32_t shape[] = {2, 2}; ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(lhs_contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(rhs_contents, shape, &rhs)); - EXPECT_NONFATAL_FAILURE(ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), + EXPECT_NONFATAL_FAILURE(IREE_ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), "Element types do not match"); } @@ -350,7 +350,7 @@ int32_t shape[] = {1}; ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(lhs_contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(rhs_contents, shape, &rhs)); - EXPECT_NONFATAL_FAILURE(ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), + EXPECT_NONFATAL_FAILURE(IREE_ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), "Contents does not match"); } @@ -365,7 +365,7 @@ ASSERT_NO_FATAL_FAILURE( CreateFloat32BufferView(rhs_contents, rhs_shape, &rhs)); EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), + IREE_ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), "Expected equality of these values. Element types do not match." " Shapes do not match. Contents does not match.\n" " lhs:\n" @@ -383,7 +383,7 @@ ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(lhs_contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateInt32BufferView(rhs_contents, shape, &rhs)); EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), + IREE_ASSERT_OK(Invoke("expect_eq", {lhs, rhs})), "Expected equality of these values. Contents does not match.\n" " lhs:\n" " 2x2x2xi32=[[1 2][3 4]][[5 6][7 8]]\n" @@ -397,7 +397,8 @@ int32_t shape[] = {1}; ASSERT_NO_FATAL_FAILURE( CreateFloat32BufferView(contents, shape, &input_buffer_view)); - ASSERT_OK(Invoke("expect_almost_eq", {input_buffer_view, input_buffer_view})); + IREE_ASSERT_OK( + Invoke("expect_almost_eq", {input_buffer_view, input_buffer_view})); } TEST_F(CheckTest, ExpectAlmostEqIdenticalBufferSuccess) { @@ -407,7 +408,7 @@ int32_t shape[] = {1}; ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(contents, shape, &rhs)); - ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})); + IREE_ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})); } TEST_F(CheckTest, ExpectAlmostEqNearIdenticalBufferSuccess) { @@ -418,7 +419,7 @@ int32_t shape[] = {4}; ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(lhs_contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(rhs_contents, shape, &rhs)); - ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})); + IREE_ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})); } TEST_F(CheckTest, ExpectAlmostEqIdentical3DBufferSuccess) { @@ -428,7 +429,7 @@ int32_t shape[] = {2, 2, 2}; ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(contents, shape, &rhs)); - ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})); + IREE_ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})); } TEST_F(CheckTest, ExpectAlmostEqDifferentShapeFailure) { @@ -439,8 +440,9 @@ int32_t rhs_shape[] = {4}; ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(contents, lhs_shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(contents, rhs_shape, &rhs)); - EXPECT_NONFATAL_FAILURE(ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), - "Shapes do not match"); + EXPECT_NONFATAL_FAILURE( + IREE_ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), + "Shapes do not match"); } TEST_F(CheckTest, ExpectAlmostEqSmallerLhsElementCountFailure) { @@ -455,7 +457,7 @@ ASSERT_NO_FATAL_FAILURE( CreateFloat32BufferView(bigger_contents, bigger_shape, &bigger)); EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_almost_eq", {smaller, bigger})), + IREE_ASSERT_OK(Invoke("expect_almost_eq", {smaller, bigger})), "Shapes do not match"); } @@ -471,7 +473,7 @@ ASSERT_NO_FATAL_FAILURE( CreateFloat32BufferView(bigger_contents, bigger_shape, &bigger)); EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_almost_eq", {bigger, smaller})), + IREE_ASSERT_OK(Invoke("expect_almost_eq", {bigger, smaller})), "Shapes do not match"); } @@ -483,8 +485,9 @@ int32_t shape[] = {2, 2}; ASSERT_NO_FATAL_FAILURE(CreateFloat64BufferView(lhs_contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(rhs_contents, shape, &rhs)); - EXPECT_NONFATAL_FAILURE(ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), - "Element types do not match"); + EXPECT_NONFATAL_FAILURE( + IREE_ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), + "Element types do not match"); } TEST_F(CheckTest, ExpectAlmostEqDifferentContentsFailure) { @@ -495,8 +498,9 @@ int32_t shape[] = {1}; ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(lhs_contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(rhs_contents, shape, &rhs)); - EXPECT_NONFATAL_FAILURE(ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), - "Contents does not match"); + EXPECT_NONFATAL_FAILURE( + IREE_ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), + "Contents does not match"); } TEST_F(CheckTest, ExpectAlmostEqDifferentEverythingFullMessageFailure) { @@ -513,7 +517,7 @@ // Note no comment on contents. Cannot compare different shapes and element // types. EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), + IREE_ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), "Expected near equality of these values. Element types do not match." " Shapes do not match.\n" " lhs:\n" @@ -531,7 +535,7 @@ ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(lhs_contents, shape, &lhs)); ASSERT_NO_FATAL_FAILURE(CreateFloat32BufferView(rhs_contents, shape, &rhs)); EXPECT_NONFATAL_FAILURE( - ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), + IREE_ASSERT_OK(Invoke("expect_almost_eq", {lhs, rhs})), "Expected near equality of these values. Contents does not match.\n" " lhs:\n" " 2x2x2xf32=[[1 2][3 4]][[5 6][7 8]]\n"
diff --git a/iree/testing/status_matchers.h b/iree/testing/status_matchers.h index 5a10c23..b0052bb 100644 --- a/iree/testing/status_matchers.h +++ b/iree/testing/status_matchers.h
@@ -22,10 +22,6 @@ #include "iree/base/status.h" #include "iree/testing/gtest.h" -#undef EXPECT_OK -#undef ASSERT_OK -#undef ASSERT_OK_AND_ASSIGN - namespace iree { namespace internal { @@ -145,14 +141,26 @@ return GetCode(matchee.status()); } + StatusCode GetCode(const iree_status_code_t &status_code) const { + return static_cast<StatusCode>(status_code); + } + + StatusCode GetCode(const iree_status_t &status) const { + return static_cast<StatusCode>(iree_status_code(status)); + } + StatusCode GetCode(const Status &status) const { return status.code(); } template <typename T> - absl::string_view GetMessage(const T &matchee) const { + std::string GetMessage(const T &matchee) const { return GetMessage(matchee.status()); } - absl::string_view GetMessage(const Status &status) const { + std::string GetMessage(const iree_status_t &status) const { + return Status::ToString(status); + } + + std::string GetMessage(const Status &status) const { return status.ToString(); } @@ -175,13 +183,22 @@ StatusIsMatcherGenerator(Enum code, absl::optional<absl::string_view> message) : code_(code), message_(message) {} - // Type-cast operator for Matcher<const iree::Status &>. + operator ::testing::Matcher<const StatusCode &>() const { + return ::testing::MakeMatcher( + new internal::StatusMatcher<Enum, const StatusCode &>(code_, message_)); + } + + operator ::testing::Matcher<const iree_status_t &>() const { + return ::testing::MakeMatcher( + new internal::StatusMatcher<Enum, const iree_status_t &>(code_, + message_)); + } + operator ::testing::Matcher<const Status &>() const { return ::testing::MakeMatcher( new internal::StatusMatcher<Enum, const Status &>(code_, message_)); } - // Type-cast operator for Matcher<const iree::StatusOr<T> &>. template <class T> operator ::testing::Matcher<const StatusOr<T> &>() const { return ::testing::MakeMatcher( @@ -223,7 +240,7 @@ bool MatchAndExplain( const T &status_container, ::testing::MatchResultListener *listener) const override { - if (!status_container.ok()) { + if (!::iree::IsOk(status_container)) { *listener << "which is not OK"; return false; } @@ -238,13 +255,16 @@ // container. class IsOkMatcherGenerator { public: - // Type-cast operator for Matcher<const iree::Status &>. + operator ::testing::Matcher<const iree_status_t &>() const { + return ::testing::MakeMatcher( + new internal::IsOkMatcherImpl<const iree_status_t &>()); + } + operator ::testing::Matcher<const Status &>() const { return ::testing::MakeMatcher( new internal::IsOkMatcherImpl<const Status &>()); } - // Type-cast operator for Matcher<const iree::StatusOr<T> &>. template <class T> operator ::testing::Matcher<const StatusOr<T> &>() const { return ::testing::MakeMatcher( @@ -306,15 +326,13 @@ // Macros for testing the results of functions that return iree::Status or // iree::StatusOr<T> (for any type T). -#define EXPECT_OK(rexpr) EXPECT_THAT(rexpr, ::iree::testing::status::IsOk()) -#define ASSERT_OK(rexpr) ASSERT_THAT(rexpr, ::iree::testing::status::IsOk()) - -#define IREE_ASSERT_OK(expr) \ - ASSERT_EQ(IREE_STATUS_OK, iree_status_consume_code(expr)) -#define IREE_EXPECT_OK(expr) \ - EXPECT_EQ(IREE_STATUS_OK, iree_status_consume_code(expr)) -#define IREE_EXPECT_STATUS_IS(expected_code, expr) \ - EXPECT_EQ(expected_code, iree_status_consume_code(expr)) +#define IREE_EXPECT_OK(rexpr) \ + EXPECT_THAT(rexpr, ::iree::testing::status::IsOk()) +#define IREE_ASSERT_OK(rexpr) \ + ASSERT_THAT(rexpr, ::iree::testing::status::IsOk()) +#define IREE_EXPECT_STATUS_IS(expected_code, expr) \ + EXPECT_THAT(expr, ::iree::testing::status::StatusIs( \ + static_cast<::iree::StatusCode>(expected_code))) // Executes an expression that returns an iree::StatusOr<T>, and assigns the // contained variable to lhs if the error code is OK. @@ -322,20 +340,20 @@ // current function, which must have a void return type. // // Example: Assigning to an existing value -// ASSERT_OK_AND_ASSIGN(ValueType value, MaybeGetValue(arg)); +// IREE_ASSERT_OK_AND_ASSIGN(ValueType value, MaybeGetValue(arg)); // // The value assignment example might expand into: // StatusOr<ValueType> status_or_value = MaybeGetValue(arg); -// ASSERT_OK(status_or_value.status()); +// IREE_ASSERT_OK(status_or_value.status()); // ValueType value = status_or_value.value(); -#define ASSERT_OK_AND_ASSIGN(lhs, rexpr) \ +#define IREE_ASSERT_OK_AND_ASSIGN(lhs, rexpr) \ IREE_ASSERT_OK_AND_ASSIGN_IMPL( \ IREE_STATUS_MACROS_CONCAT_NAME(_status_or_value, __COUNTER__), lhs, \ rexpr); #define IREE_ASSERT_OK_AND_ASSIGN_IMPL(statusor, lhs, rexpr) \ auto statusor = (rexpr); \ - ASSERT_OK(statusor.status()) << statusor.status(); \ + IREE_ASSERT_OK(statusor.status()); \ lhs = std::move(statusor.value()) #define IREE_STATUS_MACROS_CONCAT_NAME(x, y) \ IREE_STATUS_MACROS_CONCAT_IMPL(x, y)
diff --git a/iree/tools/benchmark_module_main.cc b/iree/tools/benchmark_module_main.cc index d6d1ec0..a9a58d1 100644 --- a/iree/tools/benchmark_module_main.cc +++ b/iree/tools/benchmark_module_main.cc
@@ -157,7 +157,7 @@ void BM_RunModule(benchmark::State& state) { // Delegate to a status-returning function so we can use the status macros. - CHECK_OK(Run(state)); + IREE_CHECK_OK(Run(state)); } BENCHMARK(BM_RunModule)
diff --git a/iree/tools/run_module_main.cc b/iree/tools/run_module_main.cc index 4218382..73d3362 100644 --- a/iree/tools/run_module_main.cc +++ b/iree/tools/run_module_main.cc
@@ -151,7 +151,7 @@ extern "C" int main(int argc, char** argv) { iree::InitializeEnvironment(&argc, &argv); - CHECK_OK(Run()); + IREE_CHECK_OK(Run()); return 0; }
diff --git a/iree/tools/vm_util_test.cc b/iree/tools/vm_util_test.cc index 7c6063f..1b59f73 100644 --- a/iree/tools/vm_util_test.cc +++ b/iree/tools/vm_util_test.cc
@@ -31,7 +31,7 @@ protected: virtual void SetUp() { IREE_ASSERT_OK(iree_hal_module_register_types()); - ASSERT_OK(CreateDevice("vmla", &device_)); + IREE_ASSERT_OK(CreateDevice("vmla", &device_)); allocator_ = iree_hal_device_allocator(device_); } @@ -48,10 +48,10 @@ desc.buffer.scalar_type = AbiConstants::ScalarType::kSint32; desc.dims = {2, 2}; - ASSERT_OK_AND_ASSIGN(auto variant_list, - ParseToVariantList({desc}, allocator_, {buf_string})); + IREE_ASSERT_OK_AND_ASSIGN( + auto variant_list, ParseToVariantList({desc}, allocator_, {buf_string})); std::stringstream os; - ASSERT_OK(PrintVariantList({desc}, variant_list.get(), &os)); + IREE_ASSERT_OK(PrintVariantList({desc}, variant_list.get(), &os)); EXPECT_EQ(os.str(), absl::StrCat(buf_string, "\n")); } @@ -61,10 +61,11 @@ desc.type = RawSignatureParser::Type::kScalar; desc.scalar.type = AbiConstants::ScalarType::kSint32; - ASSERT_OK_AND_ASSIGN(auto variant_list, - ParseToVariantList({desc}, allocator_, {input_string})); + IREE_ASSERT_OK_AND_ASSIGN( + auto variant_list, + ParseToVariantList({desc}, allocator_, {input_string})); std::stringstream os; - ASSERT_OK(PrintVariantList({desc}, variant_list.get(), &os)); + IREE_ASSERT_OK(PrintVariantList({desc}, variant_list.get(), &os)); EXPECT_EQ(os.str(), absl::StrCat(input_string, "\n")); } @@ -74,10 +75,10 @@ desc.type = RawSignatureParser::Type::kBuffer; desc.buffer.scalar_type = AbiConstants::ScalarType::kSint32; - ASSERT_OK_AND_ASSIGN(auto variant_list, - ParseToVariantList({desc}, allocator_, {buf_string})); + IREE_ASSERT_OK_AND_ASSIGN( + auto variant_list, ParseToVariantList({desc}, allocator_, {buf_string})); std::stringstream os; - ASSERT_OK(PrintVariantList({desc}, variant_list.get(), &os)); + IREE_ASSERT_OK(PrintVariantList({desc}, variant_list.get(), &os)); EXPECT_EQ(os.str(), absl::StrCat(buf_string, "\n")); } @@ -94,11 +95,11 @@ desc2.buffer.scalar_type = AbiConstants::ScalarType::kIeeeFloat64; desc2.dims = {2, 3}; - ASSERT_OK_AND_ASSIGN(auto variant_list, - ParseToVariantList({desc1, desc2}, allocator_, - {buf_string1, buf_string2})); + IREE_ASSERT_OK_AND_ASSIGN(auto variant_list, + ParseToVariantList({desc1, desc2}, allocator_, + {buf_string1, buf_string2})); std::stringstream os; - ASSERT_OK(PrintVariantList({desc1, desc2}, variant_list.get(), &os)); + IREE_ASSERT_OK(PrintVariantList({desc1, desc2}, variant_list.get(), &os)); EXPECT_EQ(os.str(), absl::StrCat(buf_string1, "\n", buf_string2, "\n")); }
diff --git a/iree/vm/BUILD b/iree/vm/BUILD index a08d3a5..3703b47 100644 --- a/iree/vm/BUILD +++ b/iree/vm/BUILD
@@ -247,6 +247,7 @@ ":ref", "//iree/base:api", "//iree/base:ref_ptr", + "//iree/testing:gtest", "//iree/testing:gtest_main", ], ) @@ -282,6 +283,7 @@ ":stack", "//iree/base:api", "//iree/base:ref_ptr", + "//iree/testing:gtest", "//iree/testing:gtest_main", ], )
diff --git a/iree/vm/CMakeLists.txt b/iree/vm/CMakeLists.txt index b264602..9d8142a 100644 --- a/iree/vm/CMakeLists.txt +++ b/iree/vm/CMakeLists.txt
@@ -281,6 +281,7 @@ ::ref iree::base::api iree::base::ref_ptr + iree::testing::gtest iree::testing::gtest_main ) @@ -322,6 +323,7 @@ ::stack iree::base::api iree::base::ref_ptr + iree::testing::gtest iree::testing::gtest_main )