inference-engine/tests/unit/engines/vpu/containers_tests.cpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #include <algorithm>
   6 #include <chrono>
   7 #include <iostream>
   8 #include <unordered_map>
   9 #include <memory>
  10
  11 #include <gtest/gtest.h>
  12
  13 #include <vpu/utils/containers.hpp>
  14 #include <vpu/utils/range.hpp>
  15 #include <vpu/utils/handle.hpp>
  16
  17 using namespace testing;
  18
  19 namespace {
  20
  21 struct TestStruct final : public vpu::EnableHandleFromThis<TestStruct> {
  22     int val = 0;
  23     vpu::IntrusivePtrListNode<TestStruct> node1;
  24     vpu::IntrusivePtrListNode<TestStruct> node2;
  25     explicit TestStruct(int val) : val(val), node1(this), node2(this) {}
  26 };
  27
  28 }
  29
  30 TEST(VPU_Containers, SmallVector_API) {
  31     std::vector<int> vec1;
  32     vpu::SmallVector<int, 5> vec2;
  33
  34     for (size_t i = 0; i < 5; ++i) {
  35         vec1.push_back(i);
  36         vec2.push_back(i);
  37     }
  38
  39     for (size_t i = 0; i < vec1.size(); ++i) {
  40         ASSERT_EQ(vec1.at(i), vec2.at(i));
  41     }
  42
  43     vec1.clear();
  44     vec2.clear();
  45
  46     for (size_t i = 0; i < 5; ++i) {
  47         vec1.push_back(i);
  48     }
  49     vec2.insert(vec2.end(), vec1.begin(), vec1.end());
  50
  51     auto it1 = std::find(vec1.begin(), vec1.end(), 2);
  52     auto it2 = std::find(vec2.begin(), vec2.end(), 2);
  53
  54     ASSERT_NE(it1, vec1.end());
  55     ASSERT_NE(it2, vec2.end());
  56
  57     vec1.erase(it1);
  58     vec2.erase(it2);
  59
  60     for (size_t i = 0; i < vec1.size(); ++i) {
  61         ASSERT_EQ(vec1.at(i), vec2.at(i));
  62     }
  63
  64     vec1.push_back(15);
  65     vec1.push_back(16);
  66
  67     vec2.push_back(15);
  68     vec2.push_back(16);
  69
  70     for (size_t i = 0; i < vec1.size(); ++i) {
  71         ASSERT_EQ(vec1.at(i), vec2.at(i));
  72     }
  73 }
  74
  75 TEST(VPU_Containers, SmallVector_Equal) {
  76     vpu::SmallVector<int, 5> vec1;
  77     vpu::SmallVector<int, 5> vec2;
  78     vpu::SmallVector<int, 5> vec3;
  79
  80     for (size_t i = 0; i < 5; ++i) {
  81         vec1.push_back(i);
  82         vec2.push_back(i);
  83         vec3.push_back(i + 1);
  84     }
  85
  86     ASSERT_EQ(vec1, vec2);
  87     ASSERT_NE(vec1, vec3);
  88 }
  89
  90 TEST(VPU_Containers, SmallVector_Swap) {
  91     vpu::SmallVector<int, 5> vec1;
  92     vpu::SmallVector<int, 5> vec2;
  93
  94     for (size_t i = 0; i < 5; ++i) {
  95         vec1.push_back(i);
  96         vec2.push_back(5 - i);
  97     }
  98
  99     vec1.swap(vec2);
 100
 101     for (size_t i = 0; i < 5; ++i) {
 102         ASSERT_EQ(vec1[i], 5 - i);
 103         ASSERT_EQ(vec2[i], i);
 104     }
 105 }
 106
 107 template <class Cont>
 108 Cont buildTestVector(int contSize) {
 109     Cont vec;
 110
 111     for (int i = 0; i < contSize; ++i) {
 112         vec.push_back(i);
 113     }
 114
 115     return vec;
 116 }
 117
 118 TEST(VPU_Containers, IntrusivePtrList) {
 119     const int count = 5;
 120     int gold = 0;
 121
 122     std::vector<std::shared_ptr<TestStruct>> base;
 123     for (int i = 0; i < count; ++i) {
 124         base.push_back(std::make_shared<TestStruct>(i));
 125     }
 126
 127     vpu::IntrusivePtrList<TestStruct> list1(&TestStruct::node1);
 128     vpu::IntrusivePtrList<TestStruct> list2(&TestStruct::node2);
 129
 130     for (int i = 0; i < count; ++i) {
 131         list1.push_back(base[i]);
 132     }
 133
 134     ASSERT_FALSE(list1.empty());
 135     ASSERT_TRUE(list2.empty());
 136
 137     gold = 0;
 138     for (const auto& ptr1 : list1) {
 139         ASSERT_NE(ptr1, nullptr);
 140         ASSERT_EQ(ptr1->val, gold);
 141         ASSERT_EQ(ptr1.get(), base[ptr1->val].get());
 142         ++gold;
 143     }
 144     ASSERT_EQ(gold, count);
 145
 146     for (int i = 0; i < count / 2; ++i) {
 147         list2.push_back(base[i]);
 148     }
 149
 150     ASSERT_FALSE(list2.empty());
 151
 152     gold = 0;
 153     for (const auto& ptr2 : list2) {
 154         ASSERT_NE(ptr2, nullptr);
 155         ASSERT_EQ(ptr2->val, gold);
 156         ASSERT_EQ(ptr2.get(), base[ptr2->val].get());
 157
 158         list1.erase(ptr2);
 159
 160         ++gold;
 161     }
 162     ASSERT_EQ(gold, count / 2);
 163
 164     gold = count / 2;
 165     for (const auto& ptr1 : list1) {
 166         ASSERT_NE(ptr1, nullptr);
 167         ASSERT_EQ(ptr1->val, gold);
 168         ASSERT_EQ(ptr1.get(), base[ptr1->val].get());
 169         ++gold;
 170     }
 171     ASSERT_EQ(gold, count);
 172 }
 173
 174 TEST(VPU_Containers, IntrusivePtrList_MoveFromOneListToAnother) {
 175     const int count = 5;
 176
 177     std::list<std::shared_ptr<TestStruct>> base;
 178
 179     vpu::IntrusivePtrList<TestStruct> list1(&TestStruct::node1);
 180     vpu::IntrusivePtrList<TestStruct> list2(&TestStruct::node1);
 181
 182     for (int i = 0; i < count; ++i) {
 183         auto ptr = std::make_shared<TestStruct>(i);
 184         base.push_back(ptr);
 185         list1.push_back(ptr);
 186     }
 187
 188     ASSERT_EQ(list1.size(), base.size());
 189     ASSERT_TRUE(list2.empty());
 190
 191     for (const auto& item : list1) {
 192         list1.erase(item);
 193         list2.push_back(item);
 194     }
 195
 196     ASSERT_TRUE(list1.empty());
 197     ASSERT_EQ(list2.size(), base.size());
 198 }
 199
 200 TEST(VPU_Containers, IntrusivePtrList_ReleaseOrigObject) {
 201     const int count = 5;
 202     int gold = 0;
 203
 204     std::list<std::shared_ptr<TestStruct>> base;
 205
 206     vpu::IntrusivePtrList<TestStruct> list(&TestStruct::node1);
 207
 208     for (int i = 0; i < count; ++i) {
 209         auto ptr = std::make_shared<TestStruct>(i);
 210         base.push_back(ptr);
 211         list.push_back(ptr);
 212     }
 213
 214     ASSERT_EQ(list.size(), base.size());
 215
 216     base.pop_front();
 217     ASSERT_EQ(list.size(), base.size());
 218
 219     base.pop_back();
 220     ASSERT_EQ(list.size(), base.size());
 221
 222     list.clear();
 223     ASSERT_TRUE(list.empty());
 224
 225     gold = 0;
 226     for (const auto& item : base) {
 227         ASSERT_EQ(item->val, gold + 1);
 228         ++gold;
 229     }
 230     ASSERT_EQ(gold, count - 2);
 231 }