1 /*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "common/libs/utils/result.h"
18
19 #include <type_traits>
20
21 #include <android-base/expected.h>
22 #include <gmock/gmock.h>
23 #include <gtest/gtest.h>
24
25 #include "common/libs/utils/result_matchers.h"
26
27 namespace cuttlefish {
28 namespace {
29
30 using ::testing::HasSubstr;
31 using ::testing::StrEq;
32
33 } // namespace
34
TEST(ResultTest,ExpectBoolGoodNoMessage)35 TEST(ResultTest, ExpectBoolGoodNoMessage) {
36 const auto result = []() -> Result<std::string> {
37 CF_EXPECT(true);
38 return "okay";
39 }();
40 EXPECT_THAT(result, IsOkAndValue(StrEq("okay")));
41 }
42
TEST(ResultTest,ExpectBoolGoodWithMessage)43 TEST(ResultTest, ExpectBoolGoodWithMessage) {
44 const auto result = []() -> Result<std::string> {
45 CF_EXPECT(true, "Failed");
46 return "okay";
47 }();
48 EXPECT_THAT(result, IsOkAndValue(StrEq("okay")));
49 }
50
TEST(ResultTest,ExpectBoolBadNoMessage)51 TEST(ResultTest, ExpectBoolBadNoMessage) {
52 const auto result = []() -> Result<std::string> {
53 CF_EXPECT(false);
54 return "okay";
55 }();
56 EXPECT_THAT(result, IsError());
57 }
58
TEST(ResultTest,ExpectBoolBadWithMessage)59 TEST(ResultTest, ExpectBoolBadWithMessage) {
60 const auto result = []() -> Result<std::string> {
61 CF_EXPECT(false, "ExpectBoolBadWithMessage message");
62 return "okay";
63 }();
64 EXPECT_THAT(result,
65 IsErrorAndMessage(HasSubstr("ExpectBoolBadWithMessage message")));
66 }
67
TEST(ResultTest,ExpectWithResultGoodNoMessage)68 TEST(ResultTest, ExpectWithResultGoodNoMessage) {
69 const auto result = []() -> Result<std::string> {
70 const auto inner_result = []() -> Result<std::string> {
71 CF_EXPECT(true);
72 return "inner okay";
73 };
74 CF_EXPECT(inner_result());
75 return "outer okay";
76 }();
77 EXPECT_THAT(result, IsOkAndValue(StrEq("outer okay")));
78 }
79
TEST(ResultTest,ExpectWithResultGoodWithMessage)80 TEST(ResultTest, ExpectWithResultGoodWithMessage) {
81 const auto result = []() -> Result<std::string> {
82 const auto inner_result = []() -> Result<std::string> {
83 CF_EXPECT(true);
84 return "inner okay";
85 };
86 CF_EXPECT(inner_result(), "Failed inner result.");
87 return "outer okay";
88 }();
89 EXPECT_THAT(result, IsOkAndValue(StrEq("outer okay")));
90 }
91
TEST(ResultTest,ExpectWithResultBadNoMessage)92 TEST(ResultTest, ExpectWithResultBadNoMessage) {
93 const auto result = []() -> Result<std::string> {
94 const auto inner_result = []() -> Result<std::string> {
95 CF_EXPECT(false, "inner bad");
96 return "inner okay";
97 };
98 CF_EXPECT(inner_result());
99 return "okay";
100 }();
101 EXPECT_THAT(result, IsError());
102 }
103
TEST(ResultTest,ExpectWithResultBadWithMessage)104 TEST(ResultTest, ExpectWithResultBadWithMessage) {
105 const auto result = []() -> Result<std::string> {
106 const auto inner_result = []() -> Result<std::string> {
107 CF_EXPECT(false, "inner bad");
108 return "inner okay";
109 };
110 CF_EXPECT(inner_result(), "ExpectWithResultBadWithMessage message");
111 return "okay";
112 }();
113 EXPECT_THAT(result, IsErrorAndMessage(
114 HasSubstr("ExpectWithResultBadWithMessage message")));
115 }
116
TEST(ResultTest,ExpectEqGoodNoMessage)117 TEST(ResultTest, ExpectEqGoodNoMessage) {
118 const auto result = []() -> Result<std::string> {
119 CF_EXPECT_EQ(1, 1);
120 return "okay";
121 }();
122 EXPECT_THAT(result, IsOkAndValue(StrEq("okay")));
123 }
124
TEST(ResultTest,ExpectEqGoodWithMessage)125 TEST(ResultTest, ExpectEqGoodWithMessage) {
126 const auto result = []() -> Result<std::string> {
127 CF_EXPECT_EQ(1, 1, "Failed comparison");
128 return "okay";
129 }();
130 EXPECT_THAT(result, IsOkAndValue(StrEq("okay")));
131 }
132
TEST(ResultTest,ExpectEqBadNoMessage)133 TEST(ResultTest, ExpectEqBadNoMessage) {
134 const auto result = []() -> Result<std::string> {
135 CF_EXPECT_EQ(1, 2);
136 return "okay";
137 }();
138 EXPECT_THAT(result, IsError());
139 }
140
TEST(ResultTest,ExpectEqBadWithMessage)141 TEST(ResultTest, ExpectEqBadWithMessage) {
142 const auto result = []() -> Result<std::string> {
143 CF_EXPECT_EQ(1, 2, "ExpectEqBadWithMessage message");
144 return "okay";
145 }();
146 EXPECT_THAT(result,
147 IsErrorAndMessage(HasSubstr("ExpectEqBadWithMessage message")));
148 }
149
150 } // namespace cuttlefish
151