inference-engine/thirdparty/fluid/modules/gapi/test/internal/gapi_int_vectorref_test.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
  10 namespace opencv_test
  11 {
  12
  13 typedef ::testing::Types<int, cv::Point, cv::Rect> VectorRef_Test_Types;
  14
  15 template<typename T> struct VectorRefT: public ::testing::Test { using Type = T; };
  16
  17 TYPED_TEST_CASE(VectorRefT, VectorRef_Test_Types);
  18
  19 TYPED_TEST(VectorRefT, Reset_Valid)
  20 {
  21     using T = typename TestFixture::Type;
  22     cv::detail::VectorRefT<T> ref;       // vector ref created empty
  23     EXPECT_NO_THROW(ref.reset());        // 1st reset is OK (initializes)
  24     EXPECT_NO_THROW(ref.reset());        // 2nd reset is also OK (resets)
  25 }
  26
  27 TYPED_TEST(VectorRefT, Reset_Invalid)
  28 {
  29     using T = typename TestFixture::Type;
  30     std::vector<T> vec(42);              // create a std::vector of 42 elements
  31     cv::detail::VectorRefT<T> ref(vec);  // RO_EXT (since reference is const)
  32     EXPECT_ANY_THROW(ref.reset());       // data-bound vector ref can't be reset
  33 }
  34
  35 TYPED_TEST(VectorRefT, ReadRef_External)
  36 {
  37     using T = typename TestFixture::Type;
  38     const std::vector<T> vec(42);        // create a std::vector of 42 elements
  39     cv::detail::VectorRefT<T> ref(vec);  // RO_EXT (since reference is const)
  40     auto &vref = ref.rref();
  41     EXPECT_EQ(vec.data(), vref.data());
  42     EXPECT_EQ(vec.size(), vref.size());
  43 }
  44
  45 TYPED_TEST(VectorRefT, ReadRef_Internal)
  46 {
  47     using T = typename TestFixture::Type;
  48     cv::detail::VectorRefT<T> ref;
  49     ref.reset();                         // RW_OWN (reset on empty ref)
  50     auto &vref = ref.rref();             // read access is valid for RW_OWN
  51     EXPECT_EQ(0u, vref.size());          // by default vector is empty
  52 }
  53
  54 TYPED_TEST(VectorRefT, WriteRef_External)
  55 {
  56     using T = typename TestFixture::Type;
  57     std::vector<T> vec(42);               // create a std::vector of 42 elements
  58     cv::detail::VectorRefT<T> ref(vec);   // RW_EXT (since reference is not const)
  59     auto &vref = ref.wref();              // write access is valid with RW_EXT
  60     EXPECT_EQ(vec.data(), vref.data());
  61     EXPECT_EQ(vec.size(), vref.size());
  62 }
  63
  64 TYPED_TEST(VectorRefT, WriteRef_Internal)
  65 {
  66     using T = typename TestFixture::Type;
  67     cv::detail::VectorRefT<T> ref;
  68     ref.reset();                          // RW_OWN (reset on empty ref)
  69     auto &vref = ref.wref();              // write access is valid for RW_OWN
  70     EXPECT_EQ(0u, vref.size());           // empty vector by default
  71 }
  72
  73 TYPED_TEST(VectorRefT, WriteToRO)
  74 {
  75     using T = typename TestFixture::Type;
  76     const std::vector<T> vec(42);        // create a std::vector of 42 elements
  77     cv::detail::VectorRefT<T> ref(vec);  // RO_EXT (since reference is const)
  78     EXPECT_ANY_THROW(ref.wref());
  79 }
  80
  81 TYPED_TEST(VectorRefT, ReadAfterWrite)
  82 {
  83     using T = typename TestFixture::Type;
  84     std::vector<T> vec;                        // Initial data holder (empty vector)
  85     cv::detail::VectorRefT<T> writer(vec);     // RW_EXT
  86
  87     const auto& ro_ref = vec;
  88     cv::detail::VectorRefT<T> reader(ro_ref);  // RO_EXT
  89
  90     EXPECT_EQ(0u, writer.wref().size()); // Check the initial state
  91     EXPECT_EQ(0u, reader.rref().size());
  92
  93     writer.wref().emplace_back();        // Check that write is successfull
  94     EXPECT_EQ(1u, writer.wref().size());
  95
  96     EXPECT_EQ(1u, vec.size());           // Check that changes are reflected to the original container
  97     EXPECT_EQ(1u, reader.rref().size()); // Check that changes are reflected to reader's view
  98
  99     EXPECT_EQ(T(), vec.at(0));           // Check the value (must be default-initialized)
 100     EXPECT_EQ(T(), reader.rref().at(0));
 101     EXPECT_EQ(T(), writer.wref().at(0));
 102 }
 103
 104 template<typename T> struct VectorRefU: public ::testing::Test { using Type = T; };
 105
 106 TYPED_TEST_CASE(VectorRefU, VectorRef_Test_Types);
 107
 108 template<class T> struct custom_struct { T a; T b; };
 109
 110 TYPED_TEST(VectorRefU, Reset_Valid)
 111 {
 112     using T = typename TestFixture::Type;
 113     cv::detail::VectorRef ref;           // vector ref created empty
 114     EXPECT_NO_THROW(ref.reset<T>());     // 1st reset is OK (initializes)
 115     EXPECT_NO_THROW(ref.reset<T>());     // 2nd reset is also OK (resets)
 116
 117     EXPECT_ANY_THROW(ref.reset<custom_struct<T> >()); // type change is not allowed
 118 }
 119
 120 TYPED_TEST(VectorRefU, Reset_Invalid)
 121 {
 122     using T = typename TestFixture::Type;
 123     std::vector<T> vec(42);              // create a std::vector of 42 elements
 124     cv::detail::VectorRef ref(vec);      // RO_EXT (since reference is const)
 125     EXPECT_ANY_THROW(ref.reset<T>());    // data-bound vector ref can't be reset
 126 }
 127
 128 TYPED_TEST(VectorRefU, ReadRef_External)
 129 {
 130     using T = typename TestFixture::Type;
 131     const std::vector<T> vec(42);        // create a std::vector of 42 elements
 132     cv::detail::VectorRef ref(vec);      // RO_EXT (since reference is const)
 133     auto &vref = ref.rref<T>();
 134     EXPECT_EQ(vec.data(), vref.data());
 135     EXPECT_EQ(vec.size(), vref.size());
 136 }
 137
 138 TYPED_TEST(VectorRefU, ReadRef_Internal)
 139 {
 140     using T = typename TestFixture::Type;
 141     cv::detail::VectorRef ref;
 142     ref.reset<T>();                      // RW_OWN (reset on empty ref)
 143     auto &vref = ref.rref<T>();          // read access is valid for RW_OWN
 144     EXPECT_EQ(0u, vref.size());          // by default vector is empty
 145 }
 146
 147 TYPED_TEST(VectorRefU, WriteRef_External)
 148 {
 149     using T = typename TestFixture::Type;
 150     std::vector<T> vec(42);             // create a std::vector of 42 elements
 151     cv::detail::VectorRef ref(vec);     // RW_EXT (since reference is not const)
 152     auto &vref = ref.wref<T>();         // write access is valid with RW_EXT
 153     EXPECT_EQ(vec.data(), vref.data());
 154     EXPECT_EQ(vec.size(), vref.size());
 155 }
 156
 157 TYPED_TEST(VectorRefU, WriteRef_Internal)
 158 {
 159     using T = typename TestFixture::Type;
 160     cv::detail::VectorRef ref;
 161     ref.reset<T>();                     // RW_OWN (reset on empty ref)
 162     auto &vref = ref.wref<T>();         // write access is valid for RW_OWN
 163     EXPECT_EQ(0u, vref.size());         // empty vector by default
 164 }
 165
 166 TYPED_TEST(VectorRefU, WriteToRO)
 167 {
 168     using T = typename TestFixture::Type;
 169     const std::vector<T> vec(42);       // create a std::vector of 42 elements
 170     cv::detail::VectorRef ref(vec);     // RO_EXT (since reference is const)
 171     EXPECT_ANY_THROW(ref.wref<T>());
 172 }
 173
 174 TYPED_TEST(VectorRefU, ReadAfterWrite)
 175 {
 176     using T = typename TestFixture::Type;
 177     std::vector<T> vec;                     // Initial data holder (empty vector)
 178     cv::detail::VectorRef writer(vec);      // RW_EXT
 179
 180     const auto& ro_ref = vec;
 181     cv::detail::VectorRef reader(ro_ref);   // RO_EXT
 182
 183     EXPECT_EQ(0u, writer.wref<T>().size()); // Check the initial state
 184     EXPECT_EQ(0u, reader.rref<T>().size());
 185
 186     writer.wref<T>().emplace_back();        // Check that write is successfull
 187     EXPECT_EQ(1u, writer.wref<T>().size());
 188
 189     EXPECT_EQ(1u, vec.size());              // Check that changes are reflected to the original container
 190     EXPECT_EQ(1u, reader.rref<T>().size()); // Check that changes are reflected to reader's view
 191
 192     EXPECT_EQ(T(), vec.at(0));              // Check the value (must be default-initialized)
 193     EXPECT_EQ(T(), reader.rref<T>().at(0));
 194     EXPECT_EQ(T(), writer.wref<T>().at(0));
 195 }
 196
 197 TEST(VectorRefU, TypeCheck)
 198 {
 199     cv::detail::VectorRef ref;
 200     ref.reset<int>(); // RW_OWN
 201
 202     EXPECT_ANY_THROW(ref.reset<char>());
 203     EXPECT_ANY_THROW(ref.rref<char>());
 204     EXPECT_ANY_THROW(ref.wref<char>());
 205 }
 206
 207 } // namespace opencv_test