зеркало из https://github.com/mozilla/gecko-dev.git
580 строки
17 KiB
C++
580 строки
17 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "mozilla/ResultExtensions.h"
|
|
#include "nsLocalFile.h"
|
|
|
|
#include <functional>
|
|
|
|
using namespace mozilla;
|
|
|
|
namespace {
|
|
class TestClass {
|
|
public:
|
|
static constexpr int kTestValue = 42;
|
|
|
|
nsresult NonOverloadedNoInput(int* aOut) {
|
|
*aOut = kTestValue;
|
|
return NS_OK;
|
|
}
|
|
nsresult NonOverloadedNoInputFails(int* aOut) { return NS_ERROR_FAILURE; }
|
|
|
|
nsresult NonOverloadedNoInputConst(int* aOut) const {
|
|
*aOut = kTestValue;
|
|
return NS_OK;
|
|
}
|
|
nsresult NonOverloadedNoInputFailsConst(int* aOut) const {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsresult NonOverloadedNoInputRef(int& aOut) {
|
|
aOut = kTestValue;
|
|
return NS_OK;
|
|
}
|
|
nsresult NonOverloadedNoInputFailsRef(int& aOut) { return NS_ERROR_FAILURE; }
|
|
|
|
nsresult NonOverloadedNoInputComplex(std::pair<int, int>* aOut) {
|
|
*aOut = std::pair{kTestValue, kTestValue};
|
|
return NS_OK;
|
|
}
|
|
nsresult NonOverloadedNoInputFailsComplex(std::pair<int, int>* aOut) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsresult NonOverloadedWithInput(int aIn, int* aOut) {
|
|
*aOut = aIn;
|
|
return NS_OK;
|
|
}
|
|
nsresult NonOverloadedWithInputFails(int aIn, int* aOut) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsresult NonOverloadedNoOutput(int aIn) { return NS_OK; }
|
|
nsresult NonOverloadedNoOutputFails(int aIn) { return NS_ERROR_FAILURE; }
|
|
|
|
nsresult PolymorphicNoInput(nsIFile** aOut) {
|
|
*aOut = MakeAndAddRef<nsLocalFile>().take();
|
|
return NS_OK;
|
|
}
|
|
nsresult PolymorphicNoInputFails(nsIFile** aOut) { return NS_ERROR_FAILURE; }
|
|
};
|
|
|
|
class RefCountedTestClass {
|
|
public:
|
|
NS_INLINE_DECL_REFCOUNTING(RefCountedTestClass);
|
|
|
|
static constexpr int kTestValue = 42;
|
|
|
|
nsresult NonOverloadedNoInput(int* aOut) {
|
|
*aOut = kTestValue;
|
|
return NS_OK;
|
|
}
|
|
nsresult NonOverloadedNoInputFails(int* aOut) { return NS_ERROR_FAILURE; }
|
|
|
|
private:
|
|
~RefCountedTestClass() = default;
|
|
};
|
|
|
|
// Check that DerefedType deduces the types as expected
|
|
static_assert(std::is_same_v<mozilla::detail::DerefedType<RefCountedTestClass&>,
|
|
RefCountedTestClass>);
|
|
static_assert(std::is_same_v<mozilla::detail::DerefedType<RefCountedTestClass*>,
|
|
RefCountedTestClass>);
|
|
static_assert(
|
|
std::is_same_v<mozilla::detail::DerefedType<RefPtr<RefCountedTestClass>>,
|
|
RefCountedTestClass>);
|
|
|
|
static_assert(std::is_same_v<mozilla::detail::DerefedType<nsIFile&>, nsIFile>);
|
|
static_assert(std::is_same_v<mozilla::detail::DerefedType<nsIFile*>, nsIFile>);
|
|
static_assert(
|
|
std::is_same_v<mozilla::detail::DerefedType<nsCOMPtr<nsIFile>>, nsIFile>);
|
|
} // namespace
|
|
|
|
TEST(ResultExtensions_ToResultInvoke, Lambda_NoInput)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = ToResultInvoke<int>(
|
|
[&foo](int* out) { return foo.NonOverloadedNoInput(out); });
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = ToResultInvoke<int>(
|
|
[&foo](int* out) { return foo.NonOverloadedNoInputFails(out); });
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvoke, MemFn_NoInput)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr =
|
|
ToResultInvoke<int>(std::mem_fn(&TestClass::NonOverloadedNoInput), foo);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = ToResultInvoke<int>(
|
|
std::mem_fn(&TestClass::NonOverloadedNoInputFails), foo);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvoke, MemFn_Polymorphic_NoInput)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = ToResultInvoke<nsCOMPtr<nsIFile>>(
|
|
std::mem_fn(&TestClass::PolymorphicNoInput), foo);
|
|
static_assert(std::is_same_v<decltype(valOrErr),
|
|
Result<nsCOMPtr<nsIFile>, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_NE(nullptr, valOrErr.inspect());
|
|
|
|
ASSERT_EQ(ToResultInvoke<nsString>(std::mem_fn(&nsIFile::GetPath),
|
|
*MakeRefPtr<nsLocalFile>())
|
|
.inspect(),
|
|
ToResultInvoke<nsString>(std::mem_fn(&nsIFile::GetPath),
|
|
valOrErr.inspect())
|
|
.inspect());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = ToResultInvoke<nsCOMPtr<nsIFile>>(
|
|
std::mem_fn(&TestClass::PolymorphicNoInputFails), foo);
|
|
static_assert(std::is_same_v<decltype(valOrErr),
|
|
Result<nsCOMPtr<nsIFile>, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoInput)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInput);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr =
|
|
ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInputFails);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoInput_Const)
|
|
{
|
|
const TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr =
|
|
ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInputConst);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr =
|
|
ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInputFailsConst);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoInput_Ref)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr =
|
|
ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInputRef);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr =
|
|
ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInputFailsRef);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoInput_Complex)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr =
|
|
ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInputComplex);
|
|
static_assert(std::is_same_v<decltype(valOrErr),
|
|
Result<std::pair<int, int>, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ((std::pair{TestClass::kTestValue, TestClass::kTestValue}),
|
|
valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr =
|
|
ToResultInvokeMember(foo, &TestClass::NonOverloadedNoInputFailsComplex);
|
|
static_assert(std::is_same_v<decltype(valOrErr),
|
|
Result<std::pair<int, int>, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, WithInput)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = ToResultInvokeMember(
|
|
foo, &TestClass::NonOverloadedWithInput, -TestClass::kTestValue);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(-TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = ToResultInvokeMember(
|
|
foo, &TestClass::NonOverloadedWithInputFails, -TestClass::kTestValue);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoOutput)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = ToResultInvokeMember(foo, &TestClass::NonOverloadedNoOutput,
|
|
-TestClass::kTestValue);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<Ok, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = ToResultInvokeMember(
|
|
foo, &TestClass::NonOverloadedNoOutputFails, -TestClass::kTestValue);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<Ok, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoInput_Macro)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInput);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputFails);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoInput_Const_Macro)
|
|
{
|
|
const TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputConst);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr =
|
|
MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputFailsConst);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoInput_Ref_Macro)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputRef);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr =
|
|
MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputFailsRef);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoInput_Complex_Macro)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr =
|
|
MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputComplex);
|
|
static_assert(std::is_same_v<decltype(valOrErr),
|
|
Result<std::pair<int, int>, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ((std::pair{TestClass::kTestValue, TestClass::kTestValue}),
|
|
valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr =
|
|
MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputFailsComplex);
|
|
|
|
static_assert(std::is_same_v<decltype(valOrErr),
|
|
Result<std::pair<int, int>, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, WithInput_Macro)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedWithInput,
|
|
-TestClass::kTestValue);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(-TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(
|
|
foo, NonOverloadedWithInputFails, -TestClass::kTestValue);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoOutput_Macro)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoOutput,
|
|
-TestClass::kTestValue);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<Ok, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoOutputFails,
|
|
-TestClass::kTestValue);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<Ok, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, NoInput_Complex_Macro_Typed)
|
|
{
|
|
TestClass foo;
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
|
|
(std::pair<int, int>), foo, NonOverloadedNoInputComplex);
|
|
static_assert(std::is_same_v<decltype(valOrErr),
|
|
Result<std::pair<int, int>, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ((std::pair{TestClass::kTestValue, TestClass::kTestValue}),
|
|
valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
|
|
(std::pair<int, int>), foo, NonOverloadedNoInputFailsComplex);
|
|
static_assert(std::is_same_v<decltype(valOrErr),
|
|
Result<std::pair<int, int>, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, RefPtr_NoInput)
|
|
{
|
|
auto foo = MakeRefPtr<RefCountedTestClass>();
|
|
|
|
// success
|
|
{
|
|
auto valOrErr =
|
|
ToResultInvokeMember(foo, &RefCountedTestClass::NonOverloadedNoInput);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = ToResultInvokeMember(
|
|
foo, &RefCountedTestClass::NonOverloadedNoInputFails);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, RefPtr_NoInput_Macro)
|
|
{
|
|
auto foo = MakeRefPtr<RefCountedTestClass>();
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInput);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(foo, NonOverloadedNoInputFails);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, RawPtr_NoInput_Macro)
|
|
{
|
|
auto foo = MakeRefPtr<RefCountedTestClass>();
|
|
auto* fooPtr = foo.get();
|
|
|
|
// success
|
|
{
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(fooPtr, NonOverloadedNoInput);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(TestClass::kTestValue, valOrErr.unwrap());
|
|
}
|
|
|
|
// failure
|
|
{
|
|
auto valOrErr =
|
|
MOZ_TO_RESULT_INVOKE_MEMBER(fooPtr, NonOverloadedNoInputFails);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<int, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isErr());
|
|
ASSERT_EQ(NS_ERROR_FAILURE, valOrErr.unwrapErr());
|
|
}
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember, nsCOMPtr_AbstractClass_WithInput)
|
|
{
|
|
nsCOMPtr<nsIFile> file = MakeAndAddRef<nsLocalFile>();
|
|
|
|
auto valOrErr = ToResultInvokeMember(file, &nsIFile::Equals, file);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<bool, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(true, valOrErr.unwrap());
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember,
|
|
RawPtr_AbstractClass_WithInput_Macro)
|
|
{
|
|
nsCOMPtr<nsIFile> file = MakeAndAddRef<nsLocalFile>();
|
|
auto* filePtr = file.get();
|
|
|
|
auto valOrErr = MOZ_TO_RESULT_INVOKE_MEMBER(filePtr, Equals, file);
|
|
static_assert(std::is_same_v<decltype(valOrErr), Result<bool, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_EQ(true, valOrErr.unwrap());
|
|
}
|
|
|
|
TEST(ResultExtensions_ToResultInvokeMember,
|
|
RawPtr_AbstractClass_NoInput_Macro_Typed)
|
|
{
|
|
nsCOMPtr<nsIFile> file = MakeAndAddRef<nsLocalFile>();
|
|
auto* filePtr = file.get();
|
|
|
|
auto valOrErr =
|
|
MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsCOMPtr<nsIFile>, filePtr, Clone);
|
|
static_assert(
|
|
std::is_same_v<decltype(valOrErr), Result<nsCOMPtr<nsIFile>, nsresult>>);
|
|
ASSERT_TRUE(valOrErr.isOk());
|
|
ASSERT_NE(nullptr, valOrErr.unwrap());
|
|
}
|