| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "android-base/result.h" |
| #include <utils/ErrorsMacros.h> |
| #include "errno.h" |
| |
| #include <istream> |
| #include <memory> |
| #include <string> |
| #include <type_traits> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include "android-base/result-gmock.h" |
| |
| using namespace std::string_literals; |
| using ::testing::Eq; |
| using ::testing::ExplainMatchResult; |
| using ::testing::HasSubstr; |
| using ::testing::Not; |
| using ::testing::StartsWith; |
| |
| namespace android { |
| namespace base { |
| |
| TEST(result, result_accessors) { |
| Result<std::string> result = "success"; |
| ASSERT_RESULT_OK(result); |
| ASSERT_TRUE(result.has_value()); |
| |
| EXPECT_EQ("success", *result); |
| EXPECT_EQ("success", result.value()); |
| |
| EXPECT_EQ('s', result->data()[0]); |
| } |
| |
| TEST(result, result_accessors_rvalue) { |
| ASSERT_TRUE(Result<std::string>("success").ok()); |
| ASSERT_TRUE(Result<std::string>("success").has_value()); |
| |
| EXPECT_EQ("success", *Result<std::string>("success")); |
| EXPECT_EQ("success", Result<std::string>("success").value()); |
| |
| EXPECT_EQ('s', Result<std::string>("success")->data()[0]); |
| } |
| |
| TEST(result, result_void) { |
| Result<void> ok = {}; |
| EXPECT_RESULT_OK(ok); |
| ok.value(); // should not crash |
| ASSERT_DEATH(ok.error(), ""); |
| |
| Result<void> fail = Error() << "failure" << 1; |
| EXPECT_FALSE(fail.ok()); |
| EXPECT_EQ("failure1", fail.error().message()); |
| EXPECT_EQ(0, fail.error().code()); |
| EXPECT_TRUE(ok != fail); |
| ASSERT_DEATH(fail.value(), ""); |
| |
| auto test = [](bool ok) -> Result<void> { |
| if (ok) return {}; |
| else return Error() << "failure" << 1; |
| }; |
| EXPECT_TRUE(test(true).ok()); |
| EXPECT_FALSE(test(false).ok()); |
| test(true).value(); // should not crash |
| ASSERT_DEATH(test(true).error(), ""); |
| ASSERT_DEATH(test(false).value(), ""); |
| EXPECT_EQ("failure1", test(false).error().message()); |
| } |
| |
| TEST(result, result_error) { |
| Result<void> result = Error() << "failure" << 1; |
| ASSERT_FALSE(result.ok()); |
| ASSERT_FALSE(result.has_value()); |
| |
| EXPECT_EQ(0, result.error().code()); |
| EXPECT_EQ("failure1", result.error().message()); |
| } |
| |
| TEST(result, result_error_empty) { |
| Result<void> result = Error(); |
| ASSERT_FALSE(result.ok()); |
| ASSERT_FALSE(result.has_value()); |
| |
| EXPECT_EQ(0, result.error().code()); |
| EXPECT_EQ("", result.error().message()); |
| } |
| |
| TEST(result, result_error_rvalue) { |
| // Error() and ErrnoError() aren't actually used to create a Result<T> object. |
| // Under the hood, they are an intermediate class that can be implicitly constructed into a |
| // Result<T>. This is needed both to create the ostream and because Error() itself, by |
| // definition will not know what the type, T, of the underlying Result<T> object that it would |
| // create is. |
| |
| auto MakeRvalueErrorResult = []() -> Result<void> { return Error() << "failure" << 1; }; |
| ASSERT_FALSE(MakeRvalueErrorResult().ok()); |
| ASSERT_FALSE(MakeRvalueErrorResult().has_value()); |
| |
| EXPECT_EQ(0, MakeRvalueErrorResult().error().code()); |
| EXPECT_EQ("failure1", MakeRvalueErrorResult().error().message()); |
| } |
| |
| TEST(result, result_errno_error) { |
| constexpr int test_errno = 6; |
| errno = test_errno; |
| Result<void> result = ErrnoError() << "failure" << 1; |
| |
| ASSERT_FALSE(result.ok()); |
| ASSERT_FALSE(result.has_value()); |
| |
| EXPECT_EQ(test_errno, result.error().code()); |
| EXPECT_EQ("failure1: "s + strerror(test_errno), result.error().message()); |
| } |
| |
| TEST(result, result_errno_error_no_text) { |
| constexpr int test_errno = 6; |
| errno = test_errno; |
| Result<void> result = ErrnoError(); |
| |
| ASSERT_FALSE(result.ok()); |
| ASSERT_FALSE(result.has_value()); |
| |
| EXPECT_EQ(test_errno, result.error().code()); |
| EXPECT_EQ(strerror(test_errno), result.error().message()); |
| } |
| |
| TEST(result, result_error_from_other_result) { |
| auto error_text = "test error"s; |
| Result<void> result = Error() << error_text; |
| |
| ASSERT_FALSE(result.ok()); |
| ASSERT_FALSE(result.has_value()); |
| |
| Result<std::string> result2 = result.error(); |
| |
| ASSERT_FALSE(result2.ok()); |
| ASSERT_FALSE(result2.has_value()); |
| |
| EXPECT_EQ(0, result2.error().code()); |
| EXPECT_EQ(error_text, result2.error().message()); |
| } |
| |
| TEST(result, result_error_through_ostream) { |
| auto error_text = "test error"s; |
| Result<void> result = Error() << error_text; |
| |
| ASSERT_FALSE(result.ok()); |
| ASSERT_FALSE(result.has_value()); |
| |
| Result<std::string> result2 = Error() << result.error(); |
| |
| ASSERT_FALSE(result2.ok()); |
| ASSERT_FALSE(result2.has_value()); |
| |
| EXPECT_EQ(0, result2.error().code()); |
| EXPECT_EQ(error_text, result2.error().message()); |
| } |
| |
| TEST(result, result_errno_error_through_ostream) { |
| auto error_text = "test error"s; |
| constexpr int test_errno = 6; |
| errno = 6; |
| Result<void> result = ErrnoError() << error_text; |
| |
| errno = 0; |
| |
| ASSERT_FALSE(result.ok()); |
| ASSERT_FALSE(result.has_value()); |
| |
| Result<std::string> result2 = Error() << result.error(); |
| |
| ASSERT_FALSE(result2.ok()); |
| ASSERT_FALSE(result2.has_value()); |
| |
| EXPECT_EQ(test_errno, result2.error().code()); |
| EXPECT_EQ(error_text + ": " + strerror(test_errno), result2.error().message()); |
| } |
| |
| enum class CustomError { A, B }; |
| |
| struct CustomErrorWrapper { |
| CustomErrorWrapper() : val_(CustomError::A) {} |
| CustomErrorWrapper(const CustomError& e) : val_(e) {} |
| CustomError value() const { return val_; } |
| operator CustomError() const { return value(); } |
| std::string print() const { |
| switch (val_) { |
| case CustomError::A: |
| return "A"; |
| case CustomError::B: |
| return "B"; |
| } |
| } |
| CustomError val_; |
| }; |
| |
| #define NewCustomError(e) Error<CustomErrorWrapper>(CustomError::e) |
| |
| TEST(result, result_with_custom_errorcode) { |
| Result<void, CustomError> ok = {}; |
| EXPECT_RESULT_OK(ok); |
| ok.value(); // should not crash |
| EXPECT_DEATH(ok.error(), ""); |
| |
| auto error_text = "test error"s; |
| Result<void, CustomError> err = NewCustomError(A) << error_text; |
| |
| EXPECT_FALSE(err.ok()); |
| EXPECT_FALSE(err.has_value()); |
| |
| EXPECT_EQ(CustomError::A, err.error().code()); |
| EXPECT_EQ(error_text + ": A", err.error().message()); |
| } |
| |
| Result<std::string, CustomError> success_or_fail(bool success) { |
| if (success) |
| return "success"; |
| else |
| return NewCustomError(A) << "fail"; |
| } |
| |
| TEST(result, constructor_forwarding) { |
| auto result = Result<std::string>(std::in_place, 5, 'a'); |
| |
| ASSERT_RESULT_OK(result); |
| ASSERT_TRUE(result.has_value()); |
| |
| EXPECT_EQ("aaaaa", *result); |
| } |
| |
| TEST(result, unwrap_or_return) { |
| auto f = [](bool success) -> Result<size_t, CustomError> { |
| return OR_RETURN(success_or_fail(success)).size(); |
| }; |
| |
| auto r = f(true); |
| EXPECT_TRUE(r.ok()); |
| EXPECT_EQ(strlen("success"), *r); |
| |
| auto s = f(false); |
| EXPECT_FALSE(s.ok()); |
| EXPECT_EQ(CustomError::A, s.error().code()); |
| EXPECT_EQ("fail: A", s.error().message()); |
| } |
| |
| TEST(result, unwrap_or_return_errorcode) { |
| auto f = [](bool success) -> CustomError { |
| // Note that we use the same OR_RETURN macro for different return types: Result<U, CustomError> |
| // and CustomError. |
| std::string val = OR_RETURN(success_or_fail(success)); |
| EXPECT_EQ("success", val); |
| return CustomError::B; |
| }; |
| |
| auto r = f(true); |
| EXPECT_EQ(CustomError::B, r); |
| |
| auto s = f(false); |
| EXPECT_EQ(CustomError::A, s); |
| } |
| |
| TEST(result, unwrap_or_fatal) { |
| auto r = OR_FATAL(success_or_fail(true)); |
| EXPECT_EQ("success", r); |
| |
| EXPECT_DEATH(OR_FATAL(success_or_fail(false)), "fail: A"); |
| } |
| |
| TEST(result, unwrap_ambiguous_int) { |
| const std::string firstSuccess{"a"}; |
| constexpr int secondSuccess = 5; |
| auto enum_success_or_fail = [&](bool success) -> Result<std::string, StatusT> { |
| if (success) return firstSuccess; |
| return ResultError<StatusT>("Fail", 10); |
| }; |
| auto f = [&](bool success) -> Result<int, StatusT> { |
| auto val = OR_RETURN(enum_success_or_fail(success)); |
| EXPECT_EQ(firstSuccess, val); |
| return secondSuccess; |
| }; |
| |
| auto r = f(true); |
| ASSERT_TRUE(r.ok()); |
| EXPECT_EQ(r.value(), secondSuccess); |
| auto s = f(false); |
| ASSERT_TRUE(!s.ok()); |
| EXPECT_EQ(s.error().code(), 10); |
| } |
| |
| TEST(result, unwrap_ambiguous_uint_conv) { |
| const std::string firstSuccess{"a"}; |
| constexpr size_t secondSuccess = 5ull; |
| auto enum_success_or_fail = [&](bool success) -> Result<std::string, StatusT> { |
| if (success) return firstSuccess; |
| return ResultError<StatusT>("Fail", 10); |
| }; |
| |
| auto f = [&](bool success) -> Result<size_t, StatusT> { |
| auto val = OR_RETURN(enum_success_or_fail(success)); |
| EXPECT_EQ(firstSuccess, val); |
| return secondSuccess; |
| }; |
| |
| auto r = f(true); |
| ASSERT_TRUE(r.ok()); |
| EXPECT_EQ(r.value(), secondSuccess); |
| auto s = f(false); |
| ASSERT_TRUE(!s.ok()); |
| EXPECT_EQ(s.error().code(), 10); |
| } |
| |
| struct IntConst { |
| int val_; |
| template <typename T, typename = std::enable_if_t<std::is_convertible_v<T, int>>> |
| IntConst(T&& val) : val_(val) {} |
| operator status_t() {return val_;} |
| }; |
| |
| TEST(result, unwrap_ambiguous_constructible) { |
| constexpr int firstSuccess = 5; |
| constexpr int secondSuccess = 7; |
| struct A { |
| A (int val) : val_(val) {} |
| operator status_t() { return 0; } |
| int val_; |
| }; |
| // If this returns Result<A, ...> instead of Result<IntConst, ...>, |
| // compilation fails unless we compile with c++20 |
| auto enum_success_or_fail = [&](bool success) -> Result<IntConst, StatusT, false> { |
| if (success) return firstSuccess; |
| return ResultError<StatusT, false>(10); |
| }; |
| auto f = [&](bool success) -> Result<IntConst, StatusT, false> { |
| auto val = OR_RETURN(enum_success_or_fail(success)); |
| EXPECT_EQ(firstSuccess, val.val_); |
| return secondSuccess; |
| }; |
| auto r = f(true); |
| EXPECT_EQ(r.value().val_, secondSuccess); |
| auto s = f(false); |
| EXPECT_EQ(s.error().code(), 10); |
| } |
| |
| struct Dangerous {}; |
| struct ImplicitFromDangerous { |
| ImplicitFromDangerous(Dangerous); |
| }; |
| template <typename U> |
| struct Templated { |
| U val_; |
| template <typename T, typename=std::enable_if_t<std::is_convertible_v<T, U>>> |
| Templated(T val) : val_(val) {} |
| }; |
| |
| |
| TEST(result, dangerous_result_conversion) { |
| ResultError<Dangerous, false> error {Dangerous{}}; |
| Result<Templated<Dangerous>, Dangerous, false> surprise {error}; |
| EXPECT_TRUE(!surprise.ok()); |
| Result<Templated<ImplicitFromDangerous>, Dangerous, false> surprise2 {error}; |
| EXPECT_TRUE(!surprise2.ok()); |
| } |
| |
| TEST(result, generic_convertible) { |
| const std::string firstSuccess{"a"}; |
| struct A {}; |
| struct B { |
| operator A() {return A{};} |
| }; |
| |
| auto enum_success_or_fail = [&](bool success) -> Result<std::string, B> { |
| if (success) return firstSuccess; |
| return ResultError<B>("Fail", B{}); |
| }; |
| auto f = [&](bool success) -> Result<A, B> { |
| auto val = OR_RETURN(enum_success_or_fail(success)); |
| EXPECT_EQ(firstSuccess, val); |
| return A{}; |
| }; |
| |
| auto r = f(true); |
| EXPECT_TRUE(r.ok()); |
| auto s = f(false); |
| EXPECT_TRUE(!s.ok()); |
| } |
| |
| TEST(result, generic_exact) { |
| const std::string firstSuccess{"a"}; |
| struct A {}; |
| auto enum_success_or_fail = [&](bool success) -> Result<std::string, A> { |
| if (success) return firstSuccess; |
| return ResultError<A>("Fail", A{}); |
| }; |
| auto f = [&](bool success) -> Result<A, A> { |
| auto val = OR_RETURN(enum_success_or_fail(success)); |
| EXPECT_EQ(firstSuccess, val); |
| return A{}; |
| }; |
| |
| auto r = f(true); |
| EXPECT_TRUE(r.ok()); |
| auto s = f(false); |
| EXPECT_TRUE(!s.ok()); |
| } |
| |
| struct MyData { |
| const int data; |
| static int copy_constructed; |
| static int move_constructed; |
| explicit MyData(int d) : data(d) {} |
| MyData(const MyData& other) : data(other.data) { copy_constructed++; } |
| MyData(MyData&& other) : data(other.data) { move_constructed++; } |
| MyData& operator=(const MyData&) = delete; |
| MyData& operator=(MyData&&) = delete; |
| }; |
| |
| int MyData::copy_constructed = 0; |
| int MyData::move_constructed = 0; |
| |
| TEST(result, unwrap_does_not_incur_additional_copying) { |
| MyData::copy_constructed = 0; |
| MyData::move_constructed = 0; |
| auto f = []() -> Result<MyData> { return MyData{10}; }; |
| |
| [&]() -> Result<void> { |
| int data = OR_RETURN(f()).data; |
| EXPECT_EQ(10, data); |
| EXPECT_EQ(0, MyData::copy_constructed); |
| // Moved once when MyData{10} is returned as Result<MyData> in the lambda f. |
| // Moved once again when the variable d is constructed from OR_RETURN. |
| EXPECT_EQ(2, MyData::move_constructed); |
| return {}; |
| }(); |
| } |
| |
| TEST(result, supports_move_only_type) { |
| auto f = [](bool success) -> Result<std::unique_ptr<std::string>> { |
| if (success) return std::make_unique<std::string>("hello"); |
| return Error() << "error"; |
| }; |
| |
| auto g = [&](bool success) -> Result<std::unique_ptr<std::string>> { |
| auto r = OR_RETURN(f(success)); |
| EXPECT_EQ("hello", *(r.get())); |
| return std::make_unique<std::string>("world"); |
| }; |
| |
| auto s = g(true); |
| EXPECT_RESULT_OK(s); |
| EXPECT_EQ("world", *(s->get())); |
| |
| auto t = g(false); |
| EXPECT_FALSE(t.ok()); |
| EXPECT_EQ("error", t.error().message()); |
| } |
| |
| TEST(result, unique_ptr) { |
| using testing::Ok; |
| |
| auto return_unique_ptr = [](bool success) -> Result<std::unique_ptr<int>> { |
| auto result = OR_RETURN(Result<std::unique_ptr<int>>(std::make_unique<int>(3))); |
| if (!success) { |
| return Error() << __func__ << " failed."; |
| } |
| return result; |
| }; |
| Result<std::unique_ptr<int>> result1 = return_unique_ptr(false); |
| ASSERT_THAT(result1, Not(Ok())); |
| Result<std::unique_ptr<int>> result2 = return_unique_ptr(true); |
| ASSERT_THAT(result2, Ok()); |
| EXPECT_EQ(**result2, 3); |
| } |
| |
| struct ConstructorTracker { |
| static size_t constructor_called; |
| static size_t copy_constructor_called; |
| static size_t move_constructor_called; |
| static size_t copy_assignment_called; |
| static size_t move_assignment_called; |
| |
| template <typename T> |
| ConstructorTracker(T&& string) : string(string) { |
| ++constructor_called; |
| } |
| |
| ConstructorTracker(const ConstructorTracker& ct) { |
| ++copy_constructor_called; |
| string = ct.string; |
| } |
| ConstructorTracker(ConstructorTracker&& ct) noexcept { |
| ++move_constructor_called; |
| string = std::move(ct.string); |
| } |
| ConstructorTracker& operator=(const ConstructorTracker& ct) { |
| ++copy_assignment_called; |
| string = ct.string; |
| return *this; |
| } |
| ConstructorTracker& operator=(ConstructorTracker&& ct) noexcept { |
| ++move_assignment_called; |
| string = std::move(ct.string); |
| return *this; |
| } |
| |
| std::string string; |
| }; |
| |
| size_t ConstructorTracker::constructor_called = 0; |
| size_t ConstructorTracker::copy_constructor_called = 0; |
| size_t ConstructorTracker::move_constructor_called = 0; |
| size_t ConstructorTracker::copy_assignment_called = 0; |
| size_t ConstructorTracker::move_assignment_called = 0; |
| |
| Result<ConstructorTracker> ReturnConstructorTracker(const std::string& in) { |
| if (in.empty()) { |
| return "literal string"; |
| } |
| if (in == "test2") { |
| return ConstructorTracker(in + in + "2"); |
| } |
| ConstructorTracker result(in + " " + in); |
| return result; |
| }; |
| |
| TEST(result, no_copy_on_return) { |
| // If returning parameters that may be used to implicitly construct the type T of Result<T>, |
| // then those parameters are forwarded to the construction of Result<T>. |
| |
| // If returning an prvalue or xvalue, it will be move constructed during the construction of |
| // Result<T>. |
| |
| // This check ensures that that is the case, and particularly that no copy constructors |
| // are called. |
| |
| auto result1 = ReturnConstructorTracker(""); |
| ASSERT_RESULT_OK(result1); |
| EXPECT_EQ("literal string", result1->string); |
| EXPECT_EQ(1U, ConstructorTracker::constructor_called); |
| EXPECT_EQ(0U, ConstructorTracker::copy_constructor_called); |
| EXPECT_EQ(0U, ConstructorTracker::move_constructor_called); |
| EXPECT_EQ(0U, ConstructorTracker::copy_assignment_called); |
| EXPECT_EQ(0U, ConstructorTracker::move_assignment_called); |
| |
| auto result2 = ReturnConstructorTracker("test2"); |
| ASSERT_RESULT_OK(result2); |
| EXPECT_EQ("test2test22", result2->string); |
| EXPECT_EQ(2U, ConstructorTracker::constructor_called); |
| EXPECT_EQ(0U, ConstructorTracker::copy_constructor_called); |
| EXPECT_EQ(1U, ConstructorTracker::move_constructor_called); |
| EXPECT_EQ(0U, ConstructorTracker::copy_assignment_called); |
| EXPECT_EQ(0U, ConstructorTracker::move_assignment_called); |
| |
| auto result3 = ReturnConstructorTracker("test3"); |
| ASSERT_RESULT_OK(result3); |
| EXPECT_EQ("test3 test3", result3->string); |
| EXPECT_EQ(3U, ConstructorTracker::constructor_called); |
| EXPECT_EQ(0U, ConstructorTracker::copy_constructor_called); |
| EXPECT_EQ(2U, ConstructorTracker::move_constructor_called); |
| EXPECT_EQ(0U, ConstructorTracker::copy_assignment_called); |
| EXPECT_EQ(0U, ConstructorTracker::move_assignment_called); |
| } |
| |
| // Below two tests require that we do not hide the move constructor with our forwarding reference |
| // constructor. This is done with by disabling the forwarding reference constructor if its first |
| // and only type is Result<T>. |
| TEST(result, result_result_with_success) { |
| auto return_result_result_with_success = []() -> Result<Result<void>> { return Result<void>(); }; |
| auto result = return_result_result_with_success(); |
| ASSERT_RESULT_OK(result); |
| ASSERT_RESULT_OK(*result); |
| |
| auto inner_result = result.value(); |
| ASSERT_RESULT_OK(inner_result); |
| } |
| |
| TEST(result, result_result_with_failure) { |
| auto return_result_result_with_error = []() -> Result<Result<void>> { |
| return Result<void>(ResultError("failure string", 6)); |
| }; |
| auto result = return_result_result_with_error(); |
| ASSERT_RESULT_OK(result); |
| ASSERT_FALSE(result->ok()); |
| EXPECT_EQ("failure string", (*result).error().message()); |
| EXPECT_EQ(6, (*result).error().code()); |
| } |
| |
| // This test requires that we disable the forwarding reference constructor if Result<T> is the |
| // *only* type that we are forwarding. In otherwords, if we are forwarding Result<T>, int to |
| // construct a Result<T>, then we still need the constructor. |
| TEST(result, result_two_parameter_constructor_same_type) { |
| struct TestStruct { |
| TestStruct(int value) : value_(value) {} |
| TestStruct(Result<TestStruct> result, int value) : value_(result->value_ * value) {} |
| int value_; |
| }; |
| |
| auto return_test_struct = []() -> Result<TestStruct> { |
| return Result<TestStruct>(std::in_place, Result<TestStruct>(std::in_place, 6), 6); |
| }; |
| |
| auto result = return_test_struct(); |
| ASSERT_RESULT_OK(result); |
| EXPECT_EQ(36, result->value_); |
| } |
| |
| TEST(result, die_on_access_failed_result) { |
| Result<std::string> result = Error(); |
| ASSERT_DEATH(*result, ""); |
| } |
| |
| TEST(result, die_on_get_error_succesful_result) { |
| Result<std::string> result = "success"; |
| ASSERT_DEATH(result.error(), ""); |
| } |
| |
| template <class CharT> |
| std::basic_ostream<CharT>& SetErrnoToTwo(std::basic_ostream<CharT>& ss) { |
| errno = 2; |
| return ss; |
| } |
| |
| TEST(result, preserve_errno) { |
| errno = 1; |
| int old_errno = errno; |
| Result<int> result = Error() << "Failed" << SetErrnoToTwo<char>; |
| ASSERT_FALSE(result.ok()); |
| EXPECT_EQ(old_errno, errno); |
| |
| errno = 1; |
| old_errno = errno; |
| Result<int> result2 = ErrnoError() << "Failed" << SetErrnoToTwo<char>; |
| ASSERT_FALSE(result2.ok()); |
| EXPECT_EQ(old_errno, errno); |
| EXPECT_EQ(old_errno, result2.error().code()); |
| } |
| |
| TEST(result, error_with_fmt) { |
| Result<int> result = Errorf("{} {}!", "hello", "world"); |
| EXPECT_EQ("hello world!", result.error().message()); |
| |
| result = Errorf("{} {}!", std::string("hello"), std::string("world")); |
| EXPECT_EQ("hello world!", result.error().message()); |
| |
| result = Errorf("{1} {0}!", "world", "hello"); |
| EXPECT_EQ("hello world!", result.error().message()); |
| |
| result = Errorf("hello world!"); |
| EXPECT_EQ("hello world!", result.error().message()); |
| |
| Result<int> result2 = Errorf("error occurred with {}", result.error()); |
| EXPECT_EQ("error occurred with hello world!", result2.error().message()); |
| |
| constexpr int test_errno = 6; |
| errno = test_errno; |
| result = ErrnoErrorf("{} {}!", "hello", "world"); |
| EXPECT_EQ(test_errno, result.error().code()); |
| EXPECT_EQ("hello world!: "s + strerror(test_errno), result.error().message()); |
| } |
| |
| TEST(result, error_with_fmt_carries_errno) { |
| constexpr int inner_errno = 6; |
| errno = inner_errno; |
| Result<int> inner_result = ErrnoErrorf("inner failure"); |
| errno = 0; |
| EXPECT_EQ(inner_errno, inner_result.error().code()); |
| |
| // outer_result is created with Errorf, but its error code is got from inner_result. |
| Result<int> outer_result = Errorf("outer failure caused by {}", inner_result.error()); |
| EXPECT_EQ(inner_errno, outer_result.error().code()); |
| EXPECT_EQ("outer failure caused by inner failure: "s + strerror(inner_errno), |
| outer_result.error().message()); |
| |
| // now both result objects are created with ErrnoErrorf. errno from the inner_result |
| // is not passed to outer_result. |
| constexpr int outer_errno = 10; |
| errno = outer_errno; |
| outer_result = ErrnoErrorf("outer failure caused by {}", inner_result.error()); |
| EXPECT_EQ(outer_errno, outer_result.error().code()); |
| EXPECT_EQ("outer failure caused by inner failure: "s + strerror(inner_errno) + ": "s + |
| strerror(outer_errno), |
| outer_result.error().message()); |
| } |
| |
| TEST(result, errno_chaining_multiple) { |
| constexpr int errno1 = 6; |
| errno = errno1; |
| Result<int> inner1 = ErrnoErrorf("error1"); |
| |
| constexpr int errno2 = 10; |
| errno = errno2; |
| Result<int> inner2 = ErrnoErrorf("error2"); |
| |
| // takes the error code of inner2 since its the last one. |
| Result<int> outer = Errorf("two errors: {}, {}", inner1.error(), inner2.error()); |
| EXPECT_EQ(errno2, outer.error().code()); |
| EXPECT_EQ("two errors: error1: "s + strerror(errno1) + ", error2: "s + strerror(errno2), |
| outer.error().message()); |
| } |
| |
| TEST(result, error_without_message) { |
| constexpr bool include_message = false; |
| Result<void, Errno, include_message> res = Error<Errno, include_message>(10); |
| EXPECT_FALSE(res.ok()); |
| EXPECT_EQ(10, res.error().code()); |
| EXPECT_EQ(sizeof(int), sizeof(res.error())); |
| } |
| |
| namespace testing { |
| |
| class Listener : public ::testing::MatchResultListener { |
| public: |
| Listener() : MatchResultListener(&ss_) {} |
| ~Listener() = default; |
| std::string message() const { return ss_.str(); } |
| |
| private: |
| std::stringstream ss_; |
| }; |
| |
| class ResultMatchers : public ::testing::Test { |
| public: |
| Result<int> result = 1; |
| Result<int> error = Error(EBADF) << "error message"; |
| Listener listener; |
| }; |
| |
| TEST_F(ResultMatchers, ok_result) { |
| EXPECT_TRUE(ExplainMatchResult(Ok(), result, &listener)); |
| EXPECT_THAT(listener.message(), Eq("result is OK")); |
| } |
| |
| TEST_F(ResultMatchers, ok_error) { |
| EXPECT_FALSE(ExplainMatchResult(Ok(), error, &listener)); |
| EXPECT_THAT(listener.message(), StartsWith("error is")); |
| EXPECT_THAT(listener.message(), HasSubstr(error.error().message())); |
| EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code()))); |
| } |
| |
| TEST_F(ResultMatchers, not_ok_result) { |
| EXPECT_FALSE(ExplainMatchResult(Not(Ok()), result, &listener)); |
| EXPECT_THAT(listener.message(), Eq("result is OK")); |
| } |
| |
| TEST_F(ResultMatchers, not_ok_error) { |
| EXPECT_TRUE(ExplainMatchResult(Not(Ok()), error, &listener)); |
| EXPECT_THAT(listener.message(), StartsWith("error is")); |
| EXPECT_THAT(listener.message(), HasSubstr(error.error().message())); |
| EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code()))); |
| } |
| |
| TEST_F(ResultMatchers, has_value_result) { |
| EXPECT_TRUE(ExplainMatchResult(HasValue(*result), result, &listener)); |
| } |
| |
| TEST_F(ResultMatchers, has_value_wrong_result) { |
| EXPECT_FALSE(ExplainMatchResult(HasValue(*result + 1), result, &listener)); |
| } |
| |
| TEST_F(ResultMatchers, has_value_error) { |
| EXPECT_FALSE(ExplainMatchResult(HasValue(*result), error, &listener)); |
| EXPECT_THAT(listener.message(), StartsWith("error is")); |
| EXPECT_THAT(listener.message(), HasSubstr(error.error().message())); |
| EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code()))); |
| } |
| |
| TEST_F(ResultMatchers, has_error_code_result) { |
| EXPECT_FALSE(ExplainMatchResult(HasError(WithCode(error.error().code())), result, &listener)); |
| EXPECT_THAT(listener.message(), Eq("result is OK")); |
| } |
| |
| TEST_F(ResultMatchers, has_error_code_wrong_code) { |
| EXPECT_FALSE(ExplainMatchResult(HasError(WithCode(error.error().code() + 1)), error, &listener)); |
| EXPECT_THAT(listener.message(), StartsWith("actual error is")); |
| EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code()))); |
| } |
| |
| TEST_F(ResultMatchers, has_error_code_correct_code) { |
| EXPECT_TRUE(ExplainMatchResult(HasError(WithCode(error.error().code())), error, &listener)); |
| EXPECT_THAT(listener.message(), StartsWith("actual error is")); |
| EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code()))); |
| } |
| |
| TEST_F(ResultMatchers, has_error_message_result) { |
| EXPECT_FALSE( |
| ExplainMatchResult(HasError(WithMessage(error.error().message())), result, &listener)); |
| EXPECT_THAT(listener.message(), Eq("result is OK")); |
| } |
| |
| TEST_F(ResultMatchers, has_error_message_wrong_message) { |
| EXPECT_FALSE(ExplainMatchResult(HasError(WithMessage("foo")), error, &listener)); |
| EXPECT_THAT(listener.message(), StartsWith("actual error is")); |
| EXPECT_THAT(listener.message(), HasSubstr(error.error().message())); |
| } |
| |
| TEST_F(ResultMatchers, has_error_message_correct_message) { |
| EXPECT_TRUE(ExplainMatchResult(HasError(WithMessage(error.error().message())), error, &listener)); |
| EXPECT_THAT(listener.message(), StartsWith("actual error is")); |
| EXPECT_THAT(listener.message(), HasSubstr(error.error().message())); |
| } |
| |
| } // namespace testing |
| } // namespace base |
| } // namespace android |