inference-engine/thirdparty/fluid/modules/gapi/test/util/optional_tests.cpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html.
   4 //
   5 // Copyright (C) 2018-2019 Intel Corporation
   6
   7
   8 #include "test_precomp.hpp"
   9 #include "opencv2/gapi/util/optional.hpp"
  10 #include <opencv2/gapi/util/compiler_hints.hpp> //suppress_unused_warning
  11
  12 namespace opencv_test
  13 {
  14
  15 TEST(Optional, EmptyCtor)
  16 {
  17     util::optional<int> o;
  18     EXPECT_FALSE(o.has_value());
  19     EXPECT_FALSE(static_cast<bool>(o));
  20 }
  21
  22 TEST(Optional, ValueCTor)
  23 {
  24     util::optional<int> o(42);
  25     EXPECT_TRUE(o.has_value());
  26     EXPECT_TRUE(static_cast<bool>(o));
  27 }
  28
  29 TEST(Optional, MoveCtr)
  30 {
  31     util::optional<std::string> os1(std::string("text"));
  32     EXPECT_TRUE(os1.has_value());
  33
  34     util::optional<std::string> os2(std::move(os1));
  35     EXPECT_FALSE(os1.has_value());
  36     EXPECT_TRUE(os2.has_value());
  37     EXPECT_EQ("text", os2.value());
  38 }
  39
  40 TEST(Optional, EmptyThrows)
  41 {
  42     struct foo { int bar; };
  43     util::optional<foo> om;
  44     const util::optional<foo> oc;
  45
  46     int dummy;
  47
  48     EXPECT_THROW(dummy = om->bar,    util::bad_optional_access);
  49     EXPECT_THROW(dummy = oc->bar,    util::bad_optional_access);
  50     cv::util::suppress_unused_warning(dummy);
  51     EXPECT_THROW(*om,        util::bad_optional_access);
  52     EXPECT_THROW(*oc,        util::bad_optional_access);
  53     EXPECT_THROW(om.value(), util::bad_optional_access);
  54     EXPECT_THROW(oc.value(), util::bad_optional_access);
  55 }
  56
  57 TEST(Optional, ValueNoThrow)
  58 {
  59     struct foo { int bar; };
  60     util::optional<foo> om(foo{42});
  61     const util::optional<foo> oc(foo{42});
  62
  63     int dummy;
  64     EXPECT_NO_THROW(dummy = om->bar);
  65     EXPECT_NO_THROW(dummy = oc->bar);
  66     cv::util::suppress_unused_warning(dummy);
  67     EXPECT_NO_THROW(*om);
  68     EXPECT_NO_THROW(*oc);
  69     EXPECT_NO_THROW(om.value());
  70     EXPECT_NO_THROW(oc.value());
  71 }
  72
  73 TEST(Optional, Value)
  74 {
  75     util::optional<int> oi(42);
  76
  77     struct foo { int bar; };
  78     util::optional<foo> of(foo{42});
  79
  80     EXPECT_EQ(42, oi.value());
  81     EXPECT_EQ(42, *oi);
  82
  83     EXPECT_EQ(42, of.value().bar);
  84     EXPECT_EQ(42, of->bar);
  85 }
  86
  87 TEST(Optional, Mutable)
  88 {
  89     util::optional<int> oi(42);
  90     *oi = 43;
  91     EXPECT_EQ(43, *oi);
  92
  93     struct foo { int bar; int baz; };
  94     util::optional<foo> of(foo{11,22});
  95
  96     (*of).bar = 42;
  97     EXPECT_EQ(42, of->bar);
  98     EXPECT_EQ(22, of->baz);
  99
 100     of->baz = 33;
 101     EXPECT_EQ(42, of->bar);
 102     EXPECT_EQ(33, of->baz);
 103 }
 104
 105 TEST(Optional, MoveAssign)
 106 {
 107     util::optional<int> e, i(42);
 108
 109     EXPECT_FALSE(e.has_value());
 110     EXPECT_TRUE(i.has_value());
 111     EXPECT_EQ(42, *i);
 112
 113     e = std::move(i);
 114     EXPECT_TRUE(e.has_value());
 115     EXPECT_FALSE(i.has_value());
 116     EXPECT_EQ(42, *e);
 117 }
 118
 119 TEST(Optional, CopyAssign)
 120 {
 121     util::optional<int> e;
 122     const util::optional<int> i(42);
 123
 124     EXPECT_FALSE(e.has_value());
 125     EXPECT_TRUE(i.has_value());
 126     EXPECT_EQ(42, *i);
 127
 128     e = i;
 129     EXPECT_TRUE(e.has_value());
 130     EXPECT_TRUE(i.has_value());
 131     EXPECT_EQ(42, *e);
 132     EXPECT_EQ(42, *i);
 133 }
 134
 135 TEST(Optional, ValueOr)
 136 {
 137     util::optional<int> e;
 138     EXPECT_FALSE(e.has_value());
 139     EXPECT_EQ(42, e.value_or(42));
 140     EXPECT_EQ(42, e.value_or(42.1));
 141 }
 142
 143 TEST(Optional, Swap)
 144 {
 145     util::optional<int> e, i(42);
 146
 147     EXPECT_FALSE(e.has_value());
 148     EXPECT_TRUE(i.has_value());
 149     EXPECT_EQ(42, *i);
 150
 151     e.swap(i);
 152
 153     EXPECT_TRUE(e.has_value());
 154     EXPECT_FALSE(i.has_value());
 155     EXPECT_EQ(42, *e);
 156 }
 157
 158 TEST(Optional, Reset)
 159 {
 160     util::optional<int> i(42);
 161     EXPECT_TRUE(i.has_value());
 162
 163     i.reset();
 164     EXPECT_FALSE(i.has_value());
 165 }
 166
 167 TEST(Optional, MakeOptional)
 168 {
 169     std::string s("text");
 170     auto os = util::make_optional(s);
 171     EXPECT_TRUE(os.has_value());
 172     EXPECT_EQ(s, os.value());
 173 }
 174
 175 } // namespace opencv_test