Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Tetragramm
GitHub Repository: Tetragramm/opencv
 Path: blob/master/modules/gapi/test/util/variant_tests.cpp
16354 views
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 Intel Corporation

6


7


8
#include "test_precomp.hpp"

9
#include "opencv2/gapi/util/variant.hpp"

10
#include <cstddef> //std::max_align_t

11


12
namespace opencv_test

13
{

14


15
namespace

16
{

17
    typedef util::variant<int, std::string> TestVar;

18
    typedef util::variant<int, float>       TestVar2;

19
}

20


21
TEST(Variant, EmptyCTor)

22
{

23
    util::variant<int> vi;

24
    EXPECT_EQ(0,  util::get<int>(vi));

25


26
    util::variant<int, std::string> vis;

27
    EXPECT_EQ(0,  util::get<int>(vis));

28


29
    util::variant<std::string> vs;

30
    EXPECT_EQ("", util::get<std::string>(vs));

31


32
    util::variant<std::string, int> vsi;

33
    EXPECT_EQ("", util::get<std::string>(vsi));

34
}

35


36
TEST(Variant, ValueMoveCTor)

37
{

38
    util::variant<int> vi(42);

39
    EXPECT_EQ(0u,     vi.index());

40
    EXPECT_EQ(42,     util::get<int>(vi));

41


42
    util::variant<int, std::string> vis(2017);

43
    EXPECT_EQ(0u,     vis.index());

44
    EXPECT_EQ(2017,   util::get<int>(vis));

45


46
    util::variant<int, std::string> vis2(std::string("2017"));

47
    EXPECT_EQ(1u,     vis2.index());

48
    EXPECT_EQ("2017", util::get<std::string>(vis2));

49


50
    util::variant<std::string> vs(std::string("2017"));

51
    EXPECT_EQ(0u,     vs.index());

52
    EXPECT_EQ("2017", util::get<std::string>(vs));

53


54
    util::variant<std::string, int> vsi(std::string("2017"));

55
    EXPECT_EQ(0u,     vsi.index());

56
    EXPECT_EQ("2017", util::get<std::string>(vsi));

57


58
    util::variant<std::string, int> vsi2(42);

59
    EXPECT_EQ(1u,     vsi2.index());

60
    EXPECT_EQ(42,     util::get<int>(vsi2));

61
}

62


63
TEST(Variant, ValueCopyCTor)

64
{

65
    const int i42         = 42;

66
    const int i17         = 2017;

67
    const std::string s17 = "2017";

68


69
    util::variant<int> vi(i42);

70
    EXPECT_EQ(0u,     vi.index());

71
    EXPECT_EQ(i42,    util::get<int>(vi));

72


73
    util::variant<int, std::string> vis(i17);

74
    EXPECT_EQ(0u,     vis.index());

75
    EXPECT_EQ(i17,    util::get<int>(vis));

76


77
    util::variant<int, std::string> vis2(s17);

78
    EXPECT_EQ(1u,     vis2.index());

79
    EXPECT_EQ(s17,    util::get<std::string>(vis2));

80


81
    util::variant<std::string> vs(s17);

82
    EXPECT_EQ(0u,     vs.index());

83
    EXPECT_EQ(s17,    util::get<std::string>(vs));

84


85
    util::variant<std::string, int> vsi(s17);

86
    EXPECT_EQ(0u,     vsi.index());

87
    EXPECT_EQ(s17, util::get<std::string>(vsi));

88


89
    util::variant<std::string, int> vsi2(i42);

90
    EXPECT_EQ(1u,     vsi2.index());

91
    EXPECT_EQ(i42,    util::get<int>(vsi2));

92
}

93


94
TEST(Variant, CopyMoveCTor)

95
{

96
    const TestVar tvconst(std::string("42"));

97


98
    TestVar tv = tvconst;

99
    EXPECT_EQ( 1u,  tv.index());

100
    EXPECT_EQ("42", util::get<std::string>(tv));

101


102
    TestVar tv2(TestVar(40+2));

103
    EXPECT_EQ( 0u,  tv2.index());

104
    EXPECT_EQ( 42,  util::get<int>(tv2));

105
}

106


107
TEST(Variant, Assign_Basic)

108
{

109
    TestVar vis;

110
    EXPECT_EQ(0u, vis.index());

111
    EXPECT_EQ(0,  util::get<int>(vis));

112


113
    vis = 42;

114
    EXPECT_EQ(0u, vis.index());

115
    EXPECT_EQ(42, util::get<int>(vis));

116
}

117


118
TEST(Variant, Assign_ValueUpdate_SameType)

119
{

120
    TestVar vis(42);

121


122
    EXPECT_EQ(0u, vis.index());

123
    EXPECT_EQ(42, util::get<int>(vis));

124


125
    vis = 43;

126
    EXPECT_EQ(0u, vis.index());

127
    EXPECT_EQ(43, util::get<int>(vis));

128
}

129


130
TEST(Variant, Assign_ValueUpdate_DiffType)

131
{

132
    TestVar vis(42);

133


134
    EXPECT_EQ(0u, vis.index());

135
    EXPECT_EQ(42, util::get<int>(vis));

136


137
    vis = std::string("42");

138
    EXPECT_EQ(1u, vis.index());

139
    EXPECT_EQ("42", util::get<std::string>(vis));

140
}

141


142
TEST(Variant, Assign_ValueUpdate_Const)

143
{

144
    TestVar va(42);

145
    const TestVar vb(43);

146


147
    EXPECT_EQ(0u, va.index());

148
    EXPECT_EQ(42, util::get<int>(va));

149


150
    EXPECT_EQ(0u, vb.index());

151
    EXPECT_EQ(43, util::get<int>(vb));

152


153
    va = vb;

154


155
    EXPECT_EQ(0u, va.index());

156
    EXPECT_EQ(43, util::get<int>(va));

157
}

158


159
TEST(Variant, Assign_ValueUpdate_Const_DiffType)

160
{

161
    TestVar va(42);

162
    const TestVar vb(std::string("42"));

163


164
    EXPECT_EQ(0u, va.index());

165
    EXPECT_EQ(42, util::get<int>(va));

166


167
    EXPECT_EQ(1u, vb.index());

168
    EXPECT_EQ("42", util::get<std::string>(vb));

169


170
    va = vb;

171


172
    EXPECT_EQ(1u,   va.index());

173
    EXPECT_EQ("42", util::get<std::string>(va));

174
}

175


176
TEST(Variant, Assign_Move)

177
{

178
    TestVar va(42);

179
    TestVar vb(std::string("42"));

180
    TestVar vc(43);

181


182
    EXPECT_EQ(0u, va.index());

183
    EXPECT_EQ(42, util::get<int>(va));

184


185
    EXPECT_EQ(1u, vb.index());

186
    EXPECT_EQ("42", util::get<std::string>(vb));

187


188
    EXPECT_EQ(0u, vc.index());

189
    EXPECT_EQ(43, util::get<int>(vc));

190


191
    va = std::move(vb);

192
    EXPECT_EQ(1u, va.index());

193
    EXPECT_EQ("42", util::get<std::string>(va));

194


195
    va = std::move(vc);

196
    EXPECT_EQ(0u, va.index());

197
    EXPECT_EQ(43, util::get<int>(va));

198
}

199


200
TEST(Variant, Swap_SameIndex)

201
{

202
    TestVar tv1(42);

203
    TestVar tv2(43);

204


205
    EXPECT_EQ(0u, tv1.index());

206
    EXPECT_EQ(42, util::get<int>(tv1));

207


208
    EXPECT_EQ(0u, tv2.index());

209
    EXPECT_EQ(43, util::get<int>(tv2));

210


211
    tv1.swap(tv2);

212


213
    EXPECT_EQ(0u, tv1.index());

214
    EXPECT_EQ(43, util::get<int>(tv1));

215


216
    EXPECT_EQ(0u, tv2.index());

217
    EXPECT_EQ(42, util::get<int>(tv2));

218
}

219


220
TEST(Variant, Swap_DiffIndex)

221
{

222
    TestVar2 tv1(42);

223
    TestVar2 tv2(3.14f);

224


225
    EXPECT_EQ(0u, tv1.index());

226
    EXPECT_EQ(42, util::get<int>(tv1));

227


228
    EXPECT_EQ(1u, tv2.index());

229
    EXPECT_EQ(3.14f, util::get<float>(tv2));

230


231
    tv1.swap(tv2);

232


233
    EXPECT_EQ(0u, tv2.index());

234
    EXPECT_EQ(42, util::get<int>(tv2));

235


236
    EXPECT_EQ(1u, tv1.index());

237
    EXPECT_EQ(3.14f, util::get<float>(tv1));

238
}

239


240
TEST(Variant, Get)

241
{

242
    const TestVar cv(42);

243


244
    // Test const& get()

245
    EXPECT_EQ(42, util::get<int>(cv));

246
    EXPECT_THROW(util::get<std::string>(cv), util::bad_variant_access);

247


248
    // Test &get

249
    TestVar cv2(std::string("42"));

250
    EXPECT_EQ("42", util::get<std::string>(cv2));

251
    EXPECT_THROW(util::get<int>(cv2), util::bad_variant_access);

252
}

253


254
TEST(Variant, GetWrite)

255
{

256
    util::variant<int, std::string> v(42);

257
    EXPECT_EQ(42, util::get<int>(v));

258


259
    util::get<int>(v) = 43;

260
    EXPECT_EQ(43, util::get<int>(v));

261
}

262


263
TEST(Variant, NoDefaultCtor)

264
{

265
    struct MyType

266
    {

267
        int m_a;

268
        MyType() = delete;

269
    };

270


271
    // This code MUST compile

272
    util::variant<int, MyType> var;

273
    SUCCEED() << "Code compiled";

274


275
    // At the same time, util::variant<MyType, ...> MUST NOT.

276
}

277


278
TEST(Variant, MonoState)

279
{

280
    struct MyType

281
    {

282
        int m_a;

283
        explicit MyType(int a) : m_a(a) {}

284
        MyType() = delete;

285
    };

286


287
    util::variant<util::monostate, MyType> var;

288
    EXPECT_EQ(0u, var.index());

289


290
    var = MyType{42};

291
    EXPECT_EQ(1u, var.index());

292
    EXPECT_EQ(42, util::get<MyType>(var).m_a);

293
}

294


295


296
TEST(Variant, Eq)

297
{

298
    TestVar v1(42), v2(std::string("42"));

299
    TestVar v3(v1), v4(v2);

300


301
    EXPECT_TRUE(v1 == v3);

302
    EXPECT_TRUE(v2 == v4);

303
    EXPECT_TRUE(v1 != v2);

304
    EXPECT_TRUE(v3 != v4);

305


306
    EXPECT_FALSE(v1 == v2);

307
    EXPECT_FALSE(v3 == v4);

308
    EXPECT_FALSE(v1 != v3);

309
    EXPECT_FALSE(v2 != v4);

310
}

311


312
TEST(Variant, Eq_Monostate)

313
{

314
    using TestVar3 = util::variant<util::monostate, int>;

315
    TestVar3 v1;

316
    TestVar3 v2(42);

317


318
    EXPECT_NE(v1, v2);

319


320
    v2 = util::monostate{};

321
    EXPECT_EQ(v1, v2);

322
}

323


324
TEST(Variant, VectorOfVariants)

325
{

326
    std::vector<TestVar> vv1(1024);

327
    std::vector<TestVar> vv2(1024);

328


329
    EXPECT_TRUE(vv1 == vv2);

330


331
    std::vector<TestVar> vv3(2048, TestVar(std::string("42")));

332


333
    // Just test chat the below code compiles:

334
    // 1: internal copy of variants from one vector to another,

335
    //    with probable reallocation of 1st vector to host all elements

336
    std::copy(vv1.begin(), vv1.end(), std::back_inserter(vv2));

337
    EXPECT_EQ(2048u, vv2.size());

338


339
    // 2: truncation of vector, with probable destruction of its tail memory

340
    vv2.resize(1024);

341
    EXPECT_EQ(1024u, vv2.size());

342


343
    // 3. vector assignment, with overwriting underlying variants

344
    vv2 = vv3;

345
    EXPECT_EQ(2048u, vv2.size());

346
    EXPECT_TRUE(vv2 == vv3);

347
}

348


349
TEST(Variant, HoldsAlternative)

350
{

351
    TestVar v(42);

352
    EXPECT_TRUE (util::holds_alternative<int>        (v));

353
    EXPECT_FALSE(util::holds_alternative<std::string>(v));

354


355
    v = std::string("42");

356
    EXPECT_FALSE(util::holds_alternative<int>        (v));

357
    EXPECT_TRUE (util::holds_alternative<std::string>(v));

358
}

359


360
TEST(Variant, Sizeof)

361
{

362
    //variant has to store index of the contained type as well as the type itself

363
    EXPECT_EQ(2 * sizeof(size_t), (sizeof(util::variant<int, char>)));

364
#if !defined(__GNUG__) || __GNUG__ >= 5

365
    // GCC versions prior to 5.0 have limited C++11 support, e.g.

366
    // no std::max_align_t defined

367
    EXPECT_EQ((sizeof(std::max_align_t) + std::max(sizeof(size_t), alignof(std::max_align_t))), (sizeof(util::variant<std::max_align_t, char>)));

368
#endif

369
}

370


371
TEST(Variant, EXT_IndexOf)

372
{

373
    struct MyType{};

374
    class MyClass{};

375


376
    using V = util::variant<util::monostate, int, double, char, float, MyType, MyClass>;

377
    static_assert(0u == V::index_of<util::monostate>(), "Index is incorrect");

378
    static_assert(1u == V::index_of<int    >(), "Index is incorrect");

379
    static_assert(2u == V::index_of<double >(), "Index is incorrect");

380
    static_assert(3u == V::index_of<char   >(), "Index is incorrect");

381
    static_assert(4u == V::index_of<float  >(), "Index is incorrect");

382
    static_assert(5u == V::index_of<MyType >(), "Index is incorrect");

383
    static_assert(6u == V::index_of<MyClass>(), "Index is incorrect");

384
}

385


386
} // namespace opencv_test

387


388