missive/util/statusor_test.cc

// Copyright 2021 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "missive/util/statusor.h"

#include <errno.h>
#include <algorithm>
#include <memory>

#include <base/bind.h>
#include <base/callback.h>
#include <base/memory/ref_counted.h>
#include <base/memory/scoped_refptr.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

namespace reporting {
namespace {

class Base1 {
 public:
  virtual ~Base1() = default;
  int pad;
};

class Base2 {
 public:
  virtual ~Base2() = default;
  int yetotherpad;
};

class Derived : public Base1, public Base2 {
 public:
  ~Derived() override = default;
  int evenmorepad;
};

class CopyNoAssign {
 public:
  explicit CopyNoAssign(int value) : foo(value) {}
  CopyNoAssign(const CopyNoAssign& other) : foo(other.foo) {}
  int foo;

 private:
  const CopyNoAssign& operator=(const CopyNoAssign&);
};

TEST(StatusOr, TestDefaultCtor) {
  StatusOr<int> thing;
  EXPECT_FALSE(thing.ok());
  EXPECT_EQ(error::UNKNOWN, thing.status().code());
}

TEST(StatusOr, TestStatusCtor) {
  StatusOr<int> thing(Status(error::CANCELLED, ""));
  EXPECT_FALSE(thing.ok());
  EXPECT_EQ(Status(error::CANCELLED, ""), thing.status());
}

TEST(StatusOr, TestValueCtor) {
  const int kI = 4;
  StatusOr<int> thing(kI);
  EXPECT_TRUE(thing.ok());
  EXPECT_EQ(kI, thing.ValueOrDie());
}

TEST(StatusOr, TestCopyCtorStatusOk) {
  const int kI = 4;
  StatusOr<int> original(kI);
  StatusOr<int> copy(original);
  EXPECT_EQ(original.status(), copy.status());
  EXPECT_EQ(original.ValueOrDie(), copy.ValueOrDie());
}

TEST(StatusOr, TestCopyCtorStatusNotOk) {
  StatusOr<int> original(Status(error::CANCELLED, ""));
  StatusOr<int> copy(original);
  EXPECT_EQ(original.status(), copy.status());
}

TEST(StatusOr, TestCopyCtorStatusOKConverting) {
  const int kI = 4;
  StatusOr<int> original(kI);
  StatusOr<double> copy(original);
  EXPECT_EQ(original.status(), copy.status());
  EXPECT_EQ(original.ValueOrDie(), copy.ValueOrDie());
}

TEST(StatusOr, TestCopyCtorStatusNotOkConverting) {
  StatusOr<int> original(Status(error::CANCELLED, ""));
  StatusOr<double> copy(original);
  EXPECT_EQ(original.status(), copy.status());
}

TEST(StatusOr, TestAssignmentStatusOk) {
  const int kI = 4;
  StatusOr<int> source(kI);
  StatusOr<int> target;
  target = source;
  EXPECT_EQ(source.status(), target.status());
  EXPECT_EQ(source.ValueOrDie(), target.ValueOrDie());
}

TEST(StatusOr, TestAssignmentStatusNotOk) {
  StatusOr<int> source(Status(error::CANCELLED, ""));
  StatusOr<int> target;
  target = source;
  EXPECT_EQ(source.status(), target.status());
}

TEST(StatusOr, TestAssignmentStatusOKConverting) {
  const int kI = 4;
  StatusOr<int> source(kI);
  StatusOr<double> target;
  target = source;
  EXPECT_EQ(source.status(), target.status());
  EXPECT_DOUBLE_EQ(source.ValueOrDie(), target.ValueOrDie());
}

TEST(StatusOr, TestAssignmentStatusNotOkConverting) {
  StatusOr<int> source(Status(error::CANCELLED, ""));
  StatusOr<double> target;
  target = source;
  EXPECT_EQ(source.status(), target.status());
}

TEST(StatusOr, TestStatus) {
  StatusOr<int> good(4);
  EXPECT_TRUE(good.ok());
  StatusOr<int> bad(Status(error::CANCELLED, ""));
  EXPECT_FALSE(bad.ok());
  EXPECT_EQ(Status(error::CANCELLED, ""), bad.status());
}

TEST(StatusOr, TestValueConst) {
  const int kI = 4;
  const StatusOr<int> thing(kI);
  EXPECT_EQ(kI, thing.ValueOrDie());
}

TEST(StatusOr, TestPointerDefaultCtor) {
  StatusOr<int*> thing;
  EXPECT_FALSE(thing.ok());
  EXPECT_EQ(error::UNKNOWN, thing.status().code());
}

TEST(StatusOr, TestPointerStatusCtor) {
  StatusOr<int*> thing(Status(error::CANCELLED, ""));
  EXPECT_FALSE(thing.ok());
  EXPECT_EQ(Status(error::CANCELLED, ""), thing.status());
}

TEST(StatusOr, TestPointerValueCtor) {
  const int kI = 4;
  StatusOr<const int*> thing(&kI);
  EXPECT_TRUE(thing.ok());
  EXPECT_EQ(&kI, thing.ValueOrDie());
}

TEST(StatusOr, TestPointerCopyCtorStatusOk) {
  const int kI = 0;
  StatusOr<const int*> original(&kI);
  StatusOr<const int*> copy(original);
  EXPECT_EQ(original.status(), copy.status());
  EXPECT_EQ(original.ValueOrDie(), copy.ValueOrDie());
}

TEST(StatusOr, TestPointerCopyCtorStatusNotOk) {
  StatusOr<int*> original(Status(error::CANCELLED, ""));
  StatusOr<int*> copy(original);
  EXPECT_EQ(original.status(), copy.status());
}

TEST(StatusOr, TestPointerCopyCtorStatusOKConverting) {
  Derived derived;
  StatusOr<Derived*> original(&derived);
  StatusOr<Base2*> copy(original);
  EXPECT_EQ(original.status(), copy.status());
  EXPECT_EQ(static_cast<const Base2*>(original.ValueOrDie()),
            copy.ValueOrDie());
}

TEST(StatusOr, TestPointerCopyCtorStatusNotOkConverting) {
  StatusOr<Derived*> original(Status(error::CANCELLED, ""));
  StatusOr<Base2*> copy(original);
  EXPECT_EQ(original.status(), copy.status());
}

TEST(StatusOr, TestPointerAssignmentStatusOk) {
  const int kI = 0;
  StatusOr<const int*> source(&kI);
  StatusOr<const int*> target;
  target = source;
  EXPECT_EQ(source.status(), target.status());
  EXPECT_EQ(source.ValueOrDie(), target.ValueOrDie());
}

TEST(StatusOr, TestPointerAssignmentStatusNotOk) {
  StatusOr<int*> source(Status(error::CANCELLED, ""));
  StatusOr<int*> target;
  target = source;
  EXPECT_EQ(source.status(), target.status());
}

TEST(StatusOr, TestPointerAssignmentStatusOKConverting) {
  Derived derived;
  StatusOr<Derived*> source(&derived);
  StatusOr<Base2*> target;
  target = source;
  EXPECT_EQ(source.status(), target.status());
  EXPECT_EQ(static_cast<const Base2*>(source.ValueOrDie()),
            target.ValueOrDie());
}

TEST(StatusOr, TestPointerAssignmentStatusNotOkConverting) {
  StatusOr<Derived*> source(Status(error::CANCELLED, ""));
  StatusOr<Base2*> target;
  target = source;
  EXPECT_EQ(source.status(), target.status());
}

TEST(StatusOr, TestPointerStatus) {
  const int kI = 0;
  StatusOr<const int*> good(&kI);
  EXPECT_TRUE(good.ok());
  StatusOr<const int*> bad(Status(error::CANCELLED, ""));
  EXPECT_EQ(Status(error::CANCELLED, ""), bad.status());
}

TEST(StatusOr, TestPointerValue) {
  const int kI = 0;
  StatusOr<const int*> thing(&kI);
  EXPECT_EQ(&kI, thing.ValueOrDie());
}

TEST(StatusOr, TestPointerValueConst) {
  const int kI = 0;
  const StatusOr<const int*> thing(&kI);
  EXPECT_EQ(&kI, thing.ValueOrDie());
}

TEST(StatusOr, TestMoveStatusOr) {
  const int kI = 0;
  StatusOr<std::unique_ptr<int>> thing(std::make_unique<int>(kI));
  EXPECT_OK(thing.status());
  StatusOr<std::unique_ptr<int>> moved = std::move(thing);
  EXPECT_EQ(error::UNKNOWN, thing.status().code());
  EXPECT_TRUE(moved.ok());
  EXPECT_EQ(kI, *moved.ValueOrDie());
}

TEST(StatusOr, TestBinding) {
  class RefCountedValue : public base::RefCounted<RefCountedValue> {
   public:
    explicit RefCountedValue(StatusOr<int> value) : value_(value) {}
    Status status() const { return value_.status(); }
    int value() const { return value_.ValueOrDie(); }

   private:
    friend class base::RefCounted<RefCountedValue>;
    ~RefCountedValue() = default;
    const StatusOr<int> value_;
  };
  const int kI = 0;
  base::OnceCallback<int(StatusOr<scoped_refptr<RefCountedValue>>)> callback =
      base::BindOnce([](StatusOr<scoped_refptr<RefCountedValue>> val) {
        return val.ValueOrDie()->value();
      });
  const int result =
      std::move(callback).Run(base::MakeRefCounted<RefCountedValue>(kI));
  EXPECT_EQ(kI, result);
}

TEST(StatusOr, TestAbort) {
  StatusOr<int> thing1(Status(error::UNKNOWN, "Unknown"));
  int v1;
  EXPECT_DEATH_IF_SUPPORTED(v1 = thing1.ValueOrDie(), "");

  StatusOr<std::unique_ptr<int>> thing2(Status(error::UNKNOWN, "Unknown"));
  std::unique_ptr<int> v2;
  EXPECT_DEATH_IF_SUPPORTED(v2 = std::move(thing2.ValueOrDie()), "");
}
}  // namespace
}  // namespace reporting