138 lines
3.2 KiB
C++
138 lines
3.2 KiB
C++
#include <gtest/gtest.h>
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include "utils/result.h"
|
|
|
|
namespace rk3588 {
|
|
namespace {
|
|
|
|
TEST(ResultTest, VoidResultOk) {
|
|
Status s = Status::Ok();
|
|
EXPECT_TRUE(s.IsOk());
|
|
EXPECT_FALSE(s.Failed());
|
|
EXPECT_TRUE(static_cast<bool>(s));
|
|
EXPECT_TRUE(s.ErrMessage().empty());
|
|
}
|
|
|
|
TEST(ResultTest, VoidResultFail) {
|
|
Status s = Status::Fail("something went wrong");
|
|
EXPECT_FALSE(s.IsOk());
|
|
EXPECT_TRUE(s.Failed());
|
|
EXPECT_FALSE(static_cast<bool>(s));
|
|
EXPECT_EQ(s.ErrMessage(), "something went wrong");
|
|
}
|
|
|
|
TEST(ResultTest, VoidResultFailWithCode) {
|
|
Status s = Status::Fail("error", 42);
|
|
EXPECT_FALSE(s.IsOk());
|
|
EXPECT_EQ(s.Err().Code(), 42);
|
|
EXPECT_EQ(s.ErrMessage(), "error");
|
|
}
|
|
|
|
TEST(ResultTest, ValueResultOk) {
|
|
Result<int> r = 42;
|
|
EXPECT_TRUE(r.Ok());
|
|
EXPECT_FALSE(r.Failed());
|
|
EXPECT_TRUE(static_cast<bool>(r));
|
|
EXPECT_EQ(r.Value(), 42);
|
|
}
|
|
|
|
TEST(ResultTest, ValueResultFail) {
|
|
Result<int> r = Error("failed to compute");
|
|
EXPECT_FALSE(r.Ok());
|
|
EXPECT_TRUE(r.Failed());
|
|
EXPECT_FALSE(static_cast<bool>(r));
|
|
EXPECT_EQ(r.ErrMessage(), "failed to compute");
|
|
}
|
|
|
|
TEST(ResultTest, ValueResultValueOr) {
|
|
Result<int> ok = 100;
|
|
Result<int> fail = Error("oops");
|
|
|
|
EXPECT_EQ(ok.ValueOr(0), 100);
|
|
EXPECT_EQ(fail.ValueOr(0), 0);
|
|
}
|
|
|
|
TEST(ResultTest, ValueResultTake) {
|
|
Result<std::string> r = std::string("hello");
|
|
EXPECT_TRUE(r.Ok());
|
|
std::string s = std::move(r).Take();
|
|
EXPECT_EQ(s, "hello");
|
|
}
|
|
|
|
TEST(ResultTest, StringResult) {
|
|
Result<std::string> ok = std::string("success");
|
|
Result<std::string> fail = Error("failure");
|
|
|
|
EXPECT_TRUE(ok.Ok());
|
|
EXPECT_EQ(ok.Value(), "success");
|
|
|
|
EXPECT_TRUE(fail.Failed());
|
|
EXPECT_EQ(fail.ErrMessage(), "failure");
|
|
}
|
|
|
|
TEST(ResultTest, MakeResultHelper) {
|
|
auto r = MakeResult<int>(123);
|
|
EXPECT_TRUE(r.Ok());
|
|
EXPECT_EQ(r.Value(), 123);
|
|
}
|
|
|
|
TEST(ResultTest, MakeErrorHelper) {
|
|
auto r = MakeError<int>("test error");
|
|
EXPECT_TRUE(r.Failed());
|
|
EXPECT_EQ(r.ErrMessage(), "test error");
|
|
}
|
|
|
|
TEST(ErrorTest, Basic) {
|
|
Error e1;
|
|
EXPECT_TRUE(e1.Empty());
|
|
EXPECT_FALSE(static_cast<bool>(e1));
|
|
|
|
Error e2("message", 100);
|
|
EXPECT_FALSE(e2.Empty());
|
|
EXPECT_TRUE(static_cast<bool>(e2));
|
|
EXPECT_EQ(e2.Message(), "message");
|
|
EXPECT_EQ(e2.Code(), 100);
|
|
}
|
|
|
|
TEST(ResultTest, OkStatusHelper) {
|
|
Status s = OkStatus();
|
|
EXPECT_TRUE(s.IsOk());
|
|
}
|
|
|
|
TEST(ResultTest, FailStatusHelper) {
|
|
Status s = FailStatus("test");
|
|
EXPECT_TRUE(s.Failed());
|
|
EXPECT_EQ(s.ErrMessage(), "test");
|
|
}
|
|
|
|
// Test with complex types
|
|
struct ComplexType {
|
|
int x;
|
|
std::string s;
|
|
bool operator==(const ComplexType& o) const { return x == o.x && s == o.s; }
|
|
};
|
|
|
|
TEST(ResultTest, ComplexType) {
|
|
Result<ComplexType> ok = ComplexType{42, "test"};
|
|
EXPECT_TRUE(ok.Ok());
|
|
EXPECT_EQ(ok.Value().x, 42);
|
|
EXPECT_EQ(ok.Value().s, "test");
|
|
|
|
Result<ComplexType> fail = Error("complex error");
|
|
EXPECT_TRUE(fail.Failed());
|
|
}
|
|
|
|
// Test move semantics
|
|
TEST(ResultTest, MoveSemantics) {
|
|
Result<std::unique_ptr<int>> r = std::make_unique<int>(42);
|
|
EXPECT_TRUE(r.Ok());
|
|
auto ptr = std::move(r).Take();
|
|
EXPECT_EQ(*ptr, 42);
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace rk3588
|